Como executar o TensorFlow distribuído no Compute Engine

Neste tutorial, mostramos como usar uma configuração distribuída do TensorFlow em várias instâncias do Compute Engine para treinar um modelo de rede neural convolucional usando o conjunto de dados MNIST. Esse conjunto ativa o reconhecimento de dígitos manuscritos e é amplamente usado no aprendizado de máquina como um conjunto de treinamento para reconhecimento de imagens.

O TensorFlow é a biblioteca de código aberto do Google para aprendizado de máquina, desenvolvido por pesquisadores e engenheiros da Machine Intelligence, organização do Google que faz parte do Research at Google. O TensorFlow é projetado para ser executado em vários computadores para distribuir as cargas de trabalho de treinamento. Neste tutorial, você executará o TensorFlow em várias instâncias de máquina virtual do Compute Engine para treinar o modelo. Em vez disso, você pode usar o Cloud Machine Learning Engine, que gerencia tarefas de alocação de recursos e pode hospedar seus modelos treinados. Recomendamos que você use o Cloud ML Engine, a menos que tenha uma razão específica para não fazê-lo. Saiba mais na versão deste tutorial que usa o Cloud ML Engine e o Cloud Datalab.

No diagrama a seguir, você encontra a descrição da arquitetura para execução de uma configuração distribuída do TensorFlow no Compute Engine e do uso do Cloud ML Engine com o Cloud Datalab para fazer previsões com o modelo treinado.

imagem

Neste tutorial, mostramos como configurar e usar essa arquitetura e explicamos alguns conceitos.

Objetivos

  • Configurar o Compute Engine para criar um cluster de máquinas virtuais (VMs, na sigla em inglês) para executar o TensorFlow.
  • Aprender a executar o código de amostra do TensorFlow distribuído no cluster do Compute Engine para treinar um modelo. No código de exemplo, foram usados os padrões e as bibliotecas mais recentes do TensorFlow para que você possa usá-los como referência ao desenvolver o próprio código de treinamento.
  • Implantar o modelo treinado no Cloud ML Engine para criar uma API personalizada de previsões e executá-las usando um notebook do Cloud Datalab.

Custos

Com base nesta calculadora de preços, o preço estimado para executar este tutorial, presumindo que você use todos os recursos em um dia inteiro, é de aproximadamente US$ 1,20.

Antes de começar

  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 Compute Engine e Cloud Machine Learning APIs.

    Ativar as APIs

Como criar a instância do modelo

Neste tutorial, você usará o Cloud Shell, um shell completo do Linux no Console do Google Cloud Platform.

  1. Acesse o Cloud Shell.

    Abrir o Cloud Shell

  2. Configure a zona padrão do Google Compute Engine e o projeto padrão:

    gcloud config set compute/zone us-east1-c
    gcloud config set project [YOUR_PROJECT_ID]
  3. Clone o repositório do GitHub:

    git clone https://github.com/GoogleCloudPlatform/cloudml-dist-mnist-example
    cd cloudml-dist-mnist-example
  4. Crie a instância inicial da VM de uma imagem do Ubuntu Wily:

    gcloud compute instances create template-instance \
    --image-project ubuntu-os-cloud \
    --image-family ubuntu-1604-lts \
    --boot-disk-size 10GB \
    --machine-type n1-standard-1
  5. Use o SSH para se conectar à VM:

    gcloud compute ssh template-instance
  6. Instale o pip:

    sudo apt-get update
    sudo apt-get -y upgrade \
    && sudo apt-get install -y python-pip python-dev
  7. Instale o TensorFlow:

    sudo pip install tensorflow
    
  8. (Opcional) Siga as etapas para verificar a instalação.

  9. Digite exit para voltar ao Cloud Shell.

  10. Verifique a versão do TensorFlow em execução na instância do Cloud Shell:

    sudo python -c 'import tensorflow as tf; print(tf.__version__)'
  11. Se a versão for anterior à 1.2.1, use o pip para fazer upgrade:

    sudo pip install --upgrade tensorflow

Como criar um intervalo do Cloud Storage

Em seguida, crie um intervalo do Cloud Storage para armazenar os arquivos MNIST. Siga estas etapas:

  1. Crie um intervalo regional do Cloud Storage para manter os arquivos de dados MNIST que são compartilhados entre as instâncias de worker:

    MNIST_BUCKET="mnist-$RANDOM"
    gsutil mb -c regional -l us-east1 gs://${MNIST_BUCKET}
  2. Use este script para fazer o download dos arquivos de dados MNIST e copiá-los no intervalo:

    sudo ./scripts/create_records.py
    gsutil cp /tmp/data/train.tfrecords gs://${MNIST_BUCKET}/data/
    gsutil cp /tmp/data/test.tfrecords gs://${MNIST_BUCKET}/data/

