Recomendaciones en TensorFlow: entrena y configura en AI Platform

Este artículo es el segundo de una serie de instructivos de varias partes en la que se muestra cómo implementar un sistema de recomendación de aprendizaje automático (AA) con TensorFlow y AI Platform. En esta parte, aprenderás cómo entrenar el sistema de recomendación y configurar hiperparámetros con AI Platform en Google Cloud Platform (GCP).

La serie consta de las siguientes partes:

Descripción general
Crea el modelo (parte 1)
Entrena y configura en AI Platform (Parte 2) (este instructivo)
Aplica a datos de Google Analytics (Parte 3)
Implementa el sistema de recomendación (Parte 4)

En este instructivo, se da por sentado que completaste el instructivo anterior de la serie.

Objetivos

Aprender cómo ejecutar un trabajo de entrenamiento en AI Platform para realizar recomendaciones del conjunto de datos MovieLens
Configurar los hiperparámetros de AI Platform y optimizar el modelo de recomendación de WALS de TensorFlow para el conjunto de datos MovieLens

Costos

En este instructivo, se usa Cloud Storage y AI Platform, que son servicios facturables. Puedes usar la calculadora de precios para estimar los costos según el uso previsto. El costo previsto para este instructivo es de $0.20. Si eres un usuario nuevo de GCP, puedes ser apto para obtener prueba gratuita.

Antes de comenzar

Sigue las instrucciones de la Parte 1 para configurar tu proyecto de GCP.

Entrena el modelo

En el primer instructivo de esta serie, se revisó la implementación del algoritmo WALS en TensorFlow. En este instructivo, se muestra cómo entrenar el modelo con AI Platform. En este contexto, “entrenar el modelo” significa factorizar una matriz dispersa de calificaciones R en una matriz de factores de usuario X y una matriz de factores de elementos Y. Los factores de usuario resultantes funcionan como el modelo base para un sistema de recomendación.

En la Parte 4, implementa el sistema de recomendación en GCP.

Entrena trabajos en AI Platform

El entrenamiento de un modelo con AI Platform requiere que se especifique un directorio de trabajo, que es una carpeta de depósito de Cloud Storage. Para ejecutar un trabajo de entrenamiento, sigue estos pasos:

Crea un bucket de Cloud Storage nuevo en tu proyecto o usa uno existente.

Para crear un nuevo depósito, en Cloud Console, selecciona Cloud Storage > Navegador y, luego, haz clic en Crear depósito.

Recuerda el nombre otorgado a este bucket. Una buena idea es colocar el bucket en la misma región que tu instancia de Compute Engine.
En tu shell, establece la variable de entorno BUCKET en la URL del depósito de Cloud Storage del depósito que usas.
```
BUCKET=gs://[YOUR_BUCKET_NAME]
```

Copia los conjuntos de datos MovieLens en el depósito mediante la herramienta gsutil:

gsutil cp -r data/u.data $BUCKET/data/u.data
gsutil cp -r data/ratings.dat $BUCKET/data/ratings.dat
gsutil cp -r data/ratings.csv $BUCKET/data/ratings.csv

Para ejecutar el trabajo, ejecuta la secuencia de comandos de entrenamiento en el directorio wals_ml_engine, establece la opción train y especifica la URL del depósito de Cloud Storage, además de la ruta de acceso al archivo de datos dentro del depósito.

El conjunto de datos que uses depende de lo que decidiste usar en la Parte 1. Establece opciones adicionales adecuadas para el archivo de datos, como el delimitador o el encabezado:
```
cd wals_ml_engine
```
- Para el conjunto de datos MovieLens 100k, especifica la ruta al archivo de datos 100k:
```
./mltrain.sh train ${BUCKET} data/u.data
```
- Para el conjunto de datos 1m, incluye la opción --delimiter y especifica la ruta al archivo de datos 1m:
```
./mltrain.sh train ${BUCKET} data/ratings.dat --delimiter ::
```
- Para el conjunto de datos 20m, usa las opciones --delimiter y --headers:
```
./mltrain.sh train ${BUCKET} data/ratings.csv --delimiter , --headers
```
Puedes supervisar el estado y el resultado del trabajo en la página Trabajos de la sección AI Platform de Cloud Console. Haz clic en Registros para ver el resultado del trabajo. Los resultados se registran como un error de la raíz cuadrada de la media (RMSE) en el conjunto de prueba. El RMSE representa el error promedio para el modelo de la calificación de los usuarios prevista en el conjunto de prueba completo de las calificaciones.

