Makine Öğrenimi Deneyleri: Weights & Biases’e Giriş

Ölçmediğinizi Analiz Edemezsiniz

Hiç bir makine öğrenimi projesine geri dönüp belirli kararları neden verdiğinizi ya da kodun aslında ne yaptığını merak ettiniz mi? Örneğin, neden bu özellik alt kümesini seçtiniz, son modeli verinin hangi sürümünde eğittiniz ya da farklı model hiperparametre kümeleri performansı nasıl etkiledi? Görünen o ki, makine öğrenimi projelerinize deney yapma için en iyi uygulamaları dahil etmeniz gerekiyor!

Makine öğrenimi deneyi, belirli bir metrik veya metrikler açısından (ör. F1 skoru, RMSE vb.) istenen performansa ulaşan modeli belirlemek için bir makine öğrenimi hattını tasarlama, oluşturma, kaydetme ve değerlendirme sürecidir. Bu, hem dağıtımdan önce hem de yeniden eğitim kapsamında makine öğrenimi modelleri geliştirirken kritik bir adımdır. Diğer tüm deneyler gibi şu şekilde tasarlanmalıdır:

• Tekrarlanabilir olmak
• Önyargıyı en aza indirmek
• Gerekli tüm dosya ve yapıtları izlemek

Bu hedefleri akılda tutarak bir modelin hiperparametreleri veya bir veri kümesinin sürümü gibi ihtiyaç duyduğunuz bilgilere kolayca ulaşabilir ve model performansı ile kaynak kodu gibi bilgileri paylaşabilirsiniz.

Neyse ki burada Weights & Biases devreye giriyor! 

Weights & Biases ile Bir Makine Öğrenimi Hattı Oluşturma

Weights & Biases, makine öğrenimi mühendislerinin deneyler çalıştırması, yapıtları kaydetmesi, hiperparametre ayarlamasını otomatikleştirmesi ve performansı değerlendirmesi için bir platform ve Python kitaplığıdır. Bu eğitim, temel öğeleri kaydedip ardından bir panoda inceleyeceğimiz bir makine öğrenimi hattını göstererek çekirdek işlevselliği tanıtacak!

Kurulum ve oturum açma

# Install Python library
!pip install wandbAltyapı:

Oturum açmak için bir hesap oluşturmanız gerekir.

Hesabı oluşturduktan sonra, oturum açmak için kullanabileceğiniz bir API anahtarına erişmek üzere yetkilendirme sayfasını ziyaret edin. Bunu bir yere not edin ancak başkalarıyla paylaşmayın!

Oturum açmak için ya yeni bir Terminal açıp wandb login yazın ya da not defterinize yeni bir hücre ekleyip !wandb login komutunu çalıştırın.

Başarıyla oturum açmak için sizden API anahtarınızı girmeniz istenecek; bunu kopyalayıp yapıştırabilirsiniz. Kimlik bilgileriniz bundan sonra yerel olarak ~/.netrc içinde saklanacaktır.

wandb loginAltyapı:

Bir deney oluşturma

Weights & Biases, Experiments, Artifacts, Sweeps ve Models gibi çeşitli bileşenlere sahiptir. İş akışının özüne, yani deney oluşturup çalıştırmaya bakarak başlayalım.

# Import required modules
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
import wandb
from sklearn.model_selection import train_test_split, GridSearchCV, KFold
from sklearn.linear_model import LinearRegression, Ridge
from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import mean_squared_error, r2_scoreAltyapı:

Weights & Biases’ta bir Deney, proje olarak da bilinir. Yeni bir proje oluşturmak için wand.init() fonksiyonunu çağırır, proje adımızı project anahtar argümanına bir string olarak geçiririz. Bunu run adlı bir değişkene atayabilir, böylece önemli dosyaları, modelleri ve metrikleri bu run’a kaydedebiliriz.

