RAPIDS ve Ray ile GPU Analitiğini Hızlandırma Yöntemleri

RAPIDS, GPU hızlandırmalı veri bilimi ve yapay zeka kütüphanelerinden oluşan açık kaynak bir settir. Bu kütüphaneler, Spark ve Dask gibi dağıtık motorlarla ölçeklendirme konusunda iyi desteklenmektedir. Ray, yapay zeka ve makine öğrenimi (ML) uygulamalarını ölçeklendirmede yaygın olarak kullanılan popüler bir açık kaynak dağıtılmış Python framework’üdür. Ray, özellikle eğitim ve tahmin iş akışlarını basitleştirip ölçeklendirirken, hem CPU hem de GPU cihazlarına kolayca erişim sağlar.

Bu yazıda, Ray ve RAPIDS’in yenilikçi analiz iş akışlarını hızlandırmak için nasıl kullanılabileceğini keşfedeceğiz.

Ray Aktörleri

Ray, ML modellerinin eğitimi ve servis edilmesi için yüksek düzeyde soyutlamalar sunarken, biz Ray’in temelini, özellikle Ray Aktörlerini kullanarak deneyeceğiz. Aktörler, her bir işçiyi durum bilgisi taşıyan birer işçi olarak tanımlar; yani, her işçi, herhangi bir depolanan veriyi saklayabilir, yönetebilir ve değiştirebilir. Örneğin, GPU’da bazı verileri yüklemek için cuDF kullanmak istiyorsanız, aşağıdaki gibi bir kullanım gerçekleştirebilirsiniz:

Örnek:

@ray.remote(num_gpus=1)
class cuDFActor:
    def __init__(self):
        ...

    def read_parquet(self, filepath: str, columns: list = None) -> cudf.DataFrame:
        return cudf.read_parquet(filepath, columns=columns)

# 4 İşçi Başlat
pool_size = 4
actor_pool = [cuDFActor.remote() for i in range(pool_size)]

Bu örnek, Ray’i kullanarak dört aktör oluşturur ve her biri bir GPU üzerinde çalışır, ayrıca veriyi hızlandırmak için cuDF kullanılır. Bu örnek, RAPIDS optimizasyonları (RMM ile bellek yapılandırması) veya genel ETL rutinleri gibi filtreleme/gelişmiş ve kullanıcı tanımlı fonksiyonlarla kullanılabilir: cudf ray-aktor örneği.

Ray Aktörleri, oldukça genel bir yapıya sahiptir ve hızlı bir şekilde Python kütüphanelerini paralelleştirmek için kullanılabilir. Ayrıca, mevcut dağıtık algoritmalar ile kolayca entegre edilebilirler. Ek olarak, Ray ile bu çalışmaları çoklu GPU ve çoklu düğüm üzerinden kolayca ölçeklendirmek mümkündür.

NCCL ve cuGraph

Birçok RAPIDS uygulaması, C++ ile dağıtılmış hızlandırılmış GPU hesaplaması için zaten oluşturulmuştur. Bu uygulamalar, NCCL ile hızlandırılmış iletişim ve RAFT‘da bulunan primitifler ve çözücüler üzerine büyük ölçüde iyileştirilmiştir (iki yönlü mesafeler, k-ortalama kümeleme, yinelemeli çözücüler ve daha fazlası). RAFT primitifleri, cuML ve cuGraph gibi birçok RAPIDS kütüphanesinde kullanılmaktadır.

Örneğin, cuGraph’in zayıf bağlı bileşenler (WCC) uygulaması, sistematik olarak temizlenmiş verilerin mümkün olan en hızlı şekilde disketten CUDA C++ alt yapısına aktarılması üzerine kuruludur. WCC, geliştiricilerin RAPIDS (cuGraph) ve Ray’i bir arada kullanarak güçlü, dağıtılmış ve hızlandırılmış algoritmalara erişmelerini sağlamak için iyi bir hedeftir.

WCC’yi uygulamak için gerekenler şunlardır:

1. Verilerin GPU belleğine yüklenmesi
2. NCCL iletişimini başlatma (ve cuGraph alt iletişimcisi)
3. İçsel çok GPU’lu cuGraph uygulamasını başlatma ve yapılandırma
4. WCC’yi yürütme

İlk adımın nasıl gerçekleştirileceği gösterilmiştir. Ray’in NCCL kancaları mevcut olsa da, Ray ile RAFT NCCL arayüzlerine bağımlılığımız olduğu için iletişimleri yönetmek amacıyla RAFT’ı kullanacağız. Aşağıda, özetleyeceğimiz gereklilikler outlines:

İlgili Kod:

class RAFTActor:
    def __init__(self, index, pool_size, session_id):
        ...

    def broadcast_root_unique_id(self):
        # root/rank-0'i tüm aktörlere yaymak

    def _setup_nccl(self):
        # NCCL'i belirlenen rank-0 aktör ile başlatmak

    def _setup_raft(self):
        # RAFT ve NCCL'i birlikte yapılandırmak

    def set_root_unique_id(self, root_uniqueId):
        # Tüm aktörler için rank-0 olarak ayarlanacaktır

@ray.remote(num_gpus=1)
class WCCActor(RAFTActor):
    def __init__(self, index, pool_size, session_id):
        super().__init__(index=index, pool_size=pool_size, session_id=session_id, actor_name_prefix="WCC")

    def weakly_connected_components(self, df):
        """
        1. Her aktör bir parça yükler
        2. Her aktör bir NCCL/RAFT Kolu olur
        3. Her parçayı ve kolu MGGraph'e geçirir
        """

        src_array = df['src']
        dst_array = df['dst']
        weights = df['wgt']

        # Çoklu GPU'lu cuGraph Nesnesini yapılandır ve 
        # kenar liste verileri ile NCCL'i başlat
        graph = MGGraph(src_array, dst_array, weights, ...)
         
        # WCC'yi yürüt
        weakly_connected_components(graph)

# Ray'i başlat ve WCC algoritmasını çalıştır

Bu, cuGraph zayıf bağlı bileşenlerini çalıştırmak için gereken iki sınıfı kapsar. Daha fazla bilgi almak için zayıf bağlı bileşenler uygulaması‘na göz atabilirsiniz. Çoğu iş, NCCL/RAFT konfigürasyonunu içermektedir. Bu aynı desen, cuML k-ortalaması uygulaması gibi diğer kütüphaneler için de geçerlidir.

Sonuç

Ray, değiştirebileceğiniz ve kolaylıkla RAPIDS ile entegre edebileceğiniz ifade edilebilir ve ölçeklenebilir bir Aktör arayüzü sağlar. Bu yazıda, Ray Aktörlerini optimized CUDA C++ ve NCCL uygulamalarıyla bağlama yollarını keşfettik. Bu keşif, Ray Aktörlerinin başlangıç noktası niteliğinde Seviye 1 entegrasyonuna odaklanmıştır.

GPU hızlandırmalı veri işleme hakkında daha fazla bilgi edinmek için, RAPIDS Slack topluluğuna katılabilirsiniz; toplulukta 3,500’den fazla üye bulunmaktadır.