Esta página foi traduzida pela API Cloud Translation.

Como executar o MNIST no Cloud TPU (TF 2.x)

Este tutorial contém uma descrição de alto nível do modelo MNIST, instruções sobre como fazer o download da exemplo de código de TPU do MNIST no TensorFlow e um guia para executar o código no Cloud TPU.

Exoneração de responsabilidade

Este tutorial usa um conjunto de dados de terceiros. O Google não oferece representação, nem outras garantias sobre a validade ou quaisquer outros aspectos deste no conjunto de dados.

Descrição do modelo

O conjunto de dados MNIST contém um grande número de imagens de dígitos manuscritos no intervalo de 0 a 9, bem como os rótulos que identificam os em cada imagem.

Neste tutorial, você treinará um modelo de machine learning para classificar imagens com base no conjunto de dados MNIST. Após o treinamento, o modelo classifica as imagens recebidas em 10 categorias (0 a 9) com base no que ele aprendeu sobre imagens manuscritas de conjunto de dados MNIST. Depois, é possível enviar ao modelo uma imagem que ele não viu antes, e o modelo identifica o dígito na imagem com base no que o modelo aprendeu durante o treinamento.

O conjunto de dados MNIST foi dividido em três partes:

60.000 exemplos de dados de treinamento;
10.000 exemplos de dados de teste;
5.000 exemplos de dados de validação.

O modelo inclui sete camadas:

duas de convolução
duas de pool máximo
duas densas (totalmente conectadas)
uma de dropout

A perda é calculada usando a entropia cruzada categórica.

Essa versão do modelo MNIST usa a API Keras, uma forma recomendada de criar e executar um modelo de machine learning em um Cloud TPU.

O Keras simplifica o processo de desenvolvimento de modelos ao ocultar a maior parte dos elementos que também permite alternar entre a TPU e outras plataformas de teste como GPUs ou CPUs.

Objetivos

Criar um bucket do Cloud Storage para armazenar o conjunto de dados e a saída do modelo.
Executar o job de treinamento.
Verificar os resultados da saída.

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

Compute Engine
Cloud TPU
Cloud Storage

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Antes de começar

Nesta seção, você verá como configurar o bucket do Cloud Storage e a VM do Compute Engine.

Abra uma janela do Cloud Shell.

Abrir o Cloud Shell
Crie uma variável para o ID do seu projeto.
```
export PROJECT_ID=project-id
```
Configurar a CLI do Google Cloud para usar o projeto em que você quer criar Cloud TPU:
```
gcloud config set project ${PROJECT_ID}
```
Na primeira vez que você executar esse comando em uma nova VM do Cloud Shell, será exibida uma página Authorize Cloud Shell. Clique em Authorize na parte de baixo. da página para permitir que gcloud faça chamadas de API do Google Cloud com suas credenciais.

Crie uma conta de serviço para o projeto da Cloud TPU.

gcloud beta services identity create --service tpu.googleapis.com --project $PROJECT_ID

O comando retorna uma conta de serviço do Cloud TPU com o seguinte formato:

service-PROJECT_NUMBER@cloud-tpu.iam.gserviceaccount.com

Crie um bucket do Cloud Storage usando o seguinte comando:

Observação: no comando a seguir, substitua bucket-name pelo nome que você quer atribuir ao bucket.
```
gcloud storage buckets create gs://bucket-name \
--project=${PROJECT_ID} \
--location=us-central1
```
Esse bucket do Cloud Storage armazena os dados usados para treinar o modelo e os resultados do treinamento. O comando gcloud usado neste tutorial configura permissões padrão para a conta de serviço da Cloud TPU que você configurou no etapa anterior. Caso queira permissões mais específicas, consulte as permissões de nível de acesso.
Crie uma VM de TPU usando o comando gcloud.
```
$ gcloud compute tpus tpu-vm create mnist-tutorial \
   --zone=us-central1-b \
   --accelerator-type=v3-8 \
   --version=tpu-vm-tf-2.17.0-pjrt \
 
```
Descrições de sinalizações de comando

zone

A zona onde você planeja criar o Cloud TPU.

accelerator-type

O tipo de acelerador especifica a versão e o tamanho do Cloud TPU que você quer criar. Para mais informações sobre os tipos de aceleradores compatíveis com cada versão de TPU, consulte versões de TPU.

version

A versão do software do Cloud TPU.

Para mais informações sobre o comando gcloud, consulte a referência da gcloud.
Conecte-se à instância do Compute Engine usando SSH. Quando você estiver conectado para a VM, o prompt do shell muda de username@projectname para username@vm-name:
```
gcloud compute tpus tpu-vm ssh mnist-tutorial --zone=us-central1-b
```
Importante: a partir deste ponto, o prefixo (vm) $ significa que você deve executar o comando na instância de VM do Compute Engine.
Crie uma variável de ambiente para o nome da TPU.
```
(vm)$ export TPU_NAME=local
```

Instale os requisitos do TensorFlow.

(vm)$ pip3 install -r /usr/share/tpu/models/official/requirements.txt

Treine o modelo

O código-fonte do modelo de TPU do MNIST está disponível no GitHub (em inglês).

Configure as variáveis a seguir. Substitua bucket-name pelo nome do seu bucket:

(vm)$ export STORAGE_BUCKET=gs://bucket-name
(vm)$ export MODEL_DIR=${STORAGE_BUCKET}/mnist
(vm)$ export DATA_DIR=${STORAGE_BUCKET}/data

Defina a variável de ambiente PYTHONPATH.

(vm)$ export PYTHONPATH="${PYTHONPATH}:/usr/share/tpu/models"

Ao criar sua TPU, se você definir o parâmetro --version como uma versão que termina com -pjrt, defina as seguintes variáveis de ambiente para ativar o ambiente de execução PJRT:
```
  (vm)$ export NEXT_PLUGGABLE_DEVICE_USE_C_API=true
  (vm)$ export TF_PLUGGABLE_DEVICE_LIBRARY_PATH=/lib/libtpu.so
```

Mude para o diretório que armazena o modelo:

(vm)$ cd /usr/share/tpu/models/official/legacy/image_classification

Execute o script de treinamento do MNIST:
```
(vm)$ python3 mnist_main.py \
  --tpu=${TPU_NAME} \
  --model_dir=${MODEL_DIR} \
  --data_dir=${DATA_DIR} \
  --train_epochs=10 \
  --distribution_strategy=tpu \
  --download
```
Descrições de sinalizações de comando

tpu

O nome da Cloud TPU. Caso não tenha especificado um quando configurou o Cloud TPU e a VM do Compute Engine, o padrão é seu nome de usuário.

model_dir

O bucket do Cloud Storage em que os checkpoints e os resumos são armazenados durante o treinamento. É possível usar uma pasta existente para carregar checkpoints gerados que foram criados em uma TPU do mesmo tamanho para a versão anterior.

data_dir

O caminho do Cloud Storage da entrada de treinamento. Ele é definido como fake_imagenet.

train_epochs

O número de períodos para treinar o modelo.

distribution_strategy

Para treinar o modelo ResNet em um Cloud TPU, defina distribution_strategy para tpu.

download

Quando definido como true, o script faz o download e pré-processa conjunto de dados MNIST, caso ainda não tenha sido baixado.

O script de treinamento é executado em menos de cinco minutos em um Cloud TPU v3-8 e exibe uma saída semelhante a:

Run stats:
{
  'accuracy_top_1': 0.9762369990348816,
  'eval_loss': 0.07863274961709976,
  'loss': 0.1111728847026825,
  'training_accuracy_top_1': 0.966645359992981
}

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

Desconecte-se da instância do Compute Engine, caso ainda não tenha feito isso:
```
(vm)$ exit
```
Agora, o prompt será username@projectname, mostrando que você está no Cloud Shell.

Exclua os recursos do Cloud TPU e do Compute Engine.

$ gcloud compute tpus tpu-vm delete mnist-tutorial \
  --zone=us-central1-b

Execute gcloud compute tpus tpu-vm list para verificar se os recursos foram excluídos. A exclusão pode levar vários minutos. A saída do comando a seguir não deve incluir nenhum dos recursos criados neste tutorial:
```
$ gcloud compute tpus tpu-vm list --zone=us-central1-b
```
Exclua o bucket do Cloud Storage usando o comando a seguir. Substitua bucket-name pelo nome do seu bucket no Cloud Storage.
```
$ gcloud storage rm gs://bucket-name --recursive
```

A seguir

Geralmente, os tutoriais do Cloud TPU do TensorFlow treinam o modelo usando um conjunto de dados de amostra. Os resultados desse treinamento não são utilizáveis para inferência. Para um modelo para inferência, é possível treinar os dados em uma conjunto de dados ou seu próprio conjunto de dados. Modelos do TensorFlow treinados em Cloud TPUs geralmente exigem que os conjuntos de dados estejam TFRecord.

Você pode usar a ferramenta de conversão do conjunto de dados sample para converter uma imagem conjunto de dados de classificação no formato TFRecord. Se você não estiver usando uma imagem modelo de classificação, você terá que converter seu conjunto de dados para Formato do TFRecord você mesmo. Para mais informações, consulte TFRecord e tf.Example

Ajuste de hiperparâmetros

Para melhorar o desempenho do modelo com o conjunto de dados, é possível ajustar a e ajustar os hiperparâmetros. É possível encontrar informações sobre hiperparâmetros comuns a todos Modelos com suporte a TPU em GitHub. As informações sobre hiperparâmetros específicos do modelo podem ser encontradas na fonte para cada um modelo de machine learning. Para mais informações sobre o ajuste de hiperparâmetros, consulte a Visão geral do ajuste de hiperparâmetros e Ajuste e ajustar os hiperparâmetros.

Inferência

Depois de treinar o modelo, você pode usá-lo para inferência (também chamado de previsão). Use o conversor de inferência do Cloud TPU ferramenta para preparar e otimizar Modelo do TensorFlow para inferência no Cloud TPU v5e. Para mais informações sobre inferência no Cloud TPU v5e, consulte Inferência do Cloud TPU v5e introdução.

Execute um colab do Cloud TPU que demonstra como executar um modelo de classificação de imagem usando seus próprios dados de imagem.
Explore os outros tutoriais da Cloud TPU.
Aprenda a usar as ferramentas de monitoramento de TPU no TensorBoard.
Verifique o desempenho em um modelo de grande escala ao executar a amostra do ResNet.