İsteğe bağlı olarak, EDA, özellik mühendisliği veya hiperparametre ayarlaması gibi farklı adımları kolayca ayırt etmek için job_type anahtar argümanına da bir string verebilirsiniz. Ayrıca çalıştırdığınız kodu save_code değerini True yaparak kaydedebilirsiniz.

# Initialize a run
run = wandb.init(project="predicting_london_temperature",
                 job_type="Baseline modeling",
                 save_code=True)Altyapı:

Bir yapıt (artifact) kaydetme

Veri kümeleri, değişkenler veya dosyalar gibi tüm önemli bilgileri bir Yapıt olarak kaydedebilirsiniz. Bunu yapmak için önce wandb.Artifact() çağırarak ad ve tür sağlayıp bir değişken oluşturun. Ardından wandb.log_artifact() fonksiyonu ile bunu kaydedin. Özgün veri kümesini kaydederek başlayalım.

original_data = "london_weather.csv"
# Create an Artifact
data_artifact = wandb.Artifact(name="original_dataset", 
                               type="data",
                               description="London weather dataset")
# Add the file to the Artifact
data_artifact.add_file(original_data)
# Log the Artifact as part of the run
run.log_artifact(data_artifact)Altyapı:

Keşifsel veri analizi

Keşifsel Veri Analizi (EDA), verinin gereken veri tiplerine uyduğundan, eksik değerler ve aykırı değerlerden arınmış olduğundan emin olmanıza yardımcı olan makine öğrenimi iş akışında kritik bir adımdır. Ayrıca dağılımları ve özellikler arasındaki ilişkileri inceleme fırsatı sunar.

Weights & Biases kullanmanın ek bir faydası, önişleme yaparken veriyi ve üretilen tüm görselleştirmeleri kaydedebilmemizdir.

# Read in the data
london = pd.read_csv(original_data)

# Previewing the first five rows
london.head()Altyapı:

# Visualize distributions
plt.figure(figsize=(12,8))
london.hist()
plt.tight_layout()
plt.show()Altyapı:

# View data types and non-null counts
london.info()


<class 'pandas.core.frame.DataFrame'>
RangeIndex: 15341 entries, 0 to 15340
Data columns (total 10 columns):
 #   Column            Non-Null Count  Dtype  
---  ------            --------------  -----  
 0   date              15341 non-null  int64  
 1   cloud_cover       15322 non-null  float64
 2   sunshine          15341 non-null  float64
 3   global_radiation  15322 non-null  float64
 4   max_temp          15335 non-null  float64
 5   mean_temp         15305 non-null  float64
 6   min_temp          15339 non-null  float64
 7   precipitation     15335 non-null  float64
 8   pressure          15337 non-null  float64
 9   snow_depth        13900 non-null  float64
dtypes: float64(9), int64(1)
memory usage: 1.2 MB


# Convert date to datetime
london["date"] = pd.to_datetime(london["date"], format="%Y%m%d")

# Add a month column
london["month"] = london["date"].dt.month

# Drop missing values
london.dropna(inplace=True)Altyapı:

Artık veri temizlendi, bunu wand.Artifact() kullanarak bir Yapıt olarak kaydedebilirsiniz.

# Save and log the new version of the data
london.to_csv("london_weather_preprocessed.csv", index=False)
preprocessed_data = "london_weather_preprocessed.csv"
# Create an Artifact
preprocessed_data_artifact = wandb.Artifact(name="london_weather_preprocessed", 
                               type="data",
                               description="London weather dataset - preprocessed")
# Add the file to the Artifact
preprocessed_data_artifact.add_file(preprocessed_data)
# Log the Artifact as part of the run
run.log_artifact(preprocessed_data_artifact)


<wandb.sdk.artifacts.local_artifact.Artifact at 0x15bfe6710>Altyapı:

Özellik seçimi

İş akışındaki bir sonraki adım, çoklu bağlantıdan kaçınırken modelleme için potansiyel özellikleri belirlemektir. Bunu yapmak için önce bir korelasyon ısı haritası üretebilir, ardından "mean_temperature" tahmininde özellik önemini nicelleştirmek için Ridge Regresyonu kullanabilirsiniz.

