Fazer ajuste de hiperparâmetro em um modelo com o Azure Machine Learning (v1)

APLICA-SE A:Extensão de ML da CLI do Azure v1

Automatize o ajuste de hiperparâmetro eficiente usando o pacote HyperDrive do Azure Machine Learning (v1). Saiba como concluir as etapas necessárias para ajustar os hiperparâmetros com o SDK do Azure Machine Learning:

1. Defina o espaço de pesquisa de parâmetro
2. Especificar uma métrica primária para otimizar
3. Especificar a política de término antecipado para execuções de baixo desempenho
4. Criar e atribuir recursos
5. Inicializar um teste com a configuração definida
6. Visualizar as execuções de treinamento
7. 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

    {
        "batch_size": choice(16, 32, 64, 128)
        "number_of_hidden_layers": choice(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(low, high, q) – Retorna um valor como round(uniform(low, high) / q) * q
• qloguniform(low, high, q) – Retorna um valor como round(exp(uniform(low, high)) / 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(low, high) – Retorna um valor distribuído uniformemente entre baixo e alto
• loguniform(low, high) – Retorna um valor traçado conforme exp(uniform(low, high)) 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 é normalmente distribuído

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

    {    
        "learning_rate": normal(10, 3),
        "keep_probability": uniform(0.05, 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.

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 execuções 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.

from azureml.train.hyperdrive import RandomParameterSampling
from azureml.train.hyperdrive import normal, uniform, choice
param_sampling = RandomParameterSampling( {
        "learning_rate": normal(10, 3),
        "keep_probability": uniform(0.05, 0.1),
        "batch_size": choice(16, 32, 64, 128)
    }
)

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 execuções 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 azureml.train.hyperdrive import GridParameterSampling
from azureml.train.hyperdrive import choice
param_sampling = GridParameterSampling( {
        "num_hidden_layers": choice(1, 2, 3),
        "batch_size": choice(16, 32)
    }
)

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 execuções maiores ou iguais a 20 vezes o número de hiperparâmetros sendo ajustados.

O número de execuções simultâneas tem um impacto na eficácia do processo de ajuste. Um número menor de execuções simultâneas resultar em uma convergência de amostragem melhor, desde que o menor grau de paralelismo aumente o número de execuções que se beneficiam de execuções concluídas anteriormente.

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

from azureml.train.hyperdrive import BayesianParameterSampling
from azureml.train.hyperdrive import uniform, choice
param_sampling = BayesianParameterSampling( {
        "learning_rate": uniform(0.05, 0.1),
        "batch_size": choice(16, 32, 64, 128)
    }
)

Especificar métrica principal

Especifique a métrica primária que você deseja que o ajuste de hiperparâmetro otimize. Cada execução de treinamento é avaliada para a métrica principal. A política de término antecipado usa a métrica primária para identificar execuções de baixo desempenho.

Especifique os seguintes atributos para a métrica primária:

• primary_metric_name: o nome da métrica primária deve corresponder exatamente ao nome da métrica registrada pelo script de treinamento
• primary_metric_goal: pode ser tanto PrimaryMetricGoal.MAXIMIZE quanto PrimaryMetricGoal.MINIMIZE e determina se a métrica primária será maximizada ou minimizada ao avaliar as execuções.

primary_metric_name="accuracy",
primary_metric_goal=PrimaryMetricGoal.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 para que o HyperDrive possa acessá-la para ajuste de hiperparâmetro.

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

from azureml.core.run import Run
run_logger = Run.get_context()
run_logger.log("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 como registrar em log valores em execuções de treinamento de modelo, confira Habilitar o log em execuções de treinamento do Azure Machine Learning.

Especificar política de rescisão antecipada

Encerra automaticamente execuções 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 é definido como 1 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 execuções 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.

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. Bandit termina as execuções quando a métrica primária não estiver dentro do fator de margem de atraso/valor da margem de atraso especificado da execução mais bem-sucedida.

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

• slack_factor ou slack_amount: a margem de atraso permitida em relação à execução 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 a execução 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, toda execução de treinamento cuja melhor métrica no intervalo de 10 for menor que 0,66 (0,8/(1+slack_factor)) será encerrada.

• 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 azureml.train.hyperdrive import BanditPolicy
early_termination_policy = BanditPolicy(slack_factor = 0.1, evaluation_interval=1, delay_evaluation=5)

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 execução cuja melhor métrica seja menor que (1/(1+0,1) ou 91% da execução de melhor desempenho será encerrada.

Política de Encerramento Mediana

Encerramento mediana é uma política de término antecipado com base em médias de execução de métricas primárias relatadas pelas execuções. Esta política computa as médias de execução em todas as execuções de treinamento e encerra execuções cujo valor da métrica primária for pior do que o valor mediano 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 azureml.train.hyperdrive import MedianStoppingPolicy
early_termination_policy = MedianStoppingPolicy(evaluation_interval=1, delay_evaluation=5)

Neste exemplo, a política de encerramento inicial é aplicada a cada intervalo começando em um intervalo de avaliação 5. Uma execução será encerrada no intervalo de 5 se a sua melhor métrica primária for pior do que o valor mediano de médias de execução em intervalos de 1:5 em todas as execuções de treinamento.

Política de seleção de truncamento

A seleção de truncamento cancela um percentual das execuções de menor desempenho a cada intervalo de avaliação. As execuções são comparadas usando a métrica primária.

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

• truncation_percentage: o percentual de execuções 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 azureml.train.hyperdrive import TruncationSelectionPolicy
early_termination_policy = 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 execução será encerrada no intervalo de 5 se o seu desempenho no intervalo de 5 estiver nos 20% mais baixos de desempenho de todas as execuções em um intervalo de 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âmetro permitirá que todas as execuções de treinamento sejam executadas até a conclusão.

policy=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.

Criar e atribuir recursos

Controle o orçamento para recursos especificando o número máximo de execuções de treinamento.

• max_total_runs: número máximo de execuções de treinamento. Precisa ser um número inteiro entre 1 e 1000.
• max_duration_minutes: (opcional) duração máxima em minutos do experimento de ajuste de hiperparâmetro. É executado quando essa duração é cancelada.

Além disso, especifique o número máximo de execuções de treinamento a serem executadas simultaneamente durante sua pesquisa de ajuste de hiperparâmetro.

• max_concurrent_runs: (opcional) número máximo de execuções que podem ser executadas simultaneamente. Se não for especificado, todas as execuções são iniciadas em paralelo. Se especificado, o tempo limite deve ser um número inteiro entre 1 e 100.

max_total_runs=20,
max_concurrent_runs=4

Esse código configura o experimento de ajuste de hiperparâmetro para usar um máximo de 20 execuções no total, executando quatro configurações por vez.

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
• A política de término antecipado
• A métrica principal
• Configurações de alocação de recurso
• ScriptRunConfig script_run_config

O ScriptRunConfig é o script de treinamento executado com os hiperparâmetros amostrados. Ele define os recursos por trabalho (único ou vários nós) e o destino de computação que será usado.

Configurar seu experimento de ajuste de hiperparâmetro:

from azureml.train.hyperdrive import HyperDriveConfig
from azureml.train.hyperdrive import RandomParameterSampling, BanditPolicy, uniform, PrimaryMetricGoal

param_sampling = RandomParameterSampling( {
        'learning_rate': uniform(0.0005, 0.005),
        'momentum': uniform(0.9, 0.99)
    }
)

early_termination_policy = BanditPolicy(slack_factor=0.15, evaluation_interval=1, delay_evaluation=10)

hd_config = HyperDriveConfig(run_config=script_run_config,
                             hyperparameter_sampling=param_sampling,
                             policy=early_termination_policy,
                             primary_metric_name="accuracy",
                             primary_metric_goal=PrimaryMetricGoal.MAXIMIZE,
                             max_total_runs=100,
                             max_concurrent_runs=4)

O HyperDriveConfig define os parâmetros passados para o ScriptRunConfig script_run_config. O script_run_config, por sua vez, passa parâmetros para o script de treinamento. O snippet de código acima é extraído do notebook de amostra Treinamento, ajuste de hiperparâmetro e implantação com PyTorch. Nesta amostra, os parâmetros learning_rate e momentum serão ajustados. A interrupção antecipada de execuções será determinada por um BanditPolicy, que interrompe uma execução cuja métrica primária ficar fora do slack_factor (consulte a referência da classe BanditPolicy).

O seguinte código do exemplo mostra como os valores que estão sendo ajustados são recebidos, analisados e passados para a função fine_tune_model do script de treinamento:

# from pytorch_train.py
def main():
    print("Torch version:", torch.__version__)

    # get command-line arguments
    parser = argparse.ArgumentParser()
    parser.add_argument('--num_epochs', type=int, default=25,
                        help='number of epochs to train')
    parser.add_argument('--output_dir', type=str, help='output directory')
    parser.add_argument('--learning_rate', type=float,
                        default=0.001, help='learning rate')
    parser.add_argument('--momentum', type=float, default=0.9, help='momentum')
    args = parser.parse_args()

    data_dir = download_data()
    print("data directory is: " + data_dir)
    model = fine_tune_model(args.num_epochs, data_dir,
                            args.learning_rate, args.momentum)
    os.makedirs(args.output_dir, exist_ok=True)
    torch.save(model, os.path.join(args.output_dir, 'model.pt'))

Enviar experimento de ajuste de hiperparâmetro

Depois de definir a configuração de ajuste de hiperparâmetro, envie o experimento:

from azureml.core.experiment import Experiment
experiment = Experiment(workspace, experiment_name)
hyperdrive_run = experiment.submit(hd_config)

Ajuste de hiperparâmetro de inicialização a quente (opcional)

Encontrar os melhores valores de hiperparâmetro para seu modelo pode ser um processo iterativo. Você pode reutilizar o conhecimento das cinco execuções anteriores para acelerar o ajuste de hiperparâmetro.

A inicialização a quente é tratada de forma diferente dependendo do método de amostragem:

• Amostragem Bayesiana: as avaliações da execução anterior são usadas como conhecimento prévio para escolher novas amostras e para melhorar a métrica primária.
• Amostragem aleatória ou amostragem de grade: o término antecipado usa o conhecimento de execuções anteriores para determinar execuções com baixo desempenho.

Especifique a lista de execuções pai a partir das quais você deseja fazer a inicialização a quente.

from azureml.train.hyperdrive import HyperDriveRun

warmstart_parent_1 = HyperDriveRun(experiment, "warmstart_parent_run_ID_1")
warmstart_parent_2 = HyperDriveRun(experiment, "warmstart_parent_run_ID_2")
warmstart_parents_to_resume_from = [warmstart_parent_1, warmstart_parent_2]

Se um experimento de ajuste de hiperparâmetro for cancelado, você poderá retomar as execuções de treinamento do último ponto de verificação. No entanto, o script de treinamento deve tratar a lógica do ponto de verificação.

A execução de treinamento deve usar a mesma configuração de hiperparâmetro e montar as pastas de saídas. O script de treinamento deve aceitar o argumento resume-from, que contém os arquivos de ponto de verificação ou de modelo dos quais retomar a execução de treinamento. Você pode retomar as execuções de treinamento individuais usando o seguinte snippet:

from azureml.core.run import Run

resume_child_run_1 = Run(experiment, "resume_child_run_ID_1")
resume_child_run_2 = Run(experiment, "resume_child_run_ID_2")
child_runs_to_resume = [resume_child_run_1, resume_child_run_2]

É possível configurar o experimento de ajuste de hiperparâmetro para fazer a inicialização a quente de um experimento anterior ou retomar execuções de treinamento individuais usando os parâmetros opcionais resume_from e resume_child_runs na configuração:

from azureml.train.hyperdrive import HyperDriveConfig

hd_config = HyperDriveConfig(run_config=script_run_config,
                             hyperparameter_sampling=param_sampling,
                             policy=early_termination_policy,
                             resume_from=warmstart_parents_to_resume_from,
                             resume_child_runs=child_runs_to_resume,
                             primary_metric_name="accuracy",
                             primary_metric_goal=PrimaryMetricGoal.MAXIMIZE,
                             max_total_runs=100,
                             max_concurrent_runs=4)

Visualizar execuções de ajuste de hiperparâmetro

Você pode visualizar as execuções de ajuste de hiperparâmetro no Estúdio do Azure Machine Learning ou pode usar um widget de notebook.

Estúdio

Você pode visualizar todas as execuções de ajuste de hiperparâmetro no Estúdio do Azure Machine Learning. Para obter mais informações sobre como exibir um experimento no portal, confira exibir registros de execução no estúdio.

• Gráfico de métricas: esta visualização acompanha as métricas registradas para cada execução filho no hyperdrive executada durante o ajuste de hiperparâmetro. Cada linha representa uma execução filho e cada ponto mede o valor principal da métrica nessa iteração de 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 que plota o melhor valor de métrica correspondente ao conjunto de hiperparâmetros definido para essa instância de execução. 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.

  

Widget de notebook

Use o widget de Notebook para visualizar o progresso das execuções de treinamento. O snippet a seguir visualiza todas as execuções em um único lugar em um bloco de anotações do Jupyter de ajuste de seu parâmetro:

from azureml.widgets import RunDetails
RunDetails(hyperdrive_run).show()

Esse código exibe uma tabela com detalhes sobre as execuções de treinamento para cada uma das configurações de hiperparâmetro.

Você também pode visualizar o desempenho de cada uma das execuções à medida que o treinamento avança.

Localizar o melhor modelo

Depois de concluir todas as execuções de ajuste de hiperparâmetro, identifique a configuração de melhor desempenho e os valores de hiperparâmetro:

best_run = hyperdrive_run.get_best_run_by_primary_metric()
best_run_metrics = best_run.get_metrics()
parameter_values = best_run.get_details()['runDefinition']['arguments']

print('Best Run Id: ', best_run.id)
print('\n Accuracy:', best_run_metrics['accuracy'])
print('\n learning rate:',parameter_values[3])
print('\n keep probability:',parameter_values[5])
print('\n batch size:',parameter_values[7])

Exemplo de bloco de anotações

Consulte os notebooks train-hyperparameter-* nesta pasta:

• how-to-use-azureml/ml-frameworks

Saiba como executar notebooks seguindo o artigo Usar os notebooks do Jupyter para explorar esse serviço.

Próximas etapas

• Rastrear um experimento
• Implantar um modelo treinado