Thử nghiệm Machine Learning: Giới thiệu về Weights & Biases

Bạn không thể phân tích những gì bạn không đo lường

Bạn đã bao giờ nhìn lại một dự án machine learning và tự hỏi vì sao mình đưa ra những quyết định cụ thể, hoặc thậm chí đoạn mã thực sự đang làm gì chưa? Ví dụ, vì sao bạn chọn tập con đặc trưng này, bạn đã huấn luyện mô hình cuối cùng trên phiên bản dữ liệu nào, hoặc các bộ siêu tham số khác nhau ảnh hưởng đến hiệu năng ra sao? Có vẻ như bạn cần áp dụng các thực hành tốt về thử nghiệm vào các dự án machine learning của mình!

Thử nghiệm machine learning là quy trình thiết kế, xây dựng, ghi log và đánh giá một pipeline machine learning để xác định mô hình đạt được hiệu năng mong muốn theo một hoặc nhiều chỉ số cho trước, ví dụ F1 score, RMSE, v.v. Đây là bước then chốt trong việc phát triển mô hình, cả trước khi triển khai lẫn như một phần của quá trình huấn luyện lại. Giống như bất kỳ thí nghiệm nào khác, nó cần được thiết kế để:

• Có thể lặp lại
• Giảm thiểu sai lệch
• Theo dõi mọi tệp và tạo phẩm cần thiết

Giữ các mục tiêu này trong đầu sẽ giúp bạn dễ dàng tìm thấy những gì mình cần, như siêu tham số của mô hình hay phiên bản của bộ dữ liệu, và chia sẻ thông tin như hiệu năng mô hình và mã nguồn.

May mắn thay, đây chính là lúc Weights & Biases phát huy tác dụng! 

Tạo một pipeline Machine Learning với Weights & Biases

Weights & Biases là một nền tảng và thư viện Python dành cho kỹ sư machine learning để chạy thử nghiệm, ghi log tạo phẩm, tự động tinh chỉnh siêu tham số và đánh giá hiệu năng. Hướng dẫn này sẽ giới thiệu các chức năng cốt lõi bằng cách minh họa một pipeline machine learning trong đó các thành phần chính được ghi log và sau đó được xem xét trong một bảng điều khiển!

Cài đặt và đăng nhập

# Install Python library
!pip install wandbĐược hỗ trợ bởi

Để đăng nhập, bạn sẽ cần đăng ký tài khoản.

Sau khi tạo xong, truy cập trang cấp quyền để lấy khóa API dùng để đăng nhập. Hãy ghi lại khóa này, nhưng đừng chia sẻ với bất kỳ ai!

Để đăng nhập, bạn có thể mở một Terminal mới và nhập wandb login hoặc thêm một ô mới vào notebook của mình và thực thi !wandb login.

Bạn sẽ được yêu cầu cung cấp khóa API; chỉ cần sao chép và dán để đăng nhập thành công. Thông tin xác thực của bạn sẽ được lưu cục bộ trong ~/.netrc về sau.

wandb loginĐược hỗ trợ bởi

Tạo một thử nghiệm

Weights & Biases có một số thành phần, bao gồm Experiments, Artifacts, Sweeps và Models. Hãy bắt đầu với phần cốt lõi của quy trình làm việc - tạo và chạy thử nghiệ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_scoreĐược hỗ trợ bởi

Trong Weights & Biases, một Experiment còn được gọi là một project. Để tạo project mới, ta gọi hàm wand.init(), truyền tên project dưới dạng chuỗi vào tham số project. Bạn có thể gán nó cho biến run, để có thể ghi log các tệp, mô hình và chỉ số quan trọng vào run đó.

Tùy chọn, bạn cũng có thể cung cấp một chuỗi cho tham số job_type để dễ phân biệt giữa các bước như EDA, xây dựng đặc trưng, hoặc tinh chỉnh siêu tham số. Ngoài ra, mã bạn thực thi có thể được ghi log bằng cách đặt save_code bằng True.

# Initialize a run
run = wandb.init(project="predicting_london_temperature",
                 job_type="Baseline modeling",
                 save_code=True)Được hỗ trợ bởi

Ghi log một tạo phẩm

Bạn có thể ghi log bất kỳ thông tin quan trọng nào, như bộ dữ liệu, biến hoặc tệp, dưới dạng Artifact. Để làm điều này, trước tiên tạo một biến bằng cách gọi wandb.Artifact(), cung cấp tên và loại. Sau đó ghi log nó bằng hàm wandb.log_artifact(). Hãy bắt đầu bằng cách ghi log bộ dữ liệu gốc.

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)Được hỗ trợ bởi

Phân tích dữ liệu thăm dò

