NVIDIA, scikit-learn, UMAP ve HDBSCAN'de GPU Hızlandırmasını Duyurdu

NVIDIA'nın cuML'i, RAPIDS AI ekosisteminin bir parçası olan GPU hızlandırmalı bir makine öğrenimi kütüphanesidir. Ve şimdi, açık betada, cuML 25.02 Python kodunuzu değiştirmeden scikit-learn, UMAP ve HDBSCAN'de GPU hızlandırmasını mümkün kılıyor. Bu, modellerinin performansında artış görmeyi bekleyen Python makine öğrenimi mühendisleri, veri ve araştırma bilimcileri, geliştiriciler ve daha pek çok profesyonel için oldukça ilgi çekici bir haber olacak.

cuML'e veya hatta GPU hızlandırması fikrine hâkim değilseniz endişelenmeyin. Sizi kısa bir tura çıkaracağım ve bu yazının sonunda regresyon, sınıflandırma, boyut indirgeme veya kümeleme problemleriniz için GPU hızlandırmasını kullanabileceksiniz.

NVIDIA, RAPIDS AI ve cuML

Hızlıca tüm parçaları yerine oturtalım.

RAPIDS AI nedir? 

NVIDIA, yüksek başarımlı hesaplama, yapay zeka ve veri bilimini güçlendiren ileri teknolojiler geliştiriyor. Deepseek, Deepseek-R1'ı yayınladığında ve insanların Deepseek'in NVIDIA çipleri kullanıp kullanmadığını sorduğu dönemde adını sıkça duymuş olabilirsiniz.

NVIDIA şimdi de RAPIDS AI ekosistemindeki yeniliklerle gündemde. Bilmeyenler için RAPIDS AI, veri bilimi ve makine öğrenimi iş akışlarını hızlandırmak üzere tasarlanmış, GPU hızlandırmalı açık kaynak kütüphaneler paketidir. RAPIDS, NVIDIA tarafından geliştirilen paralel hesaplama platformu ve API modeli olan CUDA (Compute Unified Device Architecture) üzerine inşa edilmiştir. RAPIDS GPU hızlandırmalı kütüphaneler şunları içerir: 

• Hızlı DataFrame işlemleri için cuDF
• cuML, bir makine öğrenimi kütüphanesi (Bu yazıda en çok bundan bahsedeceğiz.)
• cuGraph, bir grafik analitiği kütüphanesi
• cuSpatial, bir coğrafi analitik kütüphanesi

cuML nedir? 

Şimdi cuML hakkında: cuML, klasik makine öğrenimi algoritmalarının son derece optimize edilmiş uygulamalarını sağlar. NVIDIA'nın en iyi yapay zeka çiplerine sahip olması sayesinde, NVIDIA GPU'larında çalışan bu algoritmalar belirgin bir hız kazanır. CPU'lardan farklı olarak GPU'lar paralel işlemde ustadır; pratikte bu, aynı anda binlerce hesaplamayı işleyebildikleri anlamına gelir ve bu da onları (tahmin ettiğiniz gibi) derin öğrenme ve makine öğrenimi gibi görevler için ideal kılar.

scikit-learn nedir? 

scikit-learn ile tanışık değilseniz ve makine öğrenimi ile veri bilimi konusunda ciddiseniz, mutlaka scikit-learn ile Denetimli Öğrenme kursumuza kaydolmalısınız. Bunu şunun için söylüyorum: scikit-learn, makine öğrenimi için en popüler programlama dilinde, tablolu veriler için bir numaralı kütüphanedir. Dahası, scikit-learn öğrenmesi oldukça kolaydır, basit bir API'ye sahiptir ve pandas ve NumPy ile de iyi çalışır. Bu nedenle, RAPIDS AI ekibinin scikit-learn algoritmalarına stratejik ve doğal bir tercih olarak odaklanması şaşırtıcı değildir.

cuML'in scikit-learn'e Sunduğu İmkanlar

