Esta página foi traduzida pela API Cloud Translation.

Ajuste do BERT com o Cloud TPU: tarefas de classificação de frases e pares de frases (TF 2.x)

Neste tutorial, mostraremos como treinar as representações de codificador bidirecional do modelo Transformers (BERT) no Cloud TPU.

O BERT é um método de representação de linguagem pré-treinamento. Pré-treinamento refere-se a como o BERT é primeiro treinado com base em uma grande fonte de texto, como a Wikipedia. Os resultados do treinamento podem ser aplicados a outras tarefas de processamento de linguagem natural (PLN), como sistema de perguntas e respostas e análise de sentimento. Com o BERT e o Cloud TPU, é possível treinar vários modelos de PLN em cerca de 30 minutos.

Para mais informações sobre o BERT, consulte os seguintes recursos:

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}
```

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 formato a seguir:

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 usado para criar uma TPU, O gcloud compute tpus tpu-vm create configura as permissões padrão para o Conta de serviço do Cloud TPU que você configurou na etapa anterior. Caso queira permissões mais específicas, consulte as permissões de nível de acesso.

O local do bucket precisa estar na mesma região que sua TPU (VM).
Inicie uma VM da TPU usando gcloud. Para mais informações, consulte a Referência do gcloud.
```
$ gcloud compute tpus tpu-vm create bert-tutorial \
  --zone=us-central1-b \
  --accelerator-type=v3-8 \
  --version=tpu-vm-tf-2.17.0-se
```
Descrições de sinalizações de comando

zone

A zona em que você planeja criar a 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.

Observação: se você tiver mais de um projeto, especifique o ID dele com a sinalização --project.
Conecte-se à instância de VM da TPU usando SSH. Quando você se conectar à VM, o prompt do shell vai mudar de username@projectname para username@vm-name:
```
gcloud compute tpus tpu-vm ssh bert-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
```

Preparar o conjunto de dados

Defina o bucket de armazenamento necessário para armazenar o modelo e o conjunto de dados:
```
(vm)$ export STORAGE_BUCKET=gs://bucket-name
```

Copie o checkpoint e os arquivos de vocabulário pré-treinados para o bucket de armazenamento:

  (vm)$ curl https://storage.googleapis.com/tf_model_garden/nlp/bert/v3/uncased_L-12_H-768_A-12.tar.gz -o uncased_L-12_H-768_A-12.tar.gz
  (vm)$ mkdir -p uncased_L-12_H-768_A-12
  (vm)$ tar -xvf uncased_L-12_H-768_A-12.tar.gz
  (vm)$ gcloud storage cp uncased_L-12_H-768_A-12 ${STORAGE_BUCKET} --recursive

Treine o modelo

Defina diversos valores de parâmetros que são obrigatórios ao treinar e avaliar o modelo:

  (vm)$ export INIT_CHECKPOINT=${STORAGE_BUCKET}/uncased_L-12_H-768_A-12/bert_model.ckpt
  (vm)$ export TFDS_DIR=${STORAGE_BUCKET}/tfds
  (vm)$ export VOCAB_FILE=${STORAGE_BUCKET}/uncased_L-12_H-768_A-12/vocab.txt
  (vm)$ export MODEL_DIR=${STORAGE_BUCKET}/bert-output
  (vm)$ export TASK=mnli

Instale os requisitos do TensorFlow.

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

Defina a variável de ambiente PYTHONPATH.

(vm)$ export PYTHONPATH=/usr/share/tpu/models

Mude para o diretório que armazena o modelo:
```
(vm)$ cd /usr/share/tpu/models
```

Execute o script de treinamento:

(vm)$ python3 official/nlp/train.py \
  --tpu=${TPU_NAME} \
  --experiment=bert/sentence_prediction_text \
  --mode=train_and_eval \
  --model_dir=${MODEL_DIR} \
  --config_file=official/nlp/configs/experiments/glue_mnli_text.yaml \
  --params_override="runtime.distribution_strategy=tpu, task.init_checkpoint=${INIT_CHECKPOINT}, task.train_data.tfds_data_dir=${TFDS_DIR}, task.train_data.vocab_file=${VOCAB_FILE}, task.validation_data.tfds_data_dir=${TFDS_DIR}, task.validation_data.vocab_file=${VOCAB_FILE}, trainer.train_steps=2000"

Descrições de sinalizações de comando

tpu: O nome do Cloud TPU a ser usado para treinamento.
mode: Uma destas opções: train, eval, train_and_eval, ou predict.
model_dir: O caminho do Cloud Storage em que os checkpoints e resumos são armazenados durante treinamento de modelo. Você pode reutilizar uma pasta existente para carregar anteriormente gerados e armazenar pontos de verificação adicionais, desde que checkpoints anteriores foram criados usando um Cloud TPU da mesmo tamanho e versão do TensorFlow.

O script é treinado por 2.000 etapas e, em seguida, executa 307 etapas de avaliação. Em uma TPU v3-8, após aproximadamente 5 minutos, o script de treinamento deve completar e exibir resultados semelhantes a este:

I0719 00:47:52.683979 140297079573568 controller.py:457] train | step:   2000 | steps/sec:   26.3 | output:
{'cls_accuracy': 0.7249375,
 'learning_rate': 1.4670059e-05,
 'training_loss': 0.6740678}
train | step:   2000 | steps/sec:   26.3 | output:
{'cls_accuracy': 0.7249375,
 'learning_rate': 1.4670059e-05,
 'training_loss': 0.6740678}
I0719 00:47:53.184051 140297079573568 controller.py:277]  eval | step:   2000 | running 307 steps of evaluation...
eval | step:   2000 | running 307 steps of evaluation...

Limpar

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.

Exclua os recursos do Cloud TPU e do Compute Engine.

$ gcloud compute tpus tpu-vm delete bert-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 a CLI gcloud, conforme mostrado no exemplo a seguir. Substitua bucket-name pelo nome do bucket do 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.

Conheça as ferramentas de TPU no TensorBoard.