XLNet: Entrenamiento previo generalizado para la comprensión del lenguaje (TF 2.x)

En este instructivo se muestra cómo entrenar el modelo Representaciones de codificador bidireccional de transformadores (BERT) en Cloud TPU.

XLNet es un modelo de lenguaje de entrenamiento previo autogresivo generalizado similar a BERT que permite aprender contextos bidireccionales mediante la maximización de la probabilidad esperada de todas las permutaciones del orden de factorización. Puede aprender la dependencia más allá de una longitud fija sin interrumpir la coherencia temporal mediante un mecanismo de recurrencia a nivel de segmento y un esquema de codificación posicional relativo presentado en Transformer-XL. XLNet realiza BERT en 20 tareas comparativas de PLN y logra resultados de vanguardia en 18 tareas, incluidas la respuesta a preguntas, la inferencia de lenguaje natural, el análisis de opiniones y la clasificación de documentos.

Para obtener más información, consulta el documento periódico que describe XLNet en detalle y proporciona resultados completos en varias tareas.

Objetivos

  • Crear un bucket de Cloud Storage para almacenar el resultado de tu modelo y tu conjunto de datos
  • Procesar los conjuntos de datos
  • Ajusta con XLNet.
  • Verificar los resultados de salida

Costos

En este instructivo, se usan componentes facturables de Google Cloud, que incluyen los siguientes:

  • Compute Engine
  • Cloud TPU
  • Cloud Storage

Usa la calculadora de precios para generar una estimación de los costos según el uso previsto. Los usuarios nuevos de Google Cloud pueden ser elegibles para obtener una prueba gratuita.

Antes de comenzar

En esta sección, se proporciona información sobre cómo configurar el bucket de Cloud Storage y una VM de Compute Engine.

  1. Abre una ventana de Cloud Shell.

    Abrir Cloud Shell

  2. Crea una variable para el ID de tu proyecto.

    export PROJECT_ID=project-id
    
  3. Configura la herramienta de línea de comandos gcloud para usar el proyecto en el que deseas crear Cloud TPU.

    gcloud config set project ${PROJECT_ID}
    

    La primera vez que ejecutes este comando en una VM nueva de Cloud Shell, se mostrará una página Autorizar Cloud Shell. Haz clic en Autorizar en la parte inferior de la página para permitir que gcloud realice llamadas a la API de Google Cloud Platform (GCP) con tus credenciales.

  4. Crea una cuenta de servicio para el proyecto de Cloud TPU.

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

    El comando muestra una cuenta de servicio de Cloud TPU con el siguiente formato:

    service-PROJECT_NUMBER@cloud-tpu.iam.gserviceaccount.com
    
  5. Crea un bucket de Cloud Storage

    Este bucket de Cloud Storage almacena los datos que usas para entrenar tu modelo y los resultados del entrenamiento. La ubicación del bucket debe estar en la misma región que tu Compute Engine (VM) y tu nodo de Cloud TPU.

    gsutil mb -p ${PROJECT_ID} -c standard -l europe-west4 -b on gs://bucket-name
    
  6. Antes de usar el bucket de almacenamiento, debes autorizar el acceso de la cuenta de servicio de Cloud TPU al bucket de Cloud Storage. Establece una LCA detallada para la cuenta de servicio de Cloud TPU.

  7. Inicia una VM de Compute Engine y Cloud TPU.

    $ gcloud compute tpus execution-groups create \
      --name=xlnet-tutorial \
      --machine-type=n1-standard-8 \
      --zone=europe-west4-a \
      --tf-version=2.6.0 \
      --disk-size=500GB \
      --accelerator-type=v3-8
    

    Descripciones de las marcas de comandos

    name
    El nombre de la Cloud TPU para crear.
    machine-type
    El tipo de máquina de la VM de Compute Engine que se creará.
    zone
    Es la zona en la que deseas crear la Cloud TPU.
    tf-version
    La versión de TensorFlow que se usará en la VM.
    accelerator-type
    El tipo de Cloud TPU que se creará.
  8. Cuando el comando gcloud create termine de ejecutarse, verifica que el indicador de shell haya cambiado de username@projectname a username@vm-name. Este cambio indica que accediste a tu VM de Compute Engine.

    gcloud compute ssh xlnet-tutorial --zone=europe-west4-a
    

    Mientras sigues estas instrucciones, ejecuta cada comando que empiece con (vm)$ en la ventana de sesión de tu VM.

  9. Exporta el directorio de Python y el nombre del bucket de Cloud Storage.

    (vm)$ export PYTHONPATH="${PYTHONPATH}:/usr/share/models"
    
    (vm)$ export STORAGE_BUCKET=gs://bucket-name
    

