Bagikan melalui

Melakukan penyetelan hiperparameter di Fabric (pratinjau)

  • Artikel

Penyetelan hyperparameter adalah proses menemukan nilai optimal untuk parameter model pembelajaran mesin yang memengaruhi performanya. Ini bisa menjadi tantangan dan memakan waktu, terutama ketika berhadapan dengan model yang kompleks dan himpunan data besar. Dalam artikel ini, kami akan menunjukkan kepada Anda cara melakukan penyetelan hiperparameter di Fabric.

Dalam tutorial ini, kita akan menggunakan himpunan data perumahan California, yang berisi informasi tentang nilai rumah median dan fitur lain untuk blok sensus yang berbeda di California. Setelah data disiapkan, kami akan melatih model LightGBM SynapseML untuk memprediksi nilai rumah berdasarkan fitur. Selanjutnya, kita akan menggunakan FLAML, pustaka AutoML yang cepat dan ringan, untuk menemukan hyperparameter terbaik untuk model LightGBM. Terakhir, kita akan membandingkan hasil model yang disetel dengan model garis besar yang menggunakan parameter default.

Penting

Fitur ini dalam pratinjau.

Prasyarat

  • Buat lingkungan Fabric baru atau pastikan Anda berjalan pada Fabric Runtime 1.2 (Spark 3.4 (atau lebih tinggi) dan Delta 2.4)
  • Buat buku catatan baru.
  • Lampirkan buku catatan Anda ke lakehouse. Di sisi kiri buku catatan Anda, pilih Tambahkan untuk menambahkan lakehouse yang sudah ada atau buat yang baru.

Menyiapkan himpunan data pelatihan dan pengujian

Di bagian ini, kami menyiapkan himpunan data pelatihan dan pengujian untuk model LightGBM. Kami menggunakan himpunan data perumahan California dari Sklearn. Kami membuat dataframe Spark dari data dan menggunakan VectorAssembler untuk menggabungkan fitur ke dalam satu kolom vektor.

from sklearn.datasets import fetch_california_housing
from pyspark.sql import SparkSession

# Load the Scikit-learn California Housing dataset
sklearn_dataset = fetch_california_housing()

# Convert the Scikit-learn dataset to a Pandas DataFrame
import pandas as pd
pandas_df = pd.DataFrame(sklearn_dataset.data, columns=sklearn_dataset.feature_names)
pandas_df['target'] = sklearn_dataset.target

# Create a Spark DataFrame from the Pandas DataFrame
spark_df = spark.createDataFrame(pandas_df)

# Display the data
display(spark_df)

Kami kemudian membagi data secara acak menjadi tiga subset: pelatihan, validasi, dan pengujian, dengan masing-masing 85%, 12,75%, dan 2,25%. Kami menggunakan set pelatihan dan validasi untuk penyetelan hiperparameter dan set pengujian untuk evaluasi model.

from pyspark.ml.feature import VectorAssembler

# Combine features into a single vector column
featurizer = VectorAssembler(inputCols=sklearn_dataset.feature_names, outputCol="features")
data = featurizer.transform(spark_df)["target", "features"]

# Split the data into training, validation, and test sets
train_data, test_data = data.randomSplit([0.85, 0.15], seed=41)
train_data_sub, val_data_sub = train_data.randomSplit([0.85, 0.15], seed=41)

Menyiapkan eksperimen ML

Mengonfigurasi MLflow

Sebelum melakukan penyetelan hiperparameter, kita perlu menentukan fungsi kereta yang dapat mengambil nilai hiperparameter yang berbeda dan melatih model LightGBM pada data pelatihan. Kita juga perlu mengevaluasi performa model pada data validasi menggunakan skor R2, yang mengukur seberapa baik model cocok dengan data.

Untuk melakukan ini, pertama-tama kita mengimpor modul yang diperlukan dan menyiapkan eksperimen MLflow. MLflow adalah platform sumber terbuka untuk mengelola siklus hidup pembelajaran mesin ujung-ke-ujung. Ini membantu kami melacak dan membandingkan hasil model dan hiperparameter yang berbeda.

# Import MLflow and set up the experiment name
import mlflow

