Recomendar filmes: classificação

Ver no TensorFlow.org Executar no Google Colab Ver fonte no GitHub Baixar caderno

Os sistemas de recomendação do mundo real costumam ser compostos de dois estágios:

  1. O estágio de recuperação é responsável por selecionar um conjunto inicial de centenas de candidatos de todos os candidatos possíveis. O principal objetivo desse modelo é eliminar com eficiência todos os candidatos nos quais o usuário não está interessado. Como o modelo de recuperação pode lidar com milhões de candidatos, ele deve ser computacionalmente eficiente.
  2. O estágio de classificação pega os resultados do modelo de recuperação e os ajusta para selecionar o melhor punhado possível de recomendações. Sua tarefa é restringir o conjunto de itens nos quais o usuário pode estar interessado em uma lista de prováveis ​​candidatos.

Vamos nos concentrar na segunda etapa, a classificação. Se você estiver interessado na fase de recuperação, ter um olhar para a nossa recuperação tutorial.

Neste tutorial, vamos:

  1. Obtenha nossos dados e divida-os em um conjunto de treinamento e teste.
  2. Implemente um modelo de classificação.
  3. Ajustar e avaliar.

Importações

Vamos primeiro tirar nossas importações do caminho.

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 o conjunto de dados

Vamos usar os mesmos dados como a recuperação de tutorial. Desta vez, também vamos manter as classificações: são estes os objetivos que pretendemos prever.

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

ratings = ratings.map(lambda x: {
    "movie_title": x["movie_title"],
    "user_id": x["user_id"],
    "user_rating": x["user_rating"]
})
2021-08-21 11:04:19.742064: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected
2021-08-21 11:04:19.742135: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:156] kernel driver does not appear to be running on this host (kokoro-gcp-ubuntu-prod-129765733): /proc/driver/nvidia/version does not exist
2021-08-21 11:04:19.742855: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.

Como antes, dividiremos os dados colocando 80% das avaliações no conjunto de trem e 20% no conjunto de teste.

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)

Vamos também descobrir IDs de usuário exclusivos e títulos de filmes presentes nos dados.

Isso é importante porque precisamos ser capazes de mapear os valores brutos de nossos recursos categóricos para inserir vetores em nossos modelos. Para fazer isso, precisamos de um vocabulário que mapeie um valor de recurso bruto para um inteiro em um intervalo contíguo: isso nos permite consultar os embeddings correspondentes em nossas tabelas de embedding.

movie_titles = ratings.batch(1_000_000).map(lambda x: x["movie_title"])
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)))
2021-08-21 11:04:19.937847: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:185] None of the MLIR Optimization Passes are enabled (registered 2)

Implementando um modelo

Arquitetura

Os modelos de classificação não enfrentam as mesmas restrições de eficiência que os modelos de recuperação e, portanto, temos um pouco mais de liberdade em nossa escolha de arquiteturas.

Um modelo composto de várias camadas densas empilhadas é uma arquitetura relativamente comum para tarefas de classificação. Podemos implementá-lo da seguinte maneira:

class RankingModel(tf.keras.Model):

  def __init__(self):
    super().__init__()
    embedding_dimension = 32

    # Compute embeddings for users.
    self.user_embeddings = tf.keras.Sequential([
      tf.keras.layers.experimental.preprocessing.StringLookup(
        vocabulary=unique_user_ids, mask_token=None),
      tf.keras.layers.Embedding(len(unique_user_ids) + 1, embedding_dimension)
    ])

    # Compute embeddings for movies.
    self.movie_embeddings = tf.keras.Sequential([
      tf.keras.layers.experimental.preprocessing.StringLookup(
        vocabulary=unique_movie_titles, mask_token=None),
      tf.keras.layers.Embedding(len(unique_movie_titles) + 1, embedding_dimension)
    ])

    # Compute predictions.
    self.ratings = tf.keras.Sequential([
      # Learn multiple dense layers.
      tf.keras.layers.Dense(256, activation="relu"),
      tf.keras.layers.Dense(64, activation="relu"),
      # Make rating predictions in the final layer.
      tf.keras.layers.Dense(1)
  ])

  def call(self, inputs):

    user_id, movie_title = inputs

    user_embedding = self.user_embeddings(user_id)
    movie_embedding = self.movie_embeddings(movie_title)

    return self.ratings(tf.concat([user_embedding, movie_embedding], axis=1))

Este modelo usa IDs de usuário e títulos de filmes e produz uma classificação prevista:

RankingModel()((["42"], ["One Flew Over the Cuckoo's Nest (1975)"]))
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor, but we receive a <class 'list'> input: ['42']
Consider rewriting this model with the Functional API.
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor, but we receive a <class 'list'> input: ['42']
Consider rewriting this model with the Functional API.
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor, but we receive a <class 'list'> input: ["One Flew Over the Cuckoo's Nest (1975)"]
Consider rewriting this model with the Functional API.
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor, but we receive a <class 'list'> input: ["One Flew Over the Cuckoo's Nest (1975)"]
Consider rewriting this model with the Functional API.
<tf.Tensor: shape=(1, 1), dtype=float32, numpy=array([[0.03740937]], dtype=float32)>