Procesa conjuntos de datos

El procesamiento de conjuntos de datos requiere un modelo de fragmento de oración. Puedes encontrar uno en el bucket de Cloud Storage disponible de forma pública en: gs://cloud-tpu-checkpoints/xlnet/cased_spiece.model.

  1. Desde la máquina virtual (VM) de Compute Engine, configura las siguientes variables:

    (vm)$ export SPIECE_DIR=~/cased_spiece
    (vm)$ export SPIECE_MODEL=${SPIECE_DIR}/cased_spiece.model
    (vm)$ export DATASETS_DIR=${STORAGE_BUCKET}/datasets
    
    (vm)$ mkdir -p ${SPIECE_DIR}
    
    (vm)$ gsutil cp gs://cloud-tpu-checkpoints/xlnet/cased_spiece.model ${SPIECE_DIR}
    

Prepara un conjunto de datos de clasificación

Para preparar los datos TFRecord de clasificación en el conjunto de datos IMDB, descarga y descomprime el conjunto de datos IMDB con el siguiente comando:

(vm)$ export IMDB_DIR=~/imdb
(vm)$ mkdir -p ${IMDB_DIR}
(vm)$ cd ${IMDB_DIR}
(vm)$ wget http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz
(vm)$ tar zxvf aclImdb_v1.tar.gz -C ${IMDB_DIR}
(vm)$ rm aclImdb_v1.tar.gz

Luego, el conjunto de datos puede convertirse en TFRecords con el siguiente comando:

(vm)$ export TASK_NAME=imdb
(vm)$ python3 /usr/share/models/official/nlp/xlnet/preprocess_classification_data.py \
    --max_seq_length=512 \
    --spiece_model_file=${SPIECE_MODEL} \
    --output_dir=${DATASETS_DIR}/${TASK_NAME} \
    --data_dir=${IMDB_DIR}/aclImdb \
    --task_name=${TASK_NAME}

Ajusta con XLNet

Los archivos de modelo previamente entrenados descomprimidos se pueden encontrar en la carpeta de Cloud Storage gs://cloud-tpu-checkpoints/xlnet/keras_xlnet.

  1. Exporta variables para el modelo previamente entrenado y el bucket de salida de Cloud Storage.

    (vm)$ export XLNET_DIR=gs://cloud-tpu-checkpoints/xlnet/keras_xlnet
    (vm)$ export MODEL_DIR=${STORAGE_BUCKET}/xlnet-output
    

Entrena el modelo

Este código de ejemplo ajusta XLNet en el conjunto de datos IMDB. Para esta tarea, obtener los primeros 500 pasos y completar la 1 hora en una v3-8 lleva alrededor de 11 minutos. Debería ver una precisión entre 96.15 y 96.33.

(vm)$ export TPU_NAME=xlnet-tutorial
(vm)$ python3 /usr/share/models/official/nlp/xlnet/run_classifier.py \
  --strategy_type=tpu \
  --tpu=${TPU_NAME} \
  --init_checkpoint=${XLNET_DIR}/xlnet_model.ckpt \
  --model_dir=${MODEL_DIR} \
  --test_data_size=25024 \
  --train_tfrecord_path=${DATASETS_DIR}/imdb/cased_spiece.model.len-512.train.tf_record \
  --test_tfrecord_path=${DATASETS_DIR}/imdb/cased_spiece.model.len-512.dev.eval.tf_record \
  --train_batch_size=32 \
  --seq_len=512 \
  --n_layer=24 \
  --d_model=1024 \
  --d_embed=1024 \
  --n_head=16 \
  --d_head=64 \
  --d_inner=4096 \
  --untie_r=true \
  --n_class=2 \
  --ff_activation=gelu \
  --learning_rate=2e-5 \
  --train_steps=4000 \
  --warmup_steps=500 \
  --iterations=500 \
  --bi_data=false \
  --summary_type=last

Descripciones de las marcas de comandos