Como criar a imagem de modelo e as instâncias de treinamento

Para criar as instâncias de servidor de parâmetros, worker e mestre, converta a instância de modelo em uma imagem e use essa imagem para criar novas instâncias.

  1. Desative a exclusão automática da VM da template-instance para que o disco seja preservado quando a máquina virtual for excluída:

    gcloud compute instances set-disk-auto-delete template-instance \
    --disk template-instance --no-auto-delete
  2. Exclua template-instance:

    gcloud compute instances delete template-instance
  3. Crie a imagem template-image do disco do template-instance:

    gcloud compute images create template-image \
    --source-disk template-instance
  4. Crie as instâncias adicionais. Para este tutorial, crie quatro instâncias chamadas master-0, worker-0, worker-1 e ps-0. Com o escopo storage-rw, as instâncias podem acessar o intervalo do Cloud Storage. Delimite os nomes das instâncias com espaços da seguinte forma:

    gcloud compute instances create \
    master-0 worker-0 worker-1 ps-0 \
    --image template-image \
    --machine-type n1-standard-4 \
    --scopes=default,storage-rw

O cluster está pronto para executar o TensorFlow distribuído.

Como executar o código do TensorFlow distribuído

Nesta seção, você executará um script para que o código do TensorFlow de treinamento de modelo seja executado em todas as instâncias de VM.

No Cloud Shell, execute o seguinte comando do diretório cloudml-dist-mnist-example:

./scripts/start-training.sh gs://${MNIST_BUCKET}

No script start-training.sh, o código é enviado para cada VM e os parâmetros necessários são transmitidos para iniciar o processo do TensorFlow de criação do cluster distribuído nas máquinas. No stream de saída do Cloud Shell, são mostrados os valores de perda e precisão do conjunto de dados de teste.

Valores de precisão no terminal

Quando o treinamento é concluído, o local dos arquivos de modelo recém-gerados é impresso pelo script:

Trained model is stored in gs://${MNIST_BUCKET}/job_[TIMESTAMP]/export/Servo/[JOB_ID]/

Copie o local do caminho do intervalo para usar nas etapas posteriores.

Como publicar o modelo para previsões

Você gerou um novo modelo que será usado para fazer previsões. Quanto mais sofisticado é o modelo de treinamento, mais complexo é o código do TensorFlow, mas a configuração dos recursos de computação e armazenamento é semelhante.

O treinamento do modelo é apenas a metade do processo. Agora, é necessário conectar o modelo ao aplicativo ou encapsulá-lo usando um serviço de API com autenticação e, finalmente, fazer todo o escalonamento. Há uma quantidade relativamente significativa de trabalho de engenharia a ser feito antes que você possa usar o modelo.

O Cloud ML Engine ajuda você em uma parte desse trabalho. Executado no Cloud Platform, ele é uma versão totalmente gerenciada do TensorFlow e fornece todos os recursos avançados dele, sem a necessidade de configurar infraestruturas adicionais ou instalar software. Faça o escalonamento automático do treinamento distribuído para usar milhares de CPUs ou GPUs e você pagar somente pelo que usar.

Como o TensorFlow é executado no Cloud ML Engine em segundo plano, todo o trabalho é portátil, e você não fica preso a uma ferramenta proprietária.

Consulte o tutorial Como usar o TensorFlow distribuído com o Cloud Datalab para usar o mesmo código de exemplo a fim de treinar o modelo usando o Cloud ML Engine.

Também é possível configurar o Cloud ML Engine para hospedar o modelo para as previsões. Siga as etapas abaixo para publicar esse modelo no Cloud ML Engine. Com essa hospedagem, você testa e aplica o modelo rapidamente em escala, com todos os recursos de segurança e confiabilidade oferecidos em um serviço gerenciado do Google.

