Entrena a un transformador en Cloud TPU (TF 2.x)


Descripción general

Esta es una implementación del framework del filtrado colaborativo neuronal (NCF) mediante el modelo de factorización de matrices neuronales (NeuMF), como se describe en el documento de Filtrado colaborativo neuronal. La implementación actual se basa en el código del código del NCF de los autores y la implementación de Stanford en el repositorio MLPerf.

NCF es un framework general para el filtrado colaborativo de recomendaciones en el que se usa una arquitectura de red neuronal con el fin de modelar interacciones de elementos del usuario. A diferencia de los modelos tradicionales, el NCF no es complejo para la factorización de matrices (MF) con un producto interno sobre funciones de usuarios y elementos latentes. Reemplaza el producto interno por un perceptrón de varias capas que puede aprender una función arbitraria desde los datos.

Dos implementaciones de NCF son factorizaciones de matrices generalizadas (GMF) y el perceptrón de varias capas (MLP). GMF aplica un kernel lineal para modelar las interacciones de funciones latentes y el MLP usa un kernel no lineal a fin de aprender la función de interacción a partir de los datos. NeuMF es un modelo fusionado de GMF y MLP para modelar mejor las interacciones complejas entre elementos de usuarios y unifica las fortalezas de linealidad del MF y no linealidad del MLP a fin de modelar las estructuras latentes de elementos del usuario. NeuMF permite que GMF y MLP aprendan incorporaciones independientes y combina los dos modelos mediante la concatenación de su última capa oculta. neumf_model.py define los detalles de la arquitectura.

En las instrucciones que aparecen a continuación, se supone que ya estás familiarizado con el entrenamiento de un modelo en Cloud TPU. Si eres nuevo en Cloud TPU, consulta la guía de inicio rápido para obtener una introducción básica.

Conjunto de datos

Los conjuntos de datos de MovieLens se usan para el entrenamiento y la evaluación de modelos. Específicamente, usamos dos conjuntos de datos: ml-1m (abreviatura de MovieLens 1 million) y ml-20m (abreviatura de MovieLens 20 million).

ml-1m

El conjunto de datos ml-1m contiene 1,000,209 calificaciones anónimas de aproximadamente 3,706 películas realizadas por 6,040 usuarios que se unieron a MovieLens en 2,000. Todas las calificaciones se encuentran en el archivo “ratings.dat” sin una fila de encabezado y tienen el siguiente formato:

UserID::MovieID::Rating::Timestamp

  • El rango de UserIDs varía entre 1 y 6,040.
  • El rango del MovieID varía entre 1 y 3,952.
  • Las calificaciones se establecen a una escala de 5 estrellas (solo calificaciones completas).

ml-20m

El conjunto de datos de ml-20m contiene 20,000,263 calificaciones de 26,744 películas por parte de 138,493 usuarios. Todas las calificaciones se incluyen en el archivo “ratings.csv”. Cada línea de este archivo después de la fila del encabezado representa la calificación de una película con un solo usuario y tiene el siguiente formato:

userId,movieId,rating,timestamp

Las líneas dentro de este archivo se ordenan primero por userId y, luego, en dentro del usuario, por movieId. Las calificaciones se realizan en una escala de 5 estrellas con incrementos de media estrella (de 0.5 estrellas a 5.0 estrellas). En ambos conjuntos de datos, la marca de tiempo se representa en segundos desde la medianoche del Horario Universal Coordinado (UTC) del 1 de enero de 1970. Cada usuario tiene, al menos, 20 calificaciones.

Objetivos

  • Crear un bucket de Cloud Storage para almacenar el resultado de tu modelo y tu conjunto de datos
  • Preparar el conjunto de datos de MovieLens
  • Configurar una VM de Compute Engine y un nodo de Cloud TPU para entrenamiento y evaluación
  • Ejecutar el entrenamiento y la evaluación

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

  • Compute Engine
  • Cloud TPU
  • Cloud Storage

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Antes de comenzar

