La journée communautaire ML est le 9 novembre ! Rejoignez - nous pour les mises à jour de tensorflow, JAX et plus En savoir plus

Recommandations multi-tâches

Voir sur TensorFlow.org Exécuter dans Google Colab Voir la source sur GitHub Télécharger le cahier

Dans le tutoriel recherche de base , nous avons construit un système de récupération en utilisant des montres de films en tant que signaux d'interaction positifs.

Dans de nombreuses applications, cependant, il existe de multiples sources riches de commentaires sur lesquelles s'appuyer. Par exemple, un site de commerce électronique peut enregistrer les visites des utilisateurs sur les pages de produits (signal abondant mais relativement faible), les clics sur les images, les ajouts au panier et, enfin, les achats. Il peut même enregistrer des signaux post-achat tels que des avis et des retours.

L'intégration de toutes ces différentes formes de retour d'information est essentielle pour créer des systèmes que les utilisateurs aiment utiliser et qui n'optimisent pas pour une seule métrique au détriment des performances globales.

De plus, la construction d'un modèle conjoint pour plusieurs tâches peut produire de meilleurs résultats que la construction d'un certain nombre de modèles spécifiques à une tâche. Cela est particulièrement vrai lorsque certaines données sont abondantes (par exemple, les clics) et certaines données sont clairsemées (achats, retours, revues manuelles). Dans ces scénarios, un modèle conjoint peut être en mesure d'utiliser des représentations tirées de la tâche abondante d'améliorer ses prévisions sur la tâche clairsemée par un phénomène connu sous le nom d' apprentissage de transfert . Par exemple, ce document montre qu'un modèle prédisant évaluations explicites des utilisateurs d'enquêtes auprès des utilisateurs rares peut être considérablement améliorée par l' ajout d' une tâche auxiliaire qui utilise les données du journal de clic abondant.

Dans ce didacticiel, nous allons créer un outil de recommandation multi-objectifs pour Movielens, en utilisant à la fois des signaux implicites (visionnages de films) et explicites (notes).

Importations

Éliminons d'abord nos importations.

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

Préparation du jeu de données

Nous allons utiliser le jeu de données 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

Et répétez nos préparatifs pour construire des vocabulaires et diviser les données en un train et un ensemble de test :

# 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 modèle multitâche

Les recommandations multi-tâches comportent deux éléments essentiels :

  1. Ils optimisent pour deux ou plusieurs objectifs, et ont donc deux pertes ou plus.
  2. Ils partagent des variables entre les tâches, permettant un apprentissage par transfert.

Dans ce tutoriel, nous définirons nos modèles comme avant, mais au lieu d'avoir une seule tâche, nous aurons deux tâches : une qui prédit les notes et une qui prédit les visionnages de films.

Les modèles d'utilisateur et de film sont comme avant :

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)
])

Cependant, nous aurons maintenant deux tâches. La première est la tâche de notation :

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

Son objectif est de prédire les cotes aussi précisément que possible.

La seconde est la tâche de récupération :

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

Comme précédemment, le but de cette tâche est de prédire quels films l'utilisateur regardera ou ne regardera pas.

Mettre ensemble

Nous avons tout rassemblé dans une classe modèle.

Le nouveau composant ici est que - puisque nous avons deux tâches et deux pertes - nous devons décider de l'importance de chaque perte. Nous pouvons le faire en donnant un poids à chacune des pertes et en traitant ces poids comme des hyperparamètres. Si nous attribuons un poids de perte important à la tâche d'évaluation, notre modèle se concentrera sur la prédiction des évaluations (mais utilisera toujours certaines informations de la tâche de récupération) ; si nous attribuons un poids de perte important à la tâche de récupération, elle se concentrera plutôt sur la récupération.

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)

Modèle spécialisé en notation

Selon les poids que nous attribuons, le modèle encode un équilibre différent des tâches. Commençons par un modèle qui ne prend en compte que les notes.

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.

Le modèle permet de prédire les cotes (avec un RMSE d'environ 1,11), mais est peu performant pour prédire quels films seront regardés ou non : sa précision à 100 est presque 4 fois pire qu'un modèle formé uniquement pour prédire les montres.

Modèle spécialisé dans la récupération

Essayons maintenant un modèle qui se concentre uniquement sur la récupération.

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.

Nous obtenons le résultat inverse : un modèle qui fonctionne bien sur la récupération, mais mal sur la prédiction des évaluations.

Modèle commun

Entraînons maintenant un modèle qui attribue des poids positifs aux deux tâches.

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.

Le résultat est un modèle qui fonctionne à peu près aussi bien sur les deux tâches que chaque modèle spécialisé.

Bien que les résultats ici ne montrent pas un avantage de précision clair d'un modèle conjoint dans ce cas, l'apprentissage multi-tâches est en général un outil extrêmement utile. Nous pouvons nous attendre à de meilleurs résultats lorsque nous pouvons transférer les connaissances d'une tâche riche en données (telle que les clics) à une tâche étroitement liée aux données rares (telle que les achats).