arrow_back

Vertex AI: ajuste de hiperparâmetros

Fazer login Inscreva-se
Quick tip: Review the prerequisites before you run the lab
Use an Incognito or private browser window to run this lab. This prevents any conflicts between your personal account and the student account, which may cause extra charges incurred to your personal account.
Teste e compartilhe seu conhecimento com nossa comunidade.
done
Tenha acesso a mais de 700 laboratórios, selos de habilidade e cursos

Vertex AI: ajuste de hiperparâmetros

Laboratório 2 horas 30 minutos universal_currency_alt 5 créditos show_chart Avançado
info Este laboratório pode incorporar ferramentas de IA para ajudar no seu aprendizado.
Teste e compartilhe seu conhecimento com nossa comunidade.
done
Tenha acesso a mais de 700 laboratórios, selos de habilidade e cursos

Informações gerais

Neste laboratório, você vai aprender a usar a Vertex AI para executar um job de ajuste de hiperparâmetros para um modelo do TensorFlow. Este laboratório usa o TensorFlow para o código do modelo, mas ele pode ser substituído sem problemas por outro framework.

Objetivos de aprendizagem

  • Criar um notebook de instância do Workbench.
  • Modificar o código do aplicativo de treinamento para ajuste de hiperparâmetros.
  • Iniciar um job de ajuste de hiperparâmetros usando a interface da Vertex AI.

Introdução à Vertex AI

Este laboratório usa a mais nova oferta de produtos de IA disponível no Google Cloud. A Vertex AI integra as ofertas de ML do Google Cloud em uma experiência de desenvolvimento intuitiva. Anteriormente, modelos treinados com o AutoML e modelos personalizados eram acessíveis por serviços separados. A nova oferta combina ambos em uma única API, com outros novos produtos. Você também pode migrar projetos existentes para a Vertex AI. Se você tiver algum feedback, consulte a página de suporte.

A Vertex AI inclui vários produtos diferentes para dar suporte a fluxos de trabalho integrais de ML. O foco deste laboratório são os produtos destacados abaixo: treinamento/ajuste de hiperparâmetros e Notebooks.

A Vertex AI tem duas soluções de notebooks, o Workbench e o Colab Enterprise.

Workbench

O Vertex AI Workbench é uma boa opção para projetos que priorizam o controle e a personalização. Ele é ótimo para quando há vários arquivos com dependências complexas. Também é uma boa escolha para cientistas de dados que estão fazendo a transição da nuvem para uma estação de trabalho ou notebook.

As instâncias do Vertex AI Workbench vêm com um pacote pré-instalado de pacotes de aprendizado profundo, incluindo o suporte para os frameworks TensorFlow e PyTorch.

Configuração e requisitos

Para cada laboratório, você recebe um novo projeto do Google Cloud e um conjunto de recursos por um determinado período e sem custos financeiros.

  1. Faça login no Qwiklabs em uma janela anônima.

  2. Confira o tempo de acesso do laboratório (por exemplo, 1:15:00) e finalize todas as atividades nesse prazo.
    Não é possível pausar o laboratório. Você pode reiniciar o desafio, mas vai precisar refazer todas as etapas.

  3. Quando tudo estiver pronto, clique em Começar o laboratório.

  4. Anote as credenciais (Nome de usuário e Senha). É com elas que você vai fazer login no Console do Google Cloud.

  5. Clique em Abrir Console do Google.

  6. Clique em Usar outra conta, depois copie e cole as credenciais deste laboratório nos locais indicados.
    Se você usar outras credenciais, vai receber mensagens de erro ou cobranças.

  7. Aceite os termos e pule a página de recursos de recuperação.

Ativar a API Compute Engine

  1. No Console do Cloud, clique em Menu de navegação > API e Serviços > Biblioteca.

  2. Pesquise por API Compute Engine e, em seguida, clique em Ativar se ela ainda não estiver ativada. Você vai precisar disso para criar sua instância de notebook.

Ative a API Container Registry

  1. No Console do Cloud, clique em Menu de navegação > API e Serviços > Biblioteca.

  2. Pesquise API Google Container Registry e selecione Ativar caso ela ainda não esteja ativada. Use isso para criar um contêiner para seu job de treinamento personalizado.