NVIDIA ve cuML artık scikit-learn'e, ayrıca UMAP ve HDBSCAN'e, performans hızında büyük bir artış şeklinde önemli bir yenilik sunuyor. RAPIDS AI ekibine göre bu, scikit-learn için 50 kata, UMAP için 60 kata ve HDBSCAN için 175 kata varan hız anlamına geliyor.

Kabaca bir hesapla, scikit-learn'de çalıştırılması beş dakika sürebilecek bir algoritma teorik olarak altı saniyeye kadar düşebilir. Bu büyük bir fark. Aşağıda kıyaslamalara bakarken buna biraz daha değineceğim.

Sıfır kod değişikliği

Tüm bunlar karmaşık geliyorsa endişelenmeyin. RAPIDS AI, scikit-learn API kodunda sıfır kod değişikliği gerektirmeye odaklanmıştır. Gerçekten de, yalnızca uzantıyı şu şekilde yüklemeniz yeterli:

%load_ext cuml.accel​
$ python -m cuml.accel script.pyAltyapı:

Bu, alışık olduğunuz iş akışında çok büyük bir değişiklik değil; zaten amaç da bu. Bazen, çekirdeği yeniden başlatıp uzantıyı yeniden yüklemeniz gerekebilir.

Bu sıfır-kod-değişikliği iddiası, ilk bakışta gerçekten heyecan verici. Buradaki fikir, hâlihazırda oluşturduğunuz scikit-learn betiklerini değiştirmenize gerek olmaması—ilk seferde de, sonrasında da. cuML, uyumlu bileşenleri NVIDIA GPU'larda otomatik olarak hızlandırır; ancak kodunuzda NVIDIA GPU'larıyla uyumlu olmayan bir şey olursa betiğiniz 'normal' CPU yürütmeye geri döner. Siz kodlayıcı olarak yalnızca sonucu görürsünüz; hata yönetimi veya başka bir şeyle uğraşmanız gerekmez.

Tüm bunları söyledikten sonra, yine de ayarlama gerektiren uç durumlar beklerdim. Kodlamada işler ters gidebilir ve hiçbir şey göründüğü kadar kolay değildir. Başvuru dokümantasyonu, 'kod değişikliği yok' iddiasıyla kısmen çelişen ya da en azından bir miktar sürtünme ekleyen bazı noktaları içeriyor. Listeleri NumPy dizilerine veya Pandas DataFrame'lerine dönüştürmeniz gerekiyor ve metin etiketleri desteklenmiyor; dolayısıyla kullanıcıların kategorik etiketleri önceden kodlaması lazım. Bunları zaten yapıyor olabilirsiniz; ancak mesele şu ki, uzantıyı yüklemenin ötesinde alışmanız gereken başka şeyler de olabilir.

Önemli bir hız artışı

mtcars veri setinde basit bir doğrusal regresyon çalıştırarak temel istatistik pratiği yapıyorsanız, doğrunun eğimini ve kesişimini biraz daha hızlı bulmak için GPU hızlandırması kullanmanın pek anlamı olmayabilir. Saniyenin kesirlerini kurtarmak, gerçekten, uzantıyı yüklemeye değmez. Ancak daha karmaşık bir algoritma çalıştırıyorsanız, iki ana nedenle tasarruf edilen süre önemlidir.

İlk olarak, pek çok iş akışı için kazandığınız zaman anlamlıdır. 50 kata kadar hız artışının, varsayımsal olarak, beş dakikalık bir eğitimi altı saniyeye indirmek anlamına geldiğini söylemiştim. Bu, neredeyse beş dakikalık bir kazançtır. Ancak bir makine öğrenimi mühendisinin iş akışını düşünün; modeli doğru ayarlamak için birkaç kez çalıştırması gerekebilir. Her çalıştırmada zaman kazanmak, veri bilimcisinin toplam üretkenliği hakkında konuşmak demektir.

