Ajuste de hiperparâmetro de um modelo (v2)

APLICA-SE A:Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (current)

Neste artigo, você aprenderá a automatizar o ajuste eficiente de hiperparâmetros com o SDK do Azure Machine Learning v2 e a CLI v2 usando a classe SweepJob .

• Definir o espaço de pesquisa de parâmetros
• Escolha um algoritmo de amostragem
• Definir o objetivo de otimização
• Configurar uma política de rescisão antecipada
• Definir limites de tarefa de varrimento
• Submeter a experiência
• Visualizar trabalhos de treinamento
• Selecione a melhor configuração

O que é o ajuste de hiperparâmetros?

Os hiperparâmetros são configurações ajustáveis que controlam o treinamento do modelo. Para redes neurais, por exemplo, você escolhe o número de camadas ocultas e o número de nós por camada. O desempenho do modelo depende fortemente desses valores.

O ajuste de hiperparâmetros (ou otimização de hiperparâmetros) é o processo de encontrar a configuração de hiperparâmetro que produz o melhor desempenho. Este processo é muitas vezes computacionalmente caro e manual.

O Azure Machine Learning permite-lhe automatizar o ajuste de hiperparâmetros e executar experiências em paralelo para otimizar eficientemente os hiperparâmetros.

Definir o espaço de pesquisa

Ajuste os hiperparâmetros explorando o intervalo de valores definidos para cada hiperparâmetro.

Os hiperparâmetros podem ser discretos ou contínuos e podem ter uma distribuição de valores expressa com uma expressão de parâmetro.

Hiperparâmetros discretos

Os hiperparâmetros discretos são especificados como um Choice entre valores discretos. Choice pode ser:

• um ou mais valores separados por vírgulas
• um range objeto
• qualquer objeto arbitrário list

from azure.ai.ml.sweep import Choice

command_job_for_sweep = command_job(
    batch_size=Choice(values=[16, 32, 64, 128]),
    number_of_hidden_layers=Choice(values=range(1,5)),
)

Referências:

• Escolha

Neste caso, batch_size toma um de [16, 32, 64, 128] e number_of_hidden_layers toma um de [1, 2, 3, 4].

Os seguintes hiperparâmetros discretos avançados também podem ser especificados usando uma distribuição:

• QUniform(min_value, max_value, q) - Devolve um valor como round(Uniform(min_value, max_value) / q) * q
• QLogUniform(min_value, max_value, q) - Devolve um valor como round(exp(Uniform(min_value, max_value)) / q) * q
• QNormal(mu, sigma, q) - Devolve um valor como round(Normal(mu, sigma) / q) * q
• QLogNormal(mu, sigma, q) - Devolve um valor como round(exp(Normal(mu, sigma)) / q) * q

Hiperparâmetros contínuos

Os hiperparâmetros contínuos são especificados como uma distribuição ao longo de um intervalo contínuo de valores:

• Uniform(min_value, max_value) - Devolve um valor uniformemente distribuído entre min_value e max_value
• LogUniform(min_value, max_value) - Devolve um valor desenhado de acordo com exp(Uniform(min_value, max_value)) para que o logaritmo do valor de retorno seja uniformemente distribuído
• Normal(mu, sigma) - Devolve um valor real que é normalmente distribuído com mu médio e desvio padrão sigma
• LogNormal(mu, sigma) - Devolve um valor desenhado de acordo com exp(Normal(mu, sigma)) para que o logaritmo do valor de retorno seja normalmente distribuído

Um exemplo de uma definição de espaço de parâmetro:

from azure.ai.ml.sweep import Normal, Uniform

command_job_for_sweep = command_job(   
    learning_rate=Normal(mu=10, sigma=3),
    keep_probability=Uniform(min_value=0.05, max_value=0.1),
)

Referências:

• Normal
• Uniforme

Este código define um espaço de pesquisa com dois parâmetros - learning_rate e keep_probability. learning_rate tem uma distribuição normal com valor médio 10 e desvio padrão de 3. keep_probability tem uma distribuição uniforme com um valor mínimo de 0,05 e um valor máximo de 0,1.

