¡El Día de la Comunidad de ML es el 9 de noviembre! Únase a nosotros para recibir actualizaciones de TensorFlow, JAX, y más Más información

Recomendados multitarea

Ver en TensorFlow.org Ejecutar en Google Colab Ver fuente en GitHub Descargar cuaderno

En el tutorial de recuperación básica se construyó un sistema de recuperación usando relojes de películas como señales de interacción positiva.

En muchas aplicaciones, sin embargo, existen múltiples fuentes de retroalimentación a las que recurrir. Por ejemplo, un sitio de comercio electrónico puede registrar las visitas de los usuarios a las páginas de productos (señal abundante, pero relativamente baja), clics en imágenes, agregar al carrito y, finalmente, compras. Incluso puede registrar señales posteriores a la compra, como revisiones y devoluciones.

La integración de todas estas diferentes formas de retroalimentación es fundamental para crear sistemas que a los usuarios les encanta usar y que no se optimizan para ninguna métrica a expensas del rendimiento general.

Además, la construcción de un modelo conjunto para múltiples tareas puede producir mejores resultados que la construcción de varios modelos específicos de tareas. Esto es especialmente cierto cuando algunos datos son abundantes (por ejemplo, clics) y algunos datos son escasos (compras, devoluciones, revisiones manuales). En esos escenarios, un modelo de articulación puede ser capaz de utilizar representaciones aprendido de la tarea abundante para mejorar sus predicciones sobre la tarea dispersa a través de un fenómeno conocido como el aprendizaje de transferencia . Por ejemplo, este papel muestra que un modelo de predicción de calificaciones de usuario explícitos de encuestas a los usuarios dispersos se puede mejorar sustancialmente mediante la adición de una tarea auxiliar que utiliza los datos de registro clic abundantes.

En este tutorial, vamos a construir un recomendador multiobjetivo para Movielens, usando señales implícitas (visualizaciones de películas) y explícitas (clasificaciones).

Importaciones

Primero saquemos nuestras importaciones del camino.

pip install -q tensorflow-recommenders
pip install -q --upgrade tensorflow-datasets
import os
import pprint
import tempfile

from typing import Dict, Text

import numpy as np
import tensorflow as tf
import tensorflow_datasets as tfds
import tensorflow_recommenders as tfrs

Preparando el conjunto de datos

Vamos a utilizar el conjunto de datos Movielens 100K.

ratings = tfds.load('movielens/100k-ratings', split="train")
movies = tfds.load('movielens/100k-movies', split="train")

# Select the basic features.
ratings = ratings.map(lambda x: {
    "movie_title": x["movie_title"],
    "user_id": x["user_id"],
    "user_rating": x["user_rating"],
})
movies = movies.map(lambda x: x["movie_title"])
2021-10-02 12:05:52.001219: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected

Y repita nuestros preparativos para construir vocabularios y dividir los datos en un tren y un conjunto de prueba:

# Randomly shuffle data and split between train and test.
tf.random.set_seed(42)
shuffled = ratings.shuffle(100_000, seed=42, reshuffle_each_iteration=False)

train = shuffled.take(80_000)
test = shuffled.skip(80_000).take(20_000)

movie_titles = movies.batch(1_000)
user_ids = ratings.batch(1_000_000).map(lambda x: x["user_id"])

unique_movie_titles = np.unique(np.concatenate(list(movie_titles)))
unique_user_ids = np.unique(np.concatenate(list(user_ids)))

Un modelo multitarea

Hay dos partes críticas para los recomendadores de tareas múltiples:

  1. Optimizan para dos o más objetivos, por lo que tienen dos o más pérdidas.
  2. Comparten variables entre las tareas, lo que permite transferir el aprendizaje.

En este tutorial, definiremos nuestros modelos como antes, pero en lugar de tener una sola tarea, tendremos dos tareas: una que predice calificaciones y otra que predice películas.

Los modelos de usuario y película son como antes:

user_model = tf.keras.Sequential([
  tf.keras.layers.StringLookup(
      vocabulary=unique_user_ids, mask_token=None),
  # We add 1 to account for the unknown token.
  tf.keras.layers.Embedding(len(unique_user_ids) + 1, embedding_dimension)
])

movie_model = tf.keras.Sequential([
  tf.keras.layers.StringLookup(
      vocabulary=unique_movie_titles, mask_token=None),
  tf.keras.layers.Embedding(len(unique_movie_titles) + 1, embedding_dimension)
])

Sin embargo, ahora tendremos dos tareas. La primera es la tarea de calificación:

tfrs.tasks.Ranking(
    loss=tf.keras.losses.MeanSquaredError(),
    metrics=[tf.keras.metrics.RootMeanSquaredError()],
)

Su objetivo es predecir las calificaciones con la mayor precisión posible.

La segunda es la tarea de recuperación:

tfrs.tasks.Retrieval(
    metrics=tfrs.metrics.FactorizedTopK(
        candidates=movies.batch(128)
    )
)

Como antes, el objetivo de esta tarea es predecir qué películas verá o no verá el usuario.

Poniendo todo junto

Lo ponemos todo junto en una clase modelo.

El nuevo componente aquí es que, dado que tenemos dos tareas y dos pérdidas, debemos decidir qué tan importante es cada pérdida. Podemos hacer esto dando un peso a cada una de las pérdidas y tratando estos pesos como hiperparámetros. Si asignamos una gran pérdida de peso a la tarea de calificación, nuestro modelo se centrará en predecir calificaciones (pero aún usará parte de la información de la tarea de recuperación); si asignamos una gran pérdida de peso a la tarea de recuperación, se centrará en la recuperación.

class MovielensModel(tfrs.models.Model):

  def __init__(self, rating_weight: float, retrieval_weight: float) -> None:
    # We take the loss weights in the constructor: this allows us to instantiate
    # several model objects with different loss weights.

    super().__init__()

    embedding_dimension = 32

    # User and movie models.
    self.movie_model: tf.keras.layers.Layer = tf.keras.Sequential([
      tf.keras.layers.StringLookup(
        vocabulary=unique_movie_titles, mask_token=None),
      tf.keras.layers.Embedding(len(unique_movie_titles) + 1, embedding_dimension)
    ])
    self.user_model: tf.keras.layers.Layer = tf.keras.Sequential([
      tf.keras.layers.StringLookup(
        vocabulary=unique_user_ids, mask_token=None),
      tf.keras.layers.Embedding(len(unique_user_ids) + 1, embedding_dimension)
    ])

    # A small model to take in user and movie embeddings and predict ratings.
    # We can make this as complicated as we want as long as we output a scalar
    # as our prediction.
    self.rating_model = tf.keras.Sequential([
        tf.keras.layers.Dense(256, activation="relu"),
        tf.keras.layers.Dense(128, activation="relu"),
        tf.keras.layers.Dense(1),
    ])

    # The tasks.
    self.rating_task: tf.keras.layers.Layer = tfrs.tasks.Ranking(
        loss=tf.keras.losses.MeanSquaredError(),
        metrics=[tf.keras.metrics.RootMeanSquaredError()],
    )
    self.retrieval_task: tf.keras.layers.Layer = tfrs.tasks.Retrieval(
        metrics=tfrs.metrics.FactorizedTopK(
            candidates=movies.batch(128).map(self.movie_model)
        )
    )

    # The loss weights.
    self.rating_weight = rating_weight
    self.retrieval_weight = retrieval_weight

  def call(self, features: Dict[Text, tf.Tensor]) -> tf.Tensor:
    # We pick out the user features and pass them into the user model.
    user_embeddings = self.user_model(features["user_id"])
    # And pick out the movie features and pass them into the movie model.
    movie_embeddings = self.movie_model(features["movie_title"])

    return (
        user_embeddings,
        movie_embeddings,
        # We apply the multi-layered rating model to a concatentation of
        # user and movie embeddings.
        self.rating_model(
            tf.concat([user_embeddings, movie_embeddings], axis=1)
        ),
    )

  def compute_loss(self, features: Dict[Text, tf.Tensor], training=False) -> tf.Tensor:

    ratings = features.pop("user_rating")

    user_embeddings, movie_embeddings, rating_predictions = self(features)

    # We compute the loss for each task.
    rating_loss = self.rating_task(
        labels=ratings,
        predictions=rating_predictions,
    )
    retrieval_loss = self.retrieval_task(user_embeddings, movie_embeddings)

    # And combine them using the loss weights.
    return (self.rating_weight * rating_loss

            + self.retrieval_weight * retrieval_loss)

Modelo especializado en calificación

Dependiendo de los pesos que asignemos, el modelo codificará un equilibrio diferente de las tareas. Comencemos con un modelo que solo considera calificaciones.

model = MovielensModel(rating_weight=1.0, retrieval_weight=0.0)
model.compile(optimizer=tf.keras.optimizers.Adagrad(0.1))
cached_train = train.shuffle(100_000).batch(8192).cache()
cached_test = test.batch(4096).cache()
model.fit(cached_train, epochs=3)
metrics = model.evaluate(cached_test, return_dict=True)