İkinci olarak, ve bununla bağlantılı biçimde, bilim insanı veya mühendis artık daha karmaşık modellere yönelebilir. Önceki örnekte, aynı doğruluk düzeyini veren bir model için zaman hızını varsayıyoruz. Peki ya daha karmaşık bir modelle aslında daha yüksek doğruluğa ulaşacağınızı düşünürseniz? Farklı model parametreleri için bir ızgara araması (grid search) yapıp bir model eğittiğinizi hayal edin. (Aşağıda kendi mini örneğimi deneyeceğim.) Kombinasyonlar üstel olarak artar ve bu da CPU'da hesaplama maliyetini engelleyici hale getirir. Ancak 50 kata varan bir hız artışınız varsa bu o kadar da sorun olmaz.

Bu faydalar birlikte düşünülmelidir. Projenizi doğru kurarsanız, hem daha hızlı üretilen hem de daha doğru bir modele sahip olabilir ya da bir makine öğrenimi mühendisi gözüyle, aşırı eğitim süreleri olmadan daha sofistike bir model mimarisine sahip olabilirsiniz.

Sayısal olarak eşdeğer sonuçlar

NVIDIA, GPU'ların sayısal olarak eşdeğer sonuçlar verdiğinden özellikle bahsediyor. Bu iyi bir haber; çünkü faydaların model doğruluğu açısından bir bedeli olmadığı anlamına gelir.

Ama bu da aklıma şunu getirdi: Neden sonuçlar birebir aynı değil de sayısal olarak eşdeğer? Muhtemelen paralel işlem sonucunda çıktıdaki küçük farklılıklar ya da belirli bir yöntemin sayısal kararlılığında bazı farklılıklar vardır. Belki UMAP özelinde, UMAP projeksiyonu biraz farklıdır. Bunu, CPU ve GPU koşumları arasında çıktıda küçük farklılıklar görürseniz diye gündeme getiriyorum. NVIDIA, bir miktar fark görmeyi beklemeniz gerektiğini ve bunun normal olduğunu ima ediyor.

Tüm bunlara rağmen, kendinizi zorlayıp modeli GPU'larda çalıştırırsanız—model CPU'larda pratikte çalışmayacak kadar karmaşıksa—bu modelin çıktısını bir CPU eşdeğeriyle karşılaştırmak zorlaşacaktır.

cuML Desteklenen Algoritmalar ve Kütüphaneler

Daha önce, bu cuML 25.02 sürümünde artık scikit-learn, UMAP ve HDBSCAN için destek olduğunu belirtmiştim. Ancak scikit-learn'e aşinaysanız, scikit-learn'de pek çok farklı algoritma olduğunu bilirsiniz. Şu anda RAPIDS AI bazı kütüphaneleri destekliyor, ancak hepsini değil. Ekibe göre başlıca öne çıkanlar şunlar: 

• rastgele orman
• en yakın k komşu (k-Nearest Neighbors) 
• Temel bileşen analizi
• k-means kümeleme

Bu listede, tüm veri noktaları arasındaki mesafelerin hesaplanması gerektiği için hesaplama açısından oldukça yoğun olduğu bilinen k-Nearest Neighbors'ta hız artışı en çok beni heyecanlandırırdı. 

Aşağıdaki tablo, çoğunlukla ya da tamamen cuML ile çalışan kestirimcileri (estimator) gösterir.

cuML Kaputun Altında Nasıl Çalışıyor

Tüm bunların nasıl çalıştığını merak ediyor olabilirsiniz. Yüksek seviyeden bakıldığında, modern kütüphanelerin giderek daha fazla biçimde, CPU ya da GPU olsun, mevcut en iyi donanımı otomatik olarak algılayıp kullandığını bilin. Şimdi görüyoruz ki, scikit-learn'de bir fonksiyon çağrıldığında (cuml.accel etkinleştirildiğinde), yazılım uyumlu bir GPU olup olmadığını kontrol ediyor ve varsa yürütmeyi GPU hızlandırmalı sürüme yönlendiriyor. 

