挑战项目 A · 新闻推荐：时效性生死时速

   电影推荐：《肖申克的救赎》三十年后还在被推荐
   商品推荐：一件 T 恤能卖一整季
   新闻推荐：一条新闻 24 小时后就是废纸 💀

   这意味着：
   ① 物品冷启动不是"边缘情况"，是"每时每刻的常态"
      —— 每天几万条新新闻，全都没有历史行为
   ② ID Embedding 几乎没用
      —— 等你学好一条新闻的 Embedding，它已经过期了
   ③ 内容理解（文本）成了主战场
   ④ 时间衰减必须显式建模

   这解决了教程里反复强调的一个问题：
   ✅ 真实的"曝光未点击"负样本（第 3 节：不用自己瞎猜负样本）
   ✅ 评估无需负采样（第 9 节：在真实曝光列表上排序即可）

news.tsv:       新闻ID, 类目, 子类目, 标题, 摘要, 实体...
behaviors.tsv:  曝光ID, 用户ID, 时间, 点击历史, 曝光列表
                                              ↑
                     "N4531-1 N7098-0 N2134-0" = 展示了3条，点了第1条

import numpy as np

def evaluate_impression(labels, scores):
    """labels: [1,0,0,1,...] 该次曝光的真实点击；scores: 模型打分"""
    order = np.argsort(-np.asarray(scores))
    y = np.asarray(labels)[order]

    # AUC（该 impression 内）
    n_pos, n_neg = y.sum(), (1 - y).sum()
    if n_pos == 0 or n_neg == 0:
        return None
    rank_sum = np.where(y == 1)[0].sum()
    auc = 1 - rank_sum / (n_pos * n_neg) + (n_pos - 1) / (2 * n_neg)

    mrr = 1.0 / (np.where(y == 1)[0][0] + 1)

    def ndcg(k):
        dcg = (y[:k] / np.log2(np.arange(2, min(k, len(y)) + 2))).sum()
        ideal = np.sort(y)[::-1]
        idcg = (ideal[:k] / np.log2(np.arange(2, min(k, len(y)) + 2))).sum()
        return dcg / idcg if idcg > 0 else 0.0

    return {"auc": auc, "mrr": mrr, "ndcg5": ndcg(5), "ndcg10": ndcg(10)}

import torch, torch.nn as nn

class AttnPool(nn.Module):
    """注意力池化：一组向量 → 一个向量（学到"哪些词/哪些历史更重要"）"""
    def __init__(self, d, hidden=128):
        super().__init__()
        self.proj = nn.Sequential(nn.Linear(d, hidden), nn.Tanh(), nn.Linear(hidden, 1))
    def forward(self, x, mask=None):                    # x: (B, L, D)
        w = self.proj(x).squeeze(-1)                    # (B, L)
        if mask is not None:
            w = w.masked_fill(mask == 0, -1e9)
        w = torch.softmax(w, dim=-1)
        return torch.bmm(w.unsqueeze(1), x).squeeze(1)  # (B, D)

class NewsEncoder(nn.Module):
    """标题词序列 → 新闻向量"""
    def __init__(self, vocab, d=128, heads=8):
        super().__init__()
        self.emb = nn.Embedding(vocab, d, padding_idx=0)
        self.mha = nn.MultiheadAttention(d, heads, batch_first=True)
        self.pool = AttnPool(d)
    def forward(self, title_ids):                       # (B, L)
        x = self.emb(title_ids)
        mask = title_ids != 0
        h, _ = self.mha(x, x, x, key_padding_mask=~mask)
        return self.pool(h, mask)                       # (B, D)

class UserEncoder(nn.Module):
    """点击历史的新闻向量序列 → 用户向量（对'历史'再做一次注意力）"""
    def __init__(self, d=128, heads=8):
        super().__init__()
        self.mha = nn.MultiheadAttention(d, heads, batch_first=True)
        self.pool = AttnPool(d)
    def forward(self, hist_vecs, hist_mask):            # (B, H, D)
        h, _ = self.mha(hist_vecs, hist_vecs, hist_vecs,
                        key_padding_mask=~hist_mask.bool())
        return self.pool(h, hist_mask)

# 打分 = 用户向量 · 新闻向量 + w_age · 新闻年龄桶Embedding的贡献
# 训练 = impression 内 softmax 交叉熵（点击的那条是正类）

import math
from collections import defaultdict

class DecayPopularity:
    """流式维护每条新闻的衰减热度。必须按时间顺序喂数据！"""
    def __init__(self, half_life_hours=4.0):
        self.lam = math.log(2) / (half_life_hours * 3600)
        self.score = defaultdict(float)
        self.last_ts = defaultdict(float)

    def update(self, news_id, ts):          # 每次点击时调用
        dt = ts - self.last_ts[news_id]
        self.score[news_id] = self.score[news_id] * math.exp(-self.lam * dt) + 1.0
        self.last_ts[news_id] = ts

    def get(self, news_id, ts):             # 打分时调用（只用过去的信息）
        dt = ts - self.last_ts[news_id]
        return self.score[news_id] * math.exp(-self.lam * max(dt, 0))