Antes de comenzar este instructivo, verifica que tu proyecto de Google Cloud esté configurado correctamente.

  1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.
  2. En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyectos

  3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

  4. En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyectos

  5. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

  6. En esta explicación, se usan componentes facturables de Google Cloud. Consulta la página de precios de Cloud TPU para calcular los costos. Asegúrate de limpiar los recursos que crees cuando hayas terminado de usarlos para evitar cargos innecesarios.

Configura tus recursos

En esta sección, se proporciona información sobre cómo configurar los recursos de Cloud Storage, VM y Cloud TPU para este instructivo.

  1. Abre una ventana de Cloud Shell.

    Abra Cloud Shell

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

    export PROJECT_ID=project-id
  3. Configura Google Cloud CLI para usar el proyecto en el que deseas crear la Cloud TPU.

    gcloud config set project ${PROJECT_ID}
    

    La primera vez que ejecutes este comando en una VM de Cloud Shell nueva, se mostrará la página Authorize Cloud Shell. Haz clic en Authorize en la parte inferior de la página para permitir que gcloud realice llamadas a la API 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 con el siguiente comando:

    gsutil mb -p ${PROJECT_ID} -c standard -l europe-west4 gs://bucket-name
    

    Este bucket de Cloud Storage almacena los datos que usas para entrenar tu modelo y los resultados del entrenamiento. Con el comando de gcloud que se usa en este instructivo a fin de configurar la TPU, también se configuran los permisos predeterminados para la cuenta de servicio de Cloud TPU que configuraste en el paso anterior. Si quieres contar con permisos más detallados, revisa los permisos de nivel de acceso.

    La ubicación del bucket debe estar en la misma región que tu máquina virtual (VM) y tu nodo TPU. Las VM y los nodos TPU se encuentran en zonas específicas, que son subdivisiones dentro de una región.

  6. Inicia una VM de Compute Engine y Cloud TPU con el comando gcloud. El comando que uses depende de si usas VM de TPU o nodos TPU. Para obtener más información sobre la arquitectura de las dos VM, consulta Arquitectura del sistema.

    VM de TPU

    $ gcloud compute tpus tpu-vm create ncf-tutorial \
    --zone=europe-west4-a \
    --accelerator-type=v3-8 \
    --version=tpu-vm-tf-2.16.1-pjrt
    

    Descripciones de las marcas de comandos

    zone
    La zona en la que planeas crear tu Cloud TPU.
    accelerator-type
    El tipo de acelerador especifica la versión y el tamaño de la Cloud TPU que quieres crear. Si quieres obtener más información sobre los tipos de aceleradores compatibles con cada versión de TPU, consulta Versiones de TPU.
    version
    La versión de software de Cloud TPU.

    Nodo TPU

    $ gcloud compute tpus execution-groups create  \
     --zone=europe-west4-a \
     --name=ncf-tutorial \
     --accelerator-type=v3-8 \
     --machine-type=n1-standard-8 \
     --disk-size=300 \
     --tf-version=2.12.0
    

    Descripciones de las marcas de comandos

    zone
    La zona en la que planeas crear tu Cloud TPU.
    name
    El nombre de la TPU. Si no se especifica, el valor predeterminado es tu nombre de usuario.
    accelerator-type
    El tipo de Cloud TPU que se creará.
    machine-type
    El tipo de máquina de la VM de Compute Engine que se creará.
    disk-size
    El tamaño del volumen raíz de la VM de Compute Engine (en GB).
    tf-version
    La versión gcloud de TensorFlow se instala en la VM.

    Para obtener más información sobre el comando de gcloud, consulta la Referencia de gcloud.

  7. Si no accediste de forma automática a la instancia de Compute Engine, ejecuta el siguiente comando de ssh para acceder. Cuando accedas a la VM, el indicador de shell cambiará de username@projectname a username@vm-name:

    VM de TPU

    gcloud compute tpus tpu-vm ssh ncf-tutorial --zone=europe-west4-a
    

    Nodo TPU

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

