Hyperparameterafstemming uitvoeren in pijplijn (v2)
VAN TOEPASSING OP:
Azure CLI ml-extensie v2 (huidig)Python SDK azure-ai-ml v2 (huidig)
In dit artikel leert u hoe u hyperparameters kunt afstemmen in de Azure Machine Learning-pijplijn.
Vereiste
- Inzicht in wat hyperparameterafstemming is en hoe u hyperparameters kunt afstemmen in Azure Machine Learning met behulp van SweepJob.
- Inzicht in wat een Azure Machine Learning-pijplijn is
- Bouw een opdrachtonderdeel dat hyperparameter als invoer gebruikt.
Hyperparameterafstemming uitvoeren in Azure Machine Learning-pijplijn
In deze sectie wordt uitgelegd hoe u hyperparameters kunt afstemmen in azure Machine Learning-pijplijn met behulp van CLI v2 en Python SDK. Beide benaderingen hebben dezelfde vereiste: u hebt al een opdrachtonderdeel gemaakt en het opdrachtonderdeel gebruikt hyperparameters als invoer. Als u nog geen opdrachtonderdeel hebt. Volg de onderstaande koppelingen om eerst een opdrachtonderdeel te maken.
CLI v2
Het voorbeeld dat in dit artikel wordt gebruikt, vindt u in de opslagplaats azureml-example. Navigeer naar [azureml-examples/cli/jobs/pipelines-with-components/pipeline_with_hyperparameter_sweep om het voorbeeld te controleren.
Stel dat u al een opdrachtonderdeel hebt gedefinieerd in train.yaml. Een YAML-bestand voor een pijplijntaak in twee stappen (trainen en voorspellen) ziet er als volgt uit.
$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
De sweep_step is de stap voor het afstemmen van hyperparameters. Het type moet zijn sweep. En trial verwijst naar het opdrachtonderdeel dat is gedefinieerd in train.yaml. In het search space veld zien we dat drie hyparmeters (c_value, kernel, en coef) worden toegevoegd aan de zoekruimte. Nadat u deze pijplijntaak hebt verzonden, voert Azure Machine Learning het proefonderdeel meerdere keren uit om hyperparameters te verwijderen op basis van de zoekruimte en het beleid te beëindigen dat u hebt gedefinieerd in sweep_step. Controleer het YAML-schema van de sweeptaak voor het volledige schema van de opruimentaak.
Hieronder ziet u de definitie van het evaluatieonderdeel (train.yml-bestand).
$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.0/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}}
De hyperparameters die zijn toegevoegd aan de zoekruimte in pipeline.yml, moeten invoer zijn voor het evaluatieonderdeel. De broncode van het proefonderdeel bevindt zich onder ./train-src de map . In dit voorbeeld is het één train.py bestand. Dit is de code die wordt uitgevoerd in elke proefversie van de sweep-taak. Zorg ervoor dat u de metrische gegevens in de broncode van het proefonderdeel hebt geregistreerd met exact dezelfde naam als primary_metric de waarde in het bestand pipeline.yml. In dit voorbeeld gebruiken mlflow.autolog()we , wat de aanbevolen manier is om uw ML-experimenten bij te houden. Meer informatie over mlflow vindt u hier
Het onderstaande codefragment is de broncode van het evaluatieonderdeel.
# 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)
Python-SDK
Het Python SDK-voorbeeld vindt u in de opslagplaats azureml-example. Navigeer naar azureml-examples/sdk/jobs/pipelines/1c_pipeline_with_hyperparameter_sweep om het voorbeeld te controleren.
In Azure Machine Learning Python SDK v2 kunt u hyperparameterafstemming inschakelen voor elk opdrachtonderdeel door de methode aan te roepen .sweep() .
Het onderstaande codefragment laat zien hoe u opruimen inschakelt voor train_model.
train_component_func = load_component(source="./train.yml")
score_component_func = load_component(source="./predict.yml")
# define a pipeline
@pipeline()
def pipeline_with_hyperparameter_sweep():
"""Tune hyperparameters using sample components."""
train_model = train_component_func(
data=Input(
type="uri_file",
path="wasbs://datasets@azuremlexamples.blob.core.windows.net/iris.csv",
),
c_value=Uniform(min_value=0.5, max_value=0.9),
kernel=Choice(["rbf", "linear", "poly"]),
coef0=Uniform(min_value=0.1, max_value=1),
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,
)
sweep_step = train_model.sweep(
primary_metric="training_f1_score",
goal="minimize",
sampling_algorithm="random",
compute="cpu-cluster",
)
sweep_step.set_limits(max_total_trials=20, max_concurrent_trials=10, timeout=7200)
score_data = score_component_func(
model=sweep_step.outputs.model_output, test_data=sweep_step.outputs.test_data
)
pipeline_job = pipeline_with_hyperparameter_sweep()
# set pipeline level compute
pipeline_job.settings.default_compute = "cpu-cluster"We laden train_component_func eerst gedefinieerd in train.yml het bestand. Bij het maken van train_modelvoegen we , kernel en coef0 toe c_valueaan de zoekruimte (regel 15-17). Regel 30-35 definieert het primaire metrische gegeven, het sampling-algoritme, enzovoort.
Pijplijntaak controleren met de stap Opruimen in Studio
Nadat u een pijplijntaak hebt verzonden, geeft de SDK- of CLI-widget u een web-URL-koppeling naar de gebruikersinterface van Studio. De koppeling leidt u standaard naar de pijplijngrafiekweergave.
Als u de details van de veegstap wilt controleren, dubbelklikt u op de stap opruimen en navigeert u naar het tabblad onderliggende taak in het deelvenster aan de rechterkant.
Hiermee wordt u naar de pagina van de sweep-taak gekoppeld, zoals te zien is in de onderstaande schermopname. Navigeer naar het tabblad Onderliggende taak . Hier ziet u de metrische gegevens van alle onderliggende taken en een lijst met alle onderliggende taken.
Als een onderliggende taak is mislukt, selecteert u de naam van die onderliggende taak om de detailpagina van die specifieke onderliggende taak op te geven (zie schermopname hieronder). De nuttige foutopsporingsinformatie vindt u onder Uitvoer en logboeken.