Tarefa 1: iniciar a instância do Vertex AI Workbench

  1. No console do Google Cloud, no menu de navegação (), clique em Vertex AI.

  2. Selecione Ativar todas as APIs recomendadas.

  3. No menu de navegação, clique em Workbench.

    Verifique se você está na visualização Instâncias do topo da página do Workbench.

  4. Clique em Criar.

  5. Configure a instância:

    • Nome: lab-workbench
    • Região: configure a região como
    • Zona: configure a zona como
    • Opções avançadas (opcional): se necessário, clique em "Opções avançadas" para personalizar mais (ex.: tipo de máquina, tamanho do disco).

  1. Clique em Criar.

O processo vai levar alguns minutos, e uma marca de seleção verde vai aparecer ao lado do nome da instância quando ela estiver pronta.

  1. Clique em ABRIR O JUPYTERLAB ao lado do nome da instância para iniciar a interface do ambiente. Uma nova guia será aberta no navegador.

Observação: o modelo que você vai treinar e ajustar neste laboratório é um modelo de classificação de imagens treinado no conjunto de dados de cavalos ou humanos dos conjuntos de dados do TensorFlow.

Clique em Verificar meu progresso para conferir o objetivo. Iniciar a instância do Vertex AI Workbench

Tarefa 2: fazer a conteinerização do código do aplicativo de treinamento

Para enviar este job de ajuste de hiperparâmetros à Vertex, coloque o código do aplicativo de treinamento em um contêiner do Docker e envie-o ao Google Container Registry. Dessa forma, é possível ajustar hiperparâmetros para um modelo integrado a qualquer framework.

  1. No JupyterLab, use o menu Iniciar para abrir uma janela Terminal na instância do notebook.

  1. Crie um diretório chamado horses_or_humans e use cd nele:
mkdir horses_or_humans cd horses_or_humans

Crie um DockerFile

A primeira etapa na conteinerização de seu código é criar um Dockerfile. No Dockerfile, você vai incluir todos os comandos necessários para executar a imagem. Ele vai instalar todas as bibliotecas necessárias, incluindo a biblioteca CloudML Hypertune e também configurar o ponto de entrada para o código de treinamento.

  1. No seu Terminal, crie um Dockerfile vazio:
touch Dockerfile
  1. Abra o Dockerfile no menu à esquerda e copie o seguinte nele:
FROM gcr.io/deeplearning-platform-release/tf2-gpu.2-9 WORKDIR / # Instala a biblioteca hypertuney RUN pip install cloudml-hypertune # Copia o código de treinamento para a imagem do docker COPY trainer /trainer # Configura o ponto de entrada para invocar o treinador ENTRYPOINT ["python", "-m", "trainer.task"]
  1. Salve o arquivo pressionando CTRL+S.

Este Dockerfile usa a imagem Docker do TensorFlow Enterprise 2.9 GPU no Deep Learning Container. Os Deep Learning Containers no Google Cloud vêm com muitos frameworks comuns de ML e ciência de dados pré-instalados.

Após fazer download dessa imagem, este Dockerfile configura o ponto de entrada para o código de treinamento. Você ainda não criou esses arquivos – na próxima etapa, você vai adicionar o código para treinar e ajustar o modelo.

Adicione código de treinamento do modelo

  1. No seu Terminal, execute o seguinte para criar um diretório para o código de treinamento e um arquivo Python onde você vai adicionar o código:
mkdir trainer touch trainer/task.py

Seu diretório horses_or_humans/ agora deve conter o seguinte:

+ Dockerfile + trainer/ + task.py
  1. Em seguida, abra o arquivo task.py que você acabou de criar e copie o código abaixo:
import tensorflow as tf import tensorflow_datasets as tfds import argparse import hypertune NUM_EPOCHS = 10 def get_args(): '''Parses args. Must include all hyperparameters you want to tune.''' parser = argparse.ArgumentParser() parser.add_argument( '--learning_rate', required=True, type=float, help='learning rate') parser.add_argument( '--momentum', required=True, type=float, help='SGD momentum value') parser.add_argument( '--num_neurons', required=True, type=int, help='number of units in last hidden layer') args = parser.parse_args() return args def preprocess_data(image, label): '''Resizes and scales images.''' image = tf.image.resize(image, (150,150)) return tf.cast(image, tf.float32) / 255., label def create_dataset(): '''Loads Horses Or Humans dataset and preprocesses data.''' data, info = tfds.load(name='horses_or_humans', as_supervised=True, with_info=True) # Criar o conjunto de dados de treinamento train_data = data['train'].map(preprocess_data) train_data = train_data.shuffle(1000) train_data = train_data.batch(64) # Criar o conjunto de dados de validação validation_data = data['test'].map(preprocess_data) validation_data = validation_data.batch(64) return train_data, validation_data def create_model(num_neurons, learning_rate, momentum): '''Defines and complies model.''' inputs = tf.keras.Input(shape=(150, 150, 3)) x = tf.keras.layers.Conv2D(16, (3, 3), activation='relu')(inputs) x = tf.keras.layers.MaxPooling2D((2, 2))(x) x = tf.keras.layers.Conv2D(32, (3, 3), activation='relu')(x) x = tf.keras.layers.MaxPooling2D((2, 2))(x) x = tf.keras.layers.Conv2D(64, (3, 3), activation='relu')(x) x = tf.keras.layers.MaxPooling2D((2, 2))(x) x = tf.keras.layers.Flatten()(x) x = tf.keras.layers.Dense(num_neurons, activation='relu')(x) outputs = tf.keras.layers.Dense(1, activation='sigmoid')(x) model = tf.keras.Model(inputs, outputs) model.compile( loss='binary_crossentropy', optimizer=tf.keras.optimizers.SGD(learning_rate=learning_rate, momentum=momentum), metrics=['accuracy']) return model def main(): args = get_args() train_data, validation_data = create_dataset() model = create_model(args.num_neurons, args.learning_rate, args.momentum) history = model.fit(train_data, epochs=NUM_EPOCHS, validation_data=validation_data) # DEFINIR MÉTRICA hp_metric = history.history['val_accuracy'][-1] hpt = hypertune.HyperTune() hpt.report_hyperparameter_tuning_metric( hyperparameter_metric_tag='accuracy', metric_value=hp_metric, global_step=NUM_EPOCHS) if __name__ == "__main__": main()
  1. Salve o arquivo pressionando CTRL+S.

Antes de criar o contêiner, vamos analisar o código mais a fundo. Existem alguns componentes específicos para usar o serviço de ajuste de hiperparâmetros.

  • O script importa a biblioteca hypertune. Note que o Dockerfile da Etapa 1 incluiu instruções para instalar esta biblioteca com o pip.

  • A função get_args() define um argumento de linha de comando para cada hiperparâmetro que você quiser ajustar. Neste exemplo, os hiperparâmetros que vão ser ajustados são a taxa de aprendizado, o valor do momento no otimizador e o número de neurônios na última camada escondida do modelo, mas fique à vontade para mexer nos outros. O valor passado nesses argumentos é usado para definir o hiperparâmetro correspondente no código.

  • No final da função main(), a biblioteca hypertune é usada para definir a métrica que você quer otimizar. No TensorFlow, o método model.fit do keras retorna um objeto History. O atributo History.history é um registro de valores de perda de treinamento e valores de métricas em épocas sucessivas. Se você passar dados de validação para o model.fit, o atributo History.history também vai incluir perda de validação e valores de métricas. Por exemplo, se você treinou um modelo para três épocas com dados de validação e forneceu accuracy como uma métrica, o atributo History.history seria semelhante ao dicionário abaixo.

