Partilhar via


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

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_valueentradas , 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_steptipo de etapa necessário é sweep, e as c_valueentradas , kernel, e coef hiperparâmetro para o trial componente são adicionadas ao search_space.

O exemplo a seguir destaca o ajuste de sweep_stephiperparâ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.

Captura de tela do pipeline com o trabalho filho e o nó train_model realçado.

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.

Captura de ecrã da página de trabalho da criança com o separador Versões experimentais.

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.

Captura de ecrã do separador de saída e registos de uma execução infantil.