Otimize hiperparâmetros com o Amazon SageMaker Automatic Model Tuning

Os modelos de aprendizado de máquina (ML) estão conquistando o mundo. Seu desempenho depende do uso dos dados de treinamento corretos e da escolha do modelo e algoritmo corretos. Mas não acaba aqui. Normalmente, os algoritmos adiam algumas decisões de design para o profissional de ML adotar para seus dados e tarefas específicos. Essas decisões de design adiadas se manifestam como hiperparâmetros.

O que esse nome significa? O resultado do treinamento de ML, o modelo, pode ser amplamente visto como uma coleção de parâmetros que são aprendidos durante o treinamento. Portanto, os parâmetros usados ​​para configurar o processo de treinamento de ML são chamados de hiperparâmetros - parâmetros que descrevem a criação de parâmetros. De qualquer forma, eles são de uso muito prático, como o número de épocas para treinar, a taxa de aprendizado, a profundidade máxima de uma árvore de decisão e assim por diante. E damos muita atenção a eles porque têm um grande impacto no desempenho final do seu modelo.

Assim como girar um botão em um receptor de rádio para encontrar a frequência certa, cada hiperparâmetro deve ser cuidadosamente ajustado para otimizar o desempenho. Pesquisar o espaço de hiperparâmetros para os valores ideais é referido como ajuste de hiperparâmetro or otimização de hiperparâmetros (HPO) e deve resultar em um modelo que forneça previsões precisas.

Nesta postagem, configuramos e executamos nosso primeiro trabalho HPO usando Ajuste automático de modelo do Amazon SageMaker (AMT). Aprendemos sobre os métodos disponíveis para explorar os resultados e criamos algumas visualizações perspicazes de nossos testes de HPO e a exploração do espaço de hiperparâmetros!

Ajuste automático de modelo do Amazon SageMaker

Como um praticante de ML usando SageMaker AMT, você pode se concentrar no seguinte:

• Fornecer um trabalho de treinamento
• Definindo a métrica de objetivo certa que corresponda à sua tarefa
• Escopo do espaço de pesquisa de hiperparâmetros

O SageMaker AMT cuida do resto, e você não precisa pensar na infraestrutura, orquestrar trabalhos de treinamento e melhorar a seleção de hiperparâmetros.

Vamos começar usando o SageMaker AMT para nosso primeiro trabalho HPO simples, para treinar e ajustar um algoritmo XGBoost. Queremos que sua jornada AMT seja prática e prática, por isso compartilhamos o exemplo a seguir Repositório GitHub. Esta postagem abrange o 1_tuning_of_builtin_xgboost.ipynb notebook.

Em uma próxima postagem, vamos estender a noção de apenas encontrar os melhores hiperparâmetros e incluir o aprendizado sobre o espaço de pesquisa e a quais faixas de hiperparâmetros um modelo é sensível. Também mostraremos como transformar uma atividade de ajuste único em uma conversa de várias etapas com o praticante de ML, para aprendermos juntos. Fique ligado (trocadilho intencional)!

Pré-requisitos

Este post é para qualquer pessoa interessada em aprender sobre HPO e não requer conhecimento prévio do assunto. Familiaridade básica com conceitos de ML e programação Python é útil. Para obter a melhor experiência de aprendizado, é altamente recomendável acompanhar por executando cada etapa no notebook em paralelo à leitura deste post. E no final do notebook, você também pode experimentar uma visualização interativa que dá vida aos resultados do ajuste.

Visão geral da solução

Vamos criar uma configuração completa para executar nosso primeiro trabalho de HPO usando o SageMaker AMT. Quando nosso trabalho de ajuste estiver concluído, examinamos alguns dos métodos disponíveis para explorar os resultados, tanto por meio do Console de gerenciamento da AWS e programaticamente por meio dos AWS SDKs e APIs.

