Primeiros passos

Antes de usar o Cloud Machine Learning Engine neste tutorial, você precisa estar familiarizado com o machine learning e o TensorFlow. Para saber mais, consulte o Curso intensivo de machine learning usando APIs do TensorFlow. Confira a plataforma Aprendizado com o Google AI se quiser muito mais recursos sobre machine learning.

Visão geral

Neste documento você encontra um guia introdutório, de ponta a ponta, de treinamento e previsão no Cloud Machine Learning Engine. Você verá uma amostra que usa um conjunto de dados do censo para:

  • criar um aplicativo de treinamento TensorFlow e validá-lo localmente;
  • executar o job de treinamento em uma única instância de trabalho na nuvem;
  • executar o job de treinamento como distribuído na nuvem;
  • usar o ajuste de hiperparâmetros para otimizá-los;
  • implantar um modelo para dar suporte à previsão;
  • solicitar uma previsão on-line e ver a resposta;
  • solicitar uma previsão de lotes.

O que você criará

A amostra cria um modelo amplo e detalhado para prever a categoria de renda com base no conjunto de dados de rendimentos do censo dos Estados Unidos. As duas categorias de receita (também conhecidas como rótulos) são:

  • > 50K - maior que 50.000 dólares;
  • <= 50K - menor ou igual a 50.000 dólares.

Redes neurais detalhadas (DNNs, na sigla em inglês) são usadas por modelos amplos e detalhados para aprender abstrações gerais sobre recursos complexos ou interações entre eles. Esses modelos combinam as saídas da DNN com uma regressão linear realizada em recursos mais simples. Com isso, cria-se um equilíbrio entre potência e velocidade que resolve muitos problemas de dados estruturados de maneira eficaz.

Leia mais sobre modelos amplos e detalhados na postagem do blog Google Research chamada Aprendizado profundo e amplo: melhor com o TensorFlow.

A amostra define o modelo usando a classe DNNCombinedLinearClassifier pré-construída do TensorFlow e também define as transformações de dados específicas do conjunto de dados do censo. Em seguida, atribui esses recursos (potencialmente) transformados à DNN ou à parte linear do modelo.

Custos

Nestas instruções, há componentes do Google Cloud Platform passíveis de cobrança, entre eles:

  • Cloud Machine Learning Engine para:
    • treinamento;
    • previsão.
  • Cloud Storage para:
    • armazenar dados de entrada para treinamento;
    • preparar o pacote de aplicativos de treinamento;
    • gravar artefatos de treinamento;
    • armazenar arquivos de dados de entrada para a previsão de lotes.

Use a Calculadora de Preços para gerar uma estimativa de custo com base no uso previsto.

Configurar e testar o ambiente em nuvem

Conclua as etapas a seguir para configurar uma conta do GCP, ativar a API Cloud ML Engine e instalar e ativar o SDK do Cloud.

Configurar o projeto GCP

  1. Faça login na sua Conta do Google.

    Se você ainda não tiver uma, inscreva-se.

  2. Selecione ou crie um projeto do GCP.

    Acessar a página Gerenciar recursos

  3. Verifique se o faturamento foi ativado para o projeto.

    Saiba como ativar o faturamento

  4. Ativar Cloud Machine Learning Engine e Compute Engine APIs.

    Ativar a de APIs

  5. Instale e inicialize o SDK do Cloud.

Configurar o ambiente

Escolha uma das opções abaixo para configurar o ambiente localmente no macOS ou em um ambiente remoto no Cloud Shell.

Para usuários do macOS, recomendamos usar a guia MACOS abaixo para configurar o ambiente. O Cloud Shell, mostrado na guia CLOUD SHELL, está disponível para macOS, Linux e Windows. Com o Cloud Shell, é possível testar rapidamente o Cloud Machine Learning Engine, mas isso não é adequado para o trabalho de desenvolvimento contínuo.

