09 · 序列推荐

  ① 顺序改变含义
     [手机 → 手机壳]   ✅ 合理，该推手机壳
     [手机壳 → 手机]   ❌ 已经有手机了，别再推手机

  ② 近期行为权重远大于远期
     一年前看了育儿书，昨天连看 5 个健身视频
     → 现在该推健身，不是育儿

  ③ 兴趣会漂移
     3个月前：婚纱、婚礼策划
     现在：  婴儿用品
     → 用户的人生阶段变了，旧兴趣要衰减

 ①  FPMC (2010)  马尔可夫链 + MF
     只看上一个物品 → 简单，但记不住长期兴趣

 ②  GRU4Rec (2016)  循环神经网络
     用 GRU 把整个序列压成一个隐状态
     ✅ 能记长期  ❌ 串行计算慢，长序列会遗忘

 ③  Caser (2018)  用 CNN 做序列
     把序列当"图片"，用卷积核捕捉局部模式
     ✅ 快  ❌ 感受野有限

 ④  SASRec (2018)  ⭐ 单向 Transformer
     自注意力：每个位置能直接看到之前所有位置
     ✅ 并行、长程依赖、可解释
     ✅ 至今仍是最强 baseline 之一

 ⑤  BERT4Rec (2019)  双向 Transformer + 完形填空
     随机遮住序列中的物品，让模型猜
     ✅ 双向上下文，表征更强
     ⚠️ 但线上是"预测下一个"，训练/推理有 gap

 ⑥  HSTU / 生成式推荐 (2024+)  ⭐ 见第 14 节
     千亿参数、超长序列、出现 Scaling Law

  输入序列:  [i₁, i₂, i₃, i₄]
                              ↓ 每个位置预测下一个
  预测目标:  [i₂, i₃, i₄, i₅]

  这叫 "next-item prediction"，和 GPT 的训练方式一模一样

      能看到谁                 位置1  位置2  位置3  位置4
   位置1 只能看自己              ✅    ❌     ❌    ❌
   位置2 能看 1,2                ✅    ✅     ❌    ❌
   位置3 能看 1,2,3              ✅    ✅     ✅    ❌
   位置4 能看 1,2,3,4            ✅    ✅     ✅    ✅

   为什么？防止「偷看未来」——预测第3个时不能看到第3个是什么

  预测下一个物品时，模型关注了：
    3天前的  机械键盘   ████████ 0.42
    1周前的  显示器     █████    0.28
    2个月前的 咖啡杯    █        0.05
    1年前的  运动鞋     ▏        0.01

  → 模型自己学会了「近期 + 同品类」的注意力模式

import torch
import torch.nn as nn
import numpy as np

class SASRec(nn.Module):
    def __init__(self, n_items, max_len=50, d=64, n_heads=2, n_blocks=2, dropout=0.2):
        super().__init__()
        self.max_len = max_len
        self.item_emb = nn.Embedding(n_items + 1, d, padding_idx=0)
        self.pos_emb  = nn.Embedding(max_len, d)       # 位置编码：告诉模型顺序
        self.dropout = nn.Dropout(dropout)

        self.blocks = nn.ModuleList([
            nn.TransformerEncoderLayer(
                d_model=d, nhead=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 forward(self, seq):
        """seq: (B, L) 物品 ID 序列，0 表示 padding"""
        B, L = seq.shape
        pos = torch.arange(L, device=seq.device).unsqueeze(0).expand(B, L)

        x = self.item_emb(seq) * (self.item_emb.embedding_dim ** 0.5)
        x = self.dropout(x + self.pos_emb(pos))

        # ⭐ 因果掩码：位置 i 不能看到 i 之后的内容
        causal = torch.triu(torch.ones(L, L, device=seq.device), diagonal=1).bool()
        pad_mask = (seq == 0)

        for blk in self.blocks:
            x = blk(x, src_mask=causal, src_key_padding_mask=pad_mask)
        return self.norm(x)                        # (B, L, d)

    def loss(self, seq, pos_items, neg_items):
        """
        seq:       (B, L)  历史序列
        pos_items: (B, L)  每个位置的真实下一个物品
        neg_items: (B, L)  随机采的负样本
        """
        h = self.forward(seq)                                 # (B, L, d)
        pos_e = self.item_emb(pos_items)
        neg_e = self.item_emb(neg_items)

        pos_logit = (h * pos_e).sum(-1)                       # (B, L)
        neg_logit = (h * neg_e).sum(-1)

        mask = (pos_items != 0).float()                       # 忽略 padding 位置
        # 二元交叉熵：正样本分数要高，负样本分数要低
        loss = -(torch.log(torch.sigmoid(pos_logit) + 1e-24) * mask
                 + torch.log(1 - torch.sigmoid(neg_logit) + 1e-24) * mask).sum()
        return loss / mask.sum()

    @torch.no_grad()
    def recommend(self, seq, k=10):
        """用最后一个位置的表示，和所有物品 Embedding 点积"""
        h = self.forward(seq)[:, -1, :]                       # (B, d)
        scores = h @ self.item_emb.weight.T                   # (B, n_items+1)
        scores[:, 0] = -np.inf                                # 屏蔽 padding
        # 屏蔽已经看过的
        scores.scatter_(1, seq, -np.inf)
        return scores.topk(k, dim=-1)


# ---- 训练数据怎么造 ----
def make_training_sample(user_seq, max_len=50):
    """
    user_seq = [3, 7, 12, 45, 9]
    →  seq = [0,...,0, 3, 7, 12, 45]   （左 padding）
       pos = [0,...,0, 7, 12, 45, 9]   （每个位置的下一个）
    """
    seq = np.zeros(max_len, dtype=np.int64)
    pos = np.zeros(max_len, dtype=np.int64)
    nxt = user_seq[-1]
    idx = max_len - 1
    for item in reversed(user_seq[:-1]):
        seq[idx], pos[idx] = item, nxt
        nxt = item
        idx -= 1
        if idx < 0: break
    return seq, pos

  用户序列: [i₁, i₂, ..., i₄₈, i₄₉, i₅₀]
                              ↑验证  ↑测试
  用前 48 个训练，i₄₉ 验证，i₅₀ 测试