Nas etapas a seguir, você usa o caminho do intervalo do modelo que foi exibido anteriormente na saída do script start-training.sh.

  1. Lembre-se do caminho da saída do intervalo do Cloud Storage com os modelos gerados. Ele está no formato a seguir, em que [JOB_ID] é o código do job. Esse caminho será usado na próxima etapa:

    MODEL_BUCKET: gs://${MNIST_BUCKET}/job_[TIMESTAMP]/export/Servo/[JOB_ID]
  2. Para definir a nova versão v1 do modelo, use a ferramenta de linha de comando gcloud e aponte-a para os arquivos de modelo no intervalo. A execução do comando a seguir levará vários minutos para ser concluída. Substitua [YOUR_BUCKET_PATH] pelo caminho da saída da etapa anterior, que começa com gs://.

    MODEL="MNIST"
    MODEL_BUCKET=[YOUR_BUCKET_PATH]
    gcloud ml-engine models create ${MODEL} --regions us-east1
    gcloud ml-engine versions create \
     --origin=${MODEL_BUCKET} --model=${MODEL} v1
  3. Defina a versão padrão do modelo como "v1":

    gcloud ml-engine versions set-default --model=${MODEL} v1

Agora, o modelo está sendo executado com o Cloud ML, e você consegue processar as previsões. Na próxima seção, você usará o Cloud Datalab para fazer e visualizar as previsões.

Como executar previsões no Cloud Datalab

Teste as previsões criando uma instância do Cloud Datalab que use o Jupyter Notebook interativo para executar o código.

  1. No Cloud Shell, digite o seguinte comando para criar uma instância do Cloud Datalab.

    datalab create mnist-datalab
    
  2. No Cloud Shell, inicie a página de listagem do notebook do Cloud Datalab clicando no ícone quadrado de Visualização da Web do Cloud Shell, na parte superior direita.

  3. Selecione Alterar porta e Porta 8081 para iniciar uma nova guia no navegador.

  4. No aplicativo Cloud Datalab, crie um notebook clicando no ícone +Notebook na parte superior direita.

  5. Cole o seguinte texto na primeira célula do novo notebook:

    %%bash
    wget https://raw.githubusercontent.com/GoogleCloudPlatform/cloudml-dist-mnist-example/master/notebooks/Online%20prediction%20example.ipynb
    cat Online\ prediction\ example.ipynb > Untitled\ Notebook.ipynb
  6. Clique em Executar na parte superior da página para fazer o download do notebook Online prediction example.ipynb. O script copia o conteúdo do notebook remoto para o atual.

  7. Atualize a página do navegador para carregar o conteúdo do novo notebook. Selecione a primeira célula com o código JavaScript e clique em Executar.

  8. Role a página para baixo até ver um painel e desenhe um número nele com o cursor.

    O número 3 desenhado com um cursor.

  9. Clique na próxima célula para ativá-la e depois na seta para baixo ao lado do botão Executar na parte superior. Em seguida, selecione Executar nesta célula.

  10. O resultado da previsão é uma matriz de 10 caracteres, em que cada índice, de 0 a 9, contém um número correspondente a esse dígito. Quanto mais próximo esse número for de 1, maior será a probabilidade de o índice corresponder ao dígito inserido. Observe que o número no slot 3 destacado na lista é muito próximo de 1. Portanto, a probabilidade de correspondência do dígito é alta.

    PROBABILITIES
    [4.181503356903704e-07,
    7.12400151314796e-07,
    0.00017898145597428083,
    0.9955494403839111,
    5.323939553103507e-11,
    0.004269002005457878,
    7.927398321116996e-11,
    1.2688398953741853e-07,
    1.0825967819982907e-06,
    2.2037748692582682e-07]

Na última célula do notebook, há um gráfico de barras que mostra claramente que o número foi reconhecido, nesse caso, o 3.

O gráfico de barras mostra que o número 3 foi selecionado.

Como limpar

Para evitar que os recursos usados neste tutorial sejam cobrados na conta do Google Cloud Platform:

  1. Exclua a versão do modelo:

    gcloud ml-engine versions delete v1 --model=MNIST
  2. Exclua o modelo:

    gcloud ml-engine models delete MNIST
  3. Exclua o intervalo do Cloud Storage:

    gsutil rm -r gs://${MNIST_BUCKET}
  4. Exclua as máquinas virtuais, incluindo o Cloud DataLab:

    gcloud compute instances delete master-0 worker-0 worker-1 ps-0 mnist-datalab
  5. Exclua a imagem de modelo de VM:

    gcloud compute images delete template-image
  6. Exclua o disco permanente do Cloud Datalab:

    gcloud compute disks delete mnist-datalab-pd --zone us-east1-c

Próximas etapas

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

Enviar comentários sobre…