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:

• Open Sourcing BERT: State-of-the-Art Pre-training for Natural Language Processing (em inglês)
• BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding (em inglês)

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.

Importante:configure a VM da TPU e o Cloud Storage na mesma região e zona para reduzir a latência e os custos da rede.

1. Abra uma janela do Cloud Shell.

   Abrir o Cloud Shell

2. Crie uma variável para o ID do seu projeto.

   export PROJECT_ID=project-id

3. Configurar a CLI do Google Cloud para usar o projeto em que você quer criar Cloud TPU:

   gcloud config set project ${PROJECT_ID}

4. 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:

   [e-mail]
   

5. 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).

6. Inicie uma VM de 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.

7. Conecte-se à instância de VM da TPU usando SSH. Quando você está conectado à VM, o prompt do shell muda de username@projectname para username@vm-name:

   gcloud compute tpus tpu-vm ssh bert-tutorial --zone=us-central1-b

   Importante: a partir desse ponto, o prefixo (vm) $ significa que é necessário executar o comando na instância de VM do Compute Engine.

8. Crie uma variável de ambiente para o nome da TPU.

   (vm)$ export TPU_NAME=local

Preparar o conjunto de dados

Observação: a VM do Compute Engine tem o código de modelo pré-transferido do GitHub.

1. Defina o bucket de armazenamento necessário para armazenar o modelo e o conjunto de dados:

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

2. Copie os arquivos de vocabulário e de verificação 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

1. Defina vários valores de parâmetros necessá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
     

2. Instale os requisitos do TensorFlow.

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

3. Defina a variável de ambiente PYTHONPATH.

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

4. Mude para o diretório que armazena o modelo:

   (vm)$ cd /usr/share/tpu/models

5. 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

   Um dos campos 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 complete e exiba 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

1. 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.

2. Exclua os recursos do Cloud TPU e do Compute Engine.

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

3. 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

4. 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 deste treinamento 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 do TensorFlow treinados em Cloud TPUs geralmente 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 formato 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 a e 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 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 seu modelo, você pode usá-lo para inferência (também chamado de previsão). Você pode usar a ferramenta de conversão de inferência da Cloud TPU para preparar e otimizar um modelo do TensorFlow para inferência na 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.