Utfør hyperparameterjustering i Fabric (forhåndsversjon)
Hyperparameterjustering er prosessen med å finne de optimale verdiene for parameterne for en maskinlæringsmodell som påvirker ytelsen. Det kan være utfordrende og tidkrevende, spesielt når du arbeider med komplekse modeller og store datasett. I denne artikkelen viser vi deg hvordan du utfører hyperparameterjustering i Fabric.
I denne opplæringen skal vi bruke californiaboligdatasettet, som inneholder informasjon om medianverdien for huset og andre funksjoner for ulike folketellingsblokker i California. Når dataene er klargjort, lærer vi opp en SynapseML LightGBM-modell for å forutsi husverdien basert på funksjonene. Deretter bruker vi FLAML, et raskt og lett AutoML-bibliotek, for å finne de beste hyperparameterne for LightGBM-modellen. Til slutt vil vi sammenligne resultatene av den innstilte modellen med den opprinnelige modellen som bruker standardparameterne.
Viktig
Denne funksjonen er i forhåndsversjon.
Forutsetninger
Få et Microsoft Fabric-abonnement. Eller registrer deg for en gratis Prøveversjon av Microsoft Fabric.
Logg på Microsoft Fabric.
Bruk opplevelsesbryteren nederst til venstre på hjemmesiden for å bytte til Fabric.
- Opprett et nytt Fabric-miljø eller sørg for at du kjører på Fabric Runtime 1.2 (Spark 3.4 (eller høyere) og Delta 2.4)
- Opprett en ny notatblokk.
- Legg ved notatblokken i et lakehouse-. På venstre side av notatblokken velger du Legg til for å legge til et eksisterende lakehouse eller opprette et nytt.
Klargjøre opplærings- og testdatasett
I denne delen klargjør vi opplærings- og testdatasettene for LightGBM-modellen. Vi bruker Californias boligdatasett fra Sklearn. Vi oppretter en Spark-dataramme fra dataene og bruker en VectorAssembler til å kombinere funksjonene i én enkelt vektorkolonne.
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)
Vi deler deretter dataene tilfeldig inn i tre delsett: opplæring, validering og test, med henholdsvis 85%, 12,75%og 2,25% av dataene. Vi bruker opplærings- og valideringssettene for hyperparameterjustering og testsettet for modellevaluering.
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)
Konfigurere ML-eksperimentet
Konfigurer MLflow
Før vi utfører hyperparameterjustering, må vi definere en togfunksjon som kan ta forskjellige verdier av hyperparametere og lære opp en LightGBM-modell på opplæringsdataene. Vi må også evaluere modellytelsen på valideringsdataene ved hjelp av R2-poengsummen, som måler hvor godt modellen passer til dataene.
Hvis du vil gjøre dette, importerer vi først de nødvendige modulene og konfigurerer MLflow-eksperimentet. MLflow er en åpen kildekode-plattform for administrasjon av livssyklusen for maskinlæring fra ende til ende. Det hjelper oss med å spore og sammenligne resultatene av ulike modeller og hyperparametere.
# 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)
Angi loggingsnivå
Her konfigurerer vi loggingsnivået til å undertrykke unødvendige utdata fra biblioteket Synapse.ml, slik at loggene blir renere.
import logging
logging.getLogger('synapse.ml').setLevel(logging.ERROR)
Kalibrer grunnlinjemodell
Deretter definerer vi togfunksjonen som tar fire hyperparametere som innganger: alfa, lærerate, numLeaves og numIterations. Dette er hyperparameterne som vi ønsker å justere senere ved hjelp av FLAML.
Togfunksjonen tar også to datarammer som inndata: train_data og val_data, som er henholdsvis opplærings- og valideringsdatasettene. Togfunksjonen returnerer to utdata: den opplærte modellen og R2-poengsummen på valideringsdataene.
# 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
Til slutt bruker vi togfunksjonen til å lære opp en grunnlinjemodell med standardverdiene for hyperparameterne. Vi evaluerer også den opprinnelige modellen på testdataene og skriver ut R2-poengsummen.
# 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)
Utfør hyperparameterjustering med FLAML
FLAML er et raskt og lett AutoML-bibliotek som automatisk kan finne de beste hyperparameterne for en gitt modell og et gitt datasett. Den bruker en lavkost søkestrategi som tilpasser seg tilbakemeldingen fra evalueringsmetrikken. I denne delen skal vi bruke FLAML til å justere hyperparameterne for LightGBM-modellen som vi definerte i forrige del.
Definer tune-funksjon
Hvis du vil bruke FLAML, må vi definere en melodifunksjon som tar en konfigurasjonsordliste som inndata og returnerer en ordliste med evalueringsmetrikken som nøkkel og metrisk verdi som verdi.
Konfigurasjonsordlisten inneholder hyperparameterne vi ønsker å justere og deres verdier. Tune-funksjonen vil bruke togfunksjonen som vi definerte tidligere for å lære opp og evaluere modellen med den angitte konfigurasjonen.
# 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}
Definer søkeområde
Deretter må vi definere søkeområdet for hyperparameterne vi ønsker å justere. Søkeområdet er en ordliste som tilordner hyperparameternavnene til verdiområder som vi ønsker å utforske. FLAML gir noen praktiske funksjoner for å definere ulike typer områder, for eksempel uniform, loguniform og randint.
I dette tilfellet ønsker vi å justere følgende fire hyperparametere: alfa, lærerate, numLeaves og 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),
}
Definer hyperparameterprøve
Til slutt må vi definere en hyperparameterstudie som vil bruke FLAML til å optimalisere hyperparameterne. Vi må sende tune-funksjonen, søkeområdet, tidsbudsjettet, antall eksempler, metrisk navn, modus og detaljnivå til flaml.tune.run-funksjonen. Vi må også starte en nestet MLflow-kjøring for å spore resultatene av prøveversjonen.
Den flaml.tune.run function returnerer et analyseobjekt som inneholder den beste konfigurasjonen og den beste metriske verdien.
# 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,
)
Når prøveversjonen er fullført, kan vi vise den beste konfigurasjonen og den beste metriske verdien fra analyseobjektet.
# 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"])
Sammenlign resultater
Etter å ha funnet de beste hyperparameterne med FLAML, må vi evaluere hvor mye de forbedrer modellytelsen. For å gjøre dette bruker vi togfunksjonen til å opprette en ny modell med de beste hyperparameterne på det fullstendige opplæringsdatasettet. Vi bruker deretter testdatasettet til å beregne R2-poengsummen for både den nye modellen og den opprinnelige modellen.
# 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)
Lagre endelig modell
Når vi har fullført hyperparameterprøven, kan vi nå lagre den endelige, innstilte modellen som en ML-modell i 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.")