mode
Cuando se establece en train_and_eval, esta secuencia de comandos entrena y evalúa el modelo. Cuando se establece en “export_only”, esta secuencia de comandos exporta un modelo guardado.
input_meta_data_path
La ruta a un archivo que contiene metadatos sobre el conjunto de datos que se usará para el entrenamiento y la evaluación.
train_data_path
La ruta de Cloud Storage para la entrada de entrenamiento. En este ejemplo, se establece como el conjunto de datos fake_imagenet.
eval_data_path
La ruta de Cloud Storage para la entrada de evaluación. En este ejemplo, se establece como el conjunto de datos fake_imagenet.
init_checkpoint
La ruta al archivo json que contiene el punto de control inicial del modelo BERT entrenado previamente.
train_batch_size
El tamaño del lote de entrenamiento.
eval_batch_size
El tamaño del lote de evaluación.
learning_rate
La tasa de aprendizaje.
num_train_epochs
La cantidad de veces que se entrena el modelo con el conjunto de datos completo.
model_dir
especifica el directorio en el que se almacenan los puntos de control y los resúmenes durante el entrenamiento de modelos. Si la carpeta no existe, el programa crea una. Cuando se usa una Cloud TPU, el model_dir debe ser una ruta de Cloud Storage (`gs://...`). Puedes reutilizar una carpeta existente para cargar datos de puntos de control actuales y almacenar puntos de control adicionales, siempre que los puntos de control anteriores se hayan creado con una TPU del mismo tamaño y con la misma versión de TensorFlow.
distribution_strategy
Para entrenar el modelo ResNet en una TPU, debes configurar distribution_strategy como tpu.
tpu
El nombre de Cloud TPU. Para ello, especifica la variable de entorno (TPU_NAME).

Verifica tus resultados

El entrenamiento lleva aproximadamente una hora en una TPU v3-8. Cuando se complete la secuencia de comandos, deberías ver resultados similares a los siguientes:

Training Summary:
{'total_training_steps': 4000, 'train_loss': 0.00868087075650692,
'last_train_metrics': 0.9983749985694885, 'eval_metrics': 0.96148}

Limpia

  1. Desconéctate de la instancia de Compute Engine, si aún no lo hiciste:

    (vm)$ exit
    

    El mensaje ahora debería mostrar username@projectname, que indica que estás en Cloud Shell.

  2. En Cloud Shell, ejecuta el siguiente comando de gcloud para borrar la VM y la Cloud TPU.

    $ gcloud compute tpus execution-groups delete xlnet-tutorial \
      --zone=europe-west4-a
    
  3. Ejecuta gcloud compute tpus list para asegurarte de no tener instancias de Cloud TPU asignadas a fin de evitar cargos innecesarios por el uso de TPU. La eliminación puede tardar varios minutos.

    $ gcloud compute tpus list --zone=europe-west4-a
    

    La Cloud TPU que usaste no debería aparecer en la lista de salida después del comando:

    NAME            ZONE            ACCELERATOR_TYPE  NETWORK_ENDPOINTS   NETWORK  RANGE            STATUS  API_VERSION
    xyz-tutorial    europe-west4-a  v3-8              10.119.91.74:8470   default  10.119.91.72/29  READY   V1_ALPHA1
    
  4. Ejecuta gsutil como se muestra y reemplaza bucket-name por el nombre del depósito de Cloud Storage que creaste para este instructivo:

    $ gsutil rm -r gs://bucket-name
    

¿Qué sigue?

En este instructivo, entrenaste el modelo XLNet mediante un conjunto de datos de muestra. Los resultados de esta capacitación (en la mayoría de los casos) no se pueden usar para la inferencia. Para usar un modelo de inferencia, puedes entrenar los datos en un conjunto de datos disponible públicamente o en tu propio conjunto de datos. Los modelos entrenados en Cloud TPU requieren que los conjuntos de datos tengan el formato TFRecord.

Puedes usar la muestra de la herramienta de conversión de conjuntos de datos para convertir un conjunto de datos de clasificación de imágenes en formato TFRecord. Si no usas un modelo de clasificación de imágenes, deberás convertir tú mismo el conjunto de datos en formato TFRecord. Para obtener más información, consulta TFRecord y tf.Example.

Ajuste de hiperparámetros

Para mejorar el rendimiento del modelo con tu conjunto de datos, puedes ajustar los hiperparámetros del modelo. Puedes encontrar información sobre hiperparámetros comunes para todos los modelos compatibles con TPU en GitHub. La información sobre los hiperparámetros específicos del modelo se puede encontrar en el código fuente para cada modelo. Para obtener más información sobre el ajuste de hiperparámetros, consulta Descripción general del ajuste de hiperparámetros, Usa el servicio de ajuste de hiperparámetros y Ajusta los hiperparámetros.

Inferencia

Una vez que entrenaste tu modelo, puedes usarlo para la inferencia (también llamada predicción). AI Platform es una solución basada en la nube que sirve para desarrollar, entrenar e implementar modelos de aprendizaje automático. Una vez que se implementa un modelo, puedes usar el servicio de AI Platform Prediction.