Primeiro, nos familiarizamos com o ambiente e o treinamento do SageMaker executando um trabalho de treinamento autônomo, sem nenhum ajuste por enquanto. Usamos o algoritmo XGBoost, um dos muitos algoritmos fornecidos como um Algoritmo integrado do SageMaker (sem script de treinamento necessário!).

Vemos como o treinamento SageMaker opera das seguintes maneiras:

• Inicia e interrompe uma instância
• Fornece o contêiner necessário
• Copia os dados de treinamento e validação na instância
• Executa o treinamento
• Coleta métricas e logs
• Coleta e armazena o modelo treinado

Em seguida, passamos para AMT e executamos um trabalho HPO:

• Configuramos e lançamos nosso trabalho de tuning com AMT
• Mergulhamos nos métodos disponíveis para extrair métricas e metadados de desempenho detalhados para cada trabalho de treinamento, o que nos permite aprender mais sobre os valores ideais em nosso espaço de hiperparâmetros
• Mostramos como visualizar os resultados dos testes
• Fornecemos ferramentas para visualizar dados em uma série de gráficos que revelam informações valiosas sobre nosso espaço de hiperparâmetros

Treine um algoritmo XGBoost integrado do SageMaker

Tudo começa com o treinamento de um modelo. Ao fazer isso, temos uma noção de como o Treinamento SageMaker funciona.

Queremos aproveitar a velocidade e a facilidade de uso oferecidas pelo SageMaker algoritmos integrados. Tudo o que precisamos são alguns passos para começar o treinamento:

1. Preparar e carregar os dados – Baixamos e preparamos nosso conjunto de dados como entrada para o XGBoost e o carregamos em nosso Serviço de armazenamento simples da Amazon (Amazon S3).
2. Selecione o URI da imagem do nosso algoritmo integrado – O SageMaker usa esse URI para buscar nosso contêiner de treinamento, que em nosso caso contém um script de treinamento XGBoost pronto para uso. Várias versões de algoritmo são suportadas.
3. Defina os hiperparâmetros – O SageMaker fornece uma interface para definir o hiperparâmetros para o nosso algoritmo embutido. Esses são os mesmos hiperparâmetros usados ​​pela versão de código aberto.
4. Construir o estimador – Definimos os parâmetros de treinamento, como tipo de instância e número de instâncias.
5. Chame a função fit() – Começamos nosso trabalho de treinamento.

O diagrama a seguir mostra como essas etapas funcionam juntas.

Forneça os dados

Para executar o treinamento de ML, precisamos fornecer dados. Fornecemos nossos dados de treinamento e validação ao SageMaker via Amazon S3.

Em nosso exemplo, para simplificar, usamos o bucket padrão do SageMaker para armazenar nossos dados. Mas fique à vontade para personalizar os seguintes valores de acordo com sua preferência:

sm_sess = sagemaker.session.Session([..])

BUCKET = sm_sess.default_bucket()
PREFIX = 'amt-visualize-demo'
output_path = f's3://{BUCKET}/{PREFIX}/output'

No notebook, usamos um conjunto de dados público e armazenamos os dados localmente no data diretório. Em seguida, carregamos nossos dados de treinamento e validação no Amazon S3. Mais tarde, também definimos ponteiros para esses locais para passá-los para o SageMaker Training.

# acquire and prepare the data (not shown here)
# store the data locally
[..]
train_data.to_csv('data/train.csv', index=False, header=False)
valid_data.to_csv('data/valid.csv', index=False, header=False)
[..]
# upload the local files to S3
boto_sess.resource('s3').Bucket(BUCKET).Object(os.path.join(PREFIX, 'data/train/train.csv')).upload_file('data/train.csv')
boto_sess.resource('s3').Bucket(BUCKET).Object(os.path.join(PREFIX, 'data/valid/valid.csv')).upload_file('data/valid.csv')

