Fazer ajuste de hiperparâmetro em um modelo (v2)

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)SDK do Python azure-ai-ml v2 (atual)

Automatize o ajuste eficiente de hiperparâmetro usando o SDK do Azure Machine Learning v2 e a CLI v2 por meio do tipo SweepJob.

1. Definir o espaço de pesquisa de parâmetros para sua avaliação
2. Especificar o algoritmo de amostragem para seu trabalho de varredura
3. Especificar o objetivo para otimizar
4. Especificar a política de término antecipado para trabalhos de baixo desempenho
5. Definir limites para o trabalho de varredura
6. Inicializar um teste com a configuração definida
7. Visualizar os trabalhos de treinamento
8. Selecionar a melhor configuração para o modelo

O que é ajuste de hiperparâmetro?

Os hiperparâmetros são parâmetros ajustáveis que permitem controlar o processo de treinamento do modelo. Por exemplo, com redes neurais, você decide o número de camadas ocultas e o número de nós em cada camada. O desempenho do modelo depende muito dos hiperparâmetros.

O ajuste de hiperparâmetro, também chamado de otimização de hiperparâmetro, é o processo de localizar a configuração de hiperparâmetros que resulta no melhor desempenho. O processo normalmente é manual e caro em termos computacionais.

O Azure Machine Learning permite automatizar o ajuste de hiperparâmetro e executar experimentos em paralelo para otimizar os hiperparâmetros com eficiência.

Definir o espaço de pesquisa

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

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

Hiperparâmetros discretos

Hiperparâmetros discretos podem ser especificados como um Choice entre valores discretos. Choice pode ser:

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

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)),
)

Nesse caso, batch_size um dos valores [16, 32, 64, 128] e number_of_hidden_layers assume um dos valores de [1, 2, 3, 4].

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

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

Hiperparâmetros contínuos

Os hiperparâmetros contínuos podem ser especificados como uma distribuição em um intervalo de valores contínuos:

• Uniform(min_value, max_value) – Retorna um valor distribuído uniformemente entre min_value e max_value
• LogUniform(min_value, max_value) – Retorna um valor traçado conforme exp(Uniform(min_value, max_value)), de modo que o logaritmo do valor retornado seja distribuído uniformemente
• Normal(mu, sigma) – Retorna um valor real normalmente distribuído com sigma de desvio padrão e mu médio
• LogNormal(mu, sigma) – Retorna um valor traçado conforme exp(Normal(mu, sigma)) de modo que o logaritmo do valor retornado 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),
)

Esse 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 um desvio padrão de 3 e o valor médio 10. keep_probability tem uma distribuição uniforme com um valor mínimo de 0,05 e um valor máximo de 0.1.

Na CLI, você pode usar o esquema YAML do trabalho de varredura, para definir o espaço de pesquisa em seu YAML:

    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 do hiperparâmetro

Especifique o método de amostragem de parâmetro para usar sobre o espaço do hiperparâmetro. O Azure Machine Learning oferece suporte aos seguintes métodos:

• Amostragem aleatória
• Amostragem de grade
• Amostragem Bayesiana

Amostragem aleatória

A amostragem aleatória dá suporte a hiperparâmetros discretos e contínuos. Ela dá suporte ao término antecipado de trabalhos de baixo desempenho. Alguns usuários fazem uma pesquisa inicial com amostragem aleatória e depois refinam o espaço de pesquisa para melhorar os resultados.

Na amostragem Aleatória, os valores de hiperparâmetro serão selecionadas aleatoriamente do espaço de pesquisa definido. Depois de criar o trabalho de comando, você pode usar o parâmetro de varredura para definir o algoritmo de amostragem.

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

command_job_for_sweep = command_job(   
    learning_rate=Normal(mu=10, sigma=3),
    keep_probability=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 = "random",
    ...
)

Sobol

Sobol é um tipo de amostragem aleatória compatível com tipos de trabalho de varredura. Você pode usar sobol para reproduzir seus resultados usando a propagação e cobrir a distribuição do espaço de pesquisa de maneira mais uniforme.

Para usar sobol, use a classe RandomParameterSampling para adicionar a propagação e a regra, conforme mostrado no exemplo abaixo.

from azure.ai.ml.sweep import RandomParameterSampling

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

Amostragem de grade

A amostragem de grade dá suporte a hiperparâmetros discretos. Use a amostragem de grade se você tem o orçamento para pesquisar exaustivamente no espaço de pesquisa. Dá suporte ao término antecipado de trabalhos de baixo desempenho.

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

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",
    ...
)

Amostragem Bayesiana

A amostragem Bayesiana é baseada no algoritmo de otimização Bayesiano. Ela escolhe amostras com base em como as amostras anteriores faziam, para que novas amostras melhorem a métrica primária.

