09 · 序列推荐
推荐算法 / 09
同一组行为,换个顺序会多出什么线索?
沿原顺序例子、因果掩码和可独立运行教学代码阅读,保留原概览与保存入口。
能区分顺序线索、下一项任务与评测边界;一步训练不等于有效推荐。
⏱ 主线阅读约 25 分钟 | ⭐ 核心;动手检查另留时间
🎯 一句话
「你看东西的顺序,本身就是信息。」本章把用户近期的行为按发生顺序排好,再预测下一个可能交互的物品。
先看三个例子和因果掩码;想动手时直接去可独立运行的教学代码。代码只检查接口与数值,不承诺训练一步就会推荐得好。
🧠 顺序多提供了什么线索
顺序、时间和行为类型都是线索,不是可以直接下结论的事实。下面的箭头表示已经发生的浏览顺序;待预测的是序列之后的物品。
① 同一组物品,最后正在看的东西不同
| 已发生的浏览 | 多保留了什么线索 | 不能据此断言 |
|---|---|---|
| 手机 → 手机壳 | 最近一次在看配件,可能影响下一件物品的概率。 | 不能确定已经买了手机,也不能把已出现在历史里的手机壳再当成已知正确答案。 |
| 手机壳 → 手机 | 最近一次在看整机,与上一行的上下文不同。 | 不能直接判“顺序不合理”或“已经有手机,绝不能再推手机”。 |
看这个对照:序列模型能区分这两条历史;是否应该推荐配件、整机或别的物品,仍要从所定义的行为数据中学习。
② 昨天的行为可能比一年前更能反映当前需求
一年前看了育儿书,昨天连续看了 5 个健身视频。近期健身行为可能是强信号,但不代表育儿兴趣已经消失,也没有“近期权重永远远大于远期”的规则。
下一步要看:这是偶尔点开,还是持续观看?历史是点击、购买还是收藏?这些条件会改变结论。
③ 兴趣会变,但浏览不等于人生事实
| 时间 | 浏览主题 | 可考虑的建模线索 |
|---|---|---|
| 3 个月前 | 婚纱、婚礼策划 | 较早的主题偏好。 |
| 现在 | 婴儿用品 | 当前浏览主题发生变化,旧行为可能需要不同权重。 |
看这个对照:可以学习兴趣随时间变化;不能仅凭这段浏览就认定用户结婚、生育或进入了某个人生阶段。
基础的、没有显式加入时间和顺序的协同过滤(CF)或矩阵分解(MF) 通常只利用用户—物品交互信息,无法区分上面那两条相同物品集合的排列。加上时间或序列机制的扩展版本不在这个限定里。
🔄 换一个问题定义
| 比较什么 | 基础打分任务 | 本章的下一物品任务 |
|---|---|---|
| 问题 | 用户 u 对物品 i 的分数是多少? | 给定 [i₁, i₂, …, iₜ],下一个可能交互的是谁? |
| 典型输入 | (user, item, rating) 或隐式交互 | 按发生时间排列的用户行为历史 |
| 容易理解的类比 | 对候选打分 | 像语言模型一样,根据前缀预测后续符号 |
🔑 把物品 ID 类比成 token、把行为历史类比成句子,可以帮助理解“下一项预测”。相似的是目标对齐方式,不是所有训练细节。
例如原 SASRec 和本页代码使用正、负物品的二元分类损失;常见语言模型通常做词表上的分类交叉熵。候选空间、负采样与评测协议也可能不同。这个类比是理解生成式推荐的一条入口,后续可去第 14 节,但不要写成“推荐等于语言模型”。
📜 演进:从马尔可夫链到 Transformer
先看每种方法用什么表示历史,再看它的适用边界。年代顺序不是“后一种在所有任务上淘汰前一种”。
| 模型 | 怎样使用历史 | 要保留的边界 |
|---|---|---|
| FPMC(2010) | 一阶马尔可夫转移 + MF 用户偏好。 | 单项序列中,转移项关注上一物品;原论文的购物篮场景会汇总上一篮物品。MF 项仍保留一般/长期用户偏好,不能说整个模型“记不住长期兴趣”。原论文 |
| GRU4Rec(2016) | 用 GRU 状态逐步累计当前会话的信息。 | 原任务是会话推荐;递归计算有顺序依赖,状态也不保证可靠记住任意长的历史。原论文 |
| Caser(2018) | 把一段历史的 embedding 排成矩阵,用卷积提取序列模式。 | 使用给定的历史窗口;不同卷积方向捕捉不同组合,不能只用“快、感受野小”概括所有设置。原论文 |
| SASRec(2018)⭐ | 因果自注意力:一个有效位置可直接连接窗口内更早的有效位置。 | 可并行计算训练位置、访问长距离信息;不保证任意长序列效果,也不自动提供因果解释。值得认真调优的常用基线。原论文 |
| BERT4Rec(2019) | 训练时随机遮住物品,用双向上下文填空。 | 测试时在历史末尾添加 [MASK] 预测下一物品,不要求线上拿到未来行为。原论文 |
| HSTU / 生成式推荐(2024+) | 面向大规模生成式推荐的序列变换与工程优化。 | 论文研究长序列和模型扩展;大规模总参数包含 embedding。HSTU 不等于线性注意力,也不是所有生成式推荐的同义词。原论文 |
HSTU 的参数扩展,要连同统计口径看:上述论文报告到 1.5 万亿总参数,其中包含 embedding 参数,不能理解成 1.5 万亿个非 embedding 网络参数。
论文还在其工业数据、适当超参数和跨三个数量级的训练计算范围内,观察到指标随计算量变化的经验幂律(Scaling Law)。这是有实验条件的扩展趋势,不是“所有推荐任务只要堆参数就会变好”的保证。原论文 §4.3.1
现在只需读懂下一节 SASRec 的“一个位置预测下一项”。其他模型保留为比较与后续选择的入口。
⭐ SASRec:先看懂下一项预测
SASRec = Self-Attentive Sequential Recommendation。这里先讲它的核心思路;后面的 PyTorch 代码是 SASRec-like 教学基线,不是作者实现的精确复刻。
它做的事
| 位置 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 输入 | i₁ | i₂ | i₃ | i₄ |
| 对应目标 | i₂ | i₃ | i₄ | i₅ |
看“位置 2”这一列:位置 2 已知 i₁、i₂,要预测 i₃。目标比输入向后移一项,这叫 next-item prediction。它与自回归语言模型的目标对齐方式相似,但损失和候选协议未必相同。
关键结构:因果掩码(Causal Mask)
| 当前 query | key 1 | key 2 | key 3 | key 4 |
|---|---|---|---|---|
| 位置 1 | 允许 | 禁止 | 禁止 | 禁止 |
| 位置 2 | 允许 | 允许 | 禁止 | 禁止 |
| 位置 3 | 允许 | 允许 | 允许 | 禁止 |
| 位置 4 | 允许 | 允许 | 允许 | 允许 |
query 是“当前哪个位置在发问”,key 是“可以访问哪个历史位置”。表格的一行对应一个 query,一列对应一个 key;这里只比较位置能否互相访问。
每行只看自己及过去。这与“预测第 3 个物品时不能看 i₃”不矛盾:预测 i₃ 的是位置 2 的输出,不是位置 3 的输出。
批量输入还可能含补齐长度的 0(padding)。因果 mask 处理“未来”,padding mask 处理“不是物品的位置”,两者都需要。下面代码还会避免 padding query 一整行全被遮住的数值陷阱。
注意力权重:能看出什么,不能推出什么
训练后可以查看某层、某个头、某个 query 的注意力分布,帮助诊断模型在访问什么。以下数字完全是人为教学示意,不是原模型输出,也不是本页代码训练得到的结果。
| 历史时间 | 物品 / 位置集合 | 示意权重 |
|---|---|---|
| 3 天前 | 机械键盘 | 0.42 |
| 1 周前 | 显示器 | 0.28 |
| 2 个月前 | 咖啡杯 | 0.05 |
| 1 年前 | 运动鞋 | 0.01 |
| 其他时间 | 其余未列出的历史位置合计 | 0.24 |
| 全部有效历史位置 | 1.00 | |
看数值只能说:如果某个头出现这样的分布,它给键盘和显示器较大权重。不能从人为示意推出“模型已经学会近期 + 同品类”,也不能把 attention 权重直接当成推荐原因。
一个小反例:两个 value 都是 [2, 1] 时,权重 [0.99, 0.01] 与 [0.01, 0.99] 得到同一个加权输出 [2, 1]。还需看 value、其他头和后续网络。相关边界可读注意力解释研究;那项研究并非本页 SASRec 的专属实验。
🔨 核心实现与最小运行检查
复制下面整块代码即可跑一个 CPU 小例子:构造样本、训练一步、显式切到 eval 推理,再检查因果性、候选不足和错误输入。需要 Python、NumPy 和 PyTorch;不下载数据或模型。
原作者代码可在 SASRec 仓库对照。本例保留“物品与位置 embedding → 因果 Transformer → 点积打分”的思路,使用通用 TransformerEncoderLayer;层结构、训练数据、超参和训练预算不构成论文复现。
| 输入 / 输出 | 本例约定 |
|---|---|
| 物品 ID | 真实物品为 1…n_items;0 只用于模型输入的左 padding。原始 history 不含 0。 |
| seq | torch.long,形状 (B, L),1 ≤ L ≤ max_len;每行至少一个真实物品,最后位置必须真实。 |
| 训练样本 | 原始训练历史至少有两个有效 ID;pos 与 seq 对齐,0 目标不参加 loss。依据训练期已知历史排除已见物品,再从剩余目录采负项,不使用验证或测试反馈。 |
| recommend | 先调用 model.eval()。返回每用户的 (scores, IDs) 列表,允许不同用户返回不同数量。 |
本例按“排除已见物品”策略推荐:默认只知道传入的窗口;可用 seen_histories 补充窗口外的完整已见历史。重复消费任务不一定采用这个策略,训练和评测要另行保持一致。
左 padding 的坑:早期 padding query 的过去全是 padding,未来真实 key 又被因果 mask 禁止,可能形成全 masked 行并产生 NaN。这里让 padding query 仅看自身 dummy 项,随后把 padding 输出清零;有效 query 仍不能看未来或 padding key,也没有全局关闭 fastpath。
"""SASRec-like 教学基线:仅做 CPU 一步训练与边界检查,不复现论文准确率。"""
import numbers
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
def positive_int(value, name):
if isinstance(value, bool) or not isinstance(value, numbers.Integral) or value < 1:
raise ValueError(f"{name} must be a positive integer")
return int(value)
def checked_history(items, n_items, min_len=1):
history = list(items)
if len(history) < min_len:
raise ValueError(f"history needs at least {min_len} valid item(s)")
if any(isinstance(i, bool) or not isinstance(i, numbers.Integral)
or not 1 <= i <= n_items for i in history):
raise ValueError("history IDs must be integers in 1..n_items; no padding here")
return [int(i) for i in history]
class SASRec(nn.Module):
"""物品+位置 embedding、因果 Transformer、点积打分;不是作者实现的精确复刻。"""
def __init__(self, n_items, max_len=50, d=64, n_heads=2, n_blocks=2, dropout=0.2):
super().__init__()
self.n_items = positive_int(n_items, "n_items")
self.max_len = positive_int(max_len, "max_len")
d = positive_int(d, "d")
self.n_heads = positive_int(n_heads, "n_heads")
n_blocks = positive_int(n_blocks, "n_blocks")
if d % self.n_heads:
raise ValueError("d must be divisible by n_heads")
self.item_emb = nn.Embedding(self.n_items + 1, d, padding_idx=0)
self.pos_emb = nn.Embedding(self.max_len, d)
self.dropout = nn.Dropout(dropout)
self.blocks = nn.ModuleList([
nn.TransformerEncoderLayer(
d_model=d, nhead=self.n_heads, dim_feedforward=d * 4,
dropout=dropout, batch_first=True, norm_first=True)
for _ in range(n_blocks)
])
self.norm = nn.LayerNorm(d)
def _check_seq(self, seq):
if not isinstance(seq, torch.Tensor) or seq.dtype != torch.long or seq.ndim != 2:
raise ValueError("seq must be a torch.long tensor shaped (B, L)")
if seq.shape[0] < 1 or not 1 <= seq.shape[1] <= self.max_len:
raise ValueError("require B >= 1 and 1 <= L <= max_len")
if seq.device != self.item_emb.weight.device:
raise ValueError("seq and model must be on the same device")
if ((seq < 0) | (seq > self.n_items)).any():
raise ValueError("seq IDs must be in 0..n_items")
if not seq.ne(0).any(dim=1).all():
raise ValueError("each row needs a real item; cold start needs another policy")
if (seq[:, :-1].ne(0) & seq[:, 1:].eq(0)).any():
raise ValueError("use left padding only; the final position must be real")
def forward(self, seq):
self._check_seq(seq)
batch, length = seq.shape
pad = seq.eq(0)
positions = torch.arange(length, device=seq.device).expand(batch, length)
x = self.item_emb(seq) * self.item_emb.embedding_dim ** 0.5
x = self.dropout(x + self.pos_emb(positions))
x = x.masked_fill(pad.unsqueeze(-1), 0)
# 有效 query:仅看过去和当前位置的有效 key。
future = torch.triu(torch.ones(length, length, device=seq.device,
dtype=torch.bool), diagonal=1)
blocked = future.unsqueeze(0) | pad.unsqueeze(1)
# padding query:只看自身 dummy 项,避免全 masked 行;其输出随后丢弃。
self_only = ~torch.eye(length, device=seq.device, dtype=torch.bool).unsqueeze(0)
blocked = torch.where(pad.unsqueeze(-1), self_only, blocked)
mask = blocked.repeat_interleave(self.n_heads, dim=0)
for block in self.blocks:
x = block(x, src_mask=mask)
x = x.masked_fill(pad.unsqueeze(-1), 0)
return self.norm(x).masked_fill(pad.unsqueeze(-1), 0) # (B, L, d)
def loss(self, seq, pos_items, neg_items):
self._check_seq(seq)
for targets in (pos_items, neg_items):
if (not isinstance(targets, torch.Tensor) or targets.dtype != torch.long
or targets.shape != seq.shape or targets.device != seq.device):
raise ValueError("targets must match seq shape/device and use torch.long")
if ((targets < 0) | (targets > self.n_items)).any():
raise ValueError("target IDs must be in 0..n_items")
valid = pos_items.ne(0)
if not valid.any():
raise ValueError("no valid next-item targets in this batch")
if (valid & seq.eq(0)).any():
raise ValueError("a padding query cannot carry a target")
if (valid & (neg_items.eq(0) | neg_items.eq(pos_items))).any():
raise ValueError("valid negatives must be real items, different from positives")
h = self(seq)
pos_logits = (h * self.item_emb(pos_items)).sum(-1)[valid]
neg_logits = (h * self.item_emb(neg_items)).sum(-1)[valid]
# 先索引有效位置,再用稳定 logits loss;等价于两项之和/有效目标数。
return (F.binary_cross_entropy_with_logits(pos_logits, torch.ones_like(pos_logits))
+ F.binary_cross_entropy_with_logits(neg_logits, torch.zeros_like(neg_logits)))
@torch.no_grad()
def recommend(self, seq, k=10, seen_histories=None):
"""返回每用户的 (scores, IDs) 列表;不足 k 少返回,无候选返回空 tensor。
默认排除 seq 窗口;seen_histories 可补充窗口之外的完整已见历史。
这是“排除已见”的教学策略,重复消费任务要另定过滤协议。
"""
if self.training:
raise RuntimeError("call model.eval() before recommend(); no_grad is not eval")
if isinstance(k, bool) or not isinstance(k, numbers.Integral) or k < 0:
raise ValueError("k must be a nonnegative integer")
h = self(seq)[:, -1, :]
if not torch.isfinite(h).all():
raise FloatingPointError("nonfinite hidden state; inspect model/input numerics")
scores = h @ self.item_emb.weight.T
if not torch.isfinite(scores).all():
raise FloatingPointError("nonfinite raw scores; this is not candidate exhaustion")
scores[:, 0] = -torch.inf
if seen_histories is not None and len(seen_histories) != len(seq):
raise ValueError("seen_histories needs one history per user")
result = []
for row in range(len(seq)):
seen = set(seq[row].tolist()) - {0}
if seen_histories is not None:
seen.update(checked_history(seen_histories[row], self.n_items, min_len=0))
if seen:
scores[row, list(seen)] = -torch.inf
allowed = torch.nonzero(torch.isfinite(scores[row]), as_tuple=True)[0]
count = min(int(k), allowed.numel())
if count == 0:
result.append((scores[row, :0], allowed[:0]))
continue
values, order = scores[row, allowed].topk(count)
result.append((values, allowed[order]))
return result
def make_training_sample(user_seq, max_len=50, *, n_items):
"""历史至少两个有效 ID;左 padding,pos 是每个有效位置的下一物品。"""
n_items = positive_int(n_items, "n_items")
max_len = positive_int(max_len, "max_len")
history = checked_history(user_seq, n_items, min_len=2)
seq = np.zeros(max_len, dtype=np.int64)
pos = np.zeros(max_len, dtype=np.int64)
kept = min(max_len, len(history) - 1)
seq[-kept:] = history[-kept - 1:-1]
pos[-kept:] = history[-kept:]
return seq, pos
def sample_negatives(pos, history, n_items, rng):
"""单个用户,均匀有放回抽负项;排除提供的完整训练历史与 padding。"""
n_items = positive_int(n_items, "n_items")
known = set(checked_history(history, n_items, min_len=2))
pos = np.asarray(pos)
if pos.ndim != 1 or pos.dtype.kind not in "iu" or ((pos < 0) | (pos > n_items)).any():
raise ValueError("pos must be a 1D integer array in 0..n_items")
valid = pos != 0
if not valid.any() or not set(pos[valid].tolist()).issubset(known):
raise ValueError("valid positive targets must belong to the training history")
pool = np.array([i for i in range(1, n_items + 1) if i not in known], dtype=np.int64)
if pool.size == 0:
raise ValueError("no unobserved item available for this negative-sampling policy")
neg = np.zeros_like(pos, dtype=np.int64)
neg[valid] = rng.choice(pool, size=int(valid.sum()), replace=True)
return neg
def demo():
torch.set_num_threads(1)
torch.manual_seed(20260911)
rng = np.random.default_rng(20260911)
histories = [[3, 7, 12, 45, 9], [5, 3, 7]]
samples = [make_training_sample(h, max_len=6, n_items=50) for h in histories]
seq = torch.from_numpy(np.stack([s for s, _ in samples]))
pos = torch.from_numpy(np.stack([p for _, p in samples]))
neg = torch.from_numpy(np.stack([
sample_negatives(p, h, 50, rng) for (_, p), h in zip(samples, histories)]))
assert seq[0].tolist() == [0, 0, 3, 7, 12, 45]
assert pos[0].tolist() == [0, 0, 7, 12, 45, 9]
model = SASRec(50, max_len=6, d=8, n_heads=2, n_blocks=2)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
model.train()
optimizer.zero_grad()
loss = model.loss(seq, pos, neg)
assert torch.isfinite(loss)
loss.backward()
assert all(torch.isfinite(p.grad).all() for p in model.parameters() if p.grad is not None)
optimizer.step()
model.eval()
# 现在把完整 toy 历史当成已知前缀,预测它之后的物品,不评估准确率。
infer = torch.zeros((2, 6), dtype=torch.long)
for row, history in enumerate(histories):
infer[row, -len(history):] = torch.tensor(history)
recommendations = model.recommend(infer, k=3, seen_histories=histories)
assert all(len(ids) == 3 and torch.isfinite(scores).all()
for scores, ids in recommendations)
assert all(not set(ids.tolist()) & set(h)
for (_, ids), h in zip(recommendations, histories))
# 改未来两项,较早有效 query 的输出应保持不变。
a = torch.tensor([[0, 0, 3, 7, 12, 45]])
b = torch.tensor([[0, 0, 3, 7, 20, 21]])
with torch.no_grad():
ya, yb = model(a), model(b)
assert torch.isfinite(ya).all() and (ya[a == 0] == 0).all()
prefix_error = float((ya[:, 2:4] - yb[:, 2:4]).abs().max())
assert prefix_error < 1e-6
tiny = SASRec(3, max_len=3, d=8, n_heads=2, n_blocks=2).eval()
fewer = tiny.recommend(torch.tensor([[0, 1, 2]]), k=10)[0][1]
empty = tiny.recommend(torch.tensor([[1, 2, 3]]), k=10)[0][1]
assert fewer.tolist() == [3] and empty.numel() == 0
rejected = 0
bad_calls = [
lambda: make_training_sample([3], max_len=6, n_items=50),
lambda: make_training_sample([0, 3], max_len=6, n_items=50),
lambda: make_training_sample([1, 2], max_len=0, n_items=50),
lambda: model(torch.tensor([[1, 2, 0]])), # 右 padding
lambda: model.loss(seq, torch.zeros_like(pos), neg),
lambda: sample_negatives(np.array([2, 3]), [1, 2, 3], 3, rng),
lambda: tiny.train().recommend(torch.tensor([[0, 1, 2]])),
]
for call in bad_calls:
try:
call()
except (ValueError, RuntimeError):
rejected += 1
assert rejected == len(bad_calls)
print("torch:", torch.__version__)
print("seq[0]:", seq[0].tolist())
print("pos[0]:", pos[0].tolist())
print("training loss:", round(float(loss.detach()), 6), "; gradients finite")
print("recommendation counts:", [len(ids) for _, ids in recommendations])
print("causal prefix error:", prefix_error)
print("candidate boundary counts:", fewer.numel(), empty.numel())
print("expected invalid inputs rejected:", rejected)
if __name__ == "__main__":
demo()
这份代码在 Python 3.12.14 / NumPy 2.3.5 / PyTorch 2.14.0+cpu 上的实际输出:浮点末位可能随版本和内核变化,下面的形状、有限性和边界断言才是检查目标。
| 观察项 | 实际结果 | 说明什么 |
|---|---|---|
| 第一行 seq / pos | [0, 0, 3, 7, 12, 45] [0, 0, 7, 12, 45, 9] | 左 padding 与下一项对齐正确。 |
| training loss | 2.734558;梯度全部有限 | 前向/反向/更新走通;没有证明准确率提高。 |
| 每用户推荐数量 | [3, 3] | 两个用户都有至少 3 个有限、允许候选。 |
| 改变未来后的前缀误差 | 0.0 | 本测试的早期有效输出没有偷看未来。 |
| 候选不足 / 耗尽 | 返回 1 / 0 个 | 不把 -inf 的 padding 或已见项硬塞进 top-k。 |
| 预期非法输入 | 7 / 7 被拒绝 | 包含短历史、非法 ID、错误长度、右 padding、空目标、空负项池和忘记 eval。 |
如果要继续做真正项目,还需要训练/验证/测试划分、批量数据管线、验证选参、多轮训练和评测。这里的随机负项也不代表用户真实讨厌这些物品,只是给定训练损失下的采样对象。
🎭 BERT4Rec:另一条路(了解即可)
两者训练目标不同,但都可以用已知历史预测下一物品。不要把“双向”理解为线上必须取得未来点击。
| 维度 | SASRec 思路 | BERT4Rec 思路 |
|---|---|---|
| 训练方式 | 每个位置预测下一项。 | 随机遮住物品,用其他未遮位置填空。 |
| 训练上下文 | 当前位置与更早位置,不可见未来。 | 被遮位置左右的可用上下文。 |
| 预测下一项 | 用历史末位的表示打分,目标对齐较直接。 | 历史末尾加 [MASK],预测这个新位置;原论文也包含仅遮最后一项的训练情形。 |
| 如何比较效果 | 统一数据切分、候选集、过滤、损失选择与训练预算,再看验证/测试结果;不能只由单向或双向推出谁更好。 | |
BERT4Rec 原论文 §3.6说明了末尾 [MASK] 推理和缓解训练/推理差异的做法。SASRec 的 next-item 目标更直接,但也有训练负采样与推理候选空间等差异,不能说所有环节都与线上完全一致。
⚠️ 值得保留的行业教训:不要只看论文中的 SOTA 标签,要认真训练和比较基线。
例如,2022 年 BERT4Rec 复现研究强调充分训练的重要性;2023 年 SASRec/BERT4Rec 比较研究统一损失、增加负样本等改变后,在其数据上得到 SASRec 优势。这些结论有各自实验条件,不是“普通调参后 SASRec 永远反超”。
🕐 序列推荐的四个实战难题
① 长序列怎么办?
用户可能有 10 万条历史。普通 dense attention 的位置两两交互项随 L² 增长;完整层还包含投影、前馈等计算,因此“Transformer 是 O(L²)”通常省略了固定宽度等条件。
| 方案 | 做法 | 代价 / 边界 |
|---|---|---|
| 截断 | 例如只输入最近 50–200 条。 | 简单,但更早的原始行为不在窗口里;范围需验证,不是通用最佳值,也不等于模型毫无长期偏好。 |
| SIM(阿里) | 相对当前候选物品,先用类目/向量筛相关历史(GSU),再对小子集精细建模(ESU)。 | 原任务是 CTR 预测;它依赖当前候选,不是一个无需候选的通用用户向量召回器。原论文 |
| 长短期分离 | 长期历史池化/聚类成若干表示,短期保留细节。 | 压缩有信息损失,需比较下游任务效果。 |
| 线性注意力 | 采用不同的注意力形式,改变成对计算的组织。 | 不是只切换一个参数便与原 dense attention 完全等价,效果和具体复杂度取决于方法。 |
| HSTU | 结合大规模生成式建模与 ragged 数据、融合内核、长度策略等工程设计。 | 原论文仍有 O(N²d + Nd²) 的交互/投影项,不能归为“所有交互都线性”。更大规模总参数也包含 embedding。原论文 §2.3/§3.2,后续见第 14 节。 |
② 多行为怎么融合?
点击、加购、购买、收藏表示的行为不同。可以给每条行为加 behavior type embedding,或分别建序列后再融合。先定义本次目标是下一次点击还是下一次购买,才能决定标签和损失。
③ 时间间隔要不要建模?
连续 3 次点击,间隔 5 秒与间隔 3 天,可能对应不同节奏。相同物品序列不一定代表相同意图。
TiSASRec把交互之间的时间间隔纳入注意力,也考虑位置。简单的“距今时长分桶” embedding 可以作为工程特征,但不等价于每对交互之间的时间间隔。可对照作者实现说明。
④ 会话推荐 vs 长期推荐
匿名游客或新会话可能只有几个点击,没有完整用户长期历史。Session-based Recommendation就是根据当前会话预测后续行为;GRU4Rec、SR-GNN都是这一场景的代表。
“当前会话的整体偏好”不等于“已经观察到用户多年偏好”;有稳定用户 ID 与长期日志时,可以再考虑跨会话信息。
📏 序列推荐的评测(⚠️ 有大坑)
先定预测时刻、可用历史和候选集,再讨论指标。逐用户 Leave-One-Out(留末项)是常见研究协议,不是天然无泄漏的唯一标准。
| 阶段 | 可用历史 / 数据 | 本阶段目标 |
|---|---|---|
| 训练 | i₁…i₄₈ | 只在训练部分构造样本并更新参数。 |
| 验证 | 历史 i₁…i₄₈ | 预测 i₄₉,用验证结果选超参。 |
| 测试 | 历史可以包含已经发生的 i₄₉ | 预测 i₅₀;测试反馈不得用于选参。 |
读表结论:i₄₉ 到测试时已经是过去,可以作为测试前缀;“能作为输入历史”和“能拿来调参或泄漏测试标签”是两件事。
还要检查跨用户的全局时间。假设 A 的行为发生在时刻 [1,2,3,4],B 在 [10,11,12,13];各自留末两项后,共享训练集含 B 的 10、11,已经晚于 A 的测试时刻 4。逐用户顺序正确,也可能使用预测时本不该知道的未来日志。实际部署评测应按可用时间设计切分与物品目录。时间泄漏研究
| 指标 | 单个测试样本怎样算 | 小例子 |
|---|---|---|
| HR@K | 真实物品进入前 K 为 1,否则为 0;再对样本求平均。 | K=10,真物品第 3 名:1;第 11 名:0。 |
| NDCG@K | 命中时按位置折扣;单个真物品第 r 名时为 1/log₂(r+1),超出 K 为 0。 | K=10,第 3 名为 1/log₂4=0.5;第 1 名为 1。 |
🚨 抽样候选排名不等于全量排名
常见做法是给每个真实目标再采 100 个未交互物品,只在这个小候选集里看能否进入前 10。它评的是“小候选集上的排名”,不能直接当成全目录排名。
问题不只是负项可能冷门,而是候选池本身变了。即使物品同等热门,真实目标前面的竞争者大多没被采到,也可能造成指标虚高和模型相对排名反转。采样方式还可能是均匀或按流行度,不能一概说“100 个基本都是冷门”。
| 评价 | 模型 A:两次真实 rank 为 1、1000 | 模型 B:两次真实 rank 为 20、20 |
|---|---|---|
| 全目录 HR@10 | 0.5 | 0 |
| 采样后期望 HR@10 | 0.5 | 约 0.999997 |
这是对抽样分布求期望的构造例,不是某个训练模型的效果。模型 A 原本更好,小候选集却几乎总让模型 B 命中。Krichene & Rendle(KDD 2020)讨论了这种比较不一致性。
📌 能全量排就优先全量排,并说清协议。全量指预测时允许的候选目录,真实物品只计一次;已见物品、重复消费、上市时间等过滤要保持一致。
全量候选不能自动解决曝光偏差或时间泄漏。确实只能采样时,应报告方案、数量及局限,不能把采样指标当成可直接比较的全量成绩。未交互也不等于用户一定不喜欢。
🔗 这一章连到哪里
| 去哪 | 为什么 |
|---|---|
| ML基础 13 | 理解 GRU4Rec 的循环状态,再比较循环网络与自注意力在串行依赖、历史访问和计算上的取舍;不是所有任务上彻底取代的关系。 |
| 全景导论 02 | 理解位置编码、因果掩码与自注意力。SASRec-like 代码用了这些部件,但推荐损失不必等于语言模型损失。 |
| 上线之后 02 | 继续区分候选抽样与旧策略曝光日志的偏差。探索流量可以帮助收集评估数据,但“留 1%”本身不保证无偏:仍需动作支持、日志策略、选择概率及合适估计方法。无偏离线评估原研究 |
| 12 · 评估与 AB 实验 | 把本章的负采样问题与随机切分、曝光偏差、位置偏差、总体指标掩盖差异一起检查,再学习 AB 实验。 |
| Kaggle 18 · 多兴趣召回 | 本章用一个末位向量打分;一个向量并非数学上等于取平均。MIND / ComiRec用多个兴趣向量组织匹配,可进一步比较表达能力、检索方式与成本。MIND 原论文 |
✅ 检查点
- 序列推荐和传统推荐在「问题定义」上有什么不同?
- 为什么说序列推荐 ≈ 语言模型?这个类比在哪一步要停下来?
- SASRec 的因果掩码是干什么的?为什么当前位置可以看自己?
- SASRec 和 BERT4Rec 的训练方式区别?它们线上各怎样预测下一项?
- 长序列(10 万条历史)怎么处理?SIM 的思路是什么?
- 为什么「采样 100 个负样本」不能直接当作全量排序的评测?
👀 答案
一种常见传统任务是预测 (u,i) 分数;本章任务是给定有序行为历史,预测下一物品。传统推荐不只做评分,序列推荐也不只限这一种目标。
物品 ID 可类比 token,历史可类比句子;相似的是根据前缀预测后续、目标右移一项。损失、负采样、候选空间与评测不一定相同,不能说训练完全一致。
禁止位置 t 访问 t 之后的输入,避免偷看未来。位置 t 的输出预测 t+1,所以可看当前物品;padding 的处理还要单独保证数值有效。
SASRec 思路按位置预测下一项,BERT4Rec 用双向上下文填空。前者目标对齐更直接;后者测试在历史末尾加 [MASK],原论文也用只遮末项的训练情形缓解差异。它不要求拿到未来点击,效果需公平实验比较。
可截断、长短期分离或筛选相关历史。SIM 先相对当前候选物品检索相关历史(GSU),再对小子集细建模(ESU)。线性注意力是另一类方法;HSTU 有工程优化但仍保留二次交互项,不能混成同一种方法。
缩小候选池会改变排名分布,即使物品同等热门也可能使指标虚高、模型优劣反转。优先按合法全目录评测,真物品只计一次,并交代过滤和时间协议;全量本身也不能自动消除曝光偏差。
本节回顾
⚡ 走神救援
先记住这几件事
- 序列推荐利用行为顺序预测后续选择,不只是汇总用户点过什么。
- 因果掩码让训练位置只能使用过去和当前位置的信息,与下一项预测对应。
- 行为类型、时间间隔和会话长度要分开考虑,并保持评测口径公平。
下一节 👉 10 · 向量检索与 ANN