Neste post, nos concentramos na introdução do HPO. Para ilustração, usamos um conjunto de dados e tarefa específicos, para que possamos obter medições de métricas objetivas que usamos para otimizar a seleção de hiperparâmetros. No entanto, para o cargo geral, nem os dados nem a tarefa importam. Para apresentar uma imagem completa, vamos descrever brevemente o que fazemos: treinamos um modelo XGBoost que deve classificar dígitos manuscritos do
Conjunto de dados de reconhecimento óptico de dígitos manuscritos [1] via Scikit-learn. O XGBoost é um excelente algoritmo para dados estruturados e pode até ser aplicado ao conjunto de dados Digits. Os valores são imagens 8×8, como no exemplo a seguir mostrando um
0 a
5 e de um
4.

Selecione o URI da imagem XGBoost

Depois de escolher nosso algoritmo integrado (XGBoost), devemos recuperar o URI da imagem e passá-lo para o SageMaker para carregar em nossa instância de treinamento. Para esta etapa, revisamos o versões disponíveis. Aqui decidimos usar a versão 1.5.1, que oferece a versão mais recente do algoritmo. Dependendo da tarefa, os profissionais de ML podem escrever seu próprio roteiro de treinamento que, por exemplo, inclui etapas de preparação de dados. Mas isso não é necessário no nosso caso.

Se você quiser escrever seu próprio roteiro de treinamento, fique atento, nós o ajudaremos em nosso próximo post! Mostraremos como executar trabalhos de treinamento do SageMaker com seus próprios scripts de treinamento personalizados.

Por enquanto, precisamos do URI de imagem correto especificando o algoritmo, a região da AWS e o número da versão:

xgboost_container = sagemaker.image_uris.retrieve('xgboost', region, '1.5-1')

É isso. Agora temos uma referência ao algoritmo XGBoost.

Defina os hiperparâmetros

Agora definimos nossos hiperparâmetros. Esses valores configuram como nosso modelo será treinado e, eventualmente, influenciam o desempenho do modelo em relação à métrica objetiva com a qual estamos medindo, como a precisão em nosso caso. Observe que nada no bloco de código a seguir é específico do SageMaker. Na verdade, estamos usando o versão de código aberto do XGBoost, apenas fornecido e otimizado para o SageMaker.

Embora cada um desses hiperparâmetros seja configurável e ajustável, a métrica objetiva multi:softmax é determinado pelo nosso conjunto de dados e pelo tipo de problema que estamos resolvendo. Em nosso caso, o conjunto de dados Digits contém vários rótulos (uma observação de um dígito manuscrito pode ser 0 or 1,2,3,4,5,6,7,8,9), o que significa que é um problema de classificação multiclasse.

hyperparameters = {
    'num_class': 10,
    'max_depth': 5,
    'eta':0.2,
    'alpha': 0.2,
    'objective':'multi:softmax',
    'eval_metric':'accuracy',
    'num_round':200,
    'early_stopping_rounds': 5
}

Para obter mais informações sobre os outros hiperparâmetros, consulte Hiperparâmetros XGBoost.

Construir o estimador

Configuramos o treinamento em um objeto estimador, que é uma interface de alto nível para o SageMaker Training.

Em seguida, definimos o número de instâncias nas quais treinar, o tipo de instância (baseada em CPU ou baseada em GPU) e o tamanho do armazenamento anexado:

estimator = sagemaker.estimator.Estimator(
    image_uri=xgboost_container, 
    hyperparameters=hyperparameters,
    role=role,
    instance_count=1, 
    instance_type='ml.m5.large', 
    volume_size=5, # 5 GB 
    output_path=output_path
)

Agora temos a configuração de infraestrutura necessária para começar. O treinamento SageMaker cuidará do resto.

Chame a função fit()

Lembra dos dados que carregamos no Amazon S3 anteriormente? Agora criamos referências a ele:

s3_input_train = TrainingInput(s3_data=f's3://{BUCKET}/{PREFIX}/data/train', content_type='csv')
s3_input_valid = TrainingInput(s3_data=f's3://{BUCKET}/{PREFIX}/data/valid', content_type='csv')

