Udfør justering af hyperparametre i Fabric (prøveversion)
Hyperparameterjustering er processen med at finde de optimale værdier for parametrene for en model til maskinel indlæring, der påvirker dens ydeevne. Det kan være udfordrende og tidskrævende, især når du arbejder med komplekse modeller og store datasæt. I denne artikel viser vi dig, hvordan du udfører hyperparameterjustering i Fabric.
I dette selvstudium bruger vi datasættet til boliger i Californien, som indeholder oplysninger om medianhusværdien og andre funktioner for forskellige censusblokke i Californien. Når dataene er overskredet, oplærer vi en SynapseML LightGBM-model til at forudsige husværdien baseret på funktionerne. Derefter bruger vi FLAML, et hurtigt og letvægts AutoML-bibliotek, til at finde de bedste hyperparametre til LightGBM-modellen. Til sidst sammenligner vi resultaterne af den optimerede model med den oprindelige model, der bruger standardparametrene.
Vigtigt
Denne funktion er en prøveversion.
Forudsætninger
Få et Microsoft Fabric-abonnement. Du kan også tilmelde dig en gratis Prøveversion af Microsoft Fabric.
Brug oplevelsesskifteren i venstre side af startsiden til at skifte til Synapse Data Science-oplevelsen.
- Opret et nyt Fabric-miljø , eller sørg for, at du kører på Fabric Runtime 1.2 (Spark 3.4 (eller nyere) og Delta 2.4)
- Opret en ny notesbog.
- Vedhæft din notesbog til et lakehouse. I venstre side af notesbogen skal du vælge Tilføj for at tilføje et eksisterende lakehouse eller oprette et nyt.
Forbered oplærings- og testdatasæt
I dette afsnit forbereder vi oplærings- og testdatasæt til LightGBM-modellen. Vi bruger datasættet til boliger i Californien fra Sklearn. Vi opretter en Spark-dataramme ud fra dataene og bruger en VectorAssembler til at kombinere funktionerne i en 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)
Derefter opdeler vi tilfældigt dataene i tre undersæt: oplæring, validering og test med henholdsvis 85 %, 12,75 % og 2,25 % af dataene. Vi bruger trænings- og valideringssættene til hyperparameterjustering og testsættet til modelevaluering.
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)
Konfigurer ML-eksperimentet
Konfigurer MLflow
Før vi udfører justering af hyperparametre, skal vi definere en togfunktion, der kan tage forskellige værdier af hyperparametre og oplære en LightGBM-model på oplæringsdataene. Vi skal også evaluere modellens ydeevne for valideringsdataene ved hjælp af R2-scoren, som måler, hvor godt modellen passer til dataene.
For at gøre dette skal vi først importere de nødvendige moduler og konfigurere MLflow-eksperimentet. MLflow er en åben kildekode platform til administration af livscyklussen for maskinel indlæring fra ende til anden. Det hjælper os med at spore og sammenligne resultaterne af forskellige modeller og hyperparametre.
# 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)
Angiv logføringsniveau
Her konfigurerer vi logføringsniveauet for at undertrykke unødvendige output fra biblioteket Synapse.ml, så loggene er renere.
import logging
logging.getLogger('synapse.ml').setLevel(logging.ERROR)
Oplær oprindelig model
Derefter definerer vi den togfunktion, der tager fire hyperparametre som input: alpha, learningRate, numLeaves og numIterations. Dette er de hyperparametre, som vi vil justere senere ved hjælp af FLAML.
Togfunktionen bruger også to datarammer som input: train_data og val_data, som er henholdsvis trænings- og valideringsdatasættene. Togfunktionen returnerer to output: den oplærte model og R2-scoren 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
Endelig bruger vi funktionen Train til at oplære en oprindelig model med standardværdierne for hyperparametrene. Vi evaluerer også den oprindelige model på testdataene og udskriver R2-scoren.
# 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)
Udfør justering af hyperparameter med FLAML
FLAML er et hurtigt og letvægts AutoML-bibliotek, der automatisk kan finde de bedste hyperparametre for en given model og et givent datasæt. Den bruger en søgestrategi med lave omkostninger, der tilpasses feedbacken fra evalueringsmetrikværdien. I dette afsnit bruger vi FLAML til at justere hyperparametrene for den LightGBM-model, som vi definerede i det forrige afsnit.
Definer funktionen Tune
Hvis du vil bruge FLAML, skal vi definere en tune-funktion, der bruger en konfigurationsordbog som input og returnerer en ordbog med evalueringsmetrikværdien som nøgle og metrikværdi som værdien.
Konfigurationsordbogen indeholder de hyperparametre, vi vil justere, og deres værdier. Funktionen tune bruger den togfunktion, som vi definerede tidligere, til at oplære og evaluere modellen med den angivne konfiguration.
# 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øgeplads
Derefter skal vi definere søgeområdet for de hyperparametre, vi vil finjustere. Søgeområdet er en ordbog, der knytter hyperparameternavnene til de intervaller af værdier, vi vil udforske. FLAML indeholder nogle praktiske funktioner til at definere forskellige typer intervaller, f.eks. ensartet, loguniform og randint.
I dette tilfælde vil vi justere følgende fire hyperparametre: alpha, learningRate, 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 prøveversion af hyperparameter
Endelig skal vi definere en hyperparameter-prøveversion, der bruger FLAML til at optimere hyperparametrene. Vi skal overføre tune-funktionen, søgeområdet, tidsbudgettet, antallet af eksempler, metrikværdiens navn, tilstanden og verbositetsniveauet til funktionen flaml.tune.run. Vi skal også starte en indlejret MLflow-kørsel for at spore resultaterne af prøveversionen.
flaml.tune.run function returnerer et analyseobjekt, der indeholder den bedste konfiguration og den bedste metrikværdi.
# 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øveversionen er fuldført, kan vi se den bedste konfiguration og den bedste metrikværdi 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
Når vi har fundet de bedste hyperparametre med FLAML, skal vi evaluere, hvor meget de forbedrer modellens ydeevne. Det gør vi ved at bruge funktionen Train til at oprette en ny model med de bedste hyperparametre på det fulde oplæringsdatasæt. Derefter bruger vi testdatasættet til at beregne R2-scoren for både den nye model og den oprindelige model.
# 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)
Gem den endelige model
Når vi har fuldført vores hyperparameter-prøveversion, kan vi nu gemme den endelige, optimerede model som en ML-model 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.")