macOS

  1. Verifique a instalação do Python
    Verifique se o Python está instalado e, se necessário, instale-o.

    python -V
  2. Verifique a instalação do pip
    pip é o gerenciador de pacotes do Python, incluído nas versões atuais dele. Para verificar se o pip está instalado, execute pip --version. Se não estiver, veja como instalar o pip (em inglês).

    Para fazer upgrade do pip, execute o seguinte comando:

    pip install -U pip

    Consulte a documentação do pip para mais detalhes.

  3. Instale o virtualenv
    O virtualenv é uma ferramenta para criar ambientes isolados em Python. Para verificar se o virtualenv está instalado, execute virtualenv --version. Se não estiver, instale o virtualenv (em inglês):

    pip install --user --upgrade virtualenv

    Para ter um ambiente de desenvolvimento isolado a ser usado com este guia, crie um ambiente virtual no virtualenv. Por exemplo, o comando a seguir ativa um ambiente denominado cmle-env:

    virtualenv cmle-env
    source cmle-env/bin/activate
  4. Para este tutorial, execute o restante dos comandos no ambiente virtual.

    Veja mais informações sobre o uso do virtualenv (em inglês). Para sair do virtualenv, execute deactivate.

Cloud Shell

  1. Abra o Console do Google Cloud Platform.

    Console do Google Cloud Platform

  2. Clique no botão Ativar o Google Cloud Shell na parte superior da janela do console.

    Ativar o Google Cloud Shell

    Uma sessão do Cloud Shell é aberta em um novo frame, na parte inferior do console, e um prompt de linha de comando é exibido. A inicialização da sessão do shell pode levar alguns segundos.

    Seção do Cloud Shell

    A sessão do Cloud Shell está pronta para ser usada.

  3. Configure a ferramenta de linha de comando gcloud para usar o projeto selecionado.

    gcloud config set project [selected-project-id]

    [selected-project-id] é o código do projeto. Retire os colchetes incluídos.

Verificar os componentes do SDK do Google Cloud

Para verificar se os componentes do SDK do Google Cloud estão instalados, siga estas etapas:

  1. Liste os modelos:

    gcloud ml-engine models list
  2. Se você não tiver criado modelos antes, o comando retornará uma lista vazia:

    Listed 0 items.

    Depois que você começar a criar modelos, use esse comando para vê-los.

  3. Se você instalou gcloud anteriormente, atualize o gcloud:

    gcloud components update

Instalar o TensorFlow

Para instalar o TensorFlow, execute o seguinte comando:

pip install --user --upgrade tensorflow

Verifique a instalação:

python -c "import tensorflow as tf; print('TensorFlow version {} is installed.'.format(tf.VERSION))"

Ignore os avisos de que a biblioteca do TensorFlow não foi compilada para usar determinadas instruções.

Para mais informações sobre como instalar o TensorFlow, incluindo outras opções de instalação e informações sobre solução de problemas, consulte a documentação do TensorFlow.

Suporte à versão do Python

O Cloud ML Engine executa o Python 2.7 por padrão, e a amostra para este tutorial usa o Python 2.7.

O Python 3.5 está disponível para treinamento ao usar a versão de tempo de execução do Cloud ML Engine 1.4 ou superior. A previsão on-line e em lote funciona com modelos treinados, independentemente de terem sido treinados com o Python 2 ou o Python 3.

Consulte como enviar um job de treinamento usando o Python 3.5.

Fazer o download do código para este tutorial

  1. No repositório GitHub, faça o download da amostra.

macOS

  1. Faça o download e extraia o arquivo ZIP de amostra do Cloud ML Engine.

    Fazer o download do arquivo ZIP

  2. Abra uma janela do terminal e navegue até o diretório que contém o cloudml-samples-master extraído.

  3. Navegue para o diretório cloudml-samples-master > census > estimator. Execute os comandos deste tutorial a partir do diretório estimator.

    cd cloudml-samples-master/census/estimator
    

Cloud Shell

  1. Insira o seguinte comando para fazer o download do arquivo zip de amostra do Cloud ML Engine:

    wget https://github.com/GoogleCloudPlatform/cloudml-samples/archive/master.zip
    
  2. Descompacte o arquivo para extrair o diretório cloudml-samples-master.

    unzip master.zip
    
  3. Navegue para o diretório cloudml-samples-master > census > estimator. Execute os comandos deste tutorial a partir do diretório estimator.

    cd cloudml-samples-master/census/estimator
    

Desenvolver e validar seu aplicativo de treinamento localmente

Antes de executar seu aplicativo de treinamento na nuvem, execute-o localmente. Um fluxo de trabalho de desenvolvimento e validação eficiente é fornecido pelos ambientes locais para que a iteração seja feita rapidamente. Também não haverá cobranças por recursos da nuvem para você depurar seu aplicativo no local.

Receber dados de treinamento

