Como executar o Transformer com o Tensor2Tensor no Cloud TPU

Neste tutorial, mostramos como treinar o modelo do Transformer (em inglês), apresentado no artigo Attention Is All You Need, usando o Tensor2Tensor na Cloud TPU.

Descrição do modelo

O modelo do Transformer usa pilhas de camadas de autoatenção e de encaminhamento de feed para processar entradas sequenciais como texto. Ele é compatível com as variantes a seguir:

transformer: somente decodificador, para modelagem de sequência única. Exemplo de caso de uso: modelagem de linguagem.
transformer: codificador e decodificador, para modelagem de sequência a sequência. Exemplo de caso de uso: tradução.
transformer_encoder: somente codificador, para a sequência na modelagem de classe. Exemplo de caso de uso: classificação de sentimento.

O Transformer é apenas um dos modelos na biblioteca do Tensor2Tensor. Tensor2Tensor (T2T) é uma biblioteca de modelos de aprendizado profundo e conjuntos de dados, além de um conjunto de scripts que permite treinar os modelos, fazer o download e preparar os dados.

Objetivos

Gerar o conjunto de dados de treinamento
Treinar um modelo de linguagem em um único Cloud TPU ou um pod do Cloud TPU
Treinar um modelo de tradução de inglês para alemão em um único Cloud TPU
Treinar um classificador de sentimento em um único Cloud TPU
Limpar os recursos do Cloud TPU

Custos

Neste tutorial, há componentes faturáveis do Google Cloud, entre eles:

Compute Engine
Cloud TPU
Cloud Storage

Use a calculadora de preços para gerar uma estimativa de custos baseada na projeção de uso. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Antes de começar

Se você planeja treinar em uma fração de pod de TPU, leia Treinamento em pods de TPU que explica as considerações especiais ao treinar em uma fração de pod.

Antes de começar o tutorial, siga as etapas abaixo para verificar se o projeto do Google Cloud foi configurado corretamente.

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

Abra uma janela do Cloud Shell.

Abra o Cloud Shell
Crie uma variável para o ID do seu projeto.
```
export PROJECT_ID=project-id
```
Configure a ferramenta de linha de comando da gcloud para usar o projeto em que a Cloud TPU será criada.
```
gcloud config set project ${PROJECT_ID}
```
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.
```
gsutil mb -p ${PROJECT_ID} -c standard -l europe-west4 -b on gs://bucket-name
```
Esse bucket do Cloud Storage armazena os dados usados para treinar o modelo e os resultados do treinamento.
Inicie uma VM do Compute Engine usando o comando ctpu up.
```
ctpu up --zone=europe-west4-a \
--vm-only \
--disk-size-gb=300 \
--machine-type=n1-standard-8 \
--tf-version=1.15.3 \
--name=transformer-tutorial
```
Observação: se você tiver mais de um projeto, especifique um nome de projeto usando --project. Se --name não for especificado, os nomes de TPU e VM serão padronizados com seu nome de usuário.
A configuração especificada aparecerá. Digite y para aprovar ou n para cancelar.
Quando o comando ctpu up terminar a execução, verifique se o prompt do shell foi alterado de username@projectname para username@vm-name. Essa alteração mostra que você fez login na VM do Compute Engine.

Observação: ao executar o ctpu up em um projeto pela primeira vez, a realização das tarefas de inicialização pode levar vários minutos, como propagação da chave SSH e ativação da API. Às vezes, uma mensagem de erro (ERROR: (gcloud.compute.ssh) [/usr/bin/ssh] exited with return code [255]) é retornada durante a propagação de chave SSH. Se isso acontecer, execute o seguinte comando para resolver o problema.
```
gcloud compute ssh transformer-tutorial --zone=europe-west4-a
```
Ao seguir essas instruções, execute cada comando iniciado por (vm)$ na janela de sessão da VM.

Na VM do Compute Engine:

Crie as variáveis de ambiente a seguir:

(vm)$ export STORAGE_BUCKET=gs://bucket-name

(vm)$ export MODEL_DIR=${STORAGE_BUCKET}/transformer
(vm)$ export DATA_DIR=${STORAGE_BUCKET}/data
(vm)$ export TMP_DIR=${HOME}/t2t_tmp

Crie um diretório para armazenar arquivos temporários:
```
(vm)$ mkdir ${TMP_DIR}
```
Adicione o caminho aos scripts tensor2tensor usados para processar os dados do modelo:
```
(vm)$ export PATH=.local/bin:${PATH}
```

Treinar um modelo de idioma em um único Cloud TPU

Gere o conjunto de dados de treinamento para o modelo de idioma.
```
(vm)$ t2t-datagen --problem=languagemodel_lm1b32k_packed \
 --data_dir=${DATA_DIR} \
 --tmp_dir=${TMP_DIR}
```
Observação: o download, o pré-processamento e o upload para o Cloud Storage para o conjunto de dados leva aproximadamente duas horas.