Para a CLI, use o esquema YAML da tarefa de varredura para definir o espaço de pesquisa:

    search_space:
        conv_size:
            type: choice
            values: [2, 5, 7]
        dropout_rate:
            type: uniform
            min_value: 0.1
            max_value: 0.2

Amostragem do espaço de hiperparâmetros

Especificar o método de amostragem para o espaço de hiperparâmetros. O Azure Machine Learning suporta:

• Amostragem aleatória
• Amostragem em grelha
• Amostragem bayesiana

Amostragem aleatória

A amostragem aleatória suporta hiperparâmetros discretos e contínuos e suporta o encerramento antecipado de trabalhos de baixo desempenho. Muitos usuários começam com amostragem aleatória para identificar regiões promissoras e, em seguida, refinam.

Na amostragem aleatória, os valores são extraídos uniformemente (ou através da regra aleatória especificada) a partir do espaço de pesquisa definido. Depois de criar seu trabalho de comando, use sweep para definir o algoritmo de amostragem.

from azure.ai.ml.entities import CommandJob
from azure.ai.ml.sweep import RandomSamplingAlgorithm, SweepJob, SweepJobLimits

   command_job = CommandJob(
       inputs=dict(kernel="linear", penalty=1.0),
       compute=cpu_cluster,
       environment=f"{job_env.name}:{job_env.version}",
       code="./scripts",
       command="python scripts/train.py --kernel $kernel --penalty $penalty",
       experiment_name="sklearn-iris-flowers",
   )

   sweep = SweepJob(
       sampling_algorithm=RandomSamplingAlgorithm(seed=999, rule="sobol", logbase="e"),
       trial=command_job,
       search_space={"ss": Choice(type="choice", values=[{"space1": True}, {"space2": True}])},
       inputs={"input1": {"file": "top_level.csv", "mode": "ro_mount"}},  # type:ignore
       compute="top_level",
       limits=SweepJobLimits(trial_timeout=600),
   )

Referências:

• CommandJob
• RandomSamplingAlgorithm
• SweepJob
• SweepJobLimits
• Escolha

Sobol

Sobol é uma sequência quase aleatória que melhora o preenchimento de espaço e a reprodutibilidade. Forneça uma semente e coloque rule="sobol" em RandomSamplingAlgorithm.

from azure.ai.ml.sweep import  RandomSamplingAlgorithm

sweep_job = command_job_for_sweep.sweep(
    compute="cpu-cluster",
    sampling_algorithm = RandomSamplingAlgorithm(seed=123, rule="sobol"),
    ...
)

Referências: RandomSamplingAlgorithm

Amostragem em grelha

A amostragem em grelha suporta hiperparâmetros discretos. Use a amostragem de grade se puder fazer um orçamento para pesquisar exaustivamente no espaço de pesquisa. Suporta a rescisão antecipada de trabalhos de baixo desempenho.

A amostragem de grade faz uma pesquisa de grade simples sobre todos os valores possíveis. A amostragem em grelha só pode ser utilizada com choice hiperparâmetros. Por exemplo, o espaço a seguir tem seis exemplos:

from azure.ai.ml.sweep import Choice

command_job_for_sweep = command_job(
    batch_size=Choice(values=[16, 32]),
    number_of_hidden_layers=Choice(values=[1,2,3]),
)

sweep_job = command_job_for_sweep.sweep(
    compute="cpu-cluster",
    sampling_algorithm = "grid",
    ...
)

Referências: Escolha

Amostragem bayesiana

A amostragem bayesiana (otimização bayesiana) seleciona novas amostras com base em resultados anteriores para melhorar a métrica primária de forma eficiente.

A amostragem bayesiana é recomendada se você tiver orçamento suficiente para explorar o espaço de hiperparâmetros. Para obter melhores resultados, recomendamos um número máximo de trabalhos maior ou igual a 20 vezes o número de hiperparâmetros que estão sendo ajustados.

