Hyperparametrin säädännän suorittaminen Fabricissa (esiversio)
Hyperparametrin säätö on prosessi, jossa etsitään optimaaliset arvot koneoppimismallin parametreille, jotka vaikuttavat sen suorituskykyyn. Se voi olla haastavaa ja aikaa vievää, etenkin käsiteltäessä monimutkaisia malleja ja suuria tietojoukkoja. Tässä artikkelissa näytämme sinulle, miten hyperparametrin säätö suoritetaan Fabricissa.
Tässä opetusohjelmassa käytämme Kalifornian asuntotietojoukkoa, joka sisältää tietoja talon mediaaniarvosta ja muista ominaisuuksista Kalifornian eri väestönlaskentalohkoissa. Kun tiedot on valmis, harjoitamme SynapseML LightGBM -mallin talon arvon ennustamiseksi ominaisuuksien perusteella. Seuraavaksi käytämme FLAML-kirjastoa, nopeaa ja kevyttä AutoML-kirjastoa, parhaiden hyperparametrien löytämiseksi LightGBM-mallille. Lopuksi vertaamme viritetyn mallin tuloksia perusmalliin, joka käyttää oletusparametreja.
Edellytykset
Hanki Microsoft Fabric -tilaus. Voit myös rekisteröityä ilmaiseen Microsoft Fabric -kokeiluversioon.
Siirry Synapse Data Science -käyttökokemukseen aloitussivun vasemmassa reunassa olevan käyttökokemuksen vaihtajan avulla.
- Luo uusi Fabric-ympäristö tai varmista, että käytössäsi ovat Fabric Runtime 1.2 (Spark 3.4 (tai uudempi) ja Delta 2.4)
- Luo uusi muistikirja.
- Liitä muistikirjasi Lakehouseen. Valitse muistikirjasi vasemmasta reunasta Lisää , jos haluat lisätä aiemmin luodun lakehousen tai luoda uuden.
Koulutuksen ja testitietojoukkojen valmistelu
Tässä osiossa valmistelemme LightGBM-mallin harjoittamisen ja testaamisen tietojoukot. Käytämme Kalifornian asuntotietojoukkoa Sklearnista. Luomme spark-tietokehyksen tiedoista ja yhdistämme ominaisuudet yhdeksi vektorisarakkeeksi VectorAssemblerin avulla.
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)
Jaamme tiedot satunnaisesti kolmeen alijoukkoon, jotka ovat koulutus, vahvistus ja testi, 85 %, 12,75 % ja 2,25 % tiedoista. Käytämme harjoitus- ja vahvistusjoukkoja hyperparametrin viritykseen ja testijoukkoa mallin arviointia varten.
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)
Koneoppimiskokeilun määrittäminen
MLflow'n määrittäminen
Ennen hyperparametrin säätöä meidän on määritettävä junafunktio, joka voi ottaa hyperparametrien eri arvoja ja harjoittaa LightGBM-mallin harjoitustiedoissa. Meidän on myös arvioitava mallin suorituskyky vahvistustiedoissa käyttämällä R2-pistemäärää, joka mittaa, miten hyvin malli sopii tietoihin.
Tätä varten tuomme ensin tarvittavat moduulit ja määritämme MLflow-kokeilun. MLflow on avoin lähdekoodi alusta, jolla hallitaan koneoppimisen elinkaarta alusta loppuun. Se auttaa seuraamaan ja vertailemaan eri mallien ja hyperparametrien tuloksia.
# 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)
Kirjaamisen tason määrittäminen
Tässä määritämme kirjaustason estääksemme Synapse.ml kirjaston tarpeettomat tulokset, mikä pitää lokit siistimpinä.
import logging
logging.getLogger('synapse.ml').setLevel(logging.ERROR)
Junan perusmalli
Seuraavaksi määritämme syötteeksi junafunktion, joka ottaa neljä hyperparametria: alfa, learningRate, numLeaves ja numIterations. Nämä ovat hyperparametreita, joita haluamme hienosäätää myöhemmin FLAML:n avulla.
Train-funktion syötteenä on myös kaksi tietokehystä: train_data ja val_data. Ne ovat koulutuksen ja vahvistuksen tietojoukot. Train-funktio palauttaa kaksi tulostetta: harjoitetun mallin ja vahvistustietojen R2-pisteet.
# 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
Lopuksi käytämme train-funktiota perusmallin harjoittamiseen hyperparametrien oletusarvoilla. Arvioimme myös testitietojen perusmallin ja tulostamme R2-pistemäärän.
# 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)
Hyperparametrin virittämisen suorittaminen FLAML:n avulla
FLAML on nopea ja kevyt AutoML-kirjasto, joka löytää automaattisesti parhaat hyperparametrit tietylle mallille ja tietojoukolle. Se käyttää halpahakustrategiaa, joka sopeutuu arviointimittarin palautteeseen. Tässä osiossa käytämme FLAML-funktiota edellisessä osiossa määritetyn LightGBM-mallin hyperparametrien hienosäätämiseen.
Tune-funktion määrittäminen
Jotta voimme käyttää FLAML-funktiota, meidän on määritettävä tune-funktio, joka ottaa syötteeksi määrityshakemiston ja palauttaa hakemiston, jonka avaimena on arviointiarvo ja arvo mittausarvona.
Määrityshakemisto sisältää hyperparametrit, joita haluamme hienosäätää, ja niiden arvot. Tune-funktio käyttää aiemmin määrittämäämme train-funktiota, jolla harjoitetaan ja arvioidaan malli annetulla määrityksellä.
# 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}
Määritä hakutila
Seuraavaksi meidän on määritettävä niiden hyperparametrien hakutila, joita haluamme hienosäätää. Hakutila on sanasto, joka yhdistää hyperparametrin nimet arvoalueisiin, joita haluamme tutkia. FLAML tarjoaa käteviä funktioita erityyppisten alueiden määrittämiseen, kuten uniform, loguniform ja randint.
Tässä tapauksessa haluamme hienosäätää seuraavia neljää hyperparametria: alfa, learningRate, numLeaves ja 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),
}
Hyperparametrin kokeiluversion määrittäminen
Lopuksi meidän on määritettävä hyperparametrin kokeiluversio, joka käyttää FLAML-parametria hyperparametreiden optimointiin. Meidän on välitettävä tune-funktio, hakutila, aikabudjetti, näytteiden määrä, mittarin nimi, tila ja verbositeettitaso flaml.tune.run-funktioon. Meidän on myös aloitettava sisäkkäinen MLflow-suoritus, jotta voimme seurata kokeiluversion tuloksia.
flaml.tune.run function palauttaa analyysiobjektin, joka sisältää parhaan määrityksen ja parhaan mittausarvon.
# 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,
)
Kun kokeilu on valmis, voimme tarkastella parhaita määrityksiä ja analyysiobjektin parasta mittausarvoa.
# 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"])
Tulosten vertaileminen
Kun olet löytänyt parhaat FLAML-hyperparametrit, meidän on arvioitava, kuinka paljon ne parantavat mallin suorituskykyä. Tässä luomme junafunktion avulla uuden mallin, jossa on parhaat hyperparametrit koko harjoittamisen tietojoukossa. Laskemme sitten testitietojoukon avulla sekä uuden mallin että perusmallin R2-pisteet.
# 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)
Tallenna lopullinen malli
Kun hyperparameter-kokeilu on valmis, voimme nyt tallentaa lopullisen, viritetyn mallin koneoppimismallina Fabricissa.
# 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.")