Como fazer ajuste de hiperparâmetros em pipelines
APLICA-SE A:
Extensão de ML da CLI do Azure v2 (atual)SDK do Python azure-ai-ml v2 (atual)
Nesse artigo, você aprenderá como automatizar o ajuste de hiperparâmetros em pipelines do Azure Machine Learning usando o Azure Machine Learning CLI v2 ou o Azure Machine Learning SDK 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 automatizar o ajuste de hiperparâmetros e executar experimentos em paralelo para otimizar hiperparâmetros com eficiência.
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.
Crie e execute um pipeline de ajuste de hiperparâmetros
Os exemplos a seguir vêm de Executar um trabalho de pipeline usando sweep (hyperdrive) no pipeline no repositório de exemplos do Azure Machine Learning. Para obter mais informações sobre como criar pipelines com componentes, veja Criar e executar pipelines de machine learning usando componentes com a CLI do Azure Machine Learning.
Crie um componente de comando com entradas de hiperparâmetros
O pipeline do Azure Machine Learning deve ter um componente de comando com entradas de hiperparâmetros. O arquivo train.yml a seguir dos projetos de exemplo define um trial componente que tem as entradas de hiperparâmetros c_value, kernel e coef 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}}
Crie o código-fonte do componente de teste
O código-fonte desse exemplo é um único arquivo train.py. Esse código é executado em cada tentativa 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)
Observação
Certifique-se de registrar as métricas no código-fonte do componente de teste com exatamente o mesmo nome do valor primary_metric no arquivo do pipeline. Esse exemplo usa mlflow.autolog(), que é a maneira recomendada de rastrear experimentos de aprendizado de máquina. Para obter mais informações sobre o MLflow,veja Rastrear experimentos e modelos de ML com o MLflow.
Crie um pipeline com uma etapa de varredura de hiperparâmetro
Dado o componente de comando definido em train.yml, o código a seguir cria um arquivo de definição de pipeline de duas etapas train e predict. No sweep_step, o tipo de etapa necessária é sweep, e as c_value, kernelentradas de hiperparâmetros coef, e para o trial componente são adicionadas ao search_space.
O exemplo a seguir destaca o ajuste do hiperparâmetro 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
Para o esquema completo do trabalho de varredura, veja o esquema YAML do trabalho de varredura CLI (v2).
Enviar o trabalho do pipeline de ajuste de hiperparâmetros
Depois de enviar esse trabalho de pipeline, o Azure Machine Learning executa o componente trial várias vezes para varrer os hiperparâmetros, com base no espaço de pesquisa e nos limites definidos nosweep_step.
Exibir resultados de 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 do Azure Machine Learning.
Para visualizar os resultados do ajuste do hiperparâmetro, clique duas vezes na etapa de varredura no gráfico do pipeline, selecione a guia Trabalhos filhos no painel de detalhes e selecione o trabalho filho.
Na página do trabalho filho, selecione a guia Testes para ver e comparar métricas de todas as execuções filho. Selecione qualquer uma das execuções secundárias para ver os detalhes dessa execução.
Se uma execução secundária falhar, você pode selecionar a guia Saídas + logs na página de execução secundária para ver informações úteis de depuração.