Guarda el modelo

Después de la factorización, las matrices de factores se guardan en cinco archivos separados en formato NumPy a fin de que puedan usarse para realizar recomendaciones. En la Parte 3 de la serie de instructivos, se explican los archivos de modelo y se muestra cómo generar recomendaciones mediante su uso. En la Parte 4, se muestra cómo implementar un sistema de producción para realizar recomendaciones. Cuando el modelo se entrena de forma local, los archivos se guardan en la carpeta jobs dentro del paquete de código. Cuando el modelo se entrena en AI Platform, los archivos se guardan en un depósito de Cloud Storage que proporciona el argumento job-dir al trabajo de AI Platform descrito en la sección anterior.

Resultados del conjunto de datos MovieLens

Los resultados de las aproximaciones de factorización de matrices se basan en las calificaciones previstas para el conjunto de prueba. El conjunto de prueba se extrajo de la matriz de calificaciones durante el preprocesamiento. Para calcular la diferencia entre las calificaciones previstas y las calificaciones reales del conjunto de prueba que proporcionó el usuario, usa la fórmula de pérdida descrita en la Parte 1:

$$ L = \sum_{u,i}(r_{ui} - x^{T}_{u} \cdot y_{i})^{2} $$

Aquí, $r_ {ui}$ son las calificaciones del conjunto de prueba y $x_ {u}$ y $y_ {i}$ son los factores de fila y columna que se calculan mediante la aplicación de la factorización de WALS al conjunto de entrenamiento.

El rendimiento de la factorización de matrices depende en gran medida de varios hiperparámetros, que se explican con más detalle en la sección siguiente de este documento. Mediante el uso del conjunto de datos de 1m MovieLens y el conjunto de hiperparámetros predeterminado enumerado en la tabla 1, se logró un RMSE de 1.06 en el conjunto de prueba. El RMSE corresponde al error promedio en las calificaciones previstas en comparación con el conjunto de prueba. En promedio, cada calificación que produce el algoritmo posee un margen de error de ±1.06 de la calificación real de los usuarios en el conjunto de prueba del conjunto de datos de 1m. Es probable que una calificación de 3 que define el usuario genere una calificación predicha de entre 2 y 4, pero no es probable que produzca una de 1 o 5. Este no es un mal resultado, pero los resultados publicados para este conjunto de datos logran un RMSE inferior a 1.0.

Para mejorar el resultado, debes configurar los hiperparámetros enumerados en la tabla 1.

Nombre y descripción del hiperparámetro	Valor predeterminado	Escala
`latent_factors` Cantidad de factores K latentes	5	`UNIT_REVERSE_LOG_SCALE`
`regularization` Constante de regularización L2	0.07	`UNIT_REVERSE_LOG_SCALE`
`unobs_weight` Ponderación en las entradas de la matriz de calificaciones no observadas	0.01	`UNIT_REVERSE_LOG_SCALE`
`feature_wt_factor` Ponderación en las entradas observadas	130	`UNIT_LINEAR_SCALE`
`feature_wt_exp` Exponente de ponderación de características	1	`UNIT_LOG_SCALE`
`num_iters` Cantidad de iteraciones de mínimos cuadrados alternos	20	`UNIT_LINEAR_SCALE`

Tabla 1 Nombres de hiperparámetros y valores predeterminados que se usan en el modelo

Configura los hiperparámetros

