🏠 总目录📚 本教程 09 · 序列推荐 ← →
📑 本页目录(点开跳转)

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 教学基线,不是作者实现的精确复刻。

它做的事

同一列:输入位置处理当前物品,输出负责预测下一物品
位置1234
输入i₁i₂i₃i₄
对应目标i₂i₃i₄i₅

看“位置 2”这一列:位置 2 已知 i₁、i₂,要预测 i₃。目标比输入向后移一项,这叫 next-item prediction。它与自回归语言模型的目标对齐方式相似,但损失和候选协议未必相同。

关键结构:因果掩码(Causal Mask)

四个都是真实物品的位置;允许 = 可作为注意力的 key
当前 querykey 1key 2key 3key 4
位置 1允许禁止禁止禁止
位置 2允许允许禁止禁止
位置 3允许允许允许禁止
位置 4允许允许允许允许

query 是“当前哪个位置在发问”,key 是“可以访问哪个历史位置”。表格的一行对应一个 query,一列对应一个 key;这里只比较位置能否互相访问。

每行只看自己及过去。这与“预测第 3 个物品时不能看 i₃”不矛盾:预测 i₃ 的是位置 2 的输出,不是位置 3 的输出。

批量输入还可能含补齐长度的 0(padding)。因果 mask 处理“未来”,padding mask 处理“不是物品的位置”,两者都需要。下面代码还会避免 padding query 一整行全被遮住的数值陷阱。

注意力权重:能看出什么,不能推出什么

训练后可以查看某层、某个头、某个 query 的注意力分布,帮助诊断模型在访问什么。以下数字完全是人为教学示意,不是原模型输出,也不是本页代码训练得到的结果。

一个假设的 attention 分布:其余历史合并展示,总和为 1
历史时间物品 / 位置集合示意权重
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。
seqtorch.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 loss2.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₁…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 个基本都是冷门”。

可精确算出的反例:目录共 1000 项,每个目标从其余 999 项均匀不放回采 100 项
评价模型 A:两次真实 rank 为 1、1000模型 B:两次真实 rank 为 20、20
全目录 HR@100.50
采样后期望 HR@100.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 原论文

✅ 检查点

  1. 序列推荐和传统推荐在「问题定义」上有什么不同?
  2. 为什么说序列推荐 ≈ 语言模型?这个类比在哪一步要停下来?
  3. SASRec 的因果掩码是干什么的?为什么当前位置可以看自己?
  4. SASRec 和 BERT4Rec 的训练方式区别?它们线上各怎样预测下一项?
  5. 长序列(10 万条历史)怎么处理?SIM 的思路是什么?
  6. 为什么「采样 100 个负样本」不能直接当作全量排序的评测?
👀 答案
  1. 一种常见传统任务是预测 (u,i) 分数;本章任务是给定有序行为历史,预测下一物品。传统推荐不只做评分,序列推荐也不只限这一种目标。

  2. 物品 ID 可类比 token,历史可类比句子;相似的是根据前缀预测后续、目标右移一项。损失、负采样、候选空间与评测不一定相同,不能说训练完全一致。

  3. 禁止位置 t 访问 t 之后的输入,避免偷看未来。位置 t 的输出预测 t+1,所以可看当前物品;padding 的处理还要单独保证数值有效。

  4. SASRec 思路按位置预测下一项,BERT4Rec 用双向上下文填空。前者目标对齐更直接;后者测试在历史末尾加 [MASK],原论文也用只遮末项的训练情形缓解差异。它不要求拿到未来点击,效果需公平实验比较。

  5. 可截断、长短期分离或筛选相关历史。SIM 先相对当前候选物品检索相关历史(GSU),再对小子集细建模(ESU)。线性注意力是另一类方法;HSTU 有工程优化但仍保留二次交互项,不能混成同一种方法。

  6. 缩小候选池会改变排名分布,即使物品同等热门也可能使指标虚高、模型优劣反转。优先按合法全目录评测,真物品只计一次,并交代过滤和时间协议;全量本身也不能自动消除曝光偏差。


本节回顾

⚡ 走神救援

先记住这几件事

  • 序列推荐利用行为顺序预测后续选择,不只是汇总用户点过什么。
  • 因果掩码让训练位置只能使用过去和当前位置的信息,与下一项预测对应。
  • 行为类型、时间间隔和会话长度要分开考虑,并保持评测口径公平。

下一节 👉 10 · 向量检索与 ANN

打卡记录保存在你的浏览器里,首页能看到总进度