Prepara los datos

  1. Agrega una variable de entorno para tu bucket de almacenamiento. Reemplaza bucket-name por el nombre de tu bucket:

    (vm)$ export STORAGE_BUCKET=gs://bucket-name
    
  2. Crea una variable de entorno para el directorio de datos.

    (vm)$ export DATA_DIR=${STORAGE_BUCKET}/ncf_data
    
  3. Configura la ubicación del modelo y la variable de entorno PYTHONPATH.

    VM de TPU

    (vm)$ git clone https://github.com/tensorflow/models.git
    (vm)$ pip3 install -r models/official/requirements.txt
    
    (vm)$ export PYTHONPATH="${PWD}/models:${PYTHONPATH}"
    

    Nodo TPU

    (vm)$ export PYTHONPATH="${PYTHONPATH}:/usr/share/models"
    (vm)$ pip3 install -r /usr/share/models/official/requirements.txt
    
  4. Ve al directorio en el que se almacenan los archivos de procesamiento del modelo:

    VM de TPU

    (vm)$ cd ~/models/official/recommendation
    

    Nodo TPU

    (vm)$ cd /usr/share/models/official/recommendation
    
  5. Genera datos de entrenamiento y evaluación para el conjunto de datos ml-20m en DATA_DIR:

    (vm)$ python3 create_ncf_data.py \
        --dataset ml-20m \
        --num_train_epochs 4 \
        --meta_data_file_path ${DATA_DIR}/metadata \
        --eval_prebatch_size 160000 \
        --data_dir ${DATA_DIR}
    

Esta secuencia de comandos genera y procesa previamente el conjunto de datos en tu VM. El procesamiento previo convierte los datos en el formato TFRecord que requiere el modelo. La descarga y el procesamiento previo tardan aproximadamente 25 minutos y generan un resultado similar al siguiente:

I0804 23:03:02.370002 139664166737728 movielens.py:124] Successfully downloaded /tmp/tmpicajrlfc/ml-20m.zip 198702078 bytes
I0804 23:04:42.665195 139664166737728 data_preprocessing.py:223] Beginning data preprocessing.
I0804 23:04:59.084554 139664166737728 data_preprocessing.py:84] Generating user_map and item_map...
I0804 23:05:20.934210 139664166737728 data_preprocessing.py:103] Sorting by user, timestamp...
I0804 23:06:39.859857 139664166737728 data_preprocessing.py:194] Writing raw data cache.
I0804 23:06:42.375952 139664166737728 data_preprocessing.py:262] Data preprocessing complete. Time: 119.7 sec.
%lt;BisectionDataConstructor(Thread-1, initial daemon)>
General:
  Num users: 138493
  Num items: 26744

Training:
  Positive count:          19861770
  Batch size:              99000
  Batch count per epoch:   1004

Eval:
  Positive count:          138493
  Batch size:              160000
  Batch count per epoch:   866

I0804 23:07:14.137242 139664166737728 data_pipeline.py:887] Negative total vector built. Time: 31.8 seconds
I0804 23:11:25.013135 139664166737728 data_pipeline.py:588] Epoch construction complete. Time: 250.9 seconds
I0804 23:15:46.391308 139664166737728 data_pipeline.py:674] Eval construction complete. Time: 261.4 seconds
I0804 23:19:54.345858 139664166737728 data_pipeline.py:588] Epoch construction complete. Time: 248.0 seconds
I0804 23:24:09.182484 139664166737728 data_pipeline.py:588] Epoch construction complete. Time: 254.8 seconds
I0804 23:28:26.224653 139664166737728 data_pipeline.py:588] Epoch construction complete. Time: 257.0 seconds

Configura la Cloud TPU y comienza a entrenarla

  1. Configura la variable de nombre de Cloud TPU.

    VM de TPU

    (vm)$ export TPU_NAME=local
    

    Nodo TPU

    (vm)$ export TPU_NAME=ncf-tutorial
    

Ejecuta el entrenamiento y la evaluación