Phân tích dữ liệu thăm dò (EDA) là bước quan trọng trong quy trình machine learning, giúp bạn đảm bảo dữ liệu đúng kiểu, không có giá trị thiếu và ngoại lệ. Đây cũng là cơ hội để xem xét phân phối và mối quan hệ giữa các đặc trưng.

Lợi ích bổ sung khi dùng Weights & Biases là bạn có thể ghi log dữ liệu trong lúc tiền xử lý, cùng với mọi trực quan hóa được tạo ra.

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

# Previewing the first five rows
london.head()Được hỗ trợ bởi

# Visualize distributions
plt.figure(figsize=(12,8))
london.hist()
plt.tight_layout()
plt.show()Được hỗ trợ bởi

# 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)Được hỗ trợ bởi

Giờ dữ liệu đã được làm sạch, bạn có thể ghi log nó như một Artifact bằng wand.Artifact().

# 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>Được hỗ trợ bởi

Chọn đặc trưng

Bước tiếp theo là xác định các đặc trưng tiềm năng cho mô hình đồng thời tránh đa cộng tuyến. Để làm vậy, bạn có thể tạo bản đồ nhiệt tương quan, rồi dùng Ridge Regression để định lượng tầm quan trọng của đặc trưng trong việc dự đoán "mean_temperature".

# Correlation heatmap
sns.heatmap(london.corr(), annot=True, center=True)
plt.show()Được hỗ trợ bởi

Bạn có thể ghi log biểu đồ này bằng wandb.Image()!

# 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()Được hỗ trợ bởi

Hãy lưu mô hình và biểu đồ tầm quan trọng đặc trưng bằng pickle.dump() và wandb.log().

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>Được hỗ trợ bởi

Huấn luyện và ghi log

Bạn đã sẵn sàng! Đến lúc huấn luyện mô hình nền tảng bằng các đặc trưng quan trọng đã xác định, tức những đặc trưng có hệ số của mô hình Ridge lớn hơn 0. Bạn cũng sẽ ghi log dữ liệu huấn luyện và kiểm thử mới.

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)Được hỗ trợ bởi

Hãy huấn luyện và đánh giá một mô hình Decision Tree Regression, sử dụng Sai số căn phương bình phương gốc (RMSE) và Hệ số xác định (R-Squared) làm chỉ số hiệu năng.

# 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})Được hỗ trợ bởi

Bạn có thể đi sâu hơn vào hiệu năng mô hình bằng cách trực quan hóa phần dư của mô hình. Weights & Biases có một hàm trong mô-đun sklearn của họ để tạo phần này!

# Plot training residuals
wandb.log({"baseline_residuals_plot": wandb.sklearn.plot_residuals(dt_reg, X_train, y_train)})Được hỗ trợ bởi

Huấn luyện và đánh giá đã hoàn tất, hãy kết thúc run hiện tại.

# Finish run
wandb.finish()Được hỗ trợ bởi

Tinh chỉnh siêu tham số

Giờ bạn đã tạo và ghi log một mô hình nền tảng cùng các chỉ số hiệu năng liên quan, hãy xem cách thực hiện tinh chỉnh siêu tham số và quản lý phiên bản mô hình bằng Weights & Biases và scikit-learn.

Chúng ta sẽ dùng GridSearchCV để tìm mô hình có hiệu năng tốt nhất trong một không gian siêu tham số, dựa trên RMSE.

# 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()Được hỗ trợ bởi

Truy cập bảng điều khiển

Để xem các run và tạo phẩm, bạn có thể truy cập www.wandb.ai/<your-profile-name>/projects rồi chọn project bạn đã tạo.

Bên trong, bạn sẽ thấy từng run mình đã tạo, cùng mọi nội dung media như biểu đồ, như thế này:

Bằng cách nhấp vào biểu tượng Runs, bạn có thể xem tất cả các run và thông tin chính, bao gồm các chỉ số đã ghi log như RMSE và R-Squared.

Bước tiếp theo

Weights & Biases còn nhiều tính năng để bạn khám phá, như sử dụng các tạo phẩm hiện có như một phần của run mới, công cụ Giao diện dòng lệnh, và Prompts để phát triển LLM!

Để củng cố kiến thức về thử nghiệm machine learning và các kỹ thuật MLOps rộng hơn, bạn có thể tham khảo:

• MLOps Concepts - khóa học khái niệm bao quát vòng đời machine learning từ thiết kế đến triển khai và bảo trì, đồng thời làm nổi bật các khái niệm và bên liên quan quan trọng xuyên suốt!
• Introduction to MLFlow - khóa học Python dạy bạn cách sử dụng bốn thành phần cốt lõi của MLFlow: Tracking, Models, Projects và Model Registry.