Execute o comando a seguir para criar o recurso do Cloud TPU.

(vm)$ ctpu up --tpu-only \
 --tf-version=1.15.3 \
 --name=transformer-tutorial

Defina uma variável de ambiente para o nome da TPU.
```
(vm)$ export TPU_NAME=transformer-tutorial
```
Execute o script de treinamento.
```
(vm)$ t2t-trainer \
 --model=transformer \
 --hparams_set=transformer_tpu \
 --problem=languagemodel_lm1b32k_packed \
 --eval_steps=3 \
 --data_dir=${DATA_DIR} \
 --output_dir=${MODEL_DIR}/language_lm1b32k \
 --use_tpu=True \
 --cloud_tpu_name=${TPU_NAME} \
 --train_steps=10
```
O comando acima executa 10 etapas de treinamento e três de avaliação. A execução leva aproximadamente 5 minutos em um nó de TPU v3-8. Para deixar esse modelo mais preciso, é necessário aumentar o número de passos de treinamento ajustando a sinalização --train_steps. É recomendado treinar o modelo usando pelo menos 40 mil etapas. O modelo costuma atingir qualidade máxima após aproximadamente 250 mil etapas.

Exclua o recurso do Cloud TPU que você criou.

(vm)$ ctpu delete --tpu-only --zone=europe-west4-a --name=transformer-tutorial

Treinar um modelo de linguagem em um pod do Cloud TPU

Execute o comando ctpu up, usando o parâmetro tpu-size para especificar a fração de pod a ser usada. Por exemplo, o comando a seguir usa uma fração de pod v2-32.
```
(vm)$ ctpu up --tpu-only \
 --tpu-size=v2-32 \
 --zone=europe-west4-a \
 --tf-version=1.15.3 \
 --name=transformer-tutorial-pod
```
Defina uma variável de ambiente para o nome da nova TPU.
```
(vm)$ export TPU_NAME=transformer-tutorial-pod
```
Execute o script de treinamento.
```
(vm)$ t2t-trainer \
 --model=transformer \
 --hparams_set=transformer_tpu \
 --problem=languagemodel_lm1b32k_packed \
 --eval_steps=3 \
 --data_dir=${DATA_DIR} \
 --output_dir=${MODEL_DIR}/language_lm1b32k_pod \
 --use_tpu=True \
 --cloud_tpu_name=${TPU_NAME} \
 --tpu_num_shards=32  \
 --schedule=train \
 --train_steps=25000
```
O comando acima executa 25 mil etapas de treinamento e três de avaliação. Esse treinamento leva aproximadamente 30 minutos para ser concluído em um Cloud TPU v2-32.

É recomendado treinar o modelo usando pelo menos 40 mil etapas. O modelo costuma atingir qualidade máxima após aproximadamente 250 mil etapas.

Exclua o recurso da Cloud TPU criado para treinar o modelo em um único dispositivo.

(vm)$ ctpu delete --tpu-only \
 --zone=europe-west4-a \
 --name=transformer-tutorial-pod

Treinar um modelo de tradução inglês-alemão em uma única TPU

Use o script t2t-datagen para gerar os dados de treinamento e avaliação do modelo de tradução no bucket do Cloud Storage:
```
(vm)$ t2t-datagen \
 --problem=translate_ende_wmt32k_packed \
 --data_dir=${DATA_DIR} \
 --tmp_dir=${TMP_DIR}
```
Observação: o download, o pré-processamento e o upload para o Cloud Storage para o conjunto de dados leva aproximadamente duas horas.

Execute o comando a seguir para criar o recurso do Cloud TPU.

(vm)$ ctpu up --tpu-only \
 --tf-version=1.15.3 \
 --name=transformer-tutorial

Defina uma variável de ambiente para o nome da nova TPU.
```
(vm)$ export TPU_NAME=transformer-tutorial
```
Execute t2t-trainer para treinar e avaliar o modelo:
```
(vm)$ t2t-trainer \
 --model=transformer \
 --hparams_set=transformer_tpu \
 --problem=translate_ende_wmt32k_packed \
 --eval_steps=3 \
 --data_dir=${DATA_DIR} \
 --output_dir=${MODEL_DIR}/translate_ende \
 --use_tpu=True \
 --cloud_tpu_name=${TPU_NAME} \
 --train_steps=10
```
O comando acima executa 10 etapas de treinamento e três de avaliação. A execução leva aproximadamente 5 minutos em um nó de TPU v3-8. É possível (e recomendável) aumentar o número de etapas de treinamento ajustando a sinalização --train_steps. As traduções geralmente se tornam razoáveis após cerca de 40 mil etapas. O modelo costuma atingir qualidade máxima após aproximadamente 250 mil etapas.
Exclua o recurso da Cloud TPU criado para treinar o modelo em um único dispositivo.
```
(vm)$ ctpu delete --tpu-only --zone=europe-west4-a --name=transformer-tutorial
```