O número de trabalhos simultâneos tem impacto na eficácia do processo de ajuste. Um número menor de trabalhos simultâneos pode levar a uma melhor convergência amostral, uma vez que o menor grau de paralelismo aumenta o número de trabalhos que se beneficiam de trabalhos concluídos anteriormente.

A amostragem bayesiana suporta choice, uniforme quniform distribuições.

from azure.ai.ml.sweep import Uniform, Choice

command_job_for_sweep = command_job(   
    learning_rate=Uniform(min_value=0.05, max_value=0.1),
    batch_size=Choice(values=[16, 32, 64, 128]),
)

sweep_job = command_job_for_sweep.sweep(
    compute="cpu-cluster",
    sampling_algorithm = "bayesian",
    ...
)

Referências:

• Uniforme
• Escolha

Especificar o objetivo da varredura

Defina o objetivo do seu trabalho de varredura especificando a métrica principal e a meta que você deseja otimizar o ajuste de hiperparâmetros. Cada trabalho de treinamento é avaliado pela métrica primária. A política de rescisão antecipada usa a métrica principal para identificar trabalhos de baixo desempenho.

• primary_metric: O nome da métrica primária precisa corresponder exatamente ao nome da métrica registrada pelo script de treinamento
• goal: Pode ser um ou MaximizeMinimize e determina se a métrica primária será maximizada ou minimizada ao avaliar os trabalhos.

from azure.ai.ml.sweep import Uniform, Choice

command_job_for_sweep = command_job(   
    learning_rate=Uniform(min_value=0.05, max_value=0.1),
    batch_size=Choice(values=[16, 32, 64, 128]),
)

sweep_job = command_job_for_sweep.sweep(
    compute="cpu-cluster",
    sampling_algorithm = "bayesian",
    primary_metric="accuracy",
    goal="Maximize",
)

Referências:

• Uniforme
• Escolha

Esta amostra maximiza a "precisão".

Métricas de log para ajuste de hiperparâmetros

Seu script de treinamento deve registrar a métrica principal com o nome exato esperado pelo trabalho de varredura.

Registre a métrica principal em seu script de treinamento com o seguinte trecho de exemplo:

import mlflow
mlflow.log_metric("accuracy", float(val_accuracy))

Referências: mlflow.log_metric

O script de treinamento calcula e val_accuracy registra como a métrica primária "precisão". Cada vez que a métrica é registrada, ela é recebida pelo serviço de ajuste de hiperparâmetros. Cabe a você determinar a frequência dos relatórios.

Para obter mais informações sobre o registro de valores para trabalhos de treinamento, consulte Habilitar o registro em log em trabalhos de treinamento do Azure Machine Learning.

Especificar a política de rescisão antecipada

Acabar com os trabalhos com fraco desempenho mais cedo para melhorar a eficiência.

Você pode configurar os seguintes parâmetros que controlam quando uma política é aplicada:

• evaluation_interval: a frequência de aplicação da apólice. Cada vez que o script de treinamento registra, a métrica primária conta como um intervalo. Um evaluation_interval de 1 aplicará a política sempre que o script de treinamento relatar a métrica principal. Um evaluation_interval de 2 aplicará a política a cada duas vezes. Se não for especificado, evaluation_interval é definido como 0 por padrão.
• delay_evaluation: atrasa a primeira avaliação da política para um número especificado de intervalos. Este é um parâmetro opcional que evita o encerramento prematuro de trabalhos de treinamento, permitindo que todas as configurações sejam executadas por um número mínimo de intervalos. Se especificado, a política aplica todos os múltiplos de evaluation_interval que são maiores ou iguais a delay_evaluation. Se não for especificado, delay_evaluation é definido como 0 por padrão.

O Azure Machine Learning dá suporte às seguintes políticas de encerramento antecipado:

• Política de bandidos
• Mediana da política de paragem
• Política de seleção de truncamento
• Nenhuma política de rescisão

Política de bandidos

