Como fazer o ajuste de hiperparâmetros em pipelines
APLICA-SE A:Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (current)
Neste artigo, você aprenderá a automatizar o ajuste de hiperparâmetros nos pipelines do Azure Machine Learning usando a CLI v2 do Azure Machine Learning ou o SDK do Azure Machine Learning para Python v2.
Os hiperparâmetros são parâmetros ajustáveis que permitem controlar o processo de treinamento do modelo. O ajuste de hiperparâmetros é o processo de encontrar a configuração de hiperparâmetros que resulta no melhor desempenho. O Azure Machine Learning permite-lhe automatizar o ajuste de hiperparâmetros e executar experiências em paralelo para otimizar eficientemente os hiperparâmetros.
Pré-requisitos
- Tenha uma conta e um espaço de trabalho do Azure Machine Learning.
- Entenda os pipelines do Azure Machine Learning e o ajuste de hiperparâmetros de um modelo.
Criar e executar um pipeline de ajuste de hiperparâmetros
Os exemplos a seguir vêm de Executar um trabalho de pipeline usando varredura (hyperdrive) em pipeline no repositório de exemplos do Azure Machine Learning. Para obter mais informações sobre como criar pipelines com componentes, consulte Criar e executar pipelines de aprendizado de máquina usando componentes com a CLI do Azure Machine Learning.
Criar um componente de comando com entradas de hiperparâmetro
O pipeline do Azure Machine Learning deve ter um componente de comando com entradas de hiperparâmetro. O arquivo de train.yml a seguir dos projetos de exemplo define um trial
componente que tem as c_value
entradas , kernel
, e coef
hyperparameter e executa o código-fonte localizado na pasta ./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}}
Criar o código-fonte do componente de avaliação
O código-fonte deste exemplo é um único arquivo train.py . Esse código é executado em todas as versões de avaliação do trabalho de varredura.
# 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)
Nota
Certifique-se de registrar as métricas no código-fonte do componente de avaliação com exatamente o mesmo nome do primary_metric
valor no arquivo de pipeline. Este exemplo usa mlflow.autolog()
, que é a maneira recomendada de rastrear experimentos de aprendizado de máquina. Para obter mais informações sobre MLflow, consulte Rastrear experimentos e modelos de ML com MLflow.
Criar um pipeline com uma etapa de varredura de hiperparâmetros
Dado o componente de comando definido em train.yml, o código a seguir cria um arquivo de definição de pipeline e predict
duas etapastrain
. No , o sweep_step
tipo de etapa necessário é sweep
, e as c_value
entradas , kernel
, e coef
hiperparâmetro para o trial
componente são adicionadas ao search_space
.
O exemplo a seguir destaca o ajuste de sweep_step
hiperparâmetros.
$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
Para obter o esquema de trabalho de varredura completo, consulte Esquema YAML do trabalho de varredura CLI (v2).
Enviar o trabalho de pipeline de ajuste de hiperparâmetro
Depois de enviar esse trabalho de pipeline, o Aprendizado de Máquina do Azure executa o trial
componente várias vezes para varrer os hiperparâmetros, com base no espaço de pesquisa e nos limites definidos no sweep_step
.
Veja os resultados do ajuste de hiperparâmetros no estúdio
Depois de enviar um trabalho de pipeline, o widget SDK ou CLI fornece um link de URL da Web para o gráfico de pipeline na interface do usuário do estúdio de Aprendizado de Máquina do Azure.
Para exibir os resultados do ajuste de hiperparâmetros, clique duas vezes na etapa de varredura no gráfico de pipeline, selecione a guia Trabalhos filho no painel de detalhes e, em seguida, selecione o trabalho filho.
Na página Trabalho filho, selecione a guia Avaliações para ver e comparar as métricas de todas as execuções filho. Selecione qualquer uma das execuções filho para ver os detalhes dessa execução.
Se uma execução filho falhar, você pode selecionar a guia Saídas + logs na página de execução filho para ver informações úteis de depuração.