Os arquivos de dados relevantes, adult.data e adult.test, estão hospedados em um intervalo público do Cloud Storage. Para os fins desta amostra, use as versões no Cloud Storage, que foram submetidas a uma limpeza trivial, em vez dos dados de origem originais. Veja abaixo para mais informações sobre os dados.

Você pode ler os arquivos de dados diretamente do Cloud Storage ou copiá-los para o ambiente local. Para os fins desta amostra, faça o download das amostras para treinamento local e, depois, faça upload delas em seu próprio intervalo do Cloud Storage para treinamento em nuvem.

  1. Faça o download dos dados para um diretório local e defina variáveis que apontem para os arquivos salvos.

    mkdir data
    gsutil -m cp gs://cloud-samples-data/ml-engine/census/data/* data/
    
  2. Defina as variáveis TRAIN_DATA E EVAL_DATA para seus caminhos de arquivo local. Por exemplo, os comandos a seguir definem as variáveis nos caminhos locais.

    TRAIN_DATA=$(pwd)/data/adult.data.csv
    EVAL_DATA=$(pwd)/data/adult.test.csv
    

Os dados são armazenados em formato de valor separado por vírgulas, como mostrado na seguinte visualização do arquivo adult.data:

39, State-gov, 77516, Bachelors, 13, Never-married, Adm-clerical, Not-in-family, White, Male, 2174, 0, 40, United-States, <=50K
50, Self-emp-not-inc, 83311, Bachelors, 13, Married-civ-spouse, Exec-managerial, Husband, White, Male, 0, 0, 13, United-States, <=50K
38, Private, 215646, HS-grad, 9, Divorced, Handlers-cleaners, Not-in-family, White, Male, 0, 0, 40, United-States, <=50K
53, Private, 234721, 11th, 7, Married-civ-spouse, Handlers-cleaners, Husband, Black, Male, 0, 0, 40, United-States, <=50K
...

Instalar dependências

macOS

Para instalar o TensorFlow localmente, recomendamos o uso de um ambiente virtual. Veja como:

Se estiver familiarizado com o Docker, você poderá terminar este tutorial dentro de um contêiner do TensorFlow. Veja como instalar o TensorFlow com Docker.

Na amostra, há um arquivo requirements.txt que pode ser usado para instalar as dependências necessárias ao projeto. Dentro do seu ambiente virtual, insira o seguinte comando:

  pip install --user -r ../requirements.txt

Com a execução desse comando, o TensorFlow 1.10 será instalado para ser usado no tutorial.

Cloud Shell

O TensorFlow está instalado no Cloud Shell, mas você precisa executar o arquivo requirements.txt da amostra. Dessa forma, você verifica se está usando a mesma versão do TensorFlow necessária para a amostra.

  pip install --user -r ../requirements.txt

Com a execução desse comando, o TensorFlow 1.10 será instalado para ser usado no tutorial.

Executar um job de treinamento local