Treinar um modelo de classificador de sentimento em um único Cloud TPU

Gere o conjunto de dados para o modelo de classificador de sentimento.
```
(vm)$ t2t-datagen --problem=sentiment_imdb \
 --data_dir=${DATA_DIR} \
 --tmp_dir=${TMP_DIR}
```
Observação: o download, o pré-processamento e o upload para o Cloud Storage para o conjunto de dados leva aproximadamente duas horas.

Execute o comando a seguir para criar o recurso do Cloud TPU.

(vm)$ ctpu up --tpu-only \
 --tf-version=1.15.3 \
 --name=transformer-tutorial

Execute o script de treinamento.

(vm)$ t2t-trainer \
 --model=transformer_encoder \
 --hparams_set=transformer_tiny_tpu \
 --problem=sentiment_imdb \
 --eval_steps=1 \
 --data_dir=${DATA_DIR} \
 --output_dir=${MODEL_DIR}/sentiment_classifier \
 --use_tpu=True \
 --cloud_tpu_name=${TPU_NAME} \
 --train_steps=10

O comando acima executa 10 etapas de treinamento e três de avaliação. A execução leva aproximadamente 5 minutos em um nó de TPU v3-8. Esse modelo atinge aproximadamente 85% de precisão após cerca de 2.000 etapas.

Limpar

Para evitar cobranças dos recursos usados neste tutorial na conta do Google Cloud Platform:

Desconecte-se da instância do Compute Engine, caso ainda não tenha feito isso:
```
(vm)$ exit
```
Agora, o prompt precisa ser username@projectname, mostrando que você está no Cloud Shell.
No Cloud Shell, execute ctpu delete com a sinalização --zone usada ao configurar a Cloud TPU para excluir a VM do Compute Engine e a Cloud TPU:
```
$ ctpu delete --zone=europe-west4-a \
--name=transformer-tutorial
```
Importante: se você definir o nome dos recursos de TPU ao executar ctpu up, especifique esse nome com a sinalização --name ao executar ctpu delete para encerrar seus recursos de TPU.
Execute o seguinte comando para verificar se a VM do Compute Engine e a Cloud TPU foram encerradas:
```
$ ctpu status --zone=europe-west4-a
```
A exclusão pode levar vários minutos. Uma resposta como esta indica que não há mais instâncias alocadas:
```
2018/04/28 16:16:23 WARNING: Setting zone to "europe-west4-a"
No instances currently exist.
 Compute Engine VM:     --
 Cloud TPU:             --
```
Atenção: todos os dados de treinamento serão perdidos ao excluir o bucket. Por isso, siga essa etapa apenas quando terminar o tutorial.
Execute gsutil conforme mostrado. Substitua bucket-name pelo nome do bucket do Cloud Storage criado para este tutorial:
```
$ gsutil rm -r gs://bucket-name
```

A seguir

Neste tutorial, você treinou o modelo Transformer usando um conjunto de dados de amostra. Os resultados deste treinamento (na maioria dos casos) não podem ser usados para inferência. Para usar um modelo para inferência, é possível treinar os dados em um conjunto de dados disponível publicamente ou no seu próprio conjunto de dados. Os modelos treinados nas Cloud TPUs exigem que os conjuntos de dados estejam no formato TFRecord.

Use a amostra da ferramenta de conversão de conjunto de dados para converter um conjunto de dados de classificação de imagem no formato TFRecord. Se você não estiver usando um modelo de classificação de imagem, converta manualmente o conjunto de dados para o TFRecord. 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 os hiperparâmetros. Encontre informações sobre hiperparâmetros comuns a todos os modelos compatíveis com a TPU no GitHub. As informações sobre hiperparâmetros específicos do modelo podem ser encontradas no código-fonte de cada modelo. Para mais informações sobre o ajuste de hiperparâmetros, consulte Visão geral do ajuste de hiperparâmetros, Como usar o serviço de ajuste de hiperparâmetros e Ajustar hiperparâmetros.

Inferência

Depois de treinar o modelo, é possível usá-lo para inferência (também chamada de previsão). O AI Platform é uma solução baseada em nuvem para desenvolver, treinar e implantar modelos de machine learning. Depois que um modelo é implantado, use o serviço do AI Platform Prediction.

Saiba mais sobre ctpu (em inglês), incluindo como instalá-lo em uma máquina local.
Conheça mais modelos Tensor2Tensor para TPU.
Teste mais amostras de TPU.
Conheça as ferramentas de TPU no TensorBoard.