mlflow.set_experiment("flaml_tune_sample")

# Enable automatic logging of parameters, metrics, and models
mlflow.autolog(exclusive=False)

Set tingkat pengelogan

Di sini, kami mengonfigurasi tingkat pengelogan untuk menekan output yang tidak perlu dari pustaka Synapse.ml, menjaga log lebih bersih.

import logging
 
logging.getLogger('synapse.ml').setLevel(logging.ERROR)

Melatih model garis besar

Selanjutnya, kita menentukan fungsi kereta yang mengambil empat hyperparameter sebagai input: alpha, learningRate, numLeaves, dan numIterations. Ini adalah hiperparameter yang ingin kita setel nanti menggunakan FLAML.

Fungsi kereta juga mengambil dua kerangka data sebagai input: train_data dan val_data, yang masing-masing merupakan himpunan data pelatihan dan validasi. Fungsi latih mengembalikan dua output: model terlatih dan skor R2 pada data validasi.

# Import LightGBM and RegressionEvaluator
from synapse.ml.lightgbm import LightGBMRegressor
from pyspark.ml.evaluation import RegressionEvaluator

def train(alpha, learningRate, numLeaves, numIterations, train_data=train_data_sub, val_data=val_data_sub):
    """
    This train() function:
     - takes hyperparameters as inputs (for tuning later)
     - returns the R2 score on the validation dataset

    Wrapping code as a function makes it easier to reuse the code later for tuning.
    """
    with mlflow.start_run() as run:

        # Capture run_id for prediction later
        run_details = run.info.run_id

        # Create a LightGBM regressor with the given hyperparameters and target column
        lgr = LightGBMRegressor(
            objective="quantile",
            alpha=alpha,
            learningRate=learningRate,
            numLeaves=numLeaves,
            labelCol="target",
            numIterations=numIterations,
            dataTransferMode="bulk"
        )

        # Train the model on the training data
        model = lgr.fit(train_data)

        # Make predictions on the validation data
        predictions = model.transform(val_data)
        # Define an evaluator with R2 metric and target column
        evaluator = RegressionEvaluator(predictionCol="prediction", labelCol="target", metricName="r2")
        # Compute the R2 score on the validation data
        eval_metric = evaluator.evaluate(predictions)

        mlflow.log_metric("r2_score", eval_metric)

    # Return the model and the R2 score
    return model, eval_metric, run_details

Terakhir, kita menggunakan fungsi pelatihan untuk melatih model garis besar dengan nilai default hiperparameter. Kami juga mengevaluasi model garis besar pada data pengujian dan mencetak skor R2.

# Train the baseline model with the default hyperparameters
init_model, init_eval_metric, init_run_id = train(alpha=0.2, learningRate=0.3, numLeaves=31, numIterations=100, train_data=train_data, val_data=test_data)
# Print the R2 score of the baseline model on the test data
print("R2 of initial model on test dataset is: ", init_eval_metric)

Melakukan penyetelan hiperparameter dengan FLAML

FLAML adalah pustaka AutoML yang cepat dan ringan yang dapat secara otomatis menemukan hiperparameter terbaik untuk model dan himpunan data tertentu. Ini menggunakan strategi pencarian berbisa rendah yang beradaptasi dengan umpan balik dari metrik evaluasi. Di bagian ini, kita akan menggunakan FLAML untuk menyetel hiperparameter model LightGBM yang kita tentukan di bagian sebelumnya.

Tentukan fungsi penyetelan

Untuk menggunakan FLAML, kita perlu menentukan fungsi penyetelan yang mengambil kamus konfigurasi sebagai input dan mengembalikan kamus dengan metrik evaluasi sebagai kunci dan nilai metrik sebagai nilai .

Kamus konfigurasi berisi hiperparameter yang ingin kita sesuaikan dan nilainya. Fungsi penyetelan akan menggunakan fungsi latih yang kami tentukan sebelumnya untuk melatih dan mengevaluasi model dengan konfigurasi yang diberikan.

# Import FLAML
import flaml

