Entrena el NCF en Cloud TPU (TF 2.x)

Descripción general

Esta es una implementación del framework del filtrado colaborativo neuronal (NCF) con 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 siguientes instrucciones, se supone que ya estás familiarizado con el entrenamiento de un modelo en Cloud TPU. Si eres nuevo en Cloud TPU, puedes consultar 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. En particular, usamos dos conjuntos de datos: ml-1m (abreviatura de MovieLens 1 millón) y ml-20 min (corto para MovieLens 20 millones).

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 ml-20-20 contiene 20.000,263 calificaciones de 26,744 películas por 138493 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 una calificación de una película por usuario y tiene el siguiente formato:

userId,movieId,rating,timestamp

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

Objetivos

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

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

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

  1. Accede a tu Cuenta de Google.

    Si todavía no tienes una cuenta, regístrate para obtener una nueva.

  2. En la página de selección de proyectos de Cloud Console, selecciona o crea un proyecto de Cloud.

    Ir a la página Selector de proyectos

  3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud. Obtén información sobre cómo confirmar que tienes habilitada la facturación para tu proyecto.

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

    Abre Cloud Shell

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

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

    gcloud config set project ${PROJECT_ID}
    
  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 depósito de Cloud Storage con el siguiente comando:

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

    Este depósito de Cloud Storage almacena los datos que usas para entrenar tu modelo y los resultados del entrenamiento. Con la herramienta ctpu up que se usa en este instructivo, 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 depósito 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 con el comando ctpu up.

    $ ctpu up --zone=europe-west4-a \
     --vm-only \
     --disk-size-gb=300 \
     --machine-type=n1-standard-8 \
     --name=ncf-tutorial \
     --tf-version=2.3.1
    

    Descripciones de las marcas de comandos

    zone
    Es la zona en la que deseas crear la Cloud TPU.
    vm-only
    Crea solo una VM. De forma predeterminada, el comando ctpu up crea una VM y una Cloud TPU.
    disk-size-gb
    El tamaño del disco de la VM en GB.
    machine_type
    El tipo de máquina de la VM que crea el comando ctpu up.
    name
    El nombre de la VM de Compute Engine que se creará.
    tf-version
    La versión de Tensorflow ctpu se instala en la VM.
  7. Aparece la configuración que especificaste. Ingresa y para aprobar o n para cancelar.

  8. Cuando el comando ctpu up 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 ncf-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.

Prepara los datos

  1. Agrega una variable de entorno a tu depósito de almacenamiento. Reemplaza bucket-name por el nombre de tu depósito:

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

    (vm)$ export DATA_DIR=${STORAGE_BUCKET}/ncf_data
    
  3. Agrega una variable de entorno para la ruta de Python.

    (vm)$ export PYTHONPATH="${PYTHONPATH}:/usr/share/models"
    
  4. Genera datos de entrenamiento y evaluación para el conjunto de datos ml-20m en DATA_DIR:

    (vm)$ python3 /usr/share/models/official/recommendation/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 su VM. El preprocesamiento convierte los datos en formato TFRecord requerido por el modelo. La descarga y el procesamiento previo toman 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.

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. Ejecuta el siguiente comando para crear tu Cloud TPU.

    (vm)$ ctpu up --tpu-only \
      --tpu-size=v3-8 \
      --zone=europe-west4-a \
      --name=ncf-tutorial \
      --tf-version=2.3.1

    Descripciones de las marcas de comandos

    tpu-only
    Crea la Cloud TPU sin crear una VM. De forma predeterminada, el comando ctpu up crea una VM y una Cloud TPU.
    tpu-size
    El tipo de Cloud TPU que se creará.
    zone
    Es la zona en la que deseas crear la Cloud TPU.
    name
    El nombre de la Cloud TPU para crear.
    tf-version
    La versión de Tensorflow ctpu se instala en la VM.
  2. Aparece la configuración que especificaste. Ingresa y para aprobar o n para cancelar.

    Verás el siguiente mensaje: Operation success; not ssh-ing to Compute Engine VM due to --tpu-only flag. Como ya completaste la propagación de Llaves SSH, puedes ignorar este mensaje.

  3. Agrega una variable de entorno al nombre de tu Cloud 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. Ejecuta el siguiente comando para entrenar el modelo de NCF:

    (vm)$ python3 /usr/share/models/official/recommendation/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:

I0805 21:23:05.134161 139825684965184 ncf_keras_main.py:493] Done training epoch 3, epoch loss=0.097
I0805 21:23:06.722786 139825684965184 ncf_keras_main.py:506] Done eval epoch 3, hit_rate=0.585
I0805 21:23:16.005549 139825684965184 ncf_keras_main.py:523] Saving model as TF checkpoint: gs://gm-bucket-eu/ncf/ctl_checkpoint
I0805 21:23:16.058367 139825684965184 ncf_keras_main.py:562] Result is {'loss': , 'eval_loss': None, 'eval_hit_rate': , 'step_timestamp_log': ['BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTim
estamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp',
 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTime
stamp', 'BatchTimestamp', 'BatchTimestamp'], 'train_finish_time': 1596662568.102817, 'avg_exp_per_second': 4474047.406912873}

Limpieza

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud Platform por los recursos que usaste en este instructivo:

Limpia la instancia de VM de Compute Engine y los recursos de Cloud TPU.

  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 tu VM o Cloud Shell, ejecuta ctpu delete con las marcas --name y --zone que usaste cuando configuraste Cloud TPU para borrar tu Cloud TPU:

    $ ctpu delete --name=ncf-tutorial \
      --zone=europe-west4-a
    
  3. Ejecuta el siguiente comando para verificar que la VM de Compute Engine y la Cloud TPU se hayan cerrado:

    $ ctpu status --name=ncf-tutorial --zone=europe-west4-a
    

    La eliminación puede tardar varios minutos. Una respuesta como la que se muestra a continuación indica que no hay más instancias asignadas:

    2018/04/28 16:16:23 WARNING: Setting zone to "europe-west4-a"
    No instances currently exist.
            Compute Engine VM:     --
            Cloud TPU:             --
    
  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 de NCF con 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 tu conjunto de datos en 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 los hiperparámetros del modelo. Puedes encontrar información sobre 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 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.