Uma chamada para fit() lança nosso treinamento. Passamos as referências aos dados de treinamento que acabamos de criar para apontar o SageMaker Training para nossos dados de treinamento e validação:

estimator.fit({'train': s3_input_train, 'validation': s3_input_valid})

Observe que, para executar o HPO posteriormente, não precisamos chamar fit() aqui. Só precisamos do objeto estimador mais tarde para HPO e podemos pular para a criação de nosso trabalho de HPO. Mas, como queremos aprender sobre o treinamento do SageMaker e ver como executar um único trabalho de treinamento, o chamamos aqui e analisamos o resultado.

Após o início do treinamento, começamos a ver a saída abaixo das células, conforme mostrado na captura de tela a seguir. A saída está disponível em Amazon CloudWatch assim como neste caderno.

O texto em preto é a saída de log do próprio SageMaker, mostrando as etapas envolvidas na orquestração de treinamento, como iniciar a instância e carregar a imagem de treinamento. O texto azul é gerado diretamente da própria instância de treinamento. Podemos observar o processo de carregamento e análise dos dados de treinamento e ver visualmente o progresso do treinamento e a melhoria na métrica objetiva diretamente do script de treinamento em execução na instância.

Observe também que no final do trabalho de saída, a duração do treinamento em segundos e os segundos faturáveis ​​são mostrados.

Por fim, vemos que o SageMaker carrega nosso modelo de treinamento no caminho de saída do S3 definido no objeto estimador. O modelo está pronto para ser implantado para inferência.

Em uma postagem futura, criaremos nosso próprio contêiner de treinamento e definiremos nossas métricas de treinamento a serem emitidas. Você verá como o SageMaker é independente de qual contêiner você passa para treinamento. Isso é muito útil quando você deseja começar rapidamente com um algoritmo integrado, mas depois decide passar seu próprio script de treinamento personalizado!

Inspecionar trabalhos de treinamento atuais e anteriores

Até agora, trabalhamos em nosso notebook com nosso código e enviamos trabalhos de treinamento para o SageMaker. Vamos mudar de perspectiva e deixar o bloco de anotações por um momento para verificar como isso se parece no console do SageMaker.

O SageMaker mantém um registro histórico dos trabalhos de treinamento executados, suas configurações, como hiperparâmetros, algoritmos, entrada de dados, tempo faturável e resultados. Na lista da captura de tela anterior, você vê os trabalhos de treinamento mais recentes filtrados para XGBoost. O trabalho de treinamento destacado é o trabalho que acabamos de treinar no notebook, cuja saída você viu anteriormente. Vamos mergulhar neste trabalho de treinamento individual para obter mais informações.

A captura de tela a seguir mostra a visualização do console do nosso trabalho de treinamento.

Podemos revisar as informações que recebemos como saída da célula para o nosso fit() função no trabalho de treinamento individual no console do SageMaker, junto com os parâmetros e metadados que definimos em nosso estimador.

Lembre-se da saída de log da instância de treinamento que vimos anteriormente. Também podemos acessar os logs de nosso trabalho de treinamento aqui, rolando até o Monitore seção e escolha Ver registros.

Isso nos mostra os logs da instância dentro do CloudWatch.

Lembre-se também dos hiperparâmetros que especificamos em nosso notebook para o trabalho de treinamento. Também os vemos aqui na mesma IU do trabalho de treinamento.

Na verdade, os detalhes e metadados que especificamos anteriormente para nosso trabalho de treinamento e estimador podem ser encontrados nesta página no console do SageMaker. Temos um registro útil das configurações usadas para o treinamento, como qual contêiner de treinamento foi usado e os locais dos conjuntos de dados de treinamento e validação.

