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

Descripción general

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

NCF es un marco de trabajo general para el filtrado colaborativo de recomendaciones en que se usa para modelar las interacciones entre el usuario y el elemento. NCF reemplaza el producto interno con un perceptrón multicapa que puede aprender un una función arbitraria a partir de 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 la base de datos latente entre atributos y el MLP usa un kernel no lineal para aprender la función a partir de los datos. NeuMF es un modelo fusionado de GMF y MLP para crear un mejor modelo interacciones complejas entre usuario y elemento y unifica las fortalezas de la linealidad de los MF y la no linealidad de MLP para modelar las estructuras latentes de los elementos de usuario. NeuMF permite que GMF y MLP aprendan incorporaciones separadas y combina ambos modelos y concatenar la última capa oculta. neumf_model.py define los detalles de la arquitectura.

En las siguientes instrucciones, se supone que estás familiarizado con el entrenamiento de un modelo Cloud TPU Si eres nuevo en Cloud TPU, consulta Comienza para ver 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. Usamos dos Conjuntos de datos: ml-1m (abreviatura de MovieLens 1 millón) y ml-20m (abreviatura de MovieLens 20 millones).

ml-1m

El conjunto de datos ml-1m contiene 1,000,209 calificaciones anónimas de aproximadamente 3,706 películas creado por 6,040 usuarios que se unieron a MovieLens en 2000. Todas las calificaciones se incluyen en el archivo “ratings.dat” sin fila de encabezado y están en 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 de encabezado representa la calificación de un usuario individual de una película y tiene la con el siguiente formato:

userId,movieId,rating,timestamp

Las líneas dentro de este archivo se ordenan primero por userId y, luego, dentro de user, ID de película 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, hora universal coordinada (UTC) del 1 de enero de 1970. Cada el 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. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

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

  4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  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.

    Abrir 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 quieres crear la Cloud TPU

    gcloud config set project ${PROJECT_ID}

    La primera vez que ejecutes este comando en una nueva VM de Cloud Shell, se Se muestra la página Autoriza Cloud Shell. Haz clic en Autorizar, en al final de la página para permitir que gcloud haga 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:

    gcloud storage buckets create gs://bucket-name --project=${PROJECT_ID} --location=europe-west4

    En este bucket de Cloud Storage se almacenan los datos que usas para entrenar tu modelo y los resultados del entrenamiento. El comando gcloud que se usa en este instructivo para configurar la TPU también configura los permisos predeterminados para el servicio de Cloud TPU Cuenta 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 la VM de TPU. Las VMs de TPU son ubicados en zonas específicas, que son subdivisiones dentro de una región.

  6. Crear una VM de Cloud TPU

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

    Descripciones de las marcas de comandos

    zone
    Es la zona en la que deseas crear la Cloud TPU.
    accelerator-type
    El tipo de acelerador especifica la versión y el tamaño de la Cloud TPU que deseas crear. Para 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.

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

  7. Conectarse a la instancia de Compute Engine mediante SSH Cuando estés conectado a la VM, el símbolo del sistema de shell cambia de username@projectname a username@vm-name

    gcloud compute tpus tpu-vm 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 el PYTHONPATH variable de entorno.

    (vm)$ git clone https://github.com/tensorflow/models.git
(vm)$ pip3 install -r models/official/requirements.txt

    (vm)$ export PYTHONPATH="${PWD}/models:${PYTHONPATH}"

  4. Ve al directorio en el que se almacenan los archivos de procesamiento del modelo:

      (vm)$ cd ~/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. Procesamiento previo convierte los datos en formato TFRecord que requiere el modelo. La descarga y el procesamiento previo tarda alrededor de 25 minutos y genera un resultado similar al lo 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)$ export TPU_NAME=local

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, establece 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 los recursos de Cloud TPU.

      $ gcloud compute tpus tpu-vm 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 siguiente indica tus instancias se borraron correctamente.

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

    Listed 0 items.

  4. Ejecuta gcloud CLI como se muestra y reemplaza bucket-name por el nombre del bucket de Cloud Storage que creaste para este instructivo:

    $ gcloud storage rm gs://bucket-name --recursive

¿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 la inferencia. Para usar un modelo para inferencia, puedes entrenar los datos en un modelo conjunto de datos o uno propio. Modelos de TensorFlow entrenados con Cloud TPU generalmente requieren que los conjuntos de datos estén TFRecord.

Puedes usar la herramienta de conversión de conjuntos de datos muestra para convertir una imagen de clasificación de datos en formato TFRecord. Si no usas una imagen de clasificación de datos, tendrás que convertir tu conjunto de datos a Formato TFRecord tú mismo. 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 la hiperparámetros. Puedes encontrar información sobre los hiperparámetros comunes a todos Los modelos compatibles con TPU en GitHub: La información sobre los hiperparámetros específicos del modelo se puede encontrar en la fuente de la aplicación para cada un modelo de responsabilidad compartida. Para obtener más información sobre el ajuste de hiperparámetros, consulta Descripción general de ajuste de hiperparámetros y ajustes hiperparámetros.

Inferencia

Una vez que hayas entrenado tu modelo, puedes usarlo para inferencias (también denominado predicciones). Puedes usar el conversor de inferencia de Cloud TPU de desarrollo de software para preparar y optimizar un Modelo de TensorFlow para inferencias en Cloud TPU v5e. Para ver más información sobre la inferencia en Cloud TPU v5e, consulta Inferencia de Cloud TPU v5e introducción.