Réglage des hyperparamètres dans les pipelines
S’APPLIQUE À :
Extension Azure CLI v2 (actuelle)Kit de développement logiciel (SDK) Python azure-ai-ml v2 (version actuelle)
Dans cet article, vous allez apprendre à automatiser le réglage des hyperparamètres dans les pipelines Azure Machine Learning à l’aide d’Azure Machine Learning CLI v2 ou du Kit de développement logiciel (SDK) Azure Machine Learning pour Python v2.
Les hyperparamètres sont des paramètres réglables qui vous permettent de contrôler le processus d’entraînement du modèle. L’optimisation des hyperparamètres est le processus de recherche de la configuration des hyperparamètres qui produit les meilleures performances. Azure Machine Learning vous permet d’automatiser le réglage des hyperparamètres et d’exécuter des expérimentations parallèles pour optimiser efficacement les hyperparamètres.
Prérequis
- Disposer d’un compte et d’un espace de travail Azure Machine Learning.
- Comprendre les pipelines Azure Machine Learning et le réglage des hyperparamètres d'un modèle.
Créer et exécuter un pipeline de réglage des hyperparamètres
Les exemples suivants proviennent de la section Exécuter une tâche de pipeline à l’aide d’une organisation (hyperdrive) du référentiel azureml-examples . Pour plus d’informations sur la création de pipelines avec des composants, consultez Créer et exécuter des pipelines Machine Learning à l’aide de composants avec l’interface CLI Azure Machine Learning.
Créer un composant de commande avec des entrées d’hyperparamètre
Le pipeline Azure Machine Learning doit avoir un composant de commande avec des entrées d’hyperparamètre. Le fichier train.yml suivant à partir des exemples de projets définit un composant trial qui a les entrées d’hyperparamètres c_value, kernel et coef et exécute le code source situé dans le dossier ./train-src.
$schema: https://azuremlschemas.azureedge.net/latest/commandComponent.schema.json
type: command
name: train_model
display_name: train_model
version: 1
inputs:
data:
type: uri_folder
c_value:
type: number
default: 1.0
kernel:
type: string
default: rbf
degree:
type: integer
default: 3
gamma:
type: string
default: scale
coef0:
type: number
default: 0
shrinking:
type: boolean
default: false
probability:
type: boolean
default: false
tol:
type: number
default: 1e-3
cache_size:
type: number
default: 1024
verbose:
type: boolean
default: false
max_iter:
type: integer
default: -1
decision_function_shape:
type: string
default: ovr
break_ties:
type: boolean
default: false
random_state:
type: integer
default: 42
outputs:
model_output:
type: mlflow_model
test_data:
type: uri_folder
code: ./train-src
environment: azureml://registries/azureml/environments/sklearn-1.5/labels/latest
command: >-
python train.py
--data ${{inputs.data}}
--C ${{inputs.c_value}}
--kernel ${{inputs.kernel}}
--degree ${{inputs.degree}}
--gamma ${{inputs.gamma}}
--coef0 ${{inputs.coef0}}
--shrinking ${{inputs.shrinking}}
--probability ${{inputs.probability}}
--tol ${{inputs.tol}}
--cache_size ${{inputs.cache_size}}
--verbose ${{inputs.verbose}}
--max_iter ${{inputs.max_iter}}
--decision_function_shape ${{inputs.decision_function_shape}}
--break_ties ${{inputs.break_ties}}
--random_state ${{inputs.random_state}}
--model_output ${{outputs.model_output}}
--test_data ${{outputs.test_data}}
Créer le code source du composant d’essai
Le code source de cet exemple est un fichier train.py unique. Ce code s’exécute dans chaque version d’essai de la tâche de balayage.
# imports
import os
import mlflow
import argparse
import pandas as pd
from pathlib import Path
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
# define functions
def main(args):
# enable auto logging
mlflow.autolog()
# setup parameters
params = {
"C": args.C,
"kernel": args.kernel,
"degree": args.degree,
"gamma": args.gamma,
"coef0": args.coef0,
"shrinking": args.shrinking,
"probability": args.probability,
"tol": args.tol,
"cache_size": args.cache_size,
"class_weight": args.class_weight,
"verbose": args.verbose,
"max_iter": args.max_iter,
"decision_function_shape": args.decision_function_shape,
"break_ties": args.break_ties,
"random_state": args.random_state,
}
# read in data
df = pd.read_csv(args.data)
# process data
X_train, X_test, y_train, y_test = process_data(df, args.random_state)
# train model
model = train_model(params, X_train, X_test, y_train, y_test)
# Output the model and test data
# write to local folder first, then copy to output folder
mlflow.sklearn.save_model(model, "model")
from distutils.dir_util import copy_tree
# copy subdirectory example
from_directory = "model"
to_directory = args.model_output
copy_tree(from_directory, to_directory)
X_test.to_csv(Path(args.test_data) / "X_test.csv", index=False)
y_test.to_csv(Path(args.test_data) / "y_test.csv", index=False)
def process_data(df, random_state):
# split dataframe into X and y
X = df.drop(["species"], axis=1)
y = df["species"]
# train/test split
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=random_state
)
# return split data
return X_train, X_test, y_train, y_test
def train_model(params, X_train, X_test, y_train, y_test):
# train model
model = SVC(**params)
model = model.fit(X_train, y_train)
# return model
return model
def parse_args():
# setup arg parser
parser = argparse.ArgumentParser()
# add arguments
parser.add_argument("--data", type=str)
parser.add_argument("--C", type=float, default=1.0)
parser.add_argument("--kernel", type=str, default="rbf")
parser.add_argument("--degree", type=int, default=3)
parser.add_argument("--gamma", type=str, default="scale")
parser.add_argument("--coef0", type=float, default=0)
parser.add_argument("--shrinking", type=bool, default=False)
parser.add_argument("--probability", type=bool, default=False)
parser.add_argument("--tol", type=float, default=1e-3)
parser.add_argument("--cache_size", type=float, default=1024)
parser.add_argument("--class_weight", type=dict, default=None)
parser.add_argument("--verbose", type=bool, default=False)
parser.add_argument("--max_iter", type=int, default=-1)
parser.add_argument("--decision_function_shape", type=str, default="ovr")
parser.add_argument("--break_ties", type=bool, default=False)
parser.add_argument("--random_state", type=int, default=42)
parser.add_argument("--model_output", type=str, help="Path of output model")
parser.add_argument("--test_data", type=str, help="Path of output model")
# parse args
args = parser.parse_args()
# return args
return args
# run script
if __name__ == "__main__":
# parse args
args = parse_args()
# run main function
main(args)
Remarque
Veillez à consigner les métriques dans le code source du composant d’essai avec exactement le même nom que la valeur primary_metric dans le fichier de pipeline. Cet exemple utilise mlflow.autolog(), qui est la méthode recommandée pour suivre les expériences de Machine Learning. Pour plus d’informations sur MLflow, consultez Suivre les expériences ML et des modèles avec MLflow.
Créer un pipeline avec une étape de balayage d’hyperparamètre
Étant donné le composant de commande défini dans train.yml, le code suivant crée un fichier de définition de pipeline en deux étapes train et predict. Dans sweep_step, le type d’étape requis est sweep, et les entrées d’hyperparamètre c_value, kernel et coef pour le composant trial sont ajoutées au search_space.
L’exemple suivant met en évidence le réglage des hyperparamètres sweep_step.
$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline
display_name: pipeline_with_hyperparameter_sweep
description: Tune hyperparameters using TF component
settings:
default_compute: azureml:cpu-cluster
jobs:
sweep_step:
type: sweep
inputs:
data:
type: uri_file
path: wasbs://datasets@azuremlexamples.blob.core.windows.net/iris.csv
degree: 3
gamma: "scale"
shrinking: False
probability: False
tol: 0.001
cache_size: 1024
verbose: False
max_iter: -1
decision_function_shape: "ovr"
break_ties: False
random_state: 42
outputs:
model_output:
test_data:
sampling_algorithm: random
trial: ./train.yml
search_space:
c_value:
type: uniform
min_value: 0.5
max_value: 0.9
kernel:
type: choice
values: ["rbf", "linear", "poly"]
coef0:
type: uniform
min_value: 0.1
max_value: 1
objective:
goal: minimize
primary_metric: training_f1_score
limits:
max_total_trials: 5
max_concurrent_trials: 3
timeout: 7200
predict_step:
type: command
inputs:
model: ${{parent.jobs.sweep_step.outputs.model_output}}
test_data: ${{parent.jobs.sweep_step.outputs.test_data}}
outputs:
predict_result:
component: ./predict.yml
Pour connaître le schéma complet de la tâche de balayage, consultez schéma YAML de la tâche d’organisation CLI (v2).
Envoyer la tâche de pipeline de réglage des hyperparamètres
Après avoir envoyé cette tâche de pipeline, Azure Machine Learning exécute plusieurs fois le composant trial pour balayer les hyperparamètres, en fonction de l’espace de recherche et des limites que vous avez définis dans le sweep_step.
Afficher les résultats du réglage des hyperparamètres dans Studio
Une fois que vous avez envoyé une tâche de pipeline, le widget Kit de développement logiciel (SDK) ou CLI vous donne un lien d’URL web vers le graphique de pipeline dans l’interface utilisateur d’Azure Machine Learning Studio.
Pour afficher les résultats du réglage des hyperparamètres, double-cliquez sur l’étape de balayage dans le graphique de pipeline, sélectionnez l’onglet Tâche enfants dans le volet d’informations, puis sélectionnez la tâche enfant.
Dans la page de la tâche enfant, sélectionnez l’onglet Essais pour afficher et comparer les métriques pour toutes les exécutions enfants. Sélectionnez l’une des exécutions enfants pour afficher les détails de cette exécution.
Si une exécution enfant a échoué, vous pouvez sélectionner l'onglet Sorties + journaux d’activité de la page d’exécution enfant pour afficher des informations de débogage utiles.
