Aracılığıyla paylaş

Dokuda hiper parametre ayarlaması gerçekleştirme (önizleme)

  • Makale

Hiper parametre ayarı, bir makine öğrenmesi modelinin performansını etkileyen parametreleri için en uygun değerleri bulma işlemidir. Özellikle karmaşık modellerle ve büyük veri kümeleriyle ilgilenirken zorlayıcı ve zaman alıcı olabilir. Bu makalede, Doku'da hiper parametre ayarlama işleminin nasıl yapılacağını göstereceğiz.

Bu öğreticide, California'daki farklı nüfus sayımı blokları için ortanca ev değeri ve diğer özellikler hakkında bilgi içeren California konut veri kümesini kullanacağız. Veriler hazırlandıktan sonra, özelliklere göre ev değerini tahmin etmek için bir SynapseML LightGBM modeli eğiteceğiz. Daha sonra, LightGBM modeli için en iyi hiper parametreleri bulmak için hızlı ve basit bir AutoML kitaplığı olan FLAML'yi kullanacağız. Son olarak, ayarlanmış modelin sonuçlarını varsayılan parametreleri kullanan temel modelle karşılaştıracağız.

Önemli

Bu özellik önizleme aşamasındadır.

Önkoşullar

  • Yeni bir Doku ortamı oluşturun veya Doku Çalışma Zamanı 1.2 (Spark 3.4 (veya üzeri) ve Delta 2.4'te çalıştırdığınızdan emin olun
  • Yeni bir not defteri oluşturun.
  • Not defterinizi bir göle ekleyin. Not defterinizin sol tarafında Ekle'yi seçerek var olan bir göl evi ekleyin veya yeni bir tane oluşturun.

Eğitim ve test veri kümelerini hazırlama

Bu bölümde, LightGBM modeli için eğitim ve test veri kümelerini hazırlıyoruz. Sklearn'daki California konut veri kümesini kullanırız. Verilerden bir Spark veri çerçevesi oluşturur ve özellikleri tek bir vektör sütununda birleştirmek için VectorAssembler kullanırız.

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)

Ardından verileri rastgele olarak üç alt kümeye böleriz: sırasıyla verilerin %85'i, %12,75'i ve %2,25'iyle eğitim, doğrulama ve test. Hiper parametre ayarlaması için eğitim ve doğrulama kümelerini ve model değerlendirmesi için test kümesini kullanırız.

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)

ML denemesini ayarlama

MLflow'ı yapılandırma

Hiper parametre ayarlaması gerçekleştirmeden önce, farklı hiper parametre değerlerini alabilen ve eğitim verileri üzerinde bir LightGBM modeli eğitebilen bir tren işlevi tanımlamamız gerekir. Ayrıca, modelin verilere ne kadar uygun olduğunu ölçen R2 puanını kullanarak doğrulama verilerinde model performansını değerlendirmemiz gerekir.

Bunu yapmak için önce gerekli modülleri içeri aktarıp MLflow denemesini ayarlayacağız. MLflow, uçtan uca makine öğrenmesi yaşam döngüsünü yönetmeye yönelik açık kaynaklı bir platformdur. Farklı modellerin ve hiper parametrelerin sonuçlarını izlememize ve karşılaştırmamıza yardımcı olur.

# 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)

Günlük düzeyini ayarlama

Burada günlük düzeyini Synapse.ml kitaplığından gelen gereksiz çıkışı engelleyerek günlükleri daha temiz tutacak şekilde yapılandıracağız.

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

Temel modeli eğit

Ardından, dört hiper parametreyi giriş olarak alan train işlevini tanımlayacağız: alfa, learningRate, numLeaves ve numIterations. Bunlar, daha sonra FLAML kullanarak ayarlamak istediğimiz hiper parametrelerdir.

Train işlevi ayrıca giriş olarak iki veri çerçevesi alır: sırasıyla eğitim ve doğrulama veri kümeleri olan train_data ve val_data. Train işlevi iki çıkış döndürür: eğitilen model ve doğrulama verileri üzerindeki R2 puanı.

# 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

Son olarak, bir temel modeli hiper parametrelerin varsayılan değerleriyle eğitmek için train işlevini kullanırız. Ayrıca test verilerinde temel modeli değerlendirir ve R2 puanını yazdırırız.

# 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)

FLAML ile hiper parametre ayarlaması gerçekleştirme

FLAML, belirli bir model ve veri kümesi için en iyi hiper parametreleri otomatik olarak bulabilen hızlı ve basit bir AutoML kitaplığıdır. Değerlendirme ölçümünden gelen geri bildirimlere uyarlanan düşük maliyetli bir arama stratejisi kullanır. Bu bölümde, önceki bölümde tanımladığımız LightGBM modelinin hiper parametrelerini ayarlamak için FLAML kullanacağız.

Tune işlevini tanımlama

FLAML kullanmak için, bir yapılandırma sözlüğü giriş olarak alan ve değerlendirme ölçümünü anahtar olarak ve ölçüm değerini değer olarak döndüren bir tune işlevi tanımlamamız gerekir.

Yapılandırma sözlüğü, ayarlamak istediğimiz hiper parametreleri ve bunların değerlerini içerir. Tune işlevi, modeli verilen yapılandırmayla eğitmek ve değerlendirmek için daha önce tanımladığımız train işlevini kullanır.

# 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}

Arama alanını tanımlama

Ardından, ayarlamak istediğimiz hiper parametreler için arama alanını tanımlamamız gerekir. Arama alanı, hiper parametre adlarını incelemek istediğimiz değer aralıklarıyla eşleyen bir sözlüktür. FLAML, tekdüzen, loguniform ve randint gibi farklı aralık türlerini tanımlamak için bazı kullanışlı işlevler sağlar.

Bu durumda, şu dört hiper parametreyi ayarlamak istiyoruz: alfa, learningRate, numLeaves ve 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),
}

Hiper parametre denemesi tanımlama

Son olarak, hiper parametreleri iyileştirmek için FLAML kullanacak bir hiper parametre denemesi tanımlamamız gerekir. Tune işlevini, arama alanını, zaman bütçesini, örnek sayısını, ölçüm adını, modu ve ayrıntı düzeyini flaml.tune.run işlevine geçirmemiz gerekir. Ayrıca denemenin sonuçlarını izlemek için iç içe bir MLflow çalıştırması başlatmamız gerekir.

, flaml.tune.run function en iyi yapılandırmayı ve en iyi ölçüm değerini içeren bir analiz nesnesi döndürür.

# 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,
        )

Deneme tamamlandıktan sonra analiz nesnesinden en iyi yapılandırmayı ve en iyi ölçüm değerini görüntüleyebiliriz.

# 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"])

Sonuçları karşılaştırma

FLAML ile en iyi hiper parametreleri bulduktan sonra model performansını ne kadar artırdıklarını değerlendirmemiz gerekir. Bunu yapmak için, tam eğitim veri kümesinde en iyi hiper parametrelere sahip yeni bir model oluşturmak için train işlevini kullanırız. Ardından test veri kümesini kullanarak hem yeni model hem de temel model için R2 puanını hesaplayacağız.

# 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)

Son modeli kaydet

Hiper parametre denememizi tamamladıktan sonra, artık son ayarlanmış modeli Doku'da ML modeli olarak kaydedebiliriz.

# 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.")

İlgili içerik