print(f"Retrieval top-100 accuracy: {metrics['factorized_top_k/top_100_categorical_accuracy']:.3f}.")
print(f"Ranking RMSE: {metrics['root_mean_squared_error']:.3f}.")
Epoch 1/3
10/10 [==============================] - 7s 335ms/step - root_mean_squared_error: 2.0903 - factorized_top_k/top_1_categorical_accuracy: 3.8750e-04 - factorized_top_k/top_5_categorical_accuracy: 0.0026 - factorized_top_k/top_10_categorical_accuracy: 0.0055 - factorized_top_k/top_50_categorical_accuracy: 0.0296 - factorized_top_k/top_100_categorical_accuracy: 0.0590 - loss: 4.0315 - regularization_loss: 0.0000e+00 - total_loss: 4.0315
Epoch 2/3
10/10 [==============================] - 3s 322ms/step - root_mean_squared_error: 1.1531 - factorized_top_k/top_1_categorical_accuracy: 3.5000e-04 - factorized_top_k/top_5_categorical_accuracy: 0.0026 - factorized_top_k/top_10_categorical_accuracy: 0.0055 - factorized_top_k/top_50_categorical_accuracy: 0.0298 - factorized_top_k/top_100_categorical_accuracy: 0.0593 - loss: 1.3189 - regularization_loss: 0.0000e+00 - total_loss: 1.3189
Epoch 3/3
10/10 [==============================] - 3s 317ms/step - root_mean_squared_error: 1.1198 - factorized_top_k/top_1_categorical_accuracy: 4.2500e-04 - factorized_top_k/top_5_categorical_accuracy: 0.0026 - factorized_top_k/top_10_categorical_accuracy: 0.0056 - factorized_top_k/top_50_categorical_accuracy: 0.0302 - factorized_top_k/top_100_categorical_accuracy: 0.0598 - loss: 1.2479 - regularization_loss: 0.0000e+00 - total_loss: 1.2479
5/5 [==============================] - 3s 158ms/step - root_mean_squared_error: 1.1130 - factorized_top_k/top_1_categorical_accuracy: 5.0000e-04 - factorized_top_k/top_5_categorical_accuracy: 0.0030 - factorized_top_k/top_10_categorical_accuracy: 0.0050 - factorized_top_k/top_50_categorical_accuracy: 0.0298 - factorized_top_k/top_100_categorical_accuracy: 0.0596 - loss: 1.2336 - regularization_loss: 0.0000e+00 - total_loss: 1.2336
Retrieval top-100 accuracy: 0.060.
Ranking RMSE: 1.113.

El modelo funciona bien en la predicción de clasificaciones (con un RMSE de alrededor de 1,11), pero tiene un rendimiento deficiente al predecir qué películas se verán o no: su precisión a 100 es casi 4 veces peor que un modelo entrenado únicamente para predecir relojes.

Modelo especializado en recuperación

Probemos ahora un modelo que se centra únicamente en la recuperación.

model = MovielensModel(rating_weight=0.0, retrieval_weight=1.0)
model.compile(optimizer=tf.keras.optimizers.Adagrad(0.1))
model.fit(cached_train, epochs=3)
metrics = model.evaluate(cached_test, return_dict=True)

print(f"Retrieval top-100 accuracy: {metrics['factorized_top_k/top_100_categorical_accuracy']:.3f}.")
print(f"Ranking RMSE: {metrics['root_mean_squared_error']:.3f}.")
Epoch 1/3
10/10 [==============================] - 4s 314ms/step - root_mean_squared_error: 3.7237 - factorized_top_k/top_1_categorical_accuracy: 0.0013 - factorized_top_k/top_5_categorical_accuracy: 0.0104 - factorized_top_k/top_10_categorical_accuracy: 0.0217 - factorized_top_k/top_50_categorical_accuracy: 0.1027 - factorized_top_k/top_100_categorical_accuracy: 0.1817 - loss: 69818.0298 - regularization_loss: 0.0000e+00 - total_loss: 69818.0298
Epoch 2/3
10/10 [==============================] - 3s 310ms/step - root_mean_squared_error: 3.7495 - factorized_top_k/top_1_categorical_accuracy: 0.0029 - factorized_top_k/top_5_categorical_accuracy: 0.0189 - factorized_top_k/top_10_categorical_accuracy: 0.0383 - factorized_top_k/top_50_categorical_accuracy: 0.1688 - factorized_top_k/top_100_categorical_accuracy: 0.2925 - loss: 67473.2884 - regularization_loss: 0.0000e+00 - total_loss: 67473.2884
Epoch 3/3
10/10 [==============================] - 3s 307ms/step - root_mean_squared_error: 3.7648 - factorized_top_k/top_1_categorical_accuracy: 0.0031 - factorized_top_k/top_5_categorical_accuracy: 0.0224 - factorized_top_k/top_10_categorical_accuracy: 0.0461 - factorized_top_k/top_50_categorical_accuracy: 0.1884 - factorized_top_k/top_100_categorical_accuracy: 0.3156 - loss: 66329.2507 - regularization_loss: 0.0000e+00 - total_loss: 66329.2507
5/5 [==============================] - 1s 161ms/step - root_mean_squared_error: 3.7730 - factorized_top_k/top_1_categorical_accuracy: 0.0011 - factorized_top_k/top_5_categorical_accuracy: 0.0095 - factorized_top_k/top_10_categorical_accuracy: 0.0216 - factorized_top_k/top_50_categorical_accuracy: 0.1252 - factorized_top_k/top_100_categorical_accuracy: 0.2350 - loss: 31085.0693 - regularization_loss: 0.0000e+00 - total_loss: 31085.0693
Retrieval top-100 accuracy: 0.235.
Ranking RMSE: 3.773.