La siguiente secuencia de comandos ejecuta un entrenamiento de muestra para 3 ciclos de entrenamiento.

  1. Agrega una variable de entorno para el directorio de modelos a fin de guardar puntos de control y resúmenes de TensorBoard:

    (vm)$ export MODEL_DIR=${STORAGE_BUCKET}/ncf
    
  2. Cuando creas tu TPU, si estableces el parámetro --version en una versión que termina en -pjrt, configura las siguientes variables de entorno para habilitar el entorno de ejecución de PJRT:

      (vm)$ export NEXT_PLUGGABLE_DEVICE_USE_C_API=true
      (vm)$ export TF_PLUGGABLE_DEVICE_LIBRARY_PATH=/lib/libtpu.so
    
  3. Ejecuta el siguiente comando para entrenar el modelo de NCF:

    (vm)$ python3 ncf_keras_main.py \
         --model_dir=${MODEL_DIR} \
         --data_dir=${DATA_DIR} \
         --train_dataset_path=${DATA_DIR}/training_cycle_*/* \
         --eval_dataset_path=${DATA_DIR}/eval_data/* \
         --input_meta_data_path=${DATA_DIR}/metadata \
         --learning_rate=3e-5 \
         --train_epochs=3 \
         --dataset=ml-20m \
         --eval_batch_size=160000 \
         --learning_rate=0.00382059 \
         --beta1=0.783529 \
         --beta2=0.909003 \
         --epsilon=1.45439e-07 \
         --dataset=ml-20m \
         --num_factors=64 \
         --hr_threshold=0.635 \
         --keras_use_ctl=true \
         --layers=256,256,128,64 \
         --use_synthetic_data=false \
         --distribution_strategy=tpu \
         --download_if_missing=false
     

El entrenamiento y la evaluación toman aproximadamente 2 minutos y generan un resultado final similar al siguiente:

Result is {'loss': <tf.Tensor: shape=(), dtype=float32, numpy=0.10950611>,
'train_finish_time': 1618016422.1377568, 'avg_exp_per_second': 3062557.5070816963}

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

  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. Borra tus recursos de Cloud TPU y Compute Engine. El comando que uses para borrar tus recursos depende de si usas VM o nodos TPU. Para obtener más información, consulta Arquitectura del sistema.

    VM de TPU

    $ gcloud compute tpus tpu-vm delete ncf-tutorial \
    --zone=europe-west4-a
    

    Nodo TPU

    $ gcloud compute tpus execution-groups delete ncf-tutorial \
    --zone=europe-west4-a
    
  3. Ejecuta gcloud compute tpus execution-groups list para verificar que los recursos se hayan borrado. La eliminación puede tardar varios minutos. Una respuesta como la que se muestra a continuación indica que tus instancias se borraron de forma correcta.

    VM de TPU

    $ gcloud compute tpus tpu-vm list \
    --zone=europe-west4-a
    

    Nodo TPU

    $ gcloud compute tpus execution-groups list --zone=europe-west4-a
    
    Listed 0 items.
    
  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?

Los instructivos de TensorFlow Cloud TPU suelen entrenar el modelo con un conjunto de datos de muestra. Los resultados de este entrenamiento no se pueden usar para inferencias. Si quieres usar un modelo para la inferencia, puedes entrenar los datos en tu propio conjunto de datos o en un conjunto de datos disponible públicamente. Por lo general, los modelos de TensorFlow entrenados con Cloud TPU requieren que los conjuntos de datos estén en 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 al formato TFRecord. Si no usas un modelo de clasificación de imágenes, deberás convertir tu conjunto de datos al 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 sus hiperparámetros. Puedes encontrar información sobre los hiperparámetros comunes de 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 de cada modelo. Para obtener más información sobre el ajuste de hiperparámetros, consulta Descripción general del ajuste de hiperparámetros y Ajusta hiperparámetros.

Inferencia

Una vez que hayas entrenado tu modelo, puedes usarlo para la inferencia (también llamada predicción). Puedes usar la herramienta de conversión de inferencias de Cloud TPU para preparar y optimizar un modelo de TensorFlow para la inferencia en Cloud TPU v5e. Para obtener más información sobre la inferencia en Cloud TPU v5e, consulta Introducción a la inferencia con Cloud TPU v5e.