Você deve estar se perguntando neste ponto, por que exatamente isso é relevante para a otimização de hiperparâmetros? É porque você pode pesquisar, inspecionar e mergulhar mais fundo nos testes de HPO nos quais estamos interessados. Talvez aqueles com os melhores resultados ou aqueles que mostram um comportamento interessante. Vamos deixar para você o que você define como "interessante". Ele nos fornece uma interface comum para inspecionar nossos trabalhos de treinamento e você pode usá-lo com o SageMaker Search.

Embora o SageMaker AMT orquestre os trabalhos de HPO, os testes de HPO são todos iniciados como trabalhos individuais de treinamento do SageMaker e podem ser acessados ​​como tal.

Com o treinamento coberto, vamos nos afinar!

Treine e ajuste um algoritmo XGBoost integrado do SageMaker

Para ajustar nosso modelo XGBoost, vamos reutilizar nossos hiperparâmetros existentes e definir intervalos de valores que desejamos explorar para eles. Pense nisso como uma extensão das fronteiras de exploração dentro do nosso espaço de busca de hiperparâmetros. Nosso trabalho de ajuste fará uma amostra do espaço de pesquisa e executará trabalhos de treinamento para novas combinações de valores. O código a seguir mostra como especificar os intervalos de hiperparâmetros dos quais o SageMaker AMT deve fazer a amostragem:

from sagemaker.tuner import IntegerParameter, ContinuousParameter, HyperparameterTuner

hpt_ranges = {
    'alpha': ContinuousParameter(0.01, .5),
    'eta': ContinuousParameter(0.1, .5),
    'min_child_weight': ContinuousParameter(0., 2.),
    'max_depth': IntegerParameter(1, 10)
}

Os intervalos de um hiperparâmetro individual são especificados por seu tipo, como Parâmetro Contínuo. Para obter mais informações e dicas sobre como escolher essas faixas de parâmetros, consulte Ajustar um modelo XGBoost.

Ainda não executamos nenhum experimento, então não sabemos os intervalos de bons valores para nossos hiperparâmetros. Portanto, começamos com uma suposição fundamentada, usando nosso conhecimento de algoritmos e nossa documentação dos hiperparâmetros para os algoritmos integrados. Isso define um ponto de partida para definir o espaço de busca.

Em seguida, executamos uma amostragem de trabalho de ajuste de hiperparâmetros nos intervalos definidos. Como resultado, podemos ver quais faixas de hiperparâmetros produzem bons resultados. Com esse conhecimento, podemos refinar os limites do espaço de busca estreitando ou ampliando quais intervalos de hiperparâmetros usar. Demonstramos como aprender com as tentativas na próxima e última seção, onde investigamos e visualizamos os resultados.

Em nosso próximo post, continuaremos nossa jornada e mergulharemos mais fundo. Além disso, aprenderemos que existem várias estratégias que podemos usar para explorar nosso espaço de busca. Executaremos trabalhos de HPO subsequentes para encontrar valores ainda mais eficientes para nossos hiperparâmetros, enquanto comparamos essas diferentes estratégias. Também veremos como executar uma inicialização a quente com o SageMaker AMT para usar o conhecimento obtido de espaços de pesquisa explorados anteriormente em nossa exploração além desses limites iniciais.

Para esta postagem, nos concentramos em como analisar e visualizar os resultados de um único trabalho de HPO usando a estratégia de pesquisa bayesiana, que provavelmente será um bom ponto de partida.

Se você acompanhar no notebook vinculado, observe que passamos o mesmo estimador que usamos para nosso trabalho de treinamento XGBoost integrado e único. Esse objeto estimador atua como um modelo para novos trabalhos de treinamento que o AMT cria. O AMT então variará os hiperparâmetros dentro dos intervalos que definimos.

Ao especificar que queremos maximizar nossa métrica objetiva, validation:accuracy, estamos instruindo o SageMaker AMT a procurar essas métricas nos logs da instância de treinamento e escolher valores de hiperparâmetros que ele acredita que maximizarão a métrica de precisão em nossos dados de validação. Escolhemos um apropriado métrica objetiva para XGBoost da nossa documentação.

