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 Google 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, use o Cloud Machine Learning Engine, que gerencia tarefas de alocação de recursos e pode hospedar os modelos treinados. Recomendamos que você use o Cloud Machine Learning Engine, a não ser que haja um motivo específico para não usá-lo. Saiba mais na versão deste tutorial em que são usados o Cloud Machine Learning Engine e o Cloud Datalab.

No diagrama a seguir, você encontra a descrição da arquitetura para a execução de uma configuração distribuída do TensorFlow no Compute Engine e a descrição do uso do Cloud ML Engine com o Cloud Datalab para fazer prediçõ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) e executar o TensorFlow.
  • Aprender a executar o código de amostra do TensorFlow distribuído no cluster do Google 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 bloco de notas 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 a de 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 Google Cloud Storage para manter os arquivos de dados MNIST que são compartilhados entre as instâncias de trabalho:

    MNIST_BUCKET="mnist-$RANDOM"
    gsutil mb -c regional -l us-east1 gs://${MNIST_BUCKET}

  2. Use o script a seguir para fazer o download dos arquivos de dados MNIST e copiá-los para o 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 trabalho, mestre e de parâmetros, converta a instância de modelo em uma imagem e use essa imagem para criar as novas instâncias.

  1. Desative a exclusão automática para a VM do template-instance para que o disco seja preservado quando ela 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 Google Cloud Storage. Delimite os nomes das instâncias com espaços, desta maneira:

    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 Google 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á algum tempo para ser concluída. Substitua [YOUR_BUCKET_PATH] pelo caminho da saída da etapa anterior. Ele 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

Para testar as previsões, crie 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 de blocos de notas do Cloud Datalab clicando na visualização da Web do Cloud Shell (o ícone quadrado na parte superior direita).

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

  4. No aplicativo Cloud Datalab, para criar um bloco de notas, clique no ícone +Bloco de notas na parte superior direita.

  5. Cole o seguinte texto na primeira célula do novo bloco de notas:

    %%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 bloco de notas Online prediction example.ipynb. O script copia o conteúdo do bloco remoto para o bloco atual.

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

  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, clique na seta para baixo ao lado do botão Executar na parte superior e selecione Executar desta célula.

  10. O resultado da previsão é uma matriz de tamanho 10, 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 que o índice corresponda ao dígito inserido. Observe que o número no slot 3 destacado na lista é muito próximo de 1 e, 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 bloco de notas, 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 Google 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…