Encontrar el conjunto óptimo de hiperparámetros es fundamental para el rendimiento de los modelos de aprendizaje automático. Por desgracia, la teoría solo proporciona una orientación escasa. Los científicos de datos se ven obligados a realizar optimizaciones mediante experimentos con varios valores en rangos razonables, pruebas del rendimiento resultante del modelo y, luego, mediante la selección de una combinación de parámetros con el mejor rendimiento. Este puede ser un proceso largo y costoso en términos de horas para una persona y recursos de procesamiento. El espacio de combinaciones de hiperparámetros posibles crece de manera exponencial en función de la cantidad de parámetros diferentes en el modelo. No es posible buscar todo el espacio. Esto te obliga a hacer suposiciones sobre qué factores afectan al modelo según la heurística, las experiencias anteriores y el conocimiento de las propiedades matemáticas de cada parámetro.

AI Platform incluye una característica de configuración de hiperparámetros, que busca de forma automática un conjunto óptimo de hiperparámetros. Para usar la característica de configuración, proporciona una lista de los hiperparámetros que deseas configurar, además de los rangos o valores esperados para estos parámetros. AI Platform ejecuta una búsqueda en el espacio de hiperparámetros, mediante la ejecución de todas las pruebas que desees, y muestra una lista clasificada de resultados para los hiperparámetros de mejor rendimiento que se encuentran en todas las pruebas. Puedes proporcionar la escala presunta del parámetro, de registro o lineal, como una sugerencia adicional para el proceso de búsqueda.

Para obtener más información sobre la configuración de hiperparámetros, consulta la documentación de AI Platform. Si quieres obtener más información sobre el algoritmo subyacente usado para configurar hiperparámetros, consulta la entrada de blog sobre el ajuste de hiperparámetros en Cloud Machine Learning Engine mediante la optimización bayesiana.

El archivo de configuración de hiperparámetros

La lista de hiperparámetros para AI Platform se puede proporcionar en un archivo de configuración JSON o YAML. En el código de ejemplo de este instructivo, el ajuste de hiperparámetros se define mediante config/config_tune.json. Cada uno de los hiperparámetros configurados en este instructivo se enumera en este archivo, junto con un rango mínimo y uno máximo, además de una escala. Para obtener valores de escala de parámetros válidos, consulta la descripción general del ajuste de hiperparámetros.

El tipo de máquina standard_gpu se especifica en el parámetro scaleTier, por lo que el ajuste se realiza en una máquina que aprovisiona GPU. El archivo de configuración se ve de la siguiente manera:

{
  "trainingInput":{
    "scaleTier":"CUSTOM",
    "masterType":"standard_gpu",
    "hyperparameters":{
      "goal":"MINIMIZE",
      "params":[
        {
          "parameterName":"regularization",
          "type":"DOUBLE",
          "minValue":"0.001",
          "maxValue":"10.0",
          "scaleType":"UNIT_REVERSE_LOG_SCALE"
        },
        {
          "parameterName":"latent_factors",
          "type":"INTEGER",
          "minValue":"5",
          "maxValue":"50",
          "scaleType":"UNIT_REVERSE_LOG_SCALE"
        },
        {
          "parameterName":"unobs_weight",
          "type":"DOUBLE",
          "minValue":"0.001",
          "maxValue":"5.0",
          "scaleType":"UNIT_REVERSE_LOG_SCALE"
        },
        {
          "parameterName":"feature_wt_factor",
          "type":"DOUBLE",
          "minValue":"1",
          "maxValue":"200",
          "scaleType":"UNIT_LOG_SCALE"
        }
      ],
      "maxTrials":500
    }
  }
}

Código de configuración de hiperparámetros

El código del modelo incluye las características siguientes para permitir la configuración de hiperparámetros:

Cada hiperparámetro se pasa como un argumento al trabajo de configuración de hiperparámetros en AI Platform. En este caso, el archivo task.py, que actúa como punto de entrada al trabajo, procesa los argumentos del hiperparámetro. Debes asegurarte de que el nombre del argumento coincida con el nombre del hiperparámetro que se encuentra en el archivo de configuración de hiperparámetros.
El modelo escribe un resumen de TensorFlow con training/hptuning/metric, un rótulo identificador especial que se establece en la métrica que evalúa la calidad del modelo. En este caso, el RMSE es la métrica del conjunto de prueba. Esta métrica de resumen habilita el proceso de búsqueda del servicio de ajuste de hiperparámetros de AI Platform para clasificar las pruebas. El valor de la métrica summary se escribe en una función de utilidad en util.py:
```
summary = Summary(value=[Summary.Value(tag='training/hptuning/metric',
                                       simple_value=metric)])

eval_path = os.path.join(args['output_dir'], 'eval')
summary_writer = tf.summary.FileWriter(eval_path)

# Note: adding the summary to the writer is enough for hyperparam tuning.
# The ml engine system is looking for any summary added with the
# hyperparam metric tag.
summary_writer.add_summary(summary)
```
Es importante tener un directorio de salida separado para cada prueba. El directorio de salida se usa para escribir el resumen de TensorFlow y el modelo guardado. Si no creas un directorio de salida diferente para cada prueba, los resultados de cada prueba reemplazan los resultados de la prueba anterior. Este código controla la creación de un directorio único para cada prueba en task.py en el método parse_arguments:
```
if args.hypertune:
  # if tuning, join the trial number to the output path
  trial = json.loads(os.environ.get('TF_CONFIG', '{}')).get('task', {}).get('trial', '')
  output_dir = os.path.join(job_dir, trial)
else:
  output_dir = os.path.join(job_dir, args.job_name)
```
Aquí, la función parse_arguments distingue entre configuración y resultado estándar, y altera el output_dir según corresponda.

Ejecuta el trabajo de configuración de hiperparámetros

Con el siguiente comando, se ejecuta el trabajo de ajuste en el conjunto de datos 100k:

./mltrain.sh tune $BUCKET data/u.data

Asegúrate de que la variable BUCKET esté establecida en el depósito que creaste antes. El tamaño pequeño del conjunto de datos de 100,000 permite que se ejecute una gran cantidad de pruebas, en este caso, 500.

Resultados del ajuste

Los resultados del ajuste de hiperparámetros se almacenan en los datos de trabajo de AI Platform, a los que puedes acceder en la página Trabajos del área AI Platform de Cloud Console. Como puedes ver en la figura 1, los resultados de trabajos incluyen la mejor puntuación de RMSE en todas las pruebas de la métrica de resumen. Puedes ver los resultados del ajuste de hiperparámetros de 500 pruebas en el conjunto de datos 100k MovieLens. Los mejores resultados se dieron en la prueba 384.

Resultados del trabajo de ajuste de hiperparámetros que destacan los resultados del trabajo 384 — **Figura 1.** Resultados del trabajo de ajuste de hiperparámetros

El ajuste de hiperparámetros puede hacer una gran diferencia en los resultados finales. En este caso, el ajuste de hiperparámetros en el conjunto de prueba de 100k logró un RMSE de 0.98. La aplicación de estos parámetros a los conjuntos de datos de 1m y 20m dio como resultado valores de RMSE respectivos de 0.90 y 0.88. Los parámetros óptimos se enumeran en la tabla 2 y los valores de RMSE previos y posteriores a la configuración se resumen en la tabla 3.

Nombre del hiperparámetro	Descripción	Valor de la configuración
`latent_factors`	Factores K latentes	34
`regularization`	Constante de regularización L2	9.83
`unobs_weight`	Peso no observado	0.001
`feature_wt_factor`	Peso observado	189.8
`feature_wt_exp`	Exponente de peso de características	N/A
`num_iters`	Cantidad de iteraciones	N/A

Tabla 2. Valores que detectó el ajuste de hiperparámetros de AI Platform

El exponente de ponderación de características no formaba parte de los parámetros de ajuste porque la ponderación lineal observada se usa para el conjunto de datos MovieLens. Se usó el valor predeterminado para num_iters, el parámetro de número de iteraciones.

Conjunto de datos	RMSE con hiperparámetros predeterminados	RMSE después de la configuración de hiperparámetros
100,000	1.06	0.98
1,000,000,000	1.11	0.90
20,000,000,00	1.30	0.88

Tabla 3. Resumen de los valores de RMSE en el conjunto de prueba para los diferentes conjuntos de datos de MovieLens, antes y después del ajuste de hiperparámetros.

¿Qué sigue?

En la sección Recomendaciones en TensorFlow: aplica a los datos desde Google Analytics (Parte 3) de la solución, se muestra cómo aplicar el modelo de recomendación a los datos en vivo desde Google Analytics.