RAPIDS AI, cuml.accel'in sklearn gibi davranmasını sağlayan bu mekanizmadan bir uyumluluk katmanı olarak bahsediyor. Bu durumda, cuML'in uyumluluk katmanı scikit-learn kodunun NVIDIA GPU'larda değişiklik yapılmadan çalışmasına izin verir. Tak-çıkar bir yedek olarak tasarlanmıştır, bir vekil gibi davranır, scikit-learn'e yapılan fonksiyon çağrılarını yakalar ve cuML'e yönlendirir. 

NVIDIA'nın RAPIDS AI ekibi, burada da paylaştığım faydalı bir görsel sunuyor:

cuML scikit-learn iş akışı diyagramı. Kaynak: NVIDIA

GPU Hızlandırma için cuML Nasıl Kullanılır

cuML, Google Colab'de zaten önceden yüklüdür; ancak bir Jupyter not defteri kullanıyorsanız, scikit-learn'i içe aktarmadan önce şu komutla etkinleştirin:

%load_ext cuml.accel
import sklearnAltyapı:

Artık sklearn kullanan Python kodumuz tanıdık görünecek; amaç da bu zaten. İşte bir OLS regresyonu örneği.

# Import necessary libraries
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression

# Generate synthetic regression data
X, y = make_regression(n_samples=500000, n_features=50, noise=0.1, random_state=0)

# Split into training and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

# Create and train an OLS regression model
ols = LinearRegression()
ols.fit(X_train, y_train)Altyapı:

CPU yerine hangi kısımların GPU'da çalıştığını görmek istersem logger kullanabilirim.

%load_ext cuml.accel

from cuml.common import logger;
logger.set_level(logger.level_enum.debug)Altyapı:

cuML: Installed accelerator for sklearn.
cuML: Successfully initialized accelerator.
cuML: Performing fit in GPUAltyapı:

Fikir bu. Şimdi daha ikna edici bir örnek deneyelim. Doğrusal regresyon, normal denklem ya da QR ayrışımı bazı sıralı işlemler içerdiği için zaten özellikle paralelleştirilebilir değildir.

OLS regresyonunun daha karmaşık bir uzantısı ridge regresyonudur. Python'da ridge regresyonu kullanırken, Ridge() çağrısı varsayılan hiperparametreleri uygular; bu da optimal olmayabilir. alpha değeri uygulanan düzenlileştirme miktarını kontrol eder. Çok küçükse model aşırı uyarlar; çok büyükse eksik uyarlar.

%load_ext cuml.accel
import sklearn

from sklearn.linear_model import Ridge
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

# Generate synthetic data
X, y = make_regression(n_samples=100000, n_features=50, noise=0.1, random_state=0)

# Split into training and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

# Train a Ridge Regression model with default settings
ridge_default = Ridge()
ridge_default.fit(X_train, y_train)

# Make predictions and evaluate
y_pred_default = ridge_default.predict(X_test)
mse_default = mean_squared_error(y_test, y_pred_default)
Altyapı:

Yukarıdaki kod tek bir modeli, tek bir alpha değeri ve çözücüyle eğitiyor. (Varsayılan olarak 'auto' olduğunu düşünüyorum.) Bu nedenle, çalışsa da düzenlileştirme gücünü veya çözücü seçimini optimize etmiyor.

Varsayılanlara güvenmek yerine başka bir şey deneyebiliriz. Bir hiperparametre ızgarası oluşturup birden çok kombinasyonu test ederek en iyisini seçebiliriz. 

from sklearn.model_selection import GridSearchCV

# Define Ridge Regression model
ridge = Ridge()

# Define a grid of hyperparameters to search
param_grid = {
    'alpha': [0.01, 0.1, 1.0, 10.0, 100.0],  # Different regularization strengths
    'solver': ['auto', 'svd', 'cholesky', 'lsqr', 'saga']  # Test multiple solvers
}