# Define the tune function
def flaml_tune(config):
    # Train and evaluate the model with the given config
    _, metric, run_id = train(**config)
    # Return the evaluation metric and its value
    return {"r2": metric}

Tentukan ruang pencarian

Selanjutnya, kita perlu menentukan ruang pencarian untuk hyperparameter yang ingin kita setel. Ruang pencarian adalah kamus yang memetakan nama hyperparameter ke rentang nilai yang ingin kita jelajahi. FLAML menyediakan beberapa fungsi yang nyaman untuk menentukan berbagai jenis rentang, seperti seragam, loguniform, dan randint.

Dalam hal ini, kita ingin menyetel empat hiperparameter berikut: alpha, learningRate, numLeaves, dan numIterations.

# Define the search space
params = {
    # Alpha is a continuous value between 0 and 1
    "alpha": flaml.tune.uniform(0, 1),
    # Learning rate is a continuous value between 0.001 and 1
    "learningRate": flaml.tune.uniform(0.001, 1),
    # Number of leaves is an integer value between 30 and 100
    "numLeaves": flaml.tune.randint(30, 100),
    # Number of iterations is an integer value between 100 and 300
    "numIterations": flaml.tune.randint(100, 300),
}

Menentukan uji coba hiperparameter

Terakhir, kita perlu menentukan uji coba hiperparameter yang akan menggunakan FLAML untuk mengoptimalkan hiperparameter. Kita perlu meneruskan fungsi penyetelan, ruang pencarian, anggaran waktu, jumlah sampel, nama metrik, mode, dan tingkat verbositas ke fungsi flaml.tune.run. Kita juga perlu memulai eksekusi MLflow berlapis untuk melacak hasil uji coba.

flaml.tune.run function akan mengembalikan objek analisis yang berisi konfigurasi terbaik dan nilai metrik terbaik.

# Start a nested MLflow run
with mlflow.start_run(nested=True, run_name="Child Run: "):
    # Run the hyperparameter trial with FLAML
    analysis = flaml.tune.run(
        # Pass the tune function
        flaml_tune,
        # Pass the search space
        params,
        # Set the time budget to 120 seconds
        time_budget_s=120,
        # Set the number of samples to 100
        num_samples=100,
        # Set the metric name to r2
        metric="r2",
        # Set the mode to max (we want to maximize the r2 score)
        mode="max",
        # Set the verbosity level to 5
        verbose=5,
        )

Setelah uji coba selesai, kita dapat melihat konfigurasi terbaik dan nilai metrik terbaik dari objek analisis.

# Get the best config from the analysis object
flaml_config = analysis.best_config
# Print the best config
print("Best config: ", flaml_config)
print("Best score on validation data: ", analysis.best_result["r2"])

Membandingkan hasil

Setelah menemukan hiperparameter terbaik dengan FLAML, kita perlu mengevaluasi berapa banyak mereka meningkatkan performa model. Untuk melakukan ini, kami menggunakan fungsi pelatihan untuk membuat model baru dengan hiperparameter terbaik pada himpunan data pelatihan penuh. Kami kemudian menggunakan himpunan data pengujian untuk menghitung skor R2 untuk model baru dan model garis besar.

# Train a new model with the best hyperparameters 
flaml_model, flaml_metric, flaml_run_id = train(train_data=train_data, val_data=test_data, **flaml_config)

# Print the R2 score of the baseline model on the test dataset
print("On the test dataset, the initial (untuned) model achieved R^2: ", init_eval_metric)
# Print the R2 score of the new model on the test dataset
print("On the test dataset, the final flaml (tuned) model achieved R^2: ", flaml_metric)

Menyimpan model akhir

Setelah menyelesaikan uji coba hyperparameter, kita sekarang dapat menyimpan model akhir yang disetel sebagai model ML di Fabric.

# Specify the model name and the path where you want to save it in the registry
model_name = "housing_model"  # Replace with your desired model name
model_path = f"runs:/{flaml_run_id}/model"

# Register the model to the MLflow registry
registered_model = mlflow.register_model(model_uri=model_path, name=model_name)

# Print the registered model's name and version
print(f"Model '{registered_model.name}' version {registered_model.version} registered successfully.")

Konten terkait