Com um job de treinamento local, você carrega o programa de treinamento em Python e inicia um processo de treinamento em um ambiente semelhante ao de um job de treinamento na nuvem ativo do Cloud ML Engine.

  1. Especifique um diretório de saída e defina uma variável MODEL_DIR. O comando a seguir define MODEL_DIR como um valor de output.

    MODEL_DIR=output
    
  2. Recomendamos excluir o conteúdo do diretório de saída se houver dados de uma execução de treinamento anterior. Com o comando a seguir, é possível remover todos os dados do diretório output.

    rm -rf $MODEL_DIR/*
    
  3. Para realizar seu treinamento localmente, execute o seguinte comando:

    gcloud ml-engine local train \
        --module-name trainer.task \
        --package-path trainer/ \
        --job-dir $MODEL_DIR \
        -- \
        --train-files $TRAIN_DATA \
        --eval-files $EVAL_DATA \
        --train-steps 1000 \
        --eval-steps 100
    

Por padrão, o registro detalhado está desativado. Você pode ativá-lo configurando a tag --verbosity para DEBUG. Um exemplo posterior mostra como ativá-lo.

Inspecionar os registros de resumo usando o TensorBoard

Para ver os resultados da avaliação, você pode usar a ferramenta de visualização chamada TensorBoard. Com ela, você consegue visualizar seu gráfico TensorFlow, traçar métricas quantitativas sobre a execução do seu gráfico e mostrar dados adicionais como imagens que passam pelo gráfico. O Tensorboard está disponível como parte da instalação do TensorFlow.

Siga as etapas abaixo para iniciar o TensorBoard e apontá-lo nos registros de resumo produzidos durante e após a execução do treinamento.

macOS

  1. Inicie o TensorBoard:

    tensorboard --logdir=$MODEL_DIR
    
  2. Quando você começa a executar o TensorBoard, é possível acessá-lo no navegador em http://localhost:6006

Cloud Shell

  1. Inicie o TensorBoard:

    tensorboard --logdir=$MODEL_DIR --port=8080
    
  2. Selecione "Visualização na porta 8080" no menu Visualização na Web, localizado na parte superior da linha de comando.

Clique em Acurácia para ver representações gráficas de como a acurácia muda conforme o job avança.

Gráficos de precisão do Tensorboard

Para encerrar o TensorBoard a qualquer momento, digite ctrl+c na linha de comando.

Executar um job de treinamento local no modo distribuído

Você pode testar se o modelo funciona com um ambiente de execução distribuído do Cloud ML Engine. Para isso, execute um job de treinamento local usando a sinalização --distributed.

  1. Especifique um diretório de saída e defina a variável MODEL_DIR novamente. O comando a seguir define MODEL_DIR como um valor de output-dist.

    MODEL_DIR=output-dist
    
  2. Exclua o conteúdo do diretório output se ainda houver dados de um treinamento anterior.

    rm -rf $MODEL_DIR/*
    
  3. Execute o comando local train com a opção --distributed. Certifique-se de colocar a sinalização acima do -- que separa os argumentos do usuário dos argumentos da linha de comando.

    gcloud ml-engine local train \
        --module-name trainer.task \
        --package-path trainer/ \
        --job-dir $MODEL_DIR \
        --distributed \
        -- \
        --train-files $TRAIN_DATA \
        --eval-files $EVAL_DATA \
        --train-steps 1000 \
        --eval-steps 100
    

Inspecionar a saída

Os arquivos de saída são gravados para o diretório especificado por --job-dir, que foi configurado para output-dist:

ls -R output-dist/

O resultado será parecido com este:

checkpoint
eval
events.out.tfevents.1488577094.<host-name>
export
graph.pbtxt
model.ckpt-1000.data-00000-of-00001
model.ckpt-1000.index
model.ckpt-1000.meta
model.ckpt-2.data-00000-of-00001
model.ckpt-2.index
model.ckpt-2.meta

output-dist//eval:
events.out.tfevents.<timestamp>.<host-name>
events.out.tfevents.<timestamp><host-name>
events.out.tfevents.<timestamp>.<host-name>

output-dist//export:
census

output-dist//export/census:
<timestamp>

output-dist//export/census/<timestamp>:
saved_model.pb
variables
...

Inspecionar os registros

Inspecione os registros de resumo com o TensorBoard da mesma forma que fez para o job de treinamento de instância única, mas altere o valor --logdir para corresponder ao nome do diretório de saída que foi usado para o modo distribuído.

macOS

  1. Inicie o TensorBoard:

    tensorboard --logdir=$MODEL_DIR
    
  2. Quando você começa a executar o TensorBoard, é possível acessá-lo no navegador em http://localhost:6006

Cloud Shell

  1. Inicie o TensorBoard:

    tensorboard --logdir=$MODEL_DIR --port=8080
    
  2. Selecione "Visualização na porta 8080" no menu Visualização na Web, localizado na parte superior da linha de comando.

Configurar o intervalo do Cloud Storage

Nesta seção, você aprende a criar um novo intervalo. Use um intervalo existente, mas caso ele não faça parte do projeto usado para executar o Cloud ML Engine, conceda acesso às contas de serviço do Cloud ML Engine obrigatoriamente e de forma explícita.

  1. Especifique um nome para seu novo intervalo. O nome precisa ser único em todos os intervalos no Cloud Storage.

    BUCKET_NAME="your_bucket_name"

    Por exemplo, use o nome do seu projeto com -mlengine anexado:

    PROJECT_ID=$(gcloud config list project --format "value(core.project)")
    BUCKET_NAME=${PROJECT_ID}-mlengine
  2. Verifique o nome do intervalo que você criou.

    echo $BUCKET_NAME
  3. Selecione uma região do intervalo e configure uma variável de ambiente REGION.

    Por exemplo, o código a seguir cria REGION e a define como us-central1.

    REGION=us-central1
  4. Crie o novo intervalo:

    gsutil mb -l $REGION gs://$BUCKET_NAME

    Observação: use a mesma região em que planeja executar jobs do Cloud ML Engine. O exemplo usa us-central1 porque essa é a região usada no guia de primeiros passos.

Faça o upload dos arquivos de dados para o intervalo do Cloud Storage.

  1. Use gsutil para copiar os dois arquivos para esse intervalo.

    gsutil cp -r data gs://$BUCKET_NAME/data
    
  2. Defina as variáveis TRAIN_DATA e EVAL_DATA para apontar para os arquivos.

    TRAIN_DATA=gs://$BUCKET_NAME/data/adult.data.csv
    EVAL_DATA=gs://$BUCKET_NAME/data/adult.test.csv
    
  3. Use o gsutil novamente para copiar o arquivo de teste JSON test.json para o intervalo do Cloud Storage.

    gsutil cp ../test.json gs://$BUCKET_NAME/data/test.json
    
  4. Defina a variável TEST_JSON para apontar para esse arquivo.

    TEST_JSON=gs://$BUCKET_NAME/data/test.json
    

Executar um job de treinamento de instância única na nuvem

Com um job de treinamento validado, que pode ser executado nos modos de instância única e distribuído, você está pronto para executar um job de treinamento na nuvem. Primeiro, solicite um job de treinamento de instância única.

Use o nível de escalonamento BASIC padrão para executar esse job. A solicitação de job inicial pode levar alguns minutos para iniciar, mas as subsequentes serão executadas mais rápido. Isso permite uma iteração rápida conforme você desenvolve e valida o job de treinamento.

  1. Selecione um nome para a execução de treinamento inicial que o diferencie de qualquer treinamento posterior. Por exemplo, adicione um número para representar a iteração.

    JOB_NAME=census_single_1
    
  2. Especifique um diretório para a saída gerada pelo Cloud ML Engine. Basta definir uma variável OUTPUT_PATH para incluir ao solicitar jobs de treinamento e predição. O OUTPUT_PATH representa o local do Cloud Storage totalmente qualificado para exportações, resumos e checkpoints de modelo. Use a variável BUCKET_NAME definida em uma etapa anterior.

    Recomendamos usar o nome do job como o diretório de saída. Por exemplo, o OUTPUT_PATH a seguir aponta para um diretório chamado census_single_1.

    OUTPUT_PATH=gs://$BUCKET_NAME/$JOB_NAME
    
  3. Execute o comando a seguir para enviar um job de treinamento na nuvem que usa um único processo. Desta vez, defina a tag --verbosity como DEBUG para inspecionar a saída de registro completa e recuperar acurácia, perda e outras métricas. A saída também contém uma série de outras mensagens de aviso que podem ser ignoradas para as finalidades desta amostra.

    gcloud ml-engine jobs submit training $JOB_NAME \
        --job-dir $OUTPUT_PATH \
        --runtime-version 1.10 \
        --module-name trainer.task \
        --package-path trainer/ \
        --region $REGION \
        -- \
        --train-files $TRAIN_DATA \
        --eval-files $EVAL_DATA \
        --train-steps 1000 \
        --eval-steps 100 \
        --verbosity DEBUG
    

Para monitorar o progresso do job, observe a saída da linha de comando ou consulte ML Engine > Jobs no Console do Google Cloud Platform.

Inspecionar a saída

No treinamento em nuvem, as saídas são produzidas no Cloud Storage. Nesta amostra, as saídas são salvas em OUTPUT_PATH. Para listá-las, execute:

gsutil ls -r $OUTPUT_PATH

As saídas precisam ser semelhantes às do treinamento local (acima).

Inspecionar os registros do Stackdriver

Os registros são um modo útil de entender o comportamento do código de treinamento na nuvem. Ao executar um job de treinamento, todos os fluxos stdout e stderr e logging statements são capturados pelo Cloud ML Engine. Esses registros são armazenados no Stackdriver Logging e são visíveis durante e após a execução.

A maneira mais fácil de localizar os registros do job é selecioná-lo em ML Engine > Jobs no Console do GCP. Em seguida, clique em "Ver registros".

Se selecionar "Todos os registros", você verá todos os registros de todos os trabalhadores. Você também pode selecionar uma tarefa específica. master-replica-0 oferece uma visão geral da execução do job na perspectiva do mestre.

Para inspecionar a saída de registro completa, selecione o registro detalhado. Procure o termo accuracy nos registros:

captura de tela do console de registro do Stackdriver para jobs do ML Engine

Se você quiser ver esses logs no terminal, pode fazer isso pela linha de comando com:

gcloud ml-engine jobs stream-logs $JOB_NAME

Consulte todas as opções de gcloud ml-engine jobs stream-logs.

Inspecionar os registros de resumo usando o TensorBoard

Inspecione o comportamento de seu job de treinamento ao iniciar o TensorBoard e apontá-lo para os registros de resumo produzidos durante e após a execução do treinamento.

Como resumos são gravados pelos programas de treinamento diretamente em um local do Cloud Storage, a leitura deles é feita automaticamente pelo TensorBoard sem a cópia manual de arquivos de eventos.

macOS

  1. Inicie o TensorBoard:

    tensorboard --logdir=$OUTPUT_PATH
    
  2. Quando você começa a executar o TensorBoard, é possível acessá-lo no navegador em http://localhost:6006

Cloud Shell

  1. Inicie o TensorBoard:

    tensorboard --logdir=$OUTPUT_PATH --port=8080
    
  2. Selecione "Visualização na porta 8080" no menu Visualização na Web, localizado na parte superior da linha de comando.

Clique em Acurácia para ver representações gráficas de como a acurácia muda conforme o job avança.

Para encerrar o TensorBoard a qualquer momento, digite ctrl+c na linha de comando.

Executar treinamento distribuído na nuvem

Para aproveitar a infraestrutura escalonável do Google, configure seu treinamento para executar no modo distribuído ao realizar jobs de treinamento.

Não é necessária nenhuma alteração de código para executar este modelo como um processo distribuído no Cloud ML Engine.

Para executar um job distribuído, defina --scale-tier como qualquer nível acima do básico. Para mais informações, consulte a documentação de níveis de escalonamento.

  1. Selecione um nome para o job de treinamento distribuído que o diferencie de outros. Por exemplo, use dist para representar "distribuído" e um número para indicar a iteração.

    JOB_NAME=census_dist_1
    
  2. Especifique OUTPUT_PATH para incluir o nome do job e não reutilizar inadvertidamente os checkpoints entre jobs. Redefina BUCKET_NAME se você iniciou uma nova sessão de linha de comando desde a última definição. Por exemplo, o OUTPUT_PATH a seguir aponta para um diretório chamado census-dist-1.

    OUTPUT_PATH=gs://$BUCKET_NAME/$JOB_NAME
    
  3. Execute o seguinte comando para enviar um job de treinamento na nuvem que usa vários workers. Pode levar alguns minutos para que o job inicie.

    Coloque --scale-tier acima do -- que separa os argumentos do usuário dos argumentos da linha de comando. Por exemplo, o comando a seguir usa um nível de escalonamento de STANDARD_1:

    gcloud ml-engine jobs submit training $JOB_NAME \
        --job-dir $OUTPUT_PATH \
        --runtime-version 1.10 \
        --module-name trainer.task \
        --package-path trainer/ \
        --region $REGION \
        --scale-tier STANDARD_1 \
        -- \
        --train-files $TRAIN_DATA \
        --eval-files $EVAL_DATA \
        --train-steps 1000 \
        --verbosity DEBUG  \
        --eval-steps 100
    

Para monitorar o progresso do job, observe a saída da linha de comando ou consulte ML Engine > Jobs no Console do Google Cloud Platform.

Inspecionar os registros

Inspecione os registros do Stackdriver e os registros de resumo da mesma forma que fez para o job de treinamento de instância única.

Para ver os registros do Stackdriver, selecione seu job em ML Engine > Jobs no Console do GCP e clique em Ver registros. Se preferir, use o seguinte comando no terminal:

gcloud ml-engine jobs stream-logs $JOB_NAME

Para TensorBoard:

macOS

  1. Inicie o TensorBoard:

    tensorboard --logdir=$OUTPUT_PATH
    
  2. Quando você começa a executar o TensorBoard, é possível acessá-lo no navegador em http://localhost:6006

Cloud Shell

  1. Inicie o TensorBoard:

    tensorboard --logdir=$OUTPUT_PATH --port=8080
    
  2. Selecione "Visualização na porta 8080" no menu Visualização na Web, localizado na parte superior da linha de comando.

Ajuste de hiperparâmetro

Maximize a precisão preditiva do modelo com o ajuste de hiperparâmetro do Cloud ML Engine. A amostra do censo armazena as definições de configuração do hiperparâmetro em um arquivo YAML chamado hptuning_config.yaml, que é incluído na solicitação de treinamento com a variável --config.

  1. Selecione um novo nome de job e crie uma variável que faça referência ao arquivo de configuração.

    HPTUNING_CONFIG=../hptuning_config.yaml
    JOB_NAME=census_core_hptune_1
    TRAIN_DATA=gs://$BUCKET_NAME/data/adult.data.csv
    EVAL_DATA=gs://$BUCKET_NAME/data/adult.test.csv
    
  2. Especifique OUTPUT_PATH para incluir o nome do job e não reutilizar inadvertidamente os checkpoints entre jobs. Redefina BUCKET_NAME se você iniciou uma nova sessão de linha de comando desde a última definição. Por exemplo, o OUTPUT_PATH a seguir aponta para um diretório chamado census_core_hptune_1.

    OUTPUT_PATH=gs://$BUCKET_NAME/$JOB_NAME
    
  3. Execute o comando a seguir para enviar um job de treinamento que usa vários workers e o ajuste de hiperparâmetro.

    gcloud ml-engine jobs submit training $JOB_NAME \
        --stream-logs \
        --job-dir $OUTPUT_PATH \
        --runtime-version 1.10 \
        --config $HPTUNING_CONFIG \
        --module-name trainer.task \
        --package-path trainer/ \
        --region $REGION \
        --scale-tier STANDARD_1 \
        -- \
        --train-files $TRAIN_DATA \
        --eval-files $EVAL_DATA \
        --train-steps 1000 \
        --verbosity DEBUG  \
        --eval-steps 100
    

Para mais informações, consulte a visão geral do ajuste de hiperparâmetros.

Implantar um modelo para auxiliar a predição

  1. Escolha um nome para o modelo. Ele precisa começar com uma letra e conter apenas letras, números e sublinhados. Por exemplo:

    MODEL_NAME=census
    
  2. Crie um modelo do Cloud ML Engine:

    gcloud ml-engine models create $MODEL_NAME --regions=$REGION
    
  3. Selecione a saída do job a ser usada. A amostra a seguir usa o job chamado census_dist_1.

    OUTPUT_PATH=gs://$BUCKET_NAME/census_dist_1
    
  4. Procure o caminho completo de seus binários de modelo treinados exportados:

    gsutil ls -r $OUTPUT_PATH/export
    
  5. Encontre um diretório chamado $OUTPUT_PATH/export/census/<timestamp> e copie esse caminho de diretório (sem os : no final). Depois, defina a variável de ambiente MODEL_BINARIES como o valor dele. Por exemplo:

    MODEL_BINARIES=gs://$BUCKET_NAME/census_dist_1/export/census/1487877383942/

    Em que $BUCKET_NAME é o nome do intervalo do Cloud Storage e census_dist_1 é o diretório de saída.

  6. Execute o seguinte comando para criar uma versão v1:

    gcloud ml-engine versions create v1 \
        --model $MODEL_NAME \
        --origin $MODEL_BINARIES \
        --runtime-version 1.10
    

Receba uma lista de seus modelos usando o comando models list.

gcloud ml-engine models list

Enviar uma solicitação de previsão on-line para um modelo implantado

Agora é possível enviar solicitações de previsão para o modelo. Por exemplo, o comando a seguir envia uma solicitação de previsão on-line usando um arquivo test.json que você baixou como parte do repositório GitHub de amostra.

gcloud ml-engine predict \
    --model $MODEL_NAME \
    --version v1 \
    --json-instances ../test.json

A resposta inclui as probabilidades de cada rótulo (> 50 mil e ≤ 50 mil) com base na entrada de dados em test.json, indicando se a receita prevista é maior ou menor que 50.000 dólares.

A resposta será assim:

CLASSES       PROBABILITIES
[u'0', u'1']  [0.9969545602798462, 0.0030454816296696663]

Enviar um job de previsão de lotes

O serviço de previsão de lotes é útil se você tem grandes quantidades de dados e não há requisitos de latência para receber resultados de previsão. Ele usa o mesmo formato que a previsão on-line, mas exige que os dados sejam armazenados no Cloud Storage.

  1. Defina um nome para o job.

    JOB_NAME=census_prediction_1
    
  2. Defina o caminho de saída.

    OUTPUT_PATH=gs://$BUCKET_NAME/$JOB_NAME
    
  3. Envie o job de previsão.

    gcloud ml-engine jobs submit prediction $JOB_NAME \
        --model $MODEL_NAME \
        --version v1 \
        --data-format text \
        --region $REGION \
        --input-paths $TEST_JSON \
        --output-path $OUTPUT_PATH/predictions
    

Este comando é retornado imediatamente, ao contrário dos anteriores. Verifique o andamento do job e aguarde que ele termine:

gcloud ml-engine jobs describe $JOB_NAME

Você verá state: SUCCEEDED quando o job estiver concluído, o que pode levar vários minutos. Você também pode ver os registros do job no seu terminal usando

gcloud ml-engine jobs stream-logs $JOB_NAME

Também é possível verificar o progresso em ML Engine > Jobs no Console do GCP.

Após a conclusão do job, é possível:

  • Ler o resumo da saída.

    gsutil cat $OUTPUT_PATH/predictions/prediction.results-00000-of-00001
    

    Um código semelhante a este será exibido:

    {"probabilities": [0.9962924122810364, 0.003707568161189556], "logits": [-5.593664646148682], "classes": 0, "logistic": [0.003707568161189556]}
    
  • Listar os outros arquivos produzidos pelo job usando o comando gsutil ls.

    gsutil ls -r $OUTPUT_PATH
    

Em comparação com a predição on-line, a predição em lote:

  • é mais lenta para este pequeno número de instâncias, mas é mais adequada para um grande número;
  • pode retornar a saída em uma ordem diferente da entrada, mas o índice numérico permite que cada uma seja adaptada à instância de entrada correspondente. Isso não é necessário para a predição on-line, uma vez que as saídas são retornadas na mesma ordem que as instâncias de entrada originais.

Após as predições estarem disponíveis, o próximo passo geralmente é ingerir essas predições em um banco de dados ou pipeline de processamento de dados.

Nesta amostra, você implantou o modelo antes de executar a previsão de lotes, mas é possível ignorar esse passo e especificar o URI dos binários do modelo quando enviar o job de previsão de lotes. Uma vantagem de gerar previsões de um modelo antes de implantá-lo é avaliar o desempenho dele em diferentes conjuntos de dados de avaliação, para decidir se atende aos critérios de implantação.

Limpeza

Se você terminar de analisar a saída das execuções de treinamento e previsão, poderá evitar cobranças adicionais na sua conta do GCP para os diretórios do Cloud Storage usados ​​neste guia:

  1. Abra uma janela do terminal se já não estiver aberta.

  2. Use o comando gsutil rm com a sinalização -r para excluir o diretório que contém o job mais recente:

    gsutil rm -r gs://$BUCKET_NAME/$JOB_NAME
    

Se for bem-sucedido, o comando retornará uma mensagem semelhante a:

Removing gs://my-awesome-bucket/just-a-folder/cloud-storage.logo.png#1456530077282000...
Removing gs://my-awesome-bucket/...

Repita o comando para todos os outros diretórios criados para essa amostra.

Como alternativa, se você não tiver outros dados armazenados no intervalo, poderá executar o comando gsutil rm -r no próprio intervalo.

Sobre os dados

O conjunto de dados de renda do Censo (em inglês), usado para treinamento nesta amostra, está hospedado no Repositório de machine learning da UC Irvine (em inglês).

Dados do censo por cortesia de: Lichman, M. (2013). Repositório de aprendizado de máquina da UCI http://archive.ics.uci.edu/ml. Irvine, CA: Universidade da Califórnia, Escola de informação e ciência da computação. Este conjunto de dados está disponível publicamente para uso por qualquer pessoa nos seguintes termos fornecidos pela fonte do conjunto de dados - http://archive.ics.uci.edu/ml - e é fornecido "NA FORMA EM QUE SE ENCONTRA", sem qualquer garantia, expressa ou implícita, do Google. O Google se isenta de qualquer responsabilidade por eventuais danos, diretos ou indiretos, decorrentes do uso do conjunto de dados.

A seguir

Você completou as instruções de uma amostra do Cloud ML Engine que usa dados do censo para treinamento e previsão. Você validou o job de treinamento localmente, executou-o na nuvem no modo de instância única e distribuído, usou o ajuste de hiperparâmetros para melhorar o modelo e usou o modelo para conseguir previsões on-line e em lote.

Com os recursos a seguir, você pode saber mais sobre o Cloud ML Engine.

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Cloud ML Engine para TensorFlow