# Perform Grid Search with cross-validation
grid_search = GridSearchCV(ridge, param_grid, scoring='neg_mean_squared_error', cv=2, n_jobs=-1)
grid_search.fit(X_train, y_train)

# Get the best model from the search
best_ridge = grid_search.best_estimator_

# Make predictions and evaluate
y_pred_best = best_ridge.predict(X_test)
mse_best = mean_squared_error(y_test, y_pred_best)
Altyapı:

Buradaki ızgara araması hiperparametrelerin tüm olası kombinasyonlarını test eder. 5 alpha değeri ([0.01, 0.1, 1.0, 10.0, 100.0]), 5 çözücü seçeneği (['auto', 'svd', 'cholesky', 'lsqr', 'saga']) tanımlayıp 2 katlı çapraz doğrulama kullanırsak, gereken toplam model eğitimi sayısı 5x5x2, yani 50 olur. Bu, tek bir model eğitmek yerine 50 model eğitmek demektir. Çok daha karmaşıktır; bu nedenle GPU'lar çok daha hızlı oldukları için harika bir seçim olacaktır. sklearn'de (50 kata kadar) hız artışı olduğundan, bu 50 modeli eğitmek tek bir modeli eğitmekle aynı süreye denk gelebilir. (Bu noktayı göstermek için sayıları kasıtlı olarak seçtim. Tüm modellerin aynı hız artışını sağlamayacağını biliyorum.)

cuML sklearn Kıyaslamaları

NVIDIA, Intel CPU'larda çalışan scikit-learn algoritmalarının performansını, kendi NVIDIA GPU'larında çalışanlarla karşılaştırdı. Sınıflandırma ve regresyon dahil farklı makine öğrenimi iş yüklerine bakıldı.

Sonuç şu: Rastgele orman gibi basit modeller CPU'larda dakikalar süren eğitimden GPU'larda saniyelere indiler; kümeleme gibi daha karmaşık modeller ise saatlerden dakikalara düştü. Her durumda iş akışları daha hızlıydı; ancak yüksek boyutlu verilerle hesaplama açısından ağır modellerde faydalar daha da netti. Burası GPU'ların parladığı yer; çünkü paralel işlem kullanırlar ve bu, yoğun matris işlemleri, mesafe hesapları veya yinelemeli yapılan optimizasyon gerektiren modellerde büyük fark yaratır.

GPU üzerinde cuML scikit-learn vs CPU üzerinde scikit-learn. Kaynak: NVIDIA

Önceki kod örneğinde doğrusal regresyondan uzaklaşmıştım; gücü göstermek için başka bir şey denemem gerektiğini düşündüm. Ama burada doğrusal regresyon için 52 kat hızlanma görüyorum. Bunun büyük bir çarpan olması nedeniyle şaşırdığımı itiraf ediyorum. Bu, NVIDIA'nın aynı zamanda başka gelişmiş şeyler de yaptığını—örneğin GPU'nun boşta kalmaması için farklı adımların birbirine iç içe geçirilmesini sağladığını—hatırlatıyor.

Bazı En İyi Uygulamalar

cuML sürüm 25.02 sayesinde, GPU'larla bir scikit-learn algoritması çalıştırmak artık çok da zor değil. Daha önce gösterdiğim gibi uzantıyı yüklemeniz yeterli. Ancak iş akışına daha derinden dahil olup GPU hızlandırmasından en iyi şekilde yararlanmak istiyorsanız, oldukça spesifik şeyleri göz önünde bulundurmak isteyeceksiniz.

NVIDIA, işlem hattınızın bir parçası olarak CPU'lar ve GPU'lar arasındaki veri transferlerini en aza indirmenizi önerir. Başka bir deyişle, ön işleme, eğitim ve çıkarım adımlarını, sonuçları ana belleğe geri göndermeden önce GPU'larda yapın. Adımları CPU'da ön işleme, GPU'da çıkarım gibi karıştırmayın. 