Perda e métricas

O próximo componente é a perda usada para treinar nosso modelo. O TFRS tem várias camadas de perda e tarefas para tornar isso fácil.

Neste caso, vamos fazer uso do Ranking objeto de tarefa: um invólucro de conveniência que agrupa a função de perda e de cálculo da métrica.

Vamos usá-lo juntamente com o MeanSquaredError perda Keras, a fim de prever os ratings.

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

A tarefa em si é uma camada Keras que considera verdadeiro e previsto como argumentos e retorna a perda calculada. Usaremos isso para implementar o loop de treinamento do modelo.

O modelo completo

Agora podemos colocar tudo junto em um modelo. TFRS expõe uma classe de modelo base ( tfrs.models.Model ) que simplifica modelos bulding: tudo o que precisamos fazer é configurar os componentes no __init__ método, e implementar o compute_loss método, tendo em recursos brutos e retornar um valor de perda .

O modelo básico se encarregará de criar o loop de treinamento apropriado para se ajustar ao nosso modelo.

class MovielensModel(tfrs.models.Model):

  def __init__(self):
    super().__init__()
    self.ranking_model: tf.keras.Model = RankingModel()
    self.task: tf.keras.layers.Layer = tfrs.tasks.Ranking(
      loss = tf.keras.losses.MeanSquaredError(),
      metrics=[tf.keras.metrics.RootMeanSquaredError()]
    )

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

    # The task computes the loss and the metrics.
    return self.task(labels=features["user_rating"], predictions=rating_predictions)

Ajustando e avaliando

Depois de definir o modelo, podemos usar rotinas de ajuste e avaliação Keras padrão para ajustar e avaliar o modelo.

Vamos primeiro instanciar o modelo.

model = MovielensModel()
model.compile(optimizer=tf.keras.optimizers.Adagrad(learning_rate=0.1))

Em seguida, embaralhe, agrupe e armazene em cache os dados de treinamento e avaliação.

cached_train = train.shuffle(100_000).batch(8192).cache()
cached_test = test.batch(4096).cache()

Em seguida, treine o modelo:

model.fit(cached_train, epochs=3)
Epoch 1/3
10/10 [==============================] - 2s 25ms/step - root_mean_squared_error: 2.1718 - loss: 4.3303 - regularization_loss: 0.0000e+00 - total_loss: 4.3303
Epoch 2/3
10/10 [==============================] - 0s 8ms/step - root_mean_squared_error: 1.1227 - loss: 1.2602 - regularization_loss: 0.0000e+00 - total_loss: 1.2602
Epoch 3/3
10/10 [==============================] - 0s 8ms/step - root_mean_squared_error: 1.1162 - loss: 1.2456 - regularization_loss: 0.0000e+00 - total_loss: 1.2456
<keras.callbacks.History at 0x7fb3e0a2ee10>

Conforme o modelo treina, a perda diminui e a métrica RMSE melhora.

Finalmente, podemos avaliar nosso modelo no conjunto de teste:

model.evaluate(cached_test, return_dict=True)
5/5 [==============================] - 2s 12ms/step - root_mean_squared_error: 1.1108 - loss: 1.2287 - regularization_loss: 0.0000e+00 - total_loss: 1.2287
{'root_mean_squared_error': 1.1108061075210571,
 'loss': 1.2062578201293945,
 'regularization_loss': 0,
 'total_loss': 1.2062578201293945}

Quanto mais baixa for a métrica RMSE, mais preciso será o nosso modelo nas classificações de previsão.

Testando o modelo de classificação

Agora podemos testar o modelo de classificação calculando previsões para um conjunto de filmes e, em seguida, classificar esses filmes com base nas previsões:

test_ratings = {}
test_movie_titles = ["M*A*S*H (1970)", "Dances with Wolves (1990)", "Speed (1994)"]
for movie_title in test_movie_titles:
  test_ratings[movie_title] = model.ranking_model((
      tf.constant(["42"]),
      tf.constant([movie_title]))).numpy()

print("Ratings:")
for title, score in sorted(test_ratings.items(), key=lambda x: x[1], reverse=True):
  print(f"{title}: {score}")
Ratings:
M*A*S*H (1970): [[3.584712]]
Dances with Wolves (1990): [[3.551556]]
Speed (1994): [[3.5215874]]

Próximos passos

O modelo acima nos dá um começo decente para a construção de um sistema de classificação.

Claro, fazer um sistema de classificação prático requer muito mais esforço.

Na maioria dos casos, um modelo de classificação pode ser substancialmente melhorado usando mais recursos, em vez de apenas identificadores de usuário e candidato. Para ver como fazer isso, ter um olhar para o lado apresenta tutorial.

Uma compreensão cuidadosa dos objetivos que vale a pena otimizar também é necessária. Para começar a construir um recommender que otimiza múltiplos objetivos, ter um olhar para o nosso multitask tutorial.