Além disso, podemos aproveitar a paralelização com max_parallel_jobs. Esta pode ser uma ferramenta poderosa, especialmente para estratégias cujas tentativas são selecionadas independentemente, sem considerar (aprender com) os resultados das tentativas anteriores. Exploraremos mais essas outras estratégias e parâmetros em nosso próximo post. Para este post, usamos Bayesian, que é uma excelente estratégia padrão.

Nós também definimos max_jobs para definir quantas tentativas serão executadas no total. Sinta-se à vontade para desviar do nosso exemplo e usar um número menor para economizar dinheiro.

n_jobs = 50
n_parallel_jobs = 3

tuner_parameters = {
    'estimator': estimator, # The same estimator object we defined above
    'base_tuning_job_name': 'bayesian',
    'objective_metric_name': 'validation:accuracy',
    'objective_type': 'Maximize',
    'hyperparameter_ranges': hpt_ranges,
    'strategy': 'Bayesian',
    'max_jobs': n_jobs,
    'max_parallel_jobs': n_parallel_jobs
}

Chamamos mais uma vez fit(), da mesma forma que quando lançamos um único trabalho de treinamento no início do post. Mas desta vez no objeto sintonizador, não no objeto estimador. Isso inicia o trabalho de ajuste e, por sua vez, o AMT inicia os trabalhos de treinamento.

tuner = HyperparameterTuner(**tuner_parameters)
tuner.fit({'train': s3_input_train, 'validation': s3_input_valid}, wait=False)
tuner_name = tuner.describe()['HyperParameterTuningJobName']
print(f'tuning job submitted: {tuner_name}.')

O diagrama a seguir expande nossa arquitetura anterior, incluindo HPO com SageMaker AMT.

Vemos que nosso trabalho de HPO foi enviado. Dependendo do número de tentativas, definido por n_jobs e o nível de paralelização, isso pode levar algum tempo. Para o nosso exemplo, pode levar até 30 minutos para 50 tentativas com apenas um nível de paralelização de 3.

tuning job submitted: bayesian-221102-2053.

Quando esse trabalho de ajuste for concluído, vamos explorar as informações disponíveis no console do SageMaker.

Investigar trabalhos AMT no console

Vamos encontrar nosso trabalho de ajuste no console do SageMaker escolhendo Training no painel de navegação e, em seguida, Jobs de ajuste de hiperparâmetros. Isso nos dá uma lista de nossos trabalhos AMT, conforme mostrado na captura de tela a seguir. Aqui localizamos nosso bayesian-221102-2053 trabalho de ajuste e descobrir que agora está completo.

Vamos dar uma olhada mais de perto nos resultados deste trabalho de HPO.

Exploramos a extração dos resultados programaticamente no caderno. Primeiro através do SDK Python do SageMaker, que é uma biblioteca Python de código aberto de nível superior, fornecendo uma API dedicada ao SageMaker. Então através boto3, que nos fornece APIs de nível inferior para SageMaker e outros serviços da AWS.

Usando o SageMaker Python SDK, podemos obter os resultados de nosso trabalho de HPO:

sagemaker.HyperparameterTuningJobAnalytics(tuner_name).dataframe()[:10]

Isso nos permitiu analisar os resultados de cada uma de nossas tentativas em um Pandas DataFrame, conforme visto na captura de tela a seguir.

Agora vamos mudar as perspectivas novamente e ver como os resultados aparecem no console do SageMaker. Em seguida, veremos nossas visualizações personalizadas.

Na mesma página, escolhendo nosso bayesian-221102-2053 O trabalho de ajuste nos fornece uma lista de testes que foram executados para nosso trabalho de ajuste. Cada teste de HPO aqui é um trabalho de treinamento do SageMaker. Lembre-se de quando treinamos nosso modelo XGBoost único e investigamos o trabalho de treinamento no console do SageMaker. Podemos fazer a mesma coisa para nossas provações aqui.