Ayrıca verimliliği en üst düzeye çıkarmak için NVIDIA tarafından geliştirilen GPU hızlandırmalı kütüphaneler koleksiyonu olan CUDA-X'i düşünmelisiniz. Örneğin rastgele ormanlarda, scikit-learn'ünkisi yerine cuML'in orman çıkarım kütüphanesini kullanabilirsiniz.

Bilinen Sınırlamalar

RAPIDS AI ekibinin yaptığı iş karmaşık; dolayısıyla bazı sorunlar olacaktır. Neyse ki bilinen sınırlamalara ilişkin dokümantasyon iyi tutuluyor. Burada sınırlamaların tümünü ya da bir kısmını tek tek paylaşmak istemiyorum; çünkü çoğu konu belirli algoritmaların ayrıntılarında kalıyor. Ayrıca güncellemeler ve yamalar hızlı ilerliyor. Bunun yerine, göz önünde bulundurmanız gereken daha genel kategorileri vereceğim.

1. Genel sınırlamalar

Yalnızca belirli algoritmalar için değil, cuML genelinde geçerli bazı kısıtlamalar var. Örnek olarak veri girişi biçimleriyle ilgili kısıtlar (Python listeleri ile bazı sorunlar), sürüm uyumluluğu ve bellek yönetimi sayılabilir.

2. Algoritmaya özgü sınırlamalar

Tek tek makine öğrenimi algoritmaları için bazı özgün kısıtlar bulunur. Bu farklar, modellerin nasıl eğitildiğini, parametrelerin nasıl davrandığını veya sonuçların nasıl hesaplandığını etkileyebilir. Örneğin cuML'deki rastgele orman algoritması, bölme eşiklerini seçmek için farklı bir yöntem kullanır; bu da biraz farklı ağaç yapılarına yol açabilir.

3. Desteklenen ve desteklenmeyen özellikler

Desteklenen parametreler, çözücüler ve başlangıç yöntemleri açısından bazı farklılıklar vardır. Örneğin PCA, "full" ve "auto" SVD çözücülerini destekler; ancak "randomized" desteklenmez. KNN, Minkowski metriklerini destekler; ancak Mahalanobis'i desteklemez.

4. Tekrarlanabilirlik ve sayısal farklılıklar

Paralellik veya çözücü farkları nedeniyle sonuçların zaman zaman biraz farklı olabileceği durumlar vardır. Bunu daha önce de belirtmiştim. Örneğin UMAP gömümeleri birebir aynı olmayabilir; ancak güvenilirlik puanı yine de yüksek olmalıdır. Başka durumlarda, PCA bileşen işaretleri ters dönebilir; bu da normalizasyon gerektirebilir. Yine de bu konu özelinde, belirli bir algoritmayı çalıştırırken en güncel dokümantasyona başvurmalısınız.

Sonuç

En yaygın Python makine öğrenimi kütüphanelerindeki iyi bilinen algoritmalar için son derece kolay kullanımlı GPU hızlandırması ihtimali beni heyecanlandırıyor. Bu, model doğruluğunda büyük bir fark yaratacak ve üstelik kullanışlı ve uygulaması zor değil. 

Makine öğrenimindeki en son gelişmelerden haberdar olun. Doğru tekniklere aşina olmak için Python ile Makine Öğrenimi Bilimcisi kariyer yolumuzu alın. Bunu, en son gelişmelerden en iyi şekilde yararlanabilmek için yapın. Ayrıca DataFramed podcast'imize abone olun. Hatta şu bölümü dinleyin: Jean-Francois Puget, NVIDIA'da Distinguished Engineer & Chris Deotte, NVIDIA'da Kıdemli Veri Bilimcisi; diğer konuların yanı sıra GPU hızlandırmanın etkisini tartışıyorlar.

• cuML dokümanları
• cuML GitHub