A amostragem Bayesiana é recomendada se você tiver orçamento suficiente para explorar o espaço de hiperparâmetro. 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 um impacto na eficácia do processo de ajuste. Um número menor de trabalhos simultâneos pode resultar em uma convergência de amostragem melhor, pois o menor grau de paralelismo aumenta o número de trabalhos que se beneficiam de trabalhos concluídos anteriormente.

Amostragem Bayesiana dá apenas suporte a distribuições choice, uniform e quniform no espaço de pesquisa.

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",
    ...
)

Especificar o objetivo da varredura

Defina o objetivo do trabalho de varredura especificando a métrica primária e a meta que você deseja que o ajuste do hiperparâmetro otimize. Cada trabalho de treinamento é avaliado para a métrica principal. A política de término antecipado usa a métrica primária para identificar trabalhos de baixo desempenho.

• primary_metric: o nome da métrica primária deve corresponder exatamente ao nome da métrica registrada pelo script de treinamento
• goal: pode ser tanto Maximize quanto Minimize e determina se a métrica primária será maximizada ou minimizada ao avaliar as 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",
)

Esta amostra maximiza a "precisão".

Registrar em log métricas de ajuste de hiperparâmetro

O script de treinamento para o modelo deve registrar a métrica primária durante o treinamento do modelo usando o mesmo nome de métrica correspondente para que o SweepJob possa acessá-la para o ajuste de hiperparâmetro.

Registre a métrica primária no script de treinamento com o seguinte snippet de exemplo:

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

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

Para obter mais informações sobre log de valores de trabalhos de treinamento, confira Habilitar o log nos trabalhos de treinamento do Azure Machine Learning.

Especificar política de rescisão antecipada

Encerra automaticamente trabalhos de baixo desempenho com uma política de término antecipado. O término antecipado melhora a eficiência computacional.

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

• evaluation_interval: a frequência de aplicação da política. Cada vez que o script de treinamento registra em log 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 primária. Um evaluation_interval de 2 aplicará a política de duas em duas vezes. Se não for especificado, evaluation_interval será definido como 0 por padrão.
• delay_evaluation: atrasa a primeira avaliação de política para um número especificado de intervalos. Este é um parâmetro opcional que evita o término prematuro de trabalhos de treinamento ao permitir que todas as configurações sejam executadas por um número mínimo de intervalos. Se for especificado, a política se aplicará a cada múltiplo de evaluation_interval maior ou igual a delay_evaluation. Se não for especificado, delay_evaluation será definido como 0 por padrão.

O Azure Machine Learning tem suporte para as seguintes políticas de término antecipado:

• Política Bandit
• Política de interrupção de mediana
• Política de seleção de truncamento
• Nenhuma política de encerramento

Política Bandit

A política Bandit é baseada em intervalo de avaliação e quantidade de margem de atraso/fator de margem de atraso. A política Bandit termina um trabalho quando a métrica primária não estiver dentro do fator/valor da margem de atraso especificado do trabalho de melhor desempenho.

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

• slack_factor ou slack_amount: a margem de atraso permitida em relação o trabalho de treinamento de melhor desempenho. slack_factor especifica a margem de atraso permitida como uma proporção. slack_amount especifica a margem de atraso permitida como um valor absoluto, em vez de uma proporção.

  Por exemplo, considere uma política Bandit aplicada no intervalo de 10. Suponha que o trabalho de melhor desempenho no intervalo 10 tenha relatado uma métrica primária de 0,8 com uma meta para maximizar a métrica primária. Se a política especifica um slack_factor de 0,2, qualquer trabalho de treinamento, cuja melhor métrica no intervalo 10 seja menor que 0,66 (0,8/(1+slack_factor)), será encerrado.

• evaluation_interval: (opcional) a frequência de aplicação da política

• delay_evaluation: (opcional) atrasa a primeira avaliação de política por 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)

Neste exemplo, a política de encerramento inicial é aplicada a cada intervalo quando as métricas são relatadas, começando no intervalo de avaliação 5. Qualquer trabalho cuja melhor métrica seja menor que (1/(1+0,1) ou 91% do trabalho de melhor desempenho, será encerrado.

Política de Encerramento Mediana

Encerramento de mediana é uma política de término antecipado com base em médias de execução de métricas primárias relatadas pelos trabalhos. Esta política computa as médias de execução em todos os trabalhos de treinamento e encerra trabalhos cujo valor da métrica primária seja pior do que a mediana das médias.

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

• evaluation_interval: a frequência para aplicar a política (parâmetro opcional).
• delay_evaluation: atrasa a primeira avaliação de 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)

Neste exemplo, a política de encerramento inicial é aplicada a cada intervalo começando em um intervalo de avaliação 5. Um trabalho será encerrado no intervalo 5 se a sua melhor métrica primária for pior do que o valor da mediana das médias das execuções em intervalos de 1:5 entre todos os trabalhos de treinamento.