Ao investigarmos nossas provações, vemos que bayesian-221102-2053-048-b59ec7b4 criou o modelo de melhor desempenho, com uma precisão de validação de aproximadamente 89.815%. Vamos explorar quais hiperparâmetros levaram a esse desempenho escolhendo o Melhor trabalho de treinamento aba.

Podemos ter uma visão detalhada dos melhores hiperparâmetros avaliados.

Podemos ver imediatamente quais valores de hiperparâmetro levaram a esse desempenho superior. No entanto, queremos saber mais. Você consegue adivinhar? Nós vemos que alpha assume um valor aproximado de 0.052456 e, da mesma forma, eta é definido como 0.433495. Isso nos diz que esses valores funcionaram bem, mas nos diz pouco sobre o próprio espaço de hiperparâmetros. Por exemplo, podemos nos perguntar se 0.433495 para eta foi o valor mais alto testado ou se há espaço para crescimento e melhoria do modelo selecionando valores mais altos.

Para isso, precisamos diminuir o zoom e ter uma visão muito mais ampla para ver o desempenho de outros valores para nossos hiperparâmetros. Uma maneira de examinar muitos dados de uma só vez é plotar nossos valores de hiperparâmetros de nossos testes de HPO em um gráfico. Dessa forma, vemos como esses valores se comportaram relativamente. Na próxima seção, extraímos esses dados do SageMaker e os visualizamos.

Visualize nossas provações

O SageMaker SDK nos fornece os dados para nossa exploração, e os notebooks dão uma olhada nisso. Mas há muitas maneiras de utilizá-lo e visualizá-lo. Nesta postagem, compartilhamos uma amostra usando o Altair biblioteca de visualização estatística, que usamos para produzir uma visão geral mais visual de nossos testes. Estes são encontrados no amtviz pacote, que estamos fornecendo como parte da amostra:

from amtviz import visualize_tuning_job
visualize_tuning_job(tuner, trials_only=True)

O poder dessas visualizações torna-se imediatamente aparente ao plotar a precisão de validação de nossos testes (eixo y) ao longo do tempo (eixo x). O gráfico a seguir à esquerda mostra a precisão da validação ao longo do tempo. Podemos ver claramente o desempenho do modelo melhorando à medida que executamos mais testes ao longo do tempo. Este é um resultado direto e esperado da execução do HPO com uma estratégia bayesiana. Em nosso próximo post, veremos como isso se compara a outras estratégias e observaremos que isso não precisa ser o caso para todas as estratégias.

Depois de revisar o progresso geral ao longo do tempo, agora vamos ver nosso espaço de hiperparâmetros.

Os gráficos a seguir mostram a precisão da validação no eixo y, com cada gráfico mostrando max_depth, alpha, eta e min_child_weight no eixo x, respectivamente. Traçamos todo o nosso trabalho de HPO em cada gráfico. Cada ponto é uma tentativa única e cada gráfico contém todas as 50 tentativas, mas separadas para cada hiperparâmetro. Isso significa que nossa tentativa de melhor desempenho, nº 48, é representada por exatamente um ponto azul em cada um desses gráficos (que destacamos para você na figura a seguir). Podemos comparar visualmente seu desempenho dentro do contexto de todas as outras 49 tentativas. Então, vamos olhar de perto.

Fascinante! Vemos imediatamente quais regiões de nossos intervalos definidos em nosso espaço de hiperparâmetros são mais eficientes! Pensando em nosso eta valor, está claro agora que os valores de amostragem mais próximos de 0 renderam um desempenho pior, ao passo que aproximar-se de nossa borda, 0.5, produz resultados melhores. O inverso parece ser verdadeiro para alpha e max_depth parece ter um conjunto mais limitado de valores preferenciais. Olhando para max_depth, você também pode ver como o uso de uma estratégia bayesiana instrui o SageMaker AMT a obter amostras de valores com mais frequência que aprendeu que funcionaram bem no passado.