# Correlation heatmap
sns.heatmap(london.corr(), annot=True, center=True)
plt.show()Altyapı:

Bu grafiği wandb.Image() kullanarak kaydedebilirsiniz!

# Log the heatmap
wandb.log({"correlation_heatmap": wandb.Image(plt)})


# Split the data
X = london.drop(columns=["mean_temp", "min_temp", "max_temp", "date"])
y = london["mean_temp"]
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.2)

# Build a Ridge regression model
ridge = Ridge(alpha=0.1)
ridge.fit(X_train, y_train)
y_pred = ridge.predict(X_test)

# Visualize feature importance using the coefficients
fig = plt.figure()
sns.barplot(x=X_train.columns, y=ridge.coef_)
plt.xticks(rotation=30)
plt.tight_layout()
plt.savefig("feature_selection.png")
plt.show()Altyapı:

Hadi modeli ve özellik önem grafiğini pickle.dump() ve wandb.log() ile kaydedelim.

import pickle
pickle.dump(ridge, open("feature_selection_model.pkl", "wb"))
feature_selection_model = wandb.Artifact("feature_selection_model", type="model")
feature_selection_model.add_file("feature_selection_model.pkl")
run.log_artifact(feature_selection_model)
wandb.log({"feature_selection_plot": wandb.Image(fig)})


<Figure size 640x480 with 0 Axes>Altyapı:

Eğitim ve kaydetme

Başardınız! Şimdi, Ridge model katsayısı sıfırdan büyük olanları önemli özellikler kabul ederek temel modelinizi eğitme zamanı. Yeni eğitim ve test verilerini de kaydedeceksiniz.

X = london[["cloud_cover", "global_radiation", "precipitation", "month"]]
y = london["mean_temp"]
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.2)

def log_data(X_train, y_train, X_test, y_test):
    # Log the training and test data
    training_features = wandb.Artifact(name="X_train", 
                               type="data",
                               description="Training features")
    X_train.to_csv("X_train.csv", index=False)
    training_features.add_file("X_train.csv")
    run.log_artifact(training_features)

    training_labels = wandb.Artifact(name="y_train", 
                               type="data",
                               description="Training labels")
    y_train.to_csv("y_train.csv", index=False)

    training_labels.add_file("y_train.csv")
    run.log_artifact(training_labels)

    test_features = wandb.Artifact(name="X_test", 
                               type="data",
                               description="Test features")
    X_test.to_csv("X_test.csv", index=False)
    test_features.add_file("X_test.csv")
    run.log_artifact(test_features)

    test_labels = wandb.Artifact(name="y_test", 
                               type="data",
                               description="Test labels")
    y_test.to_csv("y_test.csv", index=False)
    test_labels.add_file("y_test.csv")
    run.log_artifact(test_labels)

log_data(X_train, y_train, X_test, y_test)Altyapı:

Kök Ortalama Kare Hatası (RMSE) ve R-Kare’yi performans metrikleri olarak kullanarak bir Karar Ağacı Regresyon modelini eğitelim ve değerlendirelim.

# Fit and evaluate the model
dt_reg = DecisionTreeRegressor(random_state=42)
dt_reg.fit(X_train, y_train)
y_pred = dt_reg.predict(X_test)
rmse = mean_squared_error(y_test, y_pred, squared=False)
r_squared = r2_score(y_test, y_pred)
print(rmse, r_squared)


3.8627385194713346 0.5399282872125385

# Save and log the model and metrics
pickle.dump(dt_reg, open("baseline_decision_tree.pkl", "wb"))
baseline_model = wandb.Artifact("baseline_decision_tree", type="model")
baseline_model.add_file("baseline_decision_tree.pkl")
run.log_artifact(baseline_model)
wandb.log({"rmse": rmse, "r_squared": r_squared})Altyapı:

Model performansını artık artık artık daha derinlemesine incelemek için modelin artıklarını görselleştirebilirsiniz. Weights & Biases’ın sklearn modülünde bunu üretmek için bir fonksiyonu var!

# Plot training residuals
wandb.log({"baseline_residuals_plot": wandb.sklearn.plot_residuals(dt_reg, X_train, y_train)})Altyapı:

Eğitim ve değerlendirme tamamlandı, şimdi mevcut run’ı bitirelim.

# Finish run
wandb.finish()Altyapı:

Hiperparametre ayarlama

Artık ilişkili performans metrikleriyle birlikte bir temel model oluşturdunuz ve kaydettiniz; şimdi Weights & Biases ve scikit-learn kullanarak nasıl hiperparametre ayarlaması yapabileceğinize ve modellerinizi nasıl sürümlendirebileceğinize bakalım.

RMSE’ye göre, bir hiperparametre uzayında en iyi performans gösteren modeli aramak için GridSearchCV kullanacağız.

# Initialize a new run
run_v2 = wandb.init(project="predicting_london_temperature",
                 job_type="Hyperparameter tuning",
                 save_code=True)

# Split the data and create a KFold object
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.2)
kf = KFold(n_splits=5, shuffle=True, random_state=42)

# Create the hyperparameter space
params = {"max_depth":[2, 5, 8, 12, 20],
          "min_samples_split": [2, 5, 8, 12, 20],
          "max_features": [1, 2, 3, 4],
          "random_state": [42]
          }

# Create a GridSearchCV object
dt_reg = DecisionTreeRegressor()
dt_reg_cv = GridSearchCV(dt_reg, 
                         params, 
                         cv=kf,
                         scoring="neg_root_mean_squared_error")

# Fit the data
dt_reg_cv.fit(X_train, y_train)

# Evaluate and log performance
## GridSearchCV uses negative RMSE
## so you can convert it to positive
print(f"Best RMSE: {-1 * dt_reg_cv.best_score_})")
print(f"Best model: {dt_reg_cv.best_estimator_}")

# Save and log the model, metrics, and parameters
pickle.dump(dt_reg_cv, open("tuned_decision_tree.pkl", "wb"))
tuned_decision_tree = wandb.Artifact("tuned_decision_tree", type="model")
tuned_decision_tree.add_file("tuned_decision_tree.pkl")
run_v2.log_artifact(tuned_decision_tree)
wandb.log({"rmse": -1 * dt_reg_cv.best_score_})
wandb.finish()Altyapı:

Panoyu ziyaret etme

Çalıştırmaları ve yapıtları incelemek için www.wandb.ai/<your-profile-name>/projects adresine gidip oluşturduğunuz projeyi seçebilirsiniz.

İçeri girdikten sonra, oluşturduğunuz her bir run’ı ve grafikler gibi tüm medyayı aşağıdaki gibi göreceksiniz:

Runs simgesine tıklayarak tüm run’larınızı ve RMSE ile R-Kare gibi kaydedilen metrikler dahil olmak üzere temel bilgileri görebilirsiniz.

Sonraki Adımlar

Weights & Biases’ta keşfedebileceğiniz çok daha fazla işlev vardır; örneğin yeni run’ların bir parçası olarak mevcut yapıtları kullanma, bir Komut Satırı Arayüzü aracı ve LLM’lerin geliştirilmesi için Prompts!

Makine öğrenimi deneyleri ve daha geniş MLOps teknikleri konusundaki bilginizi pekiştirmek için şunlara göz atmak isteyebilirsiniz:

• MLOps Concepts - makine öğrenimi yaşam döngüsünü tasarımdan dağıtıma ve bakıma kadar kapsayan, süreç boyunca öne çıkan temel kavramları ve paydaşları vurgulayan kavramsal bir kurs!
• Introduction to MLFlow - bu Python kursu, MLFlow’un dört temel bileşenini nasıl kullanacağınızı öğretir: Tracking, Models, Projects ve Model Registry.