Hyperparameterafstemming uitvoeren in Fabric (preview)
Hyperparameterafstemming is het proces voor het vinden van de optimale waarden voor de parameters van een machine learning-model dat van invloed is op de prestaties. Het kan lastig en tijdrovend zijn, vooral bij het omgaan met complexe modellen en grote gegevenssets. In dit artikel laten we u zien hoe u hyperparameterafstemming uitvoert in Fabric.
In deze zelfstudie gebruiken we de gegevensset voor huisvesting in Californië, die informatie bevat over de mediaan huiswaarde en andere functies voor verschillende volkstellingsblokken in Californië. Zodra de gegevens zijn voorbereid, trainen we een SynapseML LightGBM-model om de huiswaarde te voorspellen op basis van de functies. Vervolgens gebruiken we FLAML, een snelle en lichtgewicht AutoML-bibliotheek, om de beste hyperparameters voor het LightGBM-model te vinden. Ten slotte vergelijken we de resultaten van het afgestemde model met het basislijnmodel dat gebruikmaakt van de standaardparameters.
Belangrijk
Deze functie is beschikbaar als preview-versie.
Vereisten
Haal een Microsoft Fabric-abonnement op. Of meld u aan voor een gratis proefversie van Microsoft Fabric.
Meld u aan bij Microsoft Fabric.
Gebruik de ervaringswisselaar aan de linkerkant van de startpagina om over te schakelen naar de Synapse-Datawetenschap-ervaring.
- Maak een nieuwe Fabric-omgeving of zorg ervoor dat u werkt met Fabric Runtime 1.2 (Spark 3.4 (of hoger) en Delta 2.4)
- Maak een nieuw notitieblok.
- Koppel uw notitieblok aan een lakehouse. Selecteer aan de linkerkant van uw notitieblok Toevoegen om een bestaand lakehouse toe te voegen of maak een nieuw lakehouse.
Trainings- en testgegevenssets voorbereiden
In deze sectie bereiden we de trainings- en testgegevenssets voor op het LightGBM-model. We gebruiken de gegevensset voor huisvesting in Californië van Sklearn. We maken een Spark-dataframe op basis van de gegevens en gebruiken een VectorAssembler om de functies te combineren in één vectorkolom.
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)
Vervolgens splitsen we de gegevens willekeurig op in drie subsets: training, validatie en test, respectievelijk met 85%, 12,75% en 2,25% van de gegevens. We gebruiken de trainings- en validatiesets voor het afstemmen van hyperparameters en de testset voor modelevaluatie.
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)
Het ML-experiment instellen
MLflow configureren
Voordat we hyperparameterafstemming uitvoeren, moeten we een trainfunctie definiëren die verschillende waarden van hyperparameters kan aannemen en een LightGBM-model op de trainingsgegevens kan trainen. We moeten ook de modelprestaties op de validatiegegevens evalueren met behulp van de R2-score, die meet hoe goed het model past bij de gegevens.
Hiervoor importeren we eerst de benodigde modules en stellen we het MLflow-experiment in. MLflow is een opensource-platform voor het beheren van de end-to-end levenscyclus van Machine Learning. Hiermee kunnen we de resultaten van verschillende modellen en hyperparameters bijhouden en vergelijken.
# 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)
Logboekregistratieniveau instellen
Hier configureren we het logboekregistratieniveau om onnodige uitvoer van de Synapse.ml-bibliotheek te onderdrukken, waardoor de logboeken overzichtelijker blijven.
import logging
logging.getLogger('synapse.ml').setLevel(logging.ERROR)
Basislijnmodel trainen
Vervolgens definiëren we de trainfunctie die vier hyperparameters als invoer gebruikt: alfa, learningRate, numLeaves en numIterations. Dit zijn de hyperparameters die we later willen afstemmen met FLAML.
De trainfunctie gebruikt ook twee gegevensframes als invoer: train_data en val_data, die respectievelijk de gegevenssets voor training en validatie zijn. De trainfunctie retourneert twee uitvoerwaarden: het getrainde model en de R2-score op de validatiegegevens.
# 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
Ten slotte gebruiken we de trainfunctie om een basislijnmodel te trainen met de standaardwaarden van de hyperparameters. We evalueren ook het basislijnmodel op de testgegevens en drukken de R2-score af.
# 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)
Hyperparameterafstemming uitvoeren met FLAML
FLAML is een snelle en lichtgewicht AutoML-bibliotheek die automatisch de beste hyperparameters voor een bepaald model en een bepaalde gegevensset kan vinden. Er wordt gebruikgemaakt van een voordelige zoekstrategie die zich aanpast aan de feedback van de metrische evaluatiegegevens. In deze sectie gebruiken we FLAML om de hyperparameters van het LightGBM-model af te stemmen dat we in de vorige sectie hebben gedefinieerd.
De functie Tune definiëren
Als u FLAML wilt gebruiken, moet u een tune-functie definiëren die een configuratiewoordenlijst als invoer gebruikt en een woordenlijst retourneert met de metrische evaluatiegegevens als sleutel en de metrische waarde als de waarde.
De configuratiewoordenlijst bevat de hyperparameters die we willen afstemmen en hun waarden. De tune-functie gebruikt de train-functie die we eerder hebben gedefinieerd om het model te trainen en te evalueren met de opgegeven configuratie.
# 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}
Zoekruimte definiëren
Vervolgens moeten we de zoekruimte definiëren voor de hyperparameters die we willen afstemmen. De zoekruimte is een woordenlijst waarmee de namen van hyperparameters worden toegewezen aan de waardenbereiken die we willen verkennen. FLAML biedt enkele handige functies voor het definiëren van verschillende soorten bereiken, zoals uniform, loguniform en randint.
In dit geval willen we de volgende vier hyperparameters afstemmen: alfa, learningRate, numLeaves en 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),
}
Hyperparameter-proefversie definiëren
Ten slotte moeten we een hyperparameter-proefversie definiëren die FLAML gebruikt om de hyperparameters te optimaliseren. We moeten de tune-functie, de zoekruimte, het tijdbudget, het aantal voorbeelden, de metrische naam, de modus en het uitgebreidheidsniveau doorgeven aan de functie flaml.tune.run. We moeten ook een geneste MLflow-uitvoering starten om de resultaten van de proefversie bij te houden.
Hiermee flaml.tune.run function wordt een analyseobject geretourneerd dat de beste configuratie en de beste metrische waarde bevat.
# 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,
)
Nadat de proefversie is voltooid, kunnen we de beste configuratie en de beste metrische waarde van het analyseobject bekijken.
# 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"])
Resultaten vergelijken
Na het vinden van de beste hyperparameters met FLAML, moeten we evalueren hoeveel ze de modelprestaties verbeteren. Hiervoor gebruiken we de trainfunctie om een nieuw model te maken met de beste hyperparameters op de volledige trainingsgegevensset. Vervolgens gebruiken we de testgegevensset om de R2-score voor zowel het nieuwe model als het basislijnmodel te berekenen.
# 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)
Definitief model opslaan
Zodra we onze hyperparameter-proefversie hebben voltooid, kunnen we nu het uiteindelijke, afgestemde model opslaan als een ML-model in 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.")