{ "accuracy": [ 0.7795261740684509, 0.9471358060836792, 0.9870933294296265 ], "loss": [ 0.6340447664260864, 0.16712145507335663, 0.04546636343002319 ], "val_accuracy": [ 0.3795261740684509, 0.4471358060836792, 0.4870933294296265 ], "val_loss": [ 2.044623374938965, 4.100203514099121, 3.0728273391723633 ]

Se quiser que o serviço de ajuste de hiperparâmetros descubra os valores que maximizam a acurácia da validação do modelo, defina a métrica como a última entrada (ou NUM_EPOCS - 1) da lista val_accuracy. Em seguida, passe essa métrica para uma instância do HyperTune. É possível escolher qualquer string que quiser para hyperparameter_metric_tag, mas você vai precisar usar a string novamente mais tarde quando iniciar o job de ajuste de hiperparâmetros.

Clique em Verificar meu progresso para conferir o objetivo. Criar um Dockerfile e adicionar o código de treinamento do modelo

Criar o contêiner

  1. No Terminal, execute o seguinte para definir uma variável de ambiente para seu projeto. Não se esqueça de substituir your-cloud-project pelo ID do seu projeto:
Observação: é possível descobrir o ID do projeto executando gcloud config list --format 'value(core.project)' no terminal. PROJECT_ID='your-cloud-project'
  1. Defina uma variável com o URI da imagem do seu contêiner no Google Container Registry:
IMAGE_URI="gcr.io/$PROJECT_ID/horse-human:hypertune"
  1. Depois crie o contêiner executando o seguinte a partir da raiz do seu diretório horses_or_humans:
docker build ./ -t $IMAGE_URI
  1. Por fim, envie para o Google Container Registry:
docker push $IMAGE_URI

Depois que o contêiner for enviado para o Container Registry, estará tudo pronto para iniciar um job de ajuste de hiperparâmetros de modelos personalizados.

Clique em Verificar meu progresso para conferir o objetivo. Criar o contêiner

Tarefa 3: executar job de ajuste de hiperparâmetros na Vertex AI

Este laboratório usa treinamento personalizado com um contêiner específico no Google Container Registry, mas também é possível executar um job de ajuste de hiperparâmetros com os contêineres pré-criados.

  • No console do Cloud, navegue até a seção de Treinamento na Vertex AI:
  • Em "API Vertex AI", clique em Ativar e depois em Fechar.

Configurar o job de treinamento

  1. Clique em Treinar novo modelo para inserir os parâmetros do seu job de ajuste de hiperparâmetros:

    • Em Conjunto de dados, selecione Sem conjunto de dados gerenciado.
    • Selecione Treinamento personalizado (avançado) como seu método de treinamento e clique em Continuar.
    • Insira horses-humans-hyptertune (ou como quiser nomear seu modelo) em Nome do modelo.
    • Clique em Continuar.

  2. Na etapa de Contêiner de treinamento, selecione Contêiner personalizado:

    • Nas Configurações do contêiner personalizado, em Imagem do contêiner, insira o valor da sua variável IMAGE_URI da seção anterior. Deve ficar: gcr.io/<your-cloud-project>/horse-human:hypertune, com o nome do seu projeto. Deixe os demais campos em branco e clique em Continuar.

Configure o job de ajuste de hiperparâmetros

  • Selecione Ativar ajuste de hiperparâmetros.

Configure os hiperparâmetros

Em seguida, você vai precisar adicionar os hiperparâmetros definidos como argumentos de linha de comando no código do aplicativo de treinamento. Ao adicionar um hiperparâmetro, primeiro você vai precisar fornecer o nome. Ele deve corresponder ao nome do argumento que você passou para argparse.

  1. Insira learning_rate no Nome do parâmetro.

  2. Selecione Double como Tipo.

  3. Insira os valores de 0,01 para Mín. e 1 para Máx..

  4. Selecione Log como Escalonamento.

  5. Clique em CONCLUÍDO.

  6. Depois de adicionar o hiperparâmetro learning_rate, adicione parâmetros para momentum e num_neurons.

  • Em momentum:

    • Clique em ADICIONAR UM HIPERPARÂMETRO.
    • Insira momentum em Nome do parâmetro.
    • Selecione Double como Tipo.
    • Insira os valores de 0 para Mín. e 1 para Máx..
    • Selecione Linear como Escalonamento.
    • Clique em CONCLUÍDO.

  • Em num_neurons:

    • Clique em ADICIONAR UM HIPERPARÂMETRO.
    • Insira num_neurons para Nome do parâmetro.
    • Selecione Discreto como Tipo.
    • Insira 64.128.512 em Valores.
    • Selecione Sem escalonamento em Escalonamento.
    • Clique em CONCLUÍDO.

Configure a métrica

Depois de adicionar os hiperparâmetros, você vai fornecer a métrica que quer otimizar, e também a meta. Isso deve ser igual à hyperparameter_metric_tag que você configurou no seu aplicativo de treinamento.

  1. Insira accuracy como a Métrica a ser otimizada.
  2. Selecione Maximizar como Meta.

O serviço de ajuste de hiperparâmetros da Vertex AI vai executar diversas avaliações do seu aplicativo de treinamento com os valores configurados nas etapas anteriores. Você vai precisar definir um limite superior para o número de tentativas que o serviço vai executar.

Uma maior quantidade de testes geralmente leva a melhores resultados, mas vai haver um ponto de retornos decrescentes e, depois dele, testes adicionais vão ter pouco ou nenhum efeito sobre a métrica que você está tentando otimizar. É uma prática recomendada começar com um número menor de testes e ter uma noção do impacto dos hiperparâmetros escolhidos antes de escalonar verticalmente para um grande número de testes.

Você também vai precisar definir um limite superior para o número de tentativas paralelas. Aumentar o número de testes paralelos vai reduzir o tempo que o job de ajuste de hiperparâmetros leva para ser executado. No entanto, isso pode reduzir a eficácia do job em geral. Isso ocorre porque a estratégia de ajuste padrão usa resultados de tentativas anteriores para informar a atribuição de valores em tentativas subsequentes. Se você executar muitos testes em paralelo, vai haver testes que vão começar sem o benefício do resultado dos testes ainda em execução.

  1. Para fins de demonstração, você pode configurar o Número máximo de testes como 15 e o Número máximo de testes em paralelo como 3. É possível usar números diferentes, mas isso pode resultar em um tempo de ajuste mais longo e em custos mais altos.

  2. Escolha Padrão como o Algoritmo, que vai usar o Google Vizier para realizar a otimização bayesiana para o ajuste de hiperparâmetros. Saiba mais sobre esse algoritmo na postagem no blog Como ajustar hiperparâmetros no Cloud Machine Learning Engine usando a otimização bayesiana (em inglês).

  3. Clique em Continuar.

Configurar computação

Em Computação e preços, não mude a região selecionada e, nas Configurações de computação, selecione Implantar em um novo pool de workers.

Configure o pool de workers 0 desta forma:

  1. Em Tipo de máquina, selecione Padrão > n1-standard-4.
  2. Em Tipo de disco, selecione SSD.
  3. Em Tamanho do disco (GB), insira 100.
  4. Clique em INICIAR TREINAMENTO para iniciar o job de ajuste de hiperparâmetros. Na seção de Treinamento do seu console, na guia de JOBS DE AJUSTE DE HIPERPARÂMETROS você vai encontrar algo assim:

Observação: o job vai levar cerca de 55 a 60 minutos para ser concluído.

Quando estiver concluído, você poderá clicar no nome do job e conferir os resultados dos testes de ajuste.

Clique em Verificar meu progresso para conferir o objetivo. Executar um job de ajuste de hiperparâmetros na Vertex AI

Tarefa 4: limpeza

  1. Se você quiser continuar usando o notebook que criou neste laboratório, é recomendado que você o desligue quando não estiver usando. A partir da interface de Notebooks no seu Console do Cloud, selecione o notebook e depois clique em Parar.

    Se quiser excluir um notebook totalmente, simplesmente clique no botão Excluir no canto superior direito.

  2. Para excluir o bucket de armazenamento, vá até o Menu de navegação > Cloud Storage, escolha seu bucket e clique em Excluir.

Parabéns!

Você aprendeu a usar a Vertex AI para:

Iniciar um job de ajuste de hiperparâmetros para um código de treinamento fornecido em um contêiner personalizado. Neste exemplo você usou um modelo do TensorFlow, mas é possível treinar um modelo criado com qualquer framework usando contêineres personalizados ou integrados. Conheça as diferentes partes da Vertex AI na documentação.

Finalize o laboratório

Após terminar seu laboratório, clique em End Lab. O Qwiklabs removerá os recursos usados e limpará a conta para você.

Você poderá avaliar sua experiência neste laboratório. Basta selecionar o número de estrelas, digitar um comentário e clicar em Submit.

O número de estrelas indica o seguinte:

  • 1 estrela = muito insatisfeito
  • 2 estrelas = insatisfeito
  • 3 estrelas = neutro
  • 4 estrelas = satisfeito
  • 5 estrelas = muito satisfeito

Feche a caixa de diálogo se não quiser enviar feedback.

Para enviar seu feedback, fazer sugestões ou correções, use a guia Support.

Copyright 2020 Google LLC. Todos os direitos reservados. Google e o logotipo do Google são marcas registradas da Google LLC. Todos os outros nomes de produtos e empresas podem ser marcas registradas das respectivas empresas a que estão associados.

Before you begin

  1. Labs create a Google Cloud project and resources for a fixed time
  2. Labs have a time limit and no pause feature. If you end the lab, you'll have to restart from the beginning.
  3. On the top left of your screen, click Start lab to begin

Este conteúdo não está disponível no momento

Você vai receber uma notificação por e-mail quando ele estiver disponível

Ótimo!

Vamos entrar em contato por e-mail se ele ficar disponível

One lab at a time

Confirm to end all existing labs and start this one

Use private browsing to run the lab

Use an Incognito or private browser window to run this lab. This prevents any conflicts between your personal account and the Student account, which may cause extra charges incurred to your personal account.