无
列表排序
作者： Abheesht Sharma, Fabien Hertschuh
创建日期 2025/04/28
最后修改日期 2025/04/28
描述： 使用成对损失而不是点对损失来对电影进行排序。
简介
在我们之前的基础排序教程中，我们探讨了一个学习预测特定用户-电影组合评分的模型。该模型以（用户，电影）对作为输入，并使用均方误差进行训练，以精确预测用户可能给某部电影的评分。
然而，仅仅优化模型预测单个电影分数的准确性，对于开发排序系统来说并非总是最有效的策略。对于排序模型而言，预测分数的精确度不如模型生成与用户偏好一致的物品有序列表的能力重要。本质上，物品的相对顺序比预测的精确值更重要。
与其关注模型对单个查询-物品对的预测（点对方法），不如根据模型对物品进行正确排序的能力来优化模型。一种常见的实现方法是成对排序。在这种方法中，模型通过比较物品对（例如，物品A和物品B）并确定哪个物品应该为给定的用户或查询排名更高来学习。目标是最小化错误排序的对的数量。
让我们首先导入所有必要的库。
!pip install -q keras-rs
import os
os.environ["KERAS_BACKEND"] = "jax" # `"tensorflow"`/`"torch"`
import collections
import keras
import numpy as np
import tensorflow as tf # Needed only for the dataset
import tensorflow_datasets as tfds
from keras import ops
import keras_rs
让我们在这里定义一些超参数。
# Data args
TRAIN_NUM_LIST_PER_USER = 50
TEST_NUM_LIST_PER_USER = 1
NUM_EXAMPLES_PER_LIST = 5
# Model args
EMBEDDING_DIM = 32
# Train args
BATCH_SIZE = 1024
EPOCHS = 5
LEARNING_RATE = 0.1
准备数据集
我们使用MovieLens数据集。数据加载和处理步骤与之前的教程类似，因此我们只在这里讨论不同之处。
# Ratings data.
ratings = tfds.load("movielens/100k-ratings", split="train")
# Features of all the available movies.
movies = tfds.load("movielens/100k-movies", split="train")
users_count = (
ratings.map(lambda x: tf.strings.to_number(x["user_id"], out_type=tf.int32))
.reduce(tf.constant(0, tf.int32), tf.maximum)
.numpy()
)
movies_count = movies.cardinality().numpy()
def preprocess_rating(x):
return {
"user_id": tf.strings.to_number(x["user_id"], out_type=tf.int32),
"movie_id": tf.strings.to_number(x["movie_id"], out_type=tf.int32),
# Normalise ratings between 0 and 1.
"user_rating": (x["user_rating"] - 1.0) / 4.0,
}
shuffled_ratings = ratings.map(preprocess_rating).shuffle(
100_000, seed=42, reshuffle_each_iteration=False
)
train_ratings = shuffled_ratings.take(70_000)
val_ratings = shuffled_ratings.skip(70_000).take(15_000)
test_ratings = shuffled_ratings.skip(85_000).take(15_000)
到目前为止，我们已经复制了基础排序教程中的内容。
但是，现有数据集并不直接适用于列表优化。列表优化要求每个用户都有一个他们评价过的电影列表，以便模型可以从该列表中的相对排序中学习。MovieLens 100K 数据集在其原始形式中，提供了单个评分实例（一个用户，一部电影，每个示例一个评分），而不是这些聚合的用户特定列表。
为了实现列表优化，我们需要重构数据集。这包括将其转换，使得每个数据点或示例代表一个单一的用户ID，以及该用户评价过的电影列表。在这些列表中，有些电影用户会自然地比其他电影评价得更高（如其评分所示）。那么，我们模型的主要目标将是学习预测与这些观察到的用户偏好相对应的物品排序。
让我们开始获取每个用户的所有电影及其相应评分的完整列表。我们删除评价过的电影数量少于 `NUM_EXAMPLES_PER_LIST` 的用户的 `user_ids`。
def get_movie_sequence_per_user(ratings, min_examples_per_list):
"""Gets movieID sequences and ratings for every user."""
sequences = collections.defaultdict(list)
for sample in ratings:
user_id = sample["user_id"]
movie_id = sample["movie_id"]
user_rating = sample["user_rating"]
sequences[int(user_id.numpy())].append(
{
"movie_id": int(movie_id.numpy()),
"user_rating": float(user_rating.numpy()),
}
)
# Remove lists with < `min_examples_per_list` number of elements.
sequences = {
user_id: sequence
for user_id, sequence in sequences.items()
if len(sequence) >= min_examples_per_list
}
return sequences
我们现在为每个用户采样50个列表用于训练数据。对于每个列表，我们从用户评价过的电影中随机采样5部电影。
def sample_sublist_from_list(
lst,
num_examples_per_list,
):
"""Random selects `num_examples_per_list` number of elements from list."""
indices = np.random.choice(
range(len(lst)),
size=num_examples_per_list,
replace=False,
)
samples = [lst[i] for i in indices]
return samples
def get_examples(
sequences,
num_list_per_user,
num_examples_per_list,
):
inputs = {
"user_id": [],
"movie_id": [],
}
labels = []
for user_id, user_list in sequences.items():
for _ in range(num_list_per_user):
sampled_list = sample_sublist_from_list(
user_list,
num_examples_per_list,
)
inputs["user_id"].append(user_id)
inputs["movie_id"].append(
tf.convert_to_tensor([f["movie_id"] for f in sampled_list])
)
labels.append(
tf.convert_to_tensor([f["user_rating"] for f in sampled_list])
)
return (
{"user_id": inputs["user_id"], "movie_id": inputs["movie_id"]},
labels,
)
train_sequences = get_movie_sequence_per_user(
ratings=train_ratings, min_examples_per_list=NUM_EXAMPLES_PER_LIST
)
train_examples = get_examples(
train_sequences,
num_list_per_user=TRAIN_NUM_LIST_PER_USER,
num_examples_per_list=NUM_EXAMPLES_PER_LIST,
)
train_ds = tf.data.Dataset.from_tensor_slices(train_examples)
val_sequences = get_movie_sequence_per_user(
ratings=val_ratings, min_examples_per_list=5
)
val_examples = get_examples(
val_sequences,
num_list_per_user=TEST_NUM_LIST_PER_USER,
num_examples_per_list=NUM_EXAMPLES_PER_LIST,
)
val_ds = tf.data.Dataset.from_tensor_slices(val_examples)
test_sequences = get_movie_sequence_per_user(
ratings=test_ratings, min_examples_per_list=5
)
test_examples = get_examples(
test_sequences,
num_list_per_user=TEST_NUM_LIST_PER_USER,
num_examples_per_list=NUM_EXAMPLES_PER_LIST,
)
test_ds = tf.data.Dataset.from_tensor_slices(test_examples)
批处理数据集并缓存它。
train_ds = train_ds.batch(BATCH_SIZE).cache()
val_ds = val_ds.batch(BATCH_SIZE).cache()
test_ds = test_ds.batch(BATCH_SIZE).cache()
构建模型
我们构建一个典型的双塔排序模型，类似于基础排序教程。我们有独立的用于用户ID和电影ID的嵌入层。获取这些嵌入后，我们将它们连接起来，并通过一个密集层网络。
唯一的区别是，对于电影ID，我们获取的是ID列表而不是单个电影ID。因此，当我们连接用户ID嵌入和电影ID嵌入时，我们将用户ID“重复” `NUM_EXAMPLES_PER_LIST` 次，以便得到与电影ID嵌入相同的形状。
class RankingModel(keras.Model):
"""Create the ranking model with the provided parameters.
Args:
num_users: Number of entries in the user embedding table.
num_candidates: Number of entries in the candidate embedding table.
embedding_dimension: Output dimension for user and movie embedding tables.
"""
def __init__(
self,
num_users,
num_candidates,
embedding_dimension=32,
**kwargs,
):
super().__init__(**kwargs)
# Embedding table for users.
self.user_embedding = keras.layers.Embedding(num_users, embedding_dimension)
# Embedding table for candidates.
self.candidate_embedding = keras.layers.Embedding(
num_candidates, embedding_dimension
)
# Predictions.
self.ratings = keras.Sequential(
[
# Learn multiple dense layers.
keras.layers.Dense(256, activation="relu"),
keras.layers.Dense(64, activation="relu"),
# Make rating predictions in the final layer.
keras.layers.Dense(1),
]
)
def build(self, input_shape):
self.user_embedding.build(input_shape["user_id"])
self.candidate_embedding.build(input_shape["movie_id"])
output_shape = self.candidate_embedding.compute_output_shape(
input_shape["movie_id"]
)
self.ratings.build(list(output_shape[:-1]) + [2 * output_shape[-1]])
def call(self, inputs):
user_id, movie_id = inputs["user_id"], inputs["movie_id"]
user_embeddings = self.user_embedding(user_id)
candidate_embeddings = self.candidate_embedding(movie_id)
list_length = ops.shape(movie_id)[-1]
user_embeddings_repeated = ops.repeat(
ops.expand_dims(user_embeddings, axis=1),
repeats=list_length,
axis=1,
)
concatenated_embeddings = ops.concatenate(
[user_embeddings_repeated, candidate_embeddings], axis=-1
)
scores = self.ratings(concatenated_embeddings)
scores = ops.squeeze(scores, axis=-1)
return scores
def compute_output_shape(self, input_shape):
return (input_shape[0], input_shape[1])
让我们实例化、编译和训练我们的模型。我们将训练两个模型：一个使用标准的均方误差，另一个使用成对铰链损失。对于后者，我们将使用keras_rs.losses.PairwiseHingeLoss。
成对损失在每个列表内的物品对进行比较，对具有更高真实标签的物品比具有较低真实标签的物品预测得分更低的案例进行惩罚。这就是为什么它们比点对损失更适合排序任务。
为了量化这些结果，我们计算nDCG。nDCG是衡量排序质量的标准，它评估系统根据相关性对物品进行排序的优劣程度，对列表顶部的相关物品给予更高的权重，并针对理想排序对分数进行归一化。为了计算它，我们只需将 `keras_rs.metrics.NDCG()` 作为指标传递给 `model.compile`。
model_mse = RankingModel(
num_users=users_count + 1,
num_candidates=movies_count + 1,
embedding_dimension=EMBEDDING_DIM,
)
model_mse.compile(
loss=keras.losses.MeanSquaredError(),
metrics=[keras_rs.metrics.NDCG(k=NUM_EXAMPLES_PER_LIST, name="ndcg")],
optimizer=keras.optimizers.Adagrad(learning_rate=LEARNING_RATE),
)
model_mse.fit(train_ds, validation_data=val_ds, epochs=EPOCHS)
Epoch 1/5
47/47 ━━━━━━━━━━━━━━━━━━━━ 6s 82ms/step - loss: 0.1209 - ndcg: 0.8871 - val_loss: 0.0782 - val_ndcg: 0.8943
Epoch 2/5
47/47 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - loss: 0.0780 - ndcg: 0.8928 - val_loss: 0.0776 - val_ndcg: 0.9020
Epoch 3/5
47/47 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - loss: 0.0774 - ndcg: 0.8975 - val_loss: 0.0770 - val_ndcg: 0.9052
Epoch 4/5
47/47 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - loss: 0.0768 - ndcg: 0.9008 - val_loss: 0.0765 - val_ndcg: 0.9089
Epoch 5/5
47/47 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - loss: 0.0762 - ndcg: 0.9043 - val_loss: 0.0756 - val_ndcg: 0.9121
<keras.src.callbacks.history.History at 0x7f0bd21e8df0>
现在，是带有成对铰链损失的模型。
model_hinge = RankingModel(
num_users=users_count + 1,
num_candidates=movies_count + 1,
embedding_dimension=EMBEDDING_DIM,
)
model_hinge.compile(
loss=keras_rs.losses.PairwiseHingeLoss(),
metrics=[keras_rs.metrics.NDCG(k=NUM_EXAMPLES_PER_LIST, name="ndcg")],
optimizer=keras.optimizers.Adagrad(learning_rate=LEARNING_RATE),
)
model_hinge.fit(train_ds, validation_data=val_ds, epochs=EPOCHS)
Epoch 1/5
47/47 ━━━━━━━━━━━━━━━━━━━━ 5s 76ms/step - loss: 1.3971 - ndcg: 0.8887 - val_loss: 1.3608 - val_ndcg: 0.8992
Epoch 2/5
47/47 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - loss: 1.3866 - ndcg: 0.9021 - val_loss: 1.2919 - val_ndcg: 0.9147
Epoch 3/5
47/47 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - loss: 1.2492 - ndcg: 0.9162 - val_loss: 1.1026 - val_ndcg: 0.9272
Epoch 4/5
47/47 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - loss: 1.0838 - ndcg: 0.9267 - val_loss: 1.0412 - val_ndcg: 0.9298
Epoch 5/5
47/47 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - loss: 1.0409 - ndcg: 0.9298 - val_loss: 1.0267 - val_ndcg: 0.9303
<keras.src.callbacks.history.History at 0x7f0b8c238490>
评估
通过比较验证nDCG值，很明显使用成对铰链损失训练的模型优于另一个模型。让我们通过比较测试集上的结果来使这一观察更加具体。
ndcg_mse = model_mse.evaluate(test_ds, return_dict=True)["ndcg"]
ndcg_hinge = model_hinge.evaluate(test_ds, return_dict=True)["ndcg"]
print(ndcg_mse, ndcg_hinge)
1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 898ms/step - loss: 1.0489 - ndcg: 0.9348
0.9109011292457581 0.9348157048225403
预测
现在，让我们对一些列表进行排序！
让我们创建一个从电影ID到电影名称的映射，以便我们可以显示排序列表的标题。
movie_id_to_movie_title = {
int(x["movie_id"]): x["movie_title"] for x in movies.as_numpy_iterator()
}
movie_id_to_movie_title[0] = "" # Because id 0 is not in the dataset.
user_id = 42
movie_ids = [409, 237, 131, 941, 543]
predictions = model_hinge.predict(
{
"user_id": keras.ops.array([user_id]),
"movie_id": keras.ops.array([movie_ids]),
}
)
predictions = keras.ops.convert_to_numpy(keras.ops.squeeze(predictions, axis=0))
sorted_indices = np.argsort(predictions)
sorted_movies = [movie_ids[i] for i in sorted_indices]
for i, movie_id in enumerate(sorted_movies):
print(f"{i + 1}. ", movie_id_to_movie_title[movie_id])
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 168ms/step
1. b'With Honors (1994)'
2. b'Mis\xc3\xa9rables, Les (1995)'
3. b'Jack (1996)'
4. b"Breakfast at Tiffany's (1961)"
5. b'Jerry Maguire (1996)'
我们都完成了！