Olhando para o nosso eta valor, podemos nos perguntar se vale a pena explorar mais à direita, talvez além de 0.45? Ele continua diminuindo a precisão ou precisamos de mais dados aqui? Essa dúvida faz parte do propósito de executar nosso primeiro trabalho de HPO. Ele nos fornece insights sobre quais áreas do espaço de hiperparâmetros devemos explorar mais.

Se você quer saber mais e está tão empolgado quanto nós com esta introdução ao assunto, fique atento ao nosso próximo post, onde falaremos mais sobre as diferentes estratégias de HPO, compararemos umas com as outras e pratique o treinamento com nosso próprio script Python.

limpar

Para evitar custos indesejados ao terminar de experimentar o HPO, você deve remover todos os arquivos em seu bucket S3 com o prefixo amt-visualize-demo e também desligar os recursos do Studio.

Execute o seguinte código em seu notebook para remover todos os arquivos S3 deste post.

!aws s3 rm s3://{BUCKET}/amt-visualize-demo --recursive

Se desejar manter os conjuntos de dados ou os artefatos do modelo, você pode modificar o prefixo no código para amt-visualize-demo/data para apenas excluir os dados ou amt-visualize-demo/output para excluir apenas os artefatos do modelo.

Conclusão

Nesta postagem, treinamos e ajustamos um modelo usando a versão integrada do SageMaker do algoritmo XGBoost. Ao usar o HPO com o SageMaker AMT, aprendemos sobre os hiperparâmetros que funcionam bem para esse algoritmo e conjunto de dados específicos.

Vimos várias maneiras de revisar os resultados de nosso trabalho de ajuste de hiperparâmetros. Começando com a extração dos hiperparâmetros do melhor teste, também aprendemos como obter uma compreensão mais profunda de como nossos testes progrediram ao longo do tempo e quais valores de hiperparâmetros são impactantes.

Usando o console do SageMaker, também vimos como mergulhar mais fundo nas corridas de treinamento individuais e revisar seus logs.

Em seguida, reduzimos o zoom para visualizar todos os nossos testes juntos e revisar seu desempenho em relação a outros testes e hiperparâmetros.

Aprendemos que, com base nas observações de cada tentativa, fomos capazes de navegar no espaço de hiperparâmetros para ver que pequenas alterações em nossos valores de hiperparâmetros podem ter um grande impacto no desempenho de nosso modelo. Com o SageMaker AMT, podemos executar a otimização de hiperparâmetros para encontrar bons valores de hiperparâmetros com eficiência e maximizar o desempenho do modelo.

No futuro, veremos diferentes estratégias de HPO oferecidas pelo SageMaker AMT e como usar nosso próprio código de treinamento personalizado. Deixe-nos saber nos comentários se você tiver alguma dúvida ou quiser sugerir uma área que devemos abordar nos próximos posts.

Até lá, desejamos a você e seus modelos um bom aprendizado e afinação!

Referências

Citações:

[1] Dua, D. e Graff, C. (2019). UCI Machine Learning Repository [http://archive.ics.uci.edu/ml]. Irvine, CA: Universidade da Califórnia, Escola de Informação e Ciência da Computação.

Sobre os autores

André Ellul é arquiteto de soluções da Amazon Web Services. Ele trabalha com pequenas e médias empresas na Alemanha. Fora do trabalho, Andrew gosta de explorar a natureza a pé ou de bicicleta.

Elina Lesyk é um Arquiteto de Soluções localizado em Munique. Seu foco é em clientes corporativos do setor de serviços financeiros. Em seu tempo livre, Elina gosta de aprender teoria do violão em espanhol para aprender e correr.

Mariano Camp é Arquiteto Principal de Soluções da Amazon Web Services. Ele trabalha com clientes de serviços financeiros na Alemanha em aprendizado de máquina. Nas horas vagas, Mariano gosta de fazer caminhadas com a esposa.