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)

Neste artigo, você aprenderá a automatizar o ajuste eficiente do hiperparâmetro 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
• Escolher um algoritmo de amostragem
• Definir o objetivo de otimização
• Configurar uma política de término antecipado
• Definir limites de tarefa de varredura
• Enviar o experimento
• Visualizar trabalhos de treinamento
• Selecione a melhor configuração

O que é ajuste de hiperparâmetro?

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 muito desses valores.

O ajuste do hiperparâmetro (ou otimização do hiperparâmetro) é o processo de localizar a configuração do hiperparâmetro que produz o melhor desempenho. Esse processo geralmente é computacionalmente caro e manual.

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 podem ter uma distribuição de valor expressa com 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)),
)

Referências:

• Escolha

Nesse caso, batch_size usa um dos [16, 32, 64, 128] e number_of_hidden_layers usa um 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

Hiperparâmetros contínuos são especificados como uma distribuição em um intervalo contínuo de valores:

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

Referências:

• Normal
• Uniforme

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.

Para a CLI, use o esquema YAML do trabalho de limpeza 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 do hiperparâmetro

Especifique o método de amostragem para o espaço do hiperparâmetro. O Azure Machine Learning dá suporte a:

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

Amostragem aleatória

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

Na amostragem aleatória, os valores são selecionados uniformemente (ou por meio da regra aleatória especificada) do espaço de busca definido. Depois de criar o 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 defina 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 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",
    ...
)

Referências: Escolha

Amostragem Bayesiana

A amostragem bayesiana (otimização bayesiana) seleciona novos exemplos com base nos resultados anteriores para melhorar a métrica primária com eficiência.

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.

A amostragem bayesiana suporta choice, uniform e 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 trabalho de limpeza 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",
)

Referências:

• Uniforme
• Escolha

Esta amostra maximiza a "precisão".

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

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

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

Referências: mlflow.log_metric

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

Termine trabalhos com baixo desempenho antecipadamente 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 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 encerramento mediana
• Política de seleção de truncamento
• Nenhuma política de término

Política Bandit

A Política Bandit utiliza um fator de folga ou valor mais um intervalo de avaliação. Ela termina um trabalho quando sua métrica primária fica fora da margem permitida do melhor trabalho.

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

• slack_factor ou slack_amount: Diferença permitida do melhor trabalho. slack_factor é uma taxa; slack_amount é um valor absoluto.

  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)

Referências: BanditPolicy

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)

Referências para MedianStoppingPolicy

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)

Referências: TruncationSelectionPolicy

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

Referências: SweepJob

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)

Referências: SweepJob.set_limits

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
)

Referências:

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

A command_job função é invocada como uma função para que você possa aplicar expressões de parâmetro. A sweep função é configurada com trialalgoritmo de amostragem, objetivo, limites e computação. O snippet vem do notebook de exemplo Executar limpeza de hiperparâmetros em um Comando ou CommandComponent. Neste exemplo, learning_rate e boosting estão ajustados. A parada antecipada é impulsionada por um MedianStoppingPolicy, que interrompe um trabalho cuja métrica primária é pior do que a mediana das médias de execução em todos os trabalhos (consulte 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 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

Referências:

• MLClient.create_or_update
• SweepJob

Visualizar trabalhos de ajuste de hiperparâmetro

Visualize trabalhos de ajuste de hiperparâmetro no Azure Machine Learning Studio. Para mais detalhes, veja Visualizar registros de atividades 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 otimização forem concluídos, recupere as melhores saídas de testes.

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

Referências:

• MLClient.jobs

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

É possível baixar apenas o melhor resultado de teste.

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)

Próximas etapas

• Rastrear um experimento
• Implantar um modelo treinado