Política de seleção de truncamento

A seleção de truncamento cancela um percentual dos trabalhos de menor desempenho a cada intervalo de avaliação. Os trabalhos são comparados usando a métrica primária.

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

• truncation_percentage: o percentual dos trabalhos de menor desempenho a encerrar a cada intervalo de avaliação. Um valor inteiro entre 1 e 99.
• evaluation_interval: (opcional) a frequência de aplicação da política
• delay_evaluation: (opcional) atrasa a primeira avaliação de política por 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)

Neste exemplo, a política de encerramento inicial é aplicada a cada intervalo começando em um intervalo de avaliação 5. Uma trabalho será encerrado no intervalo 5 se o seu desempenho no intervalo 5 estiver nos 20% mais baixos do desempenho de todos os trabalhos do intervalo 5 e excluirá os trabalhos concluídos na aplicação da política.

Sem política de término (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

Selecionar uma política de término antecipado

• Para uma política conservadora que proporciona economia sem encerrar trabalhos promissores, considere uma política de término médio 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 Bandit com uma menor margem de atraso permitida ou política de seleção de truncamento com uma porcentagem maior de truncamento.

Definir limites para o trabalho de varredura

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

• max_total_trials: número máximo de trabalhos de avaliação. Precisa 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 especificado, número de max_total_trials de trabalhos iniciados em paralelo. Se especificado, precisa ser um inteiro entre 1 e 1000.
• timeout: o tempo máximo em segundos em que todo o trabalho de limpeza tem permissão para ser executado. Quando esse limite for atingido, o sistema cancelará o trabalho de varredura, incluindo todas as respectivas avaliações gratuitas.
• trial_timeout: tempo máximo, em segundos, que cada trabalho de avaliação tem permissão para ser executado. Quando esse limite for atingido, o sistema cancelará a avaliação gratuita.

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

Esse código configura o experimento de ajuste de hiperparâmetro para usar no máximo um total de 20 trabalhos de avaliação, executando quatro trabalhos de avaliação por vez com um tempo limite de 1,200 minutos para todo o trabalho de varredura.

Configurar experimento de ajuste de hiperparâmetro

Para configurar o experimento de ajuste de hiperparâmetro, forneça:

• O espaço de pesquisa do hiperparâmetro definido
• O algoritmo de amostragem
• A política de término antecipado
• O objetivo
• Limites de recursos
• CommandJob ou CommandComponent
• SweepJob

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

Configurar seu experimento de ajuste de hiperparâmetro:

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
)

O command_job é chamado como uma função para que possamos aplicar as expressões de parâmetro às entradas de varredura. Em seguida, a função sweep é configurada com trial, sampling-algorithm, objective, limits e compute. O snippet de código acima é obtido do notebook de exemplo Executar varredura de hiperparâmetro em um Command ou CommandComponent. Nesta amostra, os parâmetros learning_rate e boosting serão ajustados. A interrupção antecipada de trabalhos será determinada por um MedianStoppingPolicy, que para um trabalho cujo valor de métrica primário seja pior do que a mediana das médias de todos os trabalhos de treinamento (consulte Referência da classe 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 a 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

Visualizar trabalhos de ajuste de hiperparâmetro

Você pode visualizar todos os trabalhos de ajuste de hiperparâmetro no Estúdio do Azure Machine Learning. Para obter mais informações sobre como ver um experimento no portal, confira Exibir registros de trabalho no estúdio.

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

  

• 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âmetro individuais. O gráfico é interativo por meio da movimentação de eixos (selecione e arraste pelo rótulo do eixo) e ao destacar 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 de métrica correspondente ao conjunto de hiperparâmetros definido para essa instância de trabalho. Esse eixo é fornecido para projetar a legenda de gradiente do gráfico nos dados de maneira mais legível.

  

• Gráfico de dispersão bidimensional: esta visualização mostra a correlação entre dois hiperparâmetros individuais juntamente com o valor de métrica primária associado.

  

• Gráfico de dispersão tridimensional: esta visualização é igual à bidimensional, mas permite três dimensões de hiperparâmetro de correlação com o valor principal de métrica. Você também pode selecionar e arrastar para reorientar o gráfico para exibir diferentes correlações no espaço tridimensional.

  

Encontrar o melhor trabalho de avaliação

Depois que todos os trabalhos de ajuste do hiperparâmetro tiverem sido concluídos, recupere as melhores saídas da avaliação:

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

Use a CLI para baixar todas as saídas padrão e nomeadas do melhor trabalho de avaliação e os logs do trabalho de varredura.

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

Opcionalmente, você pode baixar apenas a melhor saída de avaliação

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

Referências

• Exemplo de ajuste de hiperparâmetro
• Esquema YAML do trabalho de limpeza da CLI (v2) aqui

Próximas etapas

• Rastrear um experimento
• Implantar um modelo treinado