Obtenemos el resultado opuesto: un modelo que funciona bien en la recuperación, pero mal en la predicción de calificaciones.

Modelo conjunto

Entrenemos ahora un modelo que asigne pesos positivos a ambas tareas.

model = MovielensModel(rating_weight=1.0, retrieval_weight=1.0)
model.compile(optimizer=tf.keras.optimizers.Adagrad(0.1))
model.fit(cached_train, epochs=3)
metrics = model.evaluate(cached_test, return_dict=True)

print(f"Retrieval top-100 accuracy: {metrics['factorized_top_k/top_100_categorical_accuracy']:.3f}.")
print(f"Ranking RMSE: {metrics['root_mean_squared_error']:.3f}.")
Epoch 1/3
10/10 [==============================] - 4s 314ms/step - root_mean_squared_error: 2.5007 - factorized_top_k/top_1_categorical_accuracy: 0.0015 - factorized_top_k/top_5_categorical_accuracy: 0.0108 - factorized_top_k/top_10_categorical_accuracy: 0.0219 - factorized_top_k/top_50_categorical_accuracy: 0.1031 - factorized_top_k/top_100_categorical_accuracy: 0.1811 - loss: 69811.8260 - regularization_loss: 0.0000e+00 - total_loss: 69811.8260
Epoch 2/3
10/10 [==============================] - 3s 308ms/step - root_mean_squared_error: 1.2097 - factorized_top_k/top_1_categorical_accuracy: 0.0027 - factorized_top_k/top_5_categorical_accuracy: 0.0183 - factorized_top_k/top_10_categorical_accuracy: 0.0368 - factorized_top_k/top_50_categorical_accuracy: 0.1641 - factorized_top_k/top_100_categorical_accuracy: 0.2879 - loss: 67481.2734 - regularization_loss: 0.0000e+00 - total_loss: 67481.2734
Epoch 3/3
10/10 [==============================] - 3s 308ms/step - root_mean_squared_error: 1.1200 - factorized_top_k/top_1_categorical_accuracy: 0.0034 - factorized_top_k/top_5_categorical_accuracy: 0.0226 - factorized_top_k/top_10_categorical_accuracy: 0.0447 - factorized_top_k/top_50_categorical_accuracy: 0.1867 - factorized_top_k/top_100_categorical_accuracy: 0.3153 - loss: 66297.9311 - regularization_loss: 0.0000e+00 - total_loss: 66297.9311
5/5 [==============================] - 1s 163ms/step - root_mean_squared_error: 1.1312 - factorized_top_k/top_1_categorical_accuracy: 9.0000e-04 - factorized_top_k/top_5_categorical_accuracy: 0.0084 - factorized_top_k/top_10_categorical_accuracy: 0.0225 - factorized_top_k/top_50_categorical_accuracy: 0.1249 - factorized_top_k/top_100_categorical_accuracy: 0.2344 - loss: 31062.8213 - regularization_loss: 0.0000e+00 - total_loss: 31062.8213
Retrieval top-100 accuracy: 0.234.
Ranking RMSE: 1.131.

El resultado es un modelo que se desempeña aproximadamente tan bien en ambas tareas como en cada modelo especializado.

Si bien los resultados aquí no muestran un beneficio de precisión claro de un modelo conjunto en este caso, el aprendizaje multitarea es en general una herramienta extremadamente útil. Podemos esperar mejores resultados cuando podemos transferir conocimiento de una tarea con abundancia de datos (como los clics) a una tarea con escasez de datos estrechamente relacionada (como las compras).