Stacking genelizasyonu, makine öğrenimi (ML) mühendisleri arasında yaygın olarak kullanılan bir tekniktir; burada birden fazla model bir araya getirilerek genel tahmin performansı artırılmaktadır. Diğer yandan, hiperparametre optimizasyonu (HPO), belirli bir ML algoritmasının performansını maksimize etmek için en iyi hiperparametre setini sistematik bir şekilde aramayı içerir.
Stacking ve HPO’yu birlikte kullanmanın yaygın bir sorunu, önemli ölçüde hesaplama kaynakları gerektirmesidir. Bu yöntemler genellikle birden fazla modeli eğitmeyi ve her biri için sayısız hiperparametre kombinasyonu denemeyi gerektirir. Özellikle büyük veri kümesi kullanıldığında, bu süreç hızla zaman alıcı ve kaynak tüketici haline gelebilir.
Bu yazıda, stacking genelizasyonunu HPO ile birleştiren bu süreci nasıl daha verimli hale getirebileceğimizi göstereceğiz. Bu iş akışını yalnızca 15 dakikada, cuML kütüphanesi ile GPU hızlandırması kullanarak uygulayacağız. cuML’in sıfır kod değişikliği ile scikit-learn entegrasyonu sayesinde, mevcut ML iş akışınızı saat gibi çalışan bir hız artışı ile GPU hızlandırması kullanarak gerçekleştirebilirsiniz. CPU tabanlı bir yürütme ile genellikle her seferinde yalnızca bir denemenin çalıştırıldığı bir durumda, GPU hızlandırması çoklu HPO denemelerinin paralel olarak yürütülmesine olanak tanır ve bu da eğitim süresini önemli ölçüde kısaltır.
Öncelikle kullandığımız stacking yaklaşımını, uygulamasını ve elde edilen doğruluk artışını tartışacağız. Ardından, HPO’nun nasıl genel doğruluğu artıracağını ele alacağız.
Stacking Genelizasyonu
Stacking genelizasyonu, deneylerde ve birçok Kaggle yarışmasında yaygın olarak kullanılan köklü bir tekniktir. Etkili bir topluluk yöntemi olmasına karşın, genellikle uygulamalarda az kullanılmaktadır çünkü hesaplama maliyeti yüksektir.
Şekil 1, uyguladığımız stacking mimarisini göstermektedir. Temel düzeyde, üç farklı model kullandık: Random Forest, K-En Yakın Komşu (KNN) ve Lojistik Regresyon. Bu temel modellerin tahminleri, nihai sınıflandırmayı yapan bir KNN metamodeline iletildi.
Deneylerimizde, 9 özellikten oluşan ve kaynak veri setinden türetilmiş 1 milyon örnek içeren bir sınıflandırma veri seti kullandık. Bu yapı, her bir temel modelin güçlerinden yararlanarak stacking yoluyla genel tahmin doğruluğunu artırmamıza olanak sağladı.
Mevcut scikit-learn iş akışınızda GPU hızlandırmasını etkinleştirmek için, tek yapmanız gereken cuML kütüphanesini kurmak.
Kurulumdan sonra aşağıdaki komutu ekleyerek GPU hızlandırmasını arka planda etkinleştirebilirsiniz:
%load_ext cuml.accel
Bu komut, model oluşturma, eğitim veya değerlendirme kodunuza herhangi bir değişiklik yapmadan GPU hızlandırmasını etkinleştirir. Tanıdık scikit-learn sözdizimini kullanmaya devam edebilir, ancak cuML kütüphanesi ile hızlı bir yürütme elde edebilirsiniz. Aşağıdaki kod parçacığı, temel modeller olarak Random Forest, KNN ve Lojistik Regresyon kullanarak stacking boru hattımızı nasıl kurduğumuzu göstermektedir. Kendi denemelerinizi yapmak için eşlik eden Jupyter Not Defterine göz atabilirsiniz.
%load_ext cuml.accel
# cuML kütüphanelerini yükle
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.neighbors import KNeighborsClassifier
# Temel modellerin tanımı (seviye-0 modelleri)
base_models = [
("lojistik_regresyon", LogisticRegression(**lr_study.best_params, max_iter = 20000, tol=1e-3)),
("rastgele_orman", RandomForestClassifier(**rf_study.best_params, random_state = 42)),
("k_yakın_komşu", KNeighborsClassifier(**knn_study.best_params))
]
# Stacking için meta özellikler oluşturma fonksiyonu
def generate_meta_features_for_stacking(base_models, X, y, X_meta):
kfold = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
meta_features = cp.zeros((X_meta.shape[0], len(base_models)))
for i, (name, model) in enumerate(base_models):
# Eğitim verisi için yalnızca dışarıdan fold tahminlerini tutacak dizi
meta_predictions = cp.zeros((X.shape[0],))
print("Model ismi: ", name)
# Dışarıdan fold tahminleri (X_meta == X ise yalnızca kullanılır)
for train_idx, val_idx in kfold.split(X, y):
model.fit(cp.array(X.iloc[train_idx]), cp.array(y.iloc[train_idx]))
predictions = model.predict(cp.array(X.iloc[val_idx]))
meta_predictions[val_idx] = predictions.ravel()
# Nihai X_meta tahmini için ve tüm eğitim verisi üzerinde model alma
model.fit(cp.array(X), cp.array(y))
# Test verisi için meta özelliklerin tahmini
predictions = model.predict(cp.array(X_meta))
meta_features[:, i] = cp.array(predictions).ravel()
return meta_features
# meta_train dışarıdan fold tahminleri kullanarak sızıntıyı önlüyor
meta_train = generate_meta_features_for_stacking(base_models, X_train_scaled, y_train_df, X_train_scaled)
# meta_valid, tam eğitim seti üzerinde eğitilmiş temel modellerin tahminlerini kullanıyor
meta_valid = generate_meta_features_for_stacking(base_models, X_train_scaled, y_train_df, X_valid_scaled)
Şekil 2’de gösterildiği gibi, stacking genelizasyonu ile tahmin doğruluğunda %0.28’lik bir artış sağlandı; bu artış, 5 katmanlı stratifiye çapraz doğrulama kullanılarak ölçüldü.
Hiperparametre Optimizasyonu
Stacking ansamblesinin performansını daha da artırmak için, temel modellere ve meta modele HPO uyguladık. Uygulamada, en iyi performansı gösteren temel modeli, dışarıdan fold tahminleri üretmek için kullandık, bu tahminler de yeni bir meta veri kümesi oluşturmak için birleştirildi. Bu meta veri kümesi, KNN metamodelinin HPO’sunu gerçekleştirmek için kullanıldı ve performansını daha da geliştirdi.
HPO için Optuna kütüphanesini kullandık ve dönüşüm doğruluğunu bir metrik olarak optimize ettik. Tüm HPO sürecinin GPU hızlandırmalı olduğunu belirtmek önemlidir; çünki cuML çekirdek komutunu %load_ext cuml.accel ile etkinleştirdik. Bu nedenle, sözdizimi scikit-learn ile aynı kalır.
Aşağıdaki kod parçacığı, Lojistik Regresyon için HPO’nun nasıl uygulandığını göstermektedir. Aynı yaklaşım Rastgele Orman, KNN ve KNN meta modeli için de geçerlidir. Tam uygulamayı keşfetmek için eşlik eden Jupyter Not Defterine göz atabilirsiniz:
%load_ext cuml.accel
# cuML kütüphanelerini yükle
from sklearn.linear_model import LogisticRegression
# Modeli eğitim ve değerlendirme fonksiyonu tanımlama
def train_and_eval(C=1, penalty='l2'):
lr = LogisticRegression(C = C, penalty = penalty, max_iter = 20000, tol=1e-3)
lr.fit(X_train_scaled, y_train_df)
y_proba = lr.predict_proba(X_valid_scaled)[:, 1]
# Doğruluk skorunu hesapla
score = cp.round(lr.score(cp.asnumpy(X_valid_scaled), cp.asnumpy(y_valid_df)) * 100, 2)
return score
# Hiperparametre ayarlama için Optuna hedef fonksiyonunu tanımlama
def objective(trial):
C = trial.suggest_float("C", 1e-2, 1e2, log = True)
penalty = trial.suggest_categorical("penalty", ["l1", "l2"])
return train_and_eval(C, penalty)
# Doğruluk skoru maksimize etmek için bir Optuna çalışması oluştur
lr_study = optuna.create_study(
direction="maximize",
study_name="optuna_logistic_acc_score",
sampler=optuna.samplers.RandomSampler(seed=142),
)
# Tanımlanan hedef ile hiperparametre optimizasyonunu başlat
lr_study.optimize(objective, n_trials=40)
# En iyi hiperparametre kümesini ve karşılık gelen değerlendirme skorunu yazdır
print(f"En iyi parametreler: {lr_study.best_params}")
print(f"En iyi doğruluk skoru: {lr_study.best_value}")
Şekil 3’te gösterildiği gibi, temel modeller ve meta model için HPO uygulamak, HPO uygulanmamış modele göre tahmin doğruluğunda %1.44’lük bir iyileşme sağladı.
cuML ile GPU Hızlandırmasının Avantajları
Dört farklı model için HPO sırasında, GPU hızlandırmalı cuML kütüphanesini kullanmak, yürütme hızını artırmak için çok faydalıdır. Bu sayede, bir CPU tabanlı yürütmenin sadece bir iterasyonda tamamlayabileceği işlemleri, çoklu iterasyonları aynı zaman diliminde tamamlayabiliriz.
Bizim senaryomuzda, her model için yaklaşık 40 iterasyon gerçekleştirdik ve her biri yaklaşık 5 saniye sürdü; oysa genellikle bir model için tek bir iterasyon yaklaşık 5 dakika sürmektedir. Üstelik, GPU hızlandırmasını etkinleştirmek oldukça basittir; kodunuza sadece %load_ext cuml.accel komutunu ekleyerek, scikit-learn ile sorunsuz entegrasyon sağlayabilirsiniz.
Başlamak
Bir sistemin doğruluğu, stacking genelizasyonunu HPO ile entegrasyona eklenerek artırılabilir. Önerdiğimiz çözümde, GPU hızlandırmalı cuML kütüphanesi kullanılarak, stacking genelizasyonu yığınında her model için derin HPO gerçekleştirilebilir. CuML kütüphanesinin scikit-learn sözdizimi ile uyumlu olması, geliştiricilerin bu tekniği üretim ortamlarına sorunsuz bir şekilde entegre etmelerini sağlar. Bu entegrasyon yalnızca üst düzey modeller geliştirmeyi kolaylaştırmakla kalmaz, aynı zamanda yineleme sürecini hızlandırır; böylece veri bilimcileri ve geliştiriciler, gerçek dünya uygulamalarında daha hızlı yürütme ve geliştirilmiş model performansı elde edebilirler.
Bu yaklaşımı kendi uygulamalarınızda denemek için en son NVIDIA cuML sürümünü indirin. Geri bildirimlerinizi her zaman Slack üzerinde #RAPIDS-GoAi kanalında paylaşabilirsiniz.
Sıfır kod değişikliği cuML ile ilgili daha fazla bilgi edinmek için, GPU hızlandırması için NVIDIA cuML’in sıfır kod değişikliği sunmasıyla ilgili yazıyı okuyabilirsiniz. Bu yetenek ile ilgili daha fazla örnek görmek için Google Colab not defterine göz atabilirsiniz. Sıfır kod değişikliği yetenekleri ile birlikte en son cuML sürümü, Google Colab’da önceden yüklenmiş olarak gelir. Sürekli ve eğitmen destekli kurslar için DLI Veri Bilimi Öğrenme Yolu‘na göz atabilirsiniz.