Política de bandidos utiliza um fator de folga ou quantidade, além de um intervalo de avaliação. Ele termina um trabalho quando sua métrica principal fica fora da folga permitida do melhor trabalho.

Especifique os seguintes parâmetros de configuração:

• slack_factor ou slack_amount: Diferença permitida em relação ao melhor trabalho. slack_factor é um rácio; slack_amount é um valor absoluto.

  Por exemplo, considere uma política de bandidos aplicada no intervalo 10. Suponha que o trabalho com melhor desempenho no intervalo 10 relatou uma métrica primária é 0,8 com o objetivo de maximizar a métrica primária. Se a política especificar um slack_factor de 0,2, todos os trabalhos de treinamento cuja melhor métrica no intervalo 10 seja inferior a 0,66 (0,8/(1+slack_factor)) serão encerrados.

• evaluation_interval: (facultativo) a frequência de aplicação da apólice

• delay_evaluation: (opcional) atrasa a primeira avaliação da política para um número especificado de intervalos

from azure.ai.ml.sweep import BanditPolicy
sweep_job.early_termination = BanditPolicy(slack_factor = 0.1, delay_evaluation = 5, evaluation_interval = 1)

Referências: BanditPolicy

Neste exemplo, a política de rescisão antecipada é aplicada em todos os intervalos em que as métricas são relatadas, começando no intervalo de avaliação 5. Qualquer trabalho cuja melhor métrica seja inferior a (1/(1+0,1) ou 91% dos trabalhos com melhor desempenho será encerrado.

Mediana da política de paragem

A parada mediana é uma política de rescisão antecipada baseada em médias de execução de métricas primárias relatadas pelos trabalhos. Esta política calcula as médias em execução em todos os trabalhos de formação e interrompe os trabalhos cujo valor métrico principal é pior do que a mediana das médias.

Esta política utiliza os seguintes parâmetros de configuração:

• evaluation_interval: a frequência de aplicação da política (parâmetro opcional).
• delay_evaluation: atrasa a primeira avaliação da política para um número especificado de intervalos (parâmetro opcional).

from azure.ai.ml.sweep import MedianStoppingPolicy
sweep_job.early_termination = MedianStoppingPolicy(delay_evaluation = 5, evaluation_interval = 1)

Referências: MedianStoppingPolicy

Neste exemplo, a política de rescisão antecipada é aplicada em todos os intervalos a partir do intervalo de avaliação 5. Um trabalho é interrompido no intervalo 5 se sua melhor métrica primária for pior do que a mediana das médias de execução em intervalos de 1:5 em todos os trabalhos de treinamento.

Política de seleção de truncamento

A seleção de truncamento cancela uma porcentagem de trabalhos com desempenho mais baixo em cada intervalo de avaliação. Os trabalhos são comparados usando a métrica principal.

Esta política utiliza os seguintes parâmetros de configuração:

• truncation_percentage: a percentagem de trabalhos com pior desempenho a terminar em cada intervalo de avaliação. Um valor inteiro entre 1 e 99.
• evaluation_interval: (facultativo) a frequência de aplicação da apólice
• delay_evaluation: (opcional) atrasa a primeira avaliação da política para um número especificado de intervalos
• exclude_finished_jobs: especifica se os trabalhos concluídos devem ser excluídos ao aplicar a política

from azure.ai.ml.sweep import TruncationSelectionPolicy
sweep_job.early_termination = TruncationSelectionPolicy(evaluation_interval=1, truncation_percentage=20, delay_evaluation=5, exclude_finished_jobs=true)

Referências: TruncationSelectionPolicy

Neste exemplo, a política de rescisão antecipada é aplicada em todos os intervalos a partir do intervalo de avaliação 5. Um trabalho termina no intervalo 5 se o seu desempenho no intervalo 5 estiver nos 20% mais baixos de desempenho de todos os trabalhos no intervalo 5 e excluirá os trabalhos concluídos ao aplicar a política.

Nenhuma política de rescisão (padrão)

Se nenhuma política for especificada, o serviço de ajuste de hiperparâmetros permitirá que todos os trabalhos de treinamento sejam executados até a conclusão.

sweep_job.early_termination = None

Referências: SweepJob

Escolher uma política de rescisão antecipada

• Para uma política conservadora que proporcione economia sem encerrar empregos promissores, considere uma Política de Parada Mediana com evaluation_interval 1 e delay_evaluation 5. Essas são configurações conservadoras que podem fornecer aproximadamente 25% a 35% de economia sem perda na métrica primária (com base em nossos dados de avaliação).
• Para economias mais agressivas, use a Política de Bandido com uma folga permitida menor ou a Política de Seleção de Truncamento com uma porcentagem de truncamento maior.

Defina limites para o seu trabalho de varredura

Controle seu orçamento de recursos definindo limites para seu trabalho de varredura.

• max_total_trials: Número máximo de trabalhos experimentais. Deve ser um número inteiro entre 1 e 1000.
• max_concurrent_trials: (opcional) Número máximo de trabalhos de avaliação que podem ser executados simultaneamente. Se não for especificado, max_total_trials número de trabalhos será iniciado em paralelo. Se especificado, deve ser um número inteiro entre 1 e 1000.
• timeout: Tempo máximo em segundos que todo o trabalho de varredura pode ser executado. Uma vez atingido esse limite, o sistema cancela o trabalho de varredura, incluindo todas as suas avaliações.
• trial_timeout: Tempo máximo em segundos que cada trabalho de avaliação pode ser executado. Uma vez atingido este limite, o sistema cancela a versão experimental.

sweep_job.set_limits(max_total_trials=20, max_concurrent_trials=4, timeout=1200)

Referências: SweepJob.set_limits

Esse código configura o experimento de ajuste de hiperparâmetros para usar um máximo de 20 trabalhos de avaliação totais, executando quatro trabalhos de avaliação de cada vez com um tempo limite de 1.200 segundos para todo o trabalho de varredura.

Configurar experimento de ajuste de hiperparâmetros

Para configurar seu experimento de ajuste de hiperparâmetros, forneça o seguinte:

• O espaço de pesquisa de hiperparâmetros definido
• O seu algoritmo de amostragem
• A sua política de rescisão antecipada
• O seu objetivo
• Limites de recursos
• CommandJob ou CommandComponent
• Varredura

SweepJob pode executar uma varredura de hiperparâmetros no Command ou Command Component.

Configure seu experimento de ajuste de hiperparâmetros:

from azure.ai.ml import MLClient
from azure.ai.ml import command, Input
from azure.ai.ml.sweep import Choice, Uniform, MedianStoppingPolicy
from azure.identity import DefaultAzureCredential

# Create your base command job
command_job = command(
    code="./src",
    command="python main.py --iris-csv ${{inputs.iris_csv}} --learning-rate ${{inputs.learning_rate}} --boosting ${{inputs.boosting}}",
    environment="AzureML-lightgbm-3.2-ubuntu18.04-py37-cpu@latest",
    inputs={
        "iris_csv": Input(
            type="uri_file",
            path="https://azuremlexamples.blob.core.windows.net/datasets/iris.csv",
        ),
        "learning_rate": 0.9,
        "boosting": "gbdt",
    },
    compute="cpu-cluster",
)

# Override your inputs with parameter expressions
command_job_for_sweep = command_job(
    learning_rate=Uniform(min_value=0.01, max_value=0.9),
    boosting=Choice(values=["gbdt", "dart"]),
)

# Call sweep() on your command job to sweep over your parameter expressions
sweep_job = command_job_for_sweep.sweep(
    compute="cpu-cluster",
    sampling_algorithm="random",
    primary_metric="test-multi_logloss",
    goal="Minimize",
)

# Specify your experiment details
sweep_job.display_name = "lightgbm-iris-sweep-example"
sweep_job.experiment_name = "lightgbm-iris-sweep-example"
sweep_job.description = "Run a hyperparameter sweep job for LightGBM on Iris dataset."

# Define the limits for this sweep
sweep_job.set_limits(max_total_trials=20, max_concurrent_trials=10, timeout=7200)

# Set early stopping on this one
sweep_job.early_termination = MedianStoppingPolicy(
    delay_evaluation=5, evaluation_interval=2
)

Referências:

• MLClient
• comando
• Entrada
• Escolha
• Uniforme
• MedianStoppingPolicy
• DefaultAzureCredential

O command_job é invocado como uma função para que você possa aplicar expressões de parâmetro. A sweep função é configurada com trial, algoritmo de amostragem, objetivo, limites e computação. O trecho vem do caderno de exemplo Executar a varredura de hiperparâmetros em um Comando ou Componente de Comando. Neste exemplo, learning_rate e boosting estão ajustados. A paragem antecipada é impulsionada por um MedianStoppingPolicy, que interrompe um trabalho cuja métrica principal é pior do que a média das médias de execução em todos os trabalhos (ver referência MedianStoppingPolicy).

Para ver como os valores de parâmetro são recebidos, analisados e passados para o script de treinamento a ser ajustado, consulte este exemplo de código

Enviar experimento de ajuste de hiperparâmetro

Depois de definir sua configuração de ajuste de hiperparâmetro, envie o trabalho:

# submit the sweep
returned_sweep_job = ml_client.create_or_update(sweep_job)
# get a URL for the status of the job
returned_sweep_job.services["Studio"].endpoint

Referências:

• MLClient.create_or_update
• SweepJob

Visualizar trabalhos de ajuste de hiperparâmetros

Visualize trabalhos de ajuste de hiperparâmetros no estúdio do Azure Machine Learning. Para obter detalhes, consulte Visualizar registos de trabalho no estúdio.

• Gráfico de métricas: esta visualização rastreia as métricas registradas para cada trabalho filho do hyperdrive durante a duração do ajuste do hiperparâmetro. Cada linha representa um trabalho filho e cada ponto mede o valor da métrica primária nessa iteração de tempo de execução.

  

• Gráfico de coordenadas paralelas: esta visualização mostra a correlação entre o desempenho da métrica primária e os valores de hiperparâmetros individuais. O gráfico é interativo através do movimento de eixos (selecione e arraste pelo rótulo do eixo) e destacando valores em um único eixo (selecione e arraste verticalmente ao longo de um único eixo para destacar um intervalo de valores desejados). O gráfico de coordenadas paralelas inclui um eixo na parte mais à direita do gráfico que plota o melhor valor métrico correspondente aos hiperparâmetros definidos para essa instância de trabalho. Este eixo é fornecido para projetar a legenda do gradiente do gráfico nos dados de uma forma mais legível.

  

• Gráfico de Dispersão 2-Dimensional: Esta visualização mostra a correlação entre quaisquer dois hiperparâmetros individuais, juntamente com o seu valor métrico primário associado.

  

• Gráfico de Dispersão 3-Dimensional: Esta visualização é a mesma que 2D, mas permite três dimensões hipermétricas de correlação com o valor métrico primário. Você também pode selecionar e arrastar para reorientar o gráfico para visualizar diferentes correlações no espaço 3D.

  

Encontre o melhor trabalho de avaliação

Depois de concluir todos os processos de ajuste, recupere os melhores resultados de teste.

# Download best trial model output
ml_client.jobs.download(returned_sweep_job.name, output_name="model")

Referências:

• MLClient.jobs

Você pode usar a CLI para baixar todas as saídas padrão e nomeadas do melhor trabalho de avaliação e logs do trabalho de varredura.

az ml job download --name <sweep-job> --all

Opcionalmente, transfira apenas a melhor versão experimental:

az ml job download --name <sweep-job> --output-name model

Referências

• Exemplo de ajuste de hiperparâmetro
• Esquema YAML da tarefa de varrimento CLI (v2)

Próximos passos

• Rastrear um experimento
• Implantar um modelo treinado