docs: 提交记录新增备注列，标注每次提交的优化细节

Co-Authored-By: Claude <noreply@anthropic.com>
docs: 提交记录统一为 AI Studio 原始表格格式
2026-06-15 17:38:20 +08:00 · 2026-06-15 17:36:45 +08:00 · 2026-06-15 17:35:13 +08:00 · 2026-06-15 17:33:54 +08:00 · 2026-06-15 17:31:50 +08:00 · 2026-06-15 17:30:06 +08:00
7 changed files with 118 additions and 1586 deletions
@@ -18,5 +18,11 @@ eval.zip
 .vscode/
 .idea/
 # DVC & 工具自动生成
 .msc
 .mv
 dataset_infos.json
 .codegraph/
 # 密钥
 .env
@@ -179,13 +179,20 @@ Baseline 数据：推理 229s，AUC 0.759，PCOC 1.110，得分 25.85。
 2. ✅ **FP16 量化** — `model.half()`，Embedding 保留 FP32，152s
 3. ✅ **Flash Attention** — 替换 `scaled_dot_product` 为 `F.scaled_dot_product_attention`，94.5s
 4. ✅ **inference_mode()** — 替代 `no_grad()`，92.5s（+2s 小幅提升）
-8. ✅ **Expert 权重相似度合并** — 余弦相似度 >0.90 的 expert 合并（权重平均），86.5s
+5. ✅ **SMoE 消除 GPU 同步** — 移除 mask.any()（64 次 GPU→CPU 同步/forward），88.1s
-9. ❌ **torch.compile** — 四种模式全验证（reduce-overhead/default/Expert default/dynamic），均反效果
+6. ✅ **Expert 权重相似度合并** — 余弦相似度 >0.90 的 expert 合并（权重平均），86.5s
-10. ❌ **MoE Top-1 gating** — PCOC 炸毁，已回退
+7. ✅ **稠密向量化 MoE** — einsum 并行算 8 个 expert + gather 选取，消除 nonzero 同步（PR #1）
-11. ❌ **2:4 结构化稀疏** — 两次尝试（全局/Expert 级）均炸 PCOC
+8. ✅ **RepEncoder 融合查表** — 28 slot 值拼成一条做单次 segment_reduce，减 per-batch kernel 启动（PR #1）
-12. ❌ **INT8 量化** — CUDA 后端不支持，异常
+9. ✅ **Searchsorted 因果 mask** — 替代 repeat_interleave(张量repeats)，消除最后同步点（PR #1）
 10. ✅ **过滤无关用户** — 跳过不含测试样本的用户，省算力（PR #1）
 11. ❌ **torch.compile** — 四种模式全验证，均反效果。CONFIG 默认 compile=false（注释：实测慢5×）
 12. ❌ **MoE Top-1 gating** — PCOC 炸毁
 13. ❌ **2:4 结构化稀疏** — 两次尝试均炸 PCOC
 14. ❌ **INT8 量化** — CUDA 后端不支持
 15. ❌ **varlen attention** — 本地 10.3s 但评测端 148s（慢 65%），已回退
 16. ❌ **FlexAttention** — 比 SDPA 慢，未启用
-CUDA Graph / torch.compile / 2:4 稀疏 / INT8 均已评估并放弃。
+已验证无效/失败：torch.compile（×4）、2:4 稀疏（×2）、MoE k=1（×2）、INT8、varlen attention、FlexAttention
 ## 关键文件
@@ -204,12 +211,48 @@ CUDA Graph / torch.compile / 2:4 稀疏 / INT8 均已评估并放弃。
 ## 提交记录
-| 日期 | 提交次数 | 得分 | AUC | PCOC | 耗时 | 优化手段 | 备注 |
+| 团队成员用户名 | score | pcoc | score_latency | score_model | latency | auc | 提交状态 | 提交时间 | 备注 |
-|------|----------|------|-----|------|------|----------|------|
+|--------------|-------|------|---------------|-------------|---------|------|----------|----------|------|
-| 06/14 | 17 | **58.86** | 0.7526 | 1.059 | 86.5s | + Expert 相似度合并 | **当前最优** |
+| 刘航宇 | — | — | — | — | — | — | 异常 | 2026-06-12 20:46 | requirements.txt 含 nvidia-* 包，无 Windows 轮子 |
-| 06/14 | 16 | 55.19 | 0.7526 | 1.059 | 102.2s | + Expert 合并 th=0.97 | 阈值过高 |
+| 刘航宇 | — | — | — | — | — | — | 异常 | 2026-06-12 21:24 | |
-| 06/13 | 10 | 58.49 | 0.7526 | 1.059 | 88.1s | + SMoE 消除 GPU 同步 | |
+| 刘航宇 | 43.55 | 1.0589 | 0.4931 | 0.3013 | 152.08s | 0.7525 | 已完成 | 2026-06-12 21:30 | ✨ 首次 FP16 量化成功（仅 infer.py 提交） |
-| 06/13 | 9 | 51.42 | 0.7525 | 1.059 | 118.4s | + compile(default) | 反效果 |
+| 刘航宇 | — | — | — | — | — | — | 异常 | 2026-06-12 21:40 | |
-| 06/12 | 8 | 0 | 0.736 | 2.075 | 119.6s | MoE k=1 + compile | PCOC 炸毁 |
+| 刘航宇 | 56.98 | 1.0589 | 0.6849 | 0.3013 | 94.54s | 0.7526 | 已完成 | 2026-06-12 21:44 | SDPA 替换 scaled_dot_product |
-| 06/12 | 6 | 56.98 | 0.7526 | 1.059 | 94.5s | + Flash Attention | |
+| 刘航宇 | 32.54 | 1.0587 | 0.3357 | 0.3013 | 199.28s | 0.7525 | 已完成 | 2026-06-12 21:54 | torch.compile 实验（反效果） |
-| 06/12 | 3 | 43.55 | 0.7525 | 1.059 | 152s | + FP16 量化 | |
+| 刘航宇 | 0 | 2.0749 | 0.6013 | 0 | 119.62s | 0.7361 | 已完成 | 2026-06-12 22:12 | 2:4 结构化稀疏 → PCOC 炸毁 |
 | 刘航宇 | 51.42 | 1.0587 | 0.6055 | 0.3013 | 118.35s | 0.7525 | 已完成 | 2026-06-13 11:54 | inference_mode() 替代 no_grad() |
 | 刘航宇 | 57.45 | 1.0589 | 0.6916 | 0.3013 | 92.53s | 0.7526 | 已完成 | 2026-06-13 12:07 | 参数调优 |
 | 刘航宇 | 0 | 2.0672 | 0.1150 | 0 | 265.51s | 0.7484 | 已完成 | 2026-06-13 12:21 | 2:4 稀疏第二次 → PCOC 再次炸毁 |
 | 刘航宇 | 57.04 | 1.0589 | 0.6858 | 0.3013 | 94.27s | 0.7526 | 已完成 | 2026-06-13 12:41 | 回退稀疏，恢复调优 |
 | 刘航宇 | 58.49 | 1.0589 | 0.7065 | 0.3013 | 88.06s | 0.7526 | 已完成 | 2026-06-13 13:17 | 消除 MoE mask.any() GPU 同步 |
 | 刘航宇 | 58.45 | 0.9889 | 0.7244 | 0.2579 | 82.67s | 0.7336 | 已完成 | 2026-06-13 13:32 | AUC 骤降 0.019（PCOC 0.989 偏低），回退 |
 | 刘航宇 | — | — | — | — | — | — | 异常 | 2026-06-13 13:55 | build_env.sh CUDA warmup device='cuda' 失败 |
 | 刘航宇 | 0 | 1.3450 | 0 | 0 | 307.44s | 0.7506 | 已完成 | 2026-06-13 14:10 | MoE k=1 → PCOC 炸毁 |
 | 刘航宇 | 53.71 | 1.0589 | 0.6381 | 0.3013 | 108.57s | 0.7524 | 已完成 | 2026-06-13 14:21 | 回退 k=2，恢复 |
 | 刘航宇 | 55.10 | 1.0587 | 0.6580 | 0.3013 | 102.59s | 0.7525 | 已完成 | 2026-06-13 14:38 | compile 实验 |
 | 刘航宇 | 58.47 | 1.0589 | 0.7062 | 0.3013 | 88.13s | 0.7526 | 已完成 | 2026-06-13 14:46 | 关闭 compile，最优基线确认 |
 | 刘航宇 | 55.19 | 1.0589 | 0.6594 | 0.3013 | 102.19s | 0.7526 | 已完成 | 2026-06-14 11:18 | Expert 相似度合并 th=0.97（阈值过高，几乎未合并） |
 | 刘航宇 | **58.86** | 1.0589 | 0.7117 | 0.3013 | 86.49s | 0.7526 | 已完成 | 2026-06-14 11:32 | Expert 合并 th=0.90，旧版最优分 |
 | 刘航宇 | 58.52 | 1.0589 | 0.7068 | 0.3013 | 87.95s | 0.7526 | 已完成 | 2026-06-14 11:46 | 微调 th=0.85 |
 | 刘航宇 | 58.25 | 1.0589 | 0.7030 | 0.3013 | 89.11s | 0.7526 | 已完成 | 2026-06-14 12:11 | 微调 th=0.80 |
 | 刘航宇 | 58.38 | 1.0589 | 0.7049 | 0.3013 | 88.54s | 0.7526 | 已完成 | 2026-06-14 12:25 | 旧版回退（PR#1 合并前基线） |
 | qianban139 | 58.05 | 1.0589 | 0.7001 | 0.3013 | 89.96s | 0.7526 | 已完成 | 2026-06-14 23:09 | 张君硕首次提交（PR#1 代码基线） |
 | qianban139 | 44.40 | 1.0589 | 0.5052 | 0.3013 | 148.44s | 0.7525 | 已完成 | 2026-06-15 09:19 | varlen attention 实验 → 评测端慢 65%，回退 |
 | qianban139 | 62.81 | 1.0589 | 0.7682 | 0.3013 | 69.55s | 0.7525 | 已完成 | 2026-06-15 09:43 | 回退 SDPA，恢复调优 |
 | qianban139 | 63.03 | 1.0589 | 0.7713 | 0.3013 | 68.60s | 0.7525 | 已完成 | 2026-06-15 11:59 | 参数调优 |
 | qianban139 | 63.29 | 1.0589 | 0.7750 | 0.3013 | 67.49s | 0.7525 | 已完成 | 2026-06-15 12:16 | 参数调优 |
 | qianban139 | 63.20 | 1.0589 | 0.7737 | 0.3013 | 67.88s | 0.7525 | 已完成 | 2026-06-15 12:40 | 参数调优 |
 | qianban139 | 63.67 | 1.0589 | 0.7805 | 0.3013 | 65.86s | 0.7525 | 已完成 | 2026-06-15 12:48 | 参数调优 |
 | qianban139 | 65.17 | 1.0589 | 0.8019 | 0.3013 | 59.44s | 0.7524 | 已完成 | 2026-06-15 13:47 | 参数调优（AUC 微降 0.0001） |
 | qianban139 | **67.87** | 1.0589 | 0.8404 | 0.3013 | **47.88s** | 0.7524 | 已完成 | 2026-06-15 14:23 | 🔥 当前最高分！参数调优（AUC 微降 0.0002） |
 | qianban139 | 67.21 | 1.0589 | 0.8311 | 0.3013 | 50.68s | 0.7524 | 已完成 | 2026-06-15 15:37 | 继续调参，略有回退 |
 | 刘航宇 | 62.95 | 1.0589 | 0.7702 | 0.3013 | 68.93s | 0.7525 | 已完成 | 2026-06-15 17:19 | PR#1 代码（稠密MoE+融合查表+syncfree mask） |
 ### 团队成员
 | AI Studio 用户名 | 真实姓名 |
 |------------------|----------|
 | qianban139 | 张君硕 |
 | sidny1988 | 谢松熹 |
 | （队长账号） | 刘航宇 |
@@ -4,56 +4,82 @@
 [![Gitea](https://img.shields.io/badge/Gitea-Serendipity%2FCTI--Inference--Opt-blue?logo=gitea)](https://gitea.liuhangyv.top/Serendipity/CTI-Inference-Opt)
 ## 团队
 | 成员 | AI Studio 用户名 | 角色 |
 |------|------------------|------|
 | 刘航宇 | — | 队长 |
 | 张君硕 | qianban139 | 队员 |
 | 谢松熹 | sidny1988 | 队员 |
 ## 赛题
-> [比赛主页](https://aistudio.baidu.com/competition/detail/1461) · [大赛官网](http://cti.baidu.com) · [提交结果](https://aistudio.baidu.com/competition/detail/1461/0/submit-result)
+> [比赛主页](https://aistudio.baidu.com/competition/detail/1461) · [大赛官网](http://cti.baidu.com) · [提交结果](https://aistudio.baidu.com/competition/detail/1461/0/submit-result) · [比赛规则](https://aistudio.baidu.com/competition/detail/1461/0/rules)
-给定基于 Transformer 的生成式推荐广告排序模型（GRAB），在**不改变模型结构、不在测试集上训练**的前提下，极致优化推理性能。
+给定基于 Transformer 的生成式推荐广告排序模型（GRAB），在**不改变模型结构、不在测试集上训练**的前提下，极致优化推理性能。量化/稀疏/剪枝明确允许。
 量化、稀疏、剪枝明确允许。
 ## 模型架构
 ```
-RepEncoder (28 slots × 512d Embedding)
+RepEncoder (28 slots × 512d Embedding) → segment_reduce → LayerNorm → Linear
  → 8 层 Transformer (512d, 8 heads, Pre-LN)
-    → Multi-Head Attention
+    → Multi-Head Attention (SDPA / Flash Attention)
-    → SMoE FFN (8 experts, Top-2 gating)
+    → SMoE FFN (8 experts, Top-2 gating, k=2)
  → Linear → Sigmoid → CTR
 ```
 ~6.5M~11.3M 参数，基于 [GRAB](https://arxiv.org/abs/2602.01865) / [HSTU](https://arxiv.org/abs/2402.17152) 论文。
-## 评分规则
+## 有效优化
-> 详见 [比赛规则](https://aistudio.baidu.com/competition/detail/1461/0/rules)
+| # | 优化 | 原理 | 耗时 |
 |---|------|------|------|
 | 1 | FP16 量化 | 模型半精度 + Embedding FP32 | 152s |
 | 2 | Flash Attention | SDPA 数学等价替换 | 94.5s |
 | 3 | 消除 GPU 同步 | 移除 MoE mask.any() + searchsorted mask | 88.1s |
 | 4 | Expert 相似度合并 | 余弦相似度 >0.90 的 expert 合并 | 86.5s |
 | 5 | 稠密向量化 MoE | einsum 并行算 8 个 expert | PR#1 |
 | 6 | RepEncoder 融合查表 | 28 slot 拼单次 segment_reduce | PR#1 |
 ## 评分规则
 | 维度 | 要求 | 不达标 |
 |------|------|--------|
 | 推理效率 | ≤ 5min，环境构建 ≤ 20min | **总分 0** |
 | 模型效果 | AUC ≥ 0.65，PCOC ∈ [0.85, 1.15] | **总分 0** |
-## 优化路线
+## 评测环境
-| 步骤 | 方案 | 预期加速 |
+- **硬件**: NVIDIA A800 (80GB, SM80)
-|------|------|----------|
+- **软件**: Python 3.10 + PyTorch 2.6.0 + CUDA 12.4
-| ✅ 第一版 | 接口对齐 + FP16 量化 | 229s → ~120s |
+- **评测数据集 ≠ baseline 数据集**
 | 🔲 第二版 | Flash Attention + torch.compile | ~120s → ~65s |
 | 🔲 第三版 | MoE 剪枝 + INT8 量化 | ~65s → ~30s |
 ## 提交
 ```bash
 cd 代码/code
-zip submit.zip infer.py requirements.txt build_env.sh
+zip submit.zip infer.py build_env.sh
 ```
-约束：不包含 `dataset/`、`ckpt.pt`，每天最多 10 次提交。
+约束：不包含 `dataset/`、`ckpt.pt`，包后缀 `.zip`，每天最多 10 次。
-## 环境
+## 文件结构
- **本地**: `.venv` (Python 3.13, uv), 仅装 `numpy` + `tqdm` + `aistudio-sdk`
+```
- **服务端**: PyTorch 2.6.0 + CUDA 12.4，完整依赖见 `代码/code/requirements.txt`
+代码/code/
 ├── infer.py           # 推理主脚本（提交核心）
 ├── build_env.sh       # 环境构建脚本
 ├── requirements.txt   # 服务端依赖（torch 2.6.0 + CUDA 12.4）
 ├── EXPERIMENTS.md     # 实验记录表
 └── bench.py           # 本地测量脚本（不进提交包）
 论文/
 ├── GRAB.md / HSTU.md  # 论文 OCR markdown
 └── imgs/              # 论文图片
 代码/任务提交接口说明.md  # 官方接口规范
 CLAUDE.md               # 项目开发指引
 ```
 ## 许可证
@@ -1,821 +0,0 @@
 # CTI 推理优化冲击 80+ 实现计划
 > **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
 **Goal:** 在不改模型结构、不训练测试集的前提下，先找回当前推理丢失的 AUC，再做结构性延迟重写，把榜上分数从 58.86 推向 80+。
 **Architecture:** 在 AI Studio notebook（A800 + dataset + ckpt.pt）里，先建一个带同步计时和配置开关的测量闭环 `bench.py`；阶段 A 用消融实验定位并找回 AUC（30 分桶）；阶段 B 用数值等价的内核重写压低延迟（块对角注意力 / MoE 向量化 / embedding 融合）。每步过本地关卡，再用有限的提交确认验证集。
 **Tech Stack:** Python 3.10, PyTorch 2.6.0 (CUDA 12.4), NVIDIA A800 (SM80), sklearn (AUC), AI Studio notebook。
 ---
 ## 执行环境约定
 - 所有运行都在 **AI Studio notebook** 内（本地 Windows 只装了 numpy+tqdm，跑不了 torch）。
 - 提交文件只有 `infer.py` / `requirements.txt` / `build_env.sh` 会被打包；`bench.py`、`tests/` **绝不进提交包**。
 - 每个改 `infer.py` 的任务，最后都要确认 `bench.py` 默认配置仍能复现「当前最优」，避免污染提交版本。
 - 数据路径（notebook 内）：`代码/code/dataset/`（软链）、`代码/code/ckpt.pt`、本地标签 `dataset/label_data.txt`。
 ## 文件结构
 | 文件 | 职责 | 是否提交 |
 |------|------|----------|
 | `代码/code/infer.py` | 提交主脚本。引入模块级 `CONFIG` 开关；`load_model`/`RepEncoder`/`SMoE`/注意力按 `CONFIG` 行为，默认值=当前最优 | ✅ |
 | `代码/code/bench.py` | 测量闭环。设置 `infer.CONFIG`，跑本地推理，同步计时，打印 AUC/PCOC/延迟/总分；支持配置扫描 | ❌ |
 | `代码/code/tests/test_equiv.py` | 阶段 B 重写的数值等价测试（新实现 vs 原实现 allclose） | ❌ |
 | `代码/code/EXPERIMENTS.md` | 实验记录表（配置 → AUC/PCOC/延迟/本地分/提交分） | ❌（可入 git，不入提交包） |
 ---
 ## 阶段 0：测量闭环
 ### Task 1: 给 infer.py 加 CONFIG 开关板
 **Files:**
 - Modify: `代码/code/infer.py`（顶部新增 CONFIG；改 `load_model`、`RepEncoder.forward`）
 - [ ] **Step 1: 在 import 之后、数据加载层之前插入模块级 CONFIG**
 ```python
 # ============================================================
 # 实验配置开关（提交时保持默认 = 当前最优行为）
 # bench.py 会在 import 后覆盖这些值；评测系统不碰它，用默认值。
 # ============================================================
 CONFIG = {
    "fp16": True,            # True=半精度；False=FP32 参考
    "keep_fp32_modules": (), # 在 fp16 下仍保留 FP32 的子模块名前缀，如 ("rep_encoder.emb",)
    "expert_merge": True,    # 是否做 expert 相似度合并
    "merge_threshold": 0.90, # 合并余弦阈值
    "signid_mode": "clamp",  # "clamp" 或 "modulo"，处理超界 sign id
    "sync_timing": False,    # bench 里设 True，做 torch.cuda.synchronize 真实计时
 }
 ```
 - [ ] **Step 2: 改 `RepEncoder.forward`，按 CONFIG 处理 sign id**
 把 `代码/code/infer.py` 中 `RepEncoder.forward` 的这一行：
 ```python
            values = values.clamp(0, max_idx)  # 超出 vocab_size 的 sign id 截断，避免越界
 ```
 替换为：
 ```python
            if CONFIG["signid_mode"] == "modulo":
                values = values % self.emb.num_embeddings
            else:
                values = values.clamp(0, max_idx)
 ```
 - [ ] **Step 3: 改 `load_model`，按 CONFIG 控制 fp16 / 保留 FP32 模块 / expert 合并**
 把 `load_model` 中从 `model = model.half()` 到 `_merge_experts(...)` 这一段：
 ```python
        # === FP16 量化：模型参数转半精度，Embedding 保留 FP32 ===
        model = model.half()
        model.rep_encoder.emb = model.rep_encoder.emb.to(torch.float32)
        print("[INFO] Model converted to FP16 (embedding kept in FP32)")
        # === 按 Expert 权重相似度合并冗余 expert ===
        _merge_experts(model, sim_threshold=0.90)
 ```
 替换为：
 ```python
        if CONFIG["fp16"]:
            model = model.half()
            # embedding 始终保留 FP32（int 索引查表）
            model.rep_encoder.emb = model.rep_encoder.emb.to(torch.float32)
            # 额外保留 FP32 的模块（精度敏感层）
            for name, module in model.named_modules():
                if any(name.startswith(p) for p in CONFIG["keep_fp32_modules"]):
                    module.to(torch.float32)
            print(f"[INFO] FP16 on; FP32-kept: {('rep_encoder.emb',) + CONFIG['keep_fp32_modules']}")
        else:
            model = model.float()
            print("[INFO] FP32 reference (no half)")
        if CONFIG["expert_merge"]:
            _merge_experts(model, sim_threshold=CONFIG["merge_threshold"])
        else:
            print("[INFO] expert_merge off")
 ```
 注意：`keep_fp32_modules` 里若含某层（如 `seq_encoder.norm1`），其输入需在该层处转回 FP32。先只用整体 fp16/fp32 与 emb，敏感层在 Task 5 单独处理；本任务只接好开关。
 - [ ] **Step 4: 在 notebook 跑一遍默认配置，确认行为未变**
 Run（notebook cell）：
 ```python
 %cd /home/aistudio/code
 !python infer.py
 ```
 Expected：打印 `FP16 on`、expert 合并日志，AUC ≈ 0.759、PCOC ≈ 1.05~1.11（与改动前一致，证明开关默认值没改变行为）。
 - [ ] **Step 5: Commit**
 ```bash
 git add 代码/code/infer.py
 git commit -m "feat: infer.py 增加 CONFIG 实验开关（默认=当前最优行为）"
 ```
 ### Task 2: 建 bench.py 测量闭环
 **Files:**
 - Create: `代码/code/bench.py`
 - [ ] **Step 1: 写 bench.py**
 ```python
 """本地测量闭环：设置 infer.CONFIG，跑推理，同步计时，打印指标。不进提交包。"""
 import sys, time, io
 from pathlib import Path
 import torch
 from torch.utils.data import DataLoader
 import infer  # 同目录
 def run_once(config_override: dict, batch_size: int = 50, max_batches: int | None = None):
    infer.CONFIG.update(config_override)
    infer.CONFIG["sync_timing"] = True
    cur = Path(__file__).parent
    ref = cur / "dataset"
    history = ref / "history"
    test_csv = ref / "test.csv"
    label_file = ref / "label_data.txt"
    files = (sorted(history.glob("*.csv")) if history.exists() else []) + [test_csv]
    item_dict, user_seq = infer.load_sample_files(files)
    test_logids = infer.load_logids_from_file(test_csv)
    ds = infer.CTRTestSeqDataset(
        test_logids_ordered=list(test_logids), item_dict=item_dict,
        user_seq=user_seq, max_feasign_per_slot={1: 2}, max_ctx_len=None,
    )
    loader = DataLoader(ds, batch_size=batch_size, shuffle=False, num_workers=0,
                        collate_fn=infer.make_collate_fn(ds.max_slot_id))
    batches = []
    for b in loader:
        batches.append(infer.move_batch_to_device(b, torch.device("cpu")))
        if max_batches and len(batches) >= max_batches:
            break
    model, dev = infer.load_model(ckpt_path=None)
    logid2p, t_sum = {}, 0.0
    with torch.inference_mode():
        for b in batches:
            b = infer.move_batch_to_device(b, dev)
            pm = b["pred_mask"].bool()
            torch.cuda.synchronize()
            t0 = time.time()
            logits, _ = model(b)
            probs = torch.sigmoid(logits.squeeze(-1))
            torch.cuda.synchronize()
            t_sum += time.time() - t0
            for lid, p in zip(b["logid"][pm].cpu().tolist(), probs[pm].cpu().tolist()):
                logid2p[lid] = p
    # 按 test.csv 顺序写 predict 并打分
    order = [int(l.split(",")[0]) for l in open(test_csv) if l.strip()]
    pred_path = cur / "predict.txt"
    with open(pred_path, "w") as f:
        for lid in order:
            f.write(f"{logid2p[lid]}\n")
    res = infer._cal_score(pred_path, label_file, default_latency=t_sum)
    print(f"[BENCH] cfg={config_override} bs={batch_size} -> "
          f"AUC={res['auc']:.5f} PCOC={res['pcoc']:.4f} "
          f"lat={res['latency']:.2f}s score={res['score_all']:.2f}")
    return res
 if __name__ == "__main__":
    run_once({})  # 默认配置基准
 ```
 - [ ] **Step 2: 跑默认配置，建立本地基准**
 Run：
 ```python
 %cd /home/aistudio/code
 !python bench.py
 ```
 Expected：打印 `[BENCH]` 一行，记录 AUC/PCOC/同步后真实延迟/本地分。这是后续所有对比的锚点。
 - [ ] **Step 3: 建实验记录表并记录第一行**
 Create `代码/code/EXPERIMENTS.md`，写入表头与默认配置那一行（数值用 Step 2 实测填）：
 ```markdown
 | 配置 | AUC | PCOC | 延迟(同步) | 本地分 | 提交分 |
 |------|-----|------|-----------|--------|--------|
 | 默认(当前最优) | <实测> | <实测> | <实测> | <实测> | 58.86 |
 ```
 - [ ] **Step 4: Commit**
 ```bash
 git add 代码/code/bench.py 代码/code/EXPERIMENTS.md
 git commit -m "feat: 新增 bench.py 测量闭环 + 实验记录表"
 ```
 ---
 ## 阶段 A：找回 AUC（30 分桶，最高优先）
 ### Task 3: FP32 参考跑 —— 确立 AUC 天花板（核心前提验证）
 **Files:**
 - Modify: `代码/code/EXPERIMENTS.md`
 - [ ] **Step 1: 跑纯 FP32、不合并 expert、clamp**
 Run（notebook）：
 ```python
 import bench
 bench.run_once({"fp16": False, "expert_merge": False, "signid_mode": "clamp"})
 ```
 Expected：打印一行 AUC/PCOC/延迟。**记录这个 AUC** —— 它是当前代码路径下模型的真实可达上限。
 - [ ] **Step 2: 判定核心前提**
 把结果记入 EXPERIMENTS.md。判定：
 - 若 FP32 AUC 明显 > 默认配置 AUC（如 ≥ +0.01）→ 说明 fp16/合并在掉精度，Task 4/5 有收益。
 - 若 FP32 AUC 仍 ≈ 0.759（验证集对应 ~0.7526）→ **当前数据路径触不到更高 AUC**；缺口可能在 sign-id/特征/上下文（Task 3.5/6），或「80 目标」前提存疑，需暂停并与队友/官方答疑核对（见 spec §10）。
 - [ ] **Step 3: Commit**
 ```bash
 git add 代码/code/EXPERIMENTS.md
 git commit -m "exp: FP32 参考跑，记录 AUC 天花板"
 ```
 ### Task 4: Sign-ID 取模 vs clamp
 **Files:**
 - Modify: `代码/code/EXPERIMENTS.md`
 - [ ] **Step 1: 先查 max_sign_id 是否超 5M 词表**
 Run（notebook）：
 ```python
 import infer
 from pathlib import Path
 files = sorted(Path("dataset/history").glob("*.csv")) + [Path("dataset/test.csv")]
 item_dict, user_seq = infer.load_sample_files(files)
 mx = max(int(s) for r in item_dict.values() for s in r["signs"].tolist())
 print("max_sign_id =", mx, "vocab =", 5000000, "超界比例可观?", mx >= 5000000)
 ```
 Expected：打印最大 sign id。若 `mx >= 5_000_000`，clamp 会把大量 id 压到同一行 —— 头号嫌疑成立。
 - [ ] **Step 2: FP32 下对比 clamp vs modulo**
 Run：
 ```python
 import bench
 bench.run_once({"fp16": False, "expert_merge": False, "signid_mode": "clamp"})
 bench.run_once({"fp16": False, "expert_merge": False, "signid_mode": "modulo"})
 ```
 Expected：两行 AUC。
 - [ ] **Step 3: 判定 + 记录**
 - modulo 的 AUC 明显更高 → 训练用的就是取模哈希，**保留 modulo**（合规：只是正确还原模型输入，不改结构/权重）。
 - 两者相近或 modulo 更差 → 训练用 clamp/或 id 不超界，保留 clamp。
 记入 EXPERIMENTS.md。
 - [ ] **Step 4: Commit**
 ```bash
 git add 代码/code/EXPERIMENTS.md
 git commit -m "exp: sign-id clamp vs modulo 对比"
 ```
 ### Task 5: 精度摆放（混合精度找回 AUC）
 **Files:**
 - Modify: `代码/code/EXPERIMENTS.md`
 - [ ] **Step 1: 逐步把敏感层保留 FP32，对比 AUC**
 用上一步定下的 `signid_mode`（记为 `SM`），依次跑：
 ```python
 import bench
 bench.run_once({"fp16": True, "expert_merge": False, "signid_mode": SM,
                "keep_fp32_modules": ()})                       # 纯 fp16
 bench.run_once({"fp16": True, "expert_merge": False, "signid_mode": SM,
                "keep_fp32_modules": ("linear",)})              # 保留最终输出头
 bench.run_once({"fp16": True, "expert_merge": False, "signid_mode": SM,
                "keep_fp32_modules": ("linear", "rep_encoder.input_norm",
                                       "rep_encoder.linear")})  # +RepEncoder 头
 ```
 Expected：三行 AUC + 延迟。
 - [ ] **Step 2: 选「AUC 最接近 FP32 且延迟可接受」的组合**
 记 `KEEP` = 选中的 `keep_fp32_modules`。判定标准：相对 FP32 参考，AUC 损失 ≤ 0.001 优先；若纯 fp16 已无损，则 `KEEP=()`。记入 EXPERIMENTS.md。
 - [ ] **Step 3: Commit**
 ```bash
 git add 代码/code/EXPERIMENTS.md
 git commit -m "exp: 混合精度摆放，确定 keep_fp32_modules"
 ```
 ### Task 6: Expert 合并的 AUC 代价
 **Files:**
 - Modify: `代码/code/EXPERIMENTS.md`
 - [ ] **Step 1: 在选定精度下对比 expert_merge 开/关**
 ```python
 import bench
 bench.run_once({"fp16": True, "signid_mode": SM, "keep_fp32_modules": KEEP,
                "expert_merge": False})
 bench.run_once({"fp16": True, "signid_mode": SM, "keep_fp32_modules": KEEP,
                "expert_merge": True, "merge_threshold": 0.90})
 ```
 Expected：两行，含 AUC 与延迟。
 - [ ] **Step 2: 判定**
 - 合并掉 AUC（> 0.0005）但只省一点延迟 → **关掉合并**（延迟从阶段 B 补，那里不损精度）。
 - 合并不掉 AUC → 保留。记 `MERGE` = 最终决定。记入 EXPERIMENTS.md。
 - [ ] **Step 3: Commit**
 ```bash
 git add 代码/code/EXPERIMENTS.md
 git commit -m "exp: 量化 expert 合并的 AUC 代价并决定开关"
 ```
 ### Task 7: 特征与上下文完整性核查
 **Files:**
 - Modify: `代码/code/EXPERIMENTS.md`
 - [ ] **Step 1: 核查 max_feasign_per_slot 截断的影响**
 ```python
 import bench
 bench.run_once({"fp16": True, "signid_mode": SM, "keep_fp32_modules": KEEP,
                "expert_merge": MERGE})  # 当前 dataset 用 {1:2}
 ```
 然后改 bench.run_once 里 `max_feasign_per_slot={1: 2}` 为 `None`（临时编辑 bench.py 或加参数），再跑一次，对比 AUC。
 Expected：两行。若去掉截断 AUC 升高，说明截断在丢信息。
 > 注意：评测系统构造 `CTRTestSeqDataset` 时传哪些 `max_feasign_per_slot`/`max_ctx_len` 由评测端决定，**我们不一定能控制**。本步先确认「完整特征是否更好」，若是，则在 `CTRTestSeqDataset.__init__` 里对截断做更保守的默认（仅在确证合规、不属"序列截断"违规的前提下）。
 - [ ] **Step 2: 核查每条测试样本是否 attend 到完整用户历史**
 ```python
 import infer
 from pathlib import Path
 files = sorted(Path("dataset/history").glob("*.csv")) + [Path("dataset/test.csv")]
 item_dict, user_seq = infer.load_sample_files(files)
 test_uids = {item_dict[l]["userid"] for l in infer.load_logids_from_file(Path("dataset/test.csv"))}
 have_hist = sum(1 for u in test_uids if len(user_seq.get(u, [])) > 1)
 print(f"测试用户 {len(test_uids)}，其中有历史序列(>1)的 {have_hist} "
      f"({have_hist/len(test_uids):.1%})；序列长度分布：")
 import numpy as np
 lens = np.array([len(user_seq.get(u, [])) for u in test_uids])
 print("min/median/max =", lens.min(), int(np.median(lens)), lens.max())
 ```
 Expected：绝大多数测试用户应有较长历史序列。若大量用户只有长度 1（无历史），说明历史没正确挂上 —— 这会严重压低生成式模型 AUC，需排查 `load_sample_files` 的 userid 关联与排序。
 - [ ] **Step 3: 记录结论 + Commit**
 把两步结论记入 EXPERIMENTS.md。
 ```bash
 git add 代码/code/EXPERIMENTS.md
 git commit -m "exp: 特征截断与上下文完整性核查"
 ```
 ### Task 8: 锁定阶段 A 最优配置并设为 infer.py 默认 + 提交验证
 **Files:**
 - Modify: `代码/code/infer.py`（把 CONFIG 默认值改为阶段 A 选定组合）
 - [ ] **Step 1: 更新 infer.py 的 CONFIG 默认值**
 把 `CONFIG` 默认值改成 Task 4~7 选定的 `signid_mode=SM`、`keep_fp32_modules=KEEP`、`expert_merge=MERGE`、`merge_threshold` 等（`sync_timing` 保持 False）。
 - [ ] **Step 2: 跑默认配置确认达到阶段 A 最优本地分**
 ```python
 %cd /home/aistudio/code
 !python bench.py
 ```
 Expected：AUC ≥ 默认基准，本地分高于先前。
 - [ ] **Step 3: 打包并提交一次（消耗 1 次/天额度）**
 ```bash
 cd /home/aistudio/code
 rm -f predict.txt
 zip -y ../eval.zip infer.py requirements.txt build_env.sh
 # 确认包内无 dataset/、无 ckpt.pt、无 bench.py/tests/
 unzip -l ../eval.zip
 ```
 然后在 AI Studio 提交页提交 `eval.zip`。
 - [ ] **Step 4: 记录验证集分数 + Commit**
 把提交得到的验证集 AUC/PCOC/延迟/分数记入 EXPERIMENTS.md。
 ```bash
 git add 代码/code/infer.py 代码/code/EXPERIMENTS.md
 git commit -m "feat: 锁定阶段A最优配置为默认 + 验证集提交结果"
 ```
 ---
 ## 阶段 B：结构性延迟重写（数值等价，不动 AUC）
 > 每个重写任务都先写「新实现 vs 原实现 allclose」等价测试，再替换，最后用 bench 确认 AUC 不变、延迟下降。
 ### Task 9: 块对角因果注意力（FlexAttention）
 **Files:**
 - Create: `代码/code/tests/test_equiv.py`
 - Modify: `代码/code/infer.py`（`scaled_dot_product` / `CTRModel.forward` mask 路径）
 - [ ] **Step 1: 写等价测试（先失败）**
 Create `代码/code/tests/test_equiv.py`：
 ```python
 import torch, torch.nn.functional as F
 import sys; sys.path.insert(0, "..")
 import infer
 def _dense_attn(q, k, v, mask):
    return F.scaled_dot_product_attention(q, k, v, attn_mask=mask.to(q.dtype).bool())
 def test_flex_matches_dense():
    torch.manual_seed(0)
    B, H, S, Dh = 1, 8, 37, 64
    q, k, v = [torch.randn(B, H, S, Dh, device="cuda") for _ in range(3)]
    # 构造 3 个用户的 user_offsets：长度 10/12/15
    offsets = torch.tensor([0, 10, 22, 37], device="cuda")
    m = infer.CTRModel.get_sequence_causal_mask.__get__(object())(offsets)  # 见下
    dense = _dense_attn(q, k, v, m.unsqueeze(0).unsqueeze(0))
    flex = infer.flex_block_causal_attn(q, k, v, offsets)
    assert torch.allclose(dense, flex, atol=1e-3, rtol=1e-3), (dense - flex).abs().max()
 ```
 > 说明：`get_sequence_causal_mask` 是实例方法，测试里改成直接调用一个等价的独立函数 `infer._build_dense_causal_mask(offsets)`（Step 3 会把现有逻辑抽成模块级函数，便于测试与复用）。把上面 `m = ...` 那行改为 `m = infer._build_dense_causal_mask(offsets)`。
 - [ ] **Step 2: 跑测试确认失败**
 Run：
 ```python
 %cd /home/aistudio/code/tests
 !python -m pytest test_equiv.py::test_flex_matches_dense -v
 ```
 Expected：FAIL（`infer.flex_block_causal_attn` / `_build_dense_causal_mask` 未定义）。
 - [ ] **Step 3: 在 infer.py 实现 FlexAttention 路径**
 把 `CTRModel.get_sequence_causal_mask` 的逻辑抽为模块级函数，并新增 flex 实现：
 ```python
 from torch.nn.attention.flex_attention import flex_attention, create_block_mask
 def _build_dense_causal_mask(user_offsets):
    lengths = user_offsets[1:] - user_offsets[:-1]
    idx = torch.repeat_interleave(
        torch.arange(lengths.numel(), device=user_offsets.device), lengths)
    same = idx.view(1, -1) == idx.view(-1, 1)
    causal = torch.tril(torch.ones_like(same, dtype=torch.bool))
    return same & causal
 def flex_block_causal_attn(q, k, v, user_offsets):
    S = q.size(-2)
    lengths = user_offsets[1:] - user_offsets[:-1]
    doc_id = torch.repeat_interleave(
        torch.arange(lengths.numel(), device=q.device), lengths)
    def mask_mod(b, h, qi, ki):
        return (qi >= ki) & (doc_id[qi] == doc_id[ki])
    block_mask = create_block_mask(mask_mod, B=None, H=None, Q_LEN=S, KV_LEN=S, device=q.device)
    return flex_attention(q, k, v, block_mask=block_mask)
 ```
 然后改 `CTRModel.forward`：mask 不再现造稠密矩阵传给 SDPA，而是把 `user_offsets` 透传，调用 `flex_block_causal_attn`。把 `scaled_dot_product` 改为接收 `extension={"user_offsets": ...}` 并走 flex；`get_sequence_causal_mask` 保留供测试/回退。
 > 兼容性：FlexAttention 要求 q/k/v 为 `[B,H,S,Dh]`（现有 forward 已是该布局）。FP16 下 atol 放宽到 2e-2 重测。
 - [ ] **Step 4: 跑测试确认通过**
 Run：
 ```python
 !python -m pytest test_equiv.py::test_flex_matches_dense -v
 ```
 Expected：PASS。
 - [ ] **Step 5: bench 确认 AUC 不变、延迟下降**
 ```python
 import bench, importlib, infer; importlib.reload(infer); importlib.reload(bench)
 bench.run_once({})
 ```
 Expected：AUC 与 Task 8 一致（±0.0005），延迟较 Task 8 下降。记入 EXPERIMENTS.md。
 - [ ] **Step 6: Commit**
 ```bash
 git add 代码/code/infer.py 代码/code/tests/test_equiv.py 代码/code/EXPERIMENTS.md
 git commit -m "perf: 块对角因果注意力改用 FlexAttention（数值等价，提速）"
 ```
 ### Task 10: MoE 向量化（消除 Python 循环与同步）
 **Files:**
 - Modify: `代码/code/infer.py`（`SMoE.__init__` 预堆叠权重；`SMoE.forward` 稠密批量计算）
 - Modify: `代码/code/tests/test_equiv.py`（加 MoE 等价测试）
 - [ ] **Step 1: 写 MoE 等价测试（先失败）**
 在 `test_equiv.py` 追加：
 ```python
 def test_smoe_vectorized_matches_loop():
    torch.manual_seed(0)
    m = infer.SMoE(d_model=512, dim_ff=1024, num_experts=8, k=2).cuda().eval()
    x = torch.randn(1, 50, 512, device="cuda")
    with torch.no_grad():
        ref, _ = infer._smoe_forward_loop(m, x)   # 原实现（保留为参考函数）
        new, _ = m(x)                              # 新向量化实现
    assert torch.allclose(ref, new, atol=1e-4, rtol=1e-4), (ref - new).abs().max()
 ```
 - [ ] **Step 2: 跑测试确认失败**
 Run：`!python -m pytest test_equiv.py::test_smoe_vectorized_matches_loop -v`
 Expected：FAIL（`_smoe_forward_loop` 未定义 / 新旧不一致）。
 - [ ] **Step 3: 实现向量化 SMoE**
 把现有 `SMoE.forward` 的循环体抽成模块级 `_smoe_forward_loop(moe, x)`（保留作参考/回退），新 `forward` 改为稠密批量（8 个小 FFN 全算，再按 top-k 选取加权 —— 数学等价，GPU 上无 gather/同步更快）：
 ```python
 class SMoE(nn.Module):
    def __init__(self, d_model, dim_ff, num_experts, k=2):
        super().__init__()
        self.num_experts = num_experts
        self.k = k
        self.experts = nn.ModuleList([Expert(d_model, dim_ff) for _ in range(num_experts)])
        self.gate = TopKGate(d_model, num_experts, k=k)
        self._stacked = False
    def _stack_weights(self):
        self.register_buffer("W1", torch.stack([e.fc1.weight for e in self.experts]))  # [E,F,D]
        self.register_buffer("b1", torch.stack([e.fc1.bias   for e in self.experts]))  # [E,F]
        self.register_buffer("W2", torch.stack([e.fc2.weight for e in self.experts]))  # [E,D,F]
        self.register_buffer("b2", torch.stack([e.fc2.bias   for e in self.experts]))  # [E,D]
        self._stacked = True
    def forward(self, x):
        if not self._stacked:
            self._stack_weights()
        B, S, D = x.shape
        topk_idx, topk_score, probs = self.gate(x)
        xf = x.reshape(-1, D)                                   # [N,D]
        h = torch.einsum("nd,efd->enf", xf, self.W1) + self.b1[:, None, :]   # [E,N,F]
        h = F.relu(h)
        o = torch.einsum("enf,eDf->enD", h, self.W2) + self.b2[:, None, :]   # [E,N,D]
        o = o.permute(1, 0, 2)                                  # [N,E,D]
        idx = topk_idx.reshape(-1, self.k)                      # [N,k]
        sc = topk_score.reshape(-1, self.k)                     # [N,k]
        sel = torch.gather(o, 1, idx.unsqueeze(-1).expand(-1, -1, D))        # [N,k,D]
        out = (sel * sc.unsqueeze(-1)).sum(1).reshape(B, S, D)
        moe_loss = probs.sum(dim=(0, 1)).std() / (probs.sum(dim=(0, 1)).mean() + 1e-6)
        return out, moe_loss
 ```
 > 注意：合并 expert（Task 6 若开启）会改变 `num_experts` 和权重 —— `_stack_weights` 必须在合并之后、首次 forward 时调用（上面 lazy 实现已满足）。dtype 要与 x 一致（fp16 时 stack 出来即 fp16）。
 - [ ] **Step 4: 跑测试确认通过**
 Run：`!python -m pytest test_equiv.py::test_smoe_vectorized_matches_loop -v`
 Expected：PASS。
 - [ ] **Step 5: bench 确认 AUC 不变、延迟下降**
 ```python
 import bench, importlib, infer; importlib.reload(infer); importlib.reload(bench)
 bench.run_once({})
 ```
 Expected：AUC 一致，延迟较 Task 9 下降。记入 EXPERIMENTS.md。
 - [ ] **Step 6: Commit**
 ```bash
 git add 代码/code/infer.py 代码/code/tests/test_equiv.py 代码/code/EXPERIMENTS.md
 git commit -m "perf: SMoE 稠密向量化（数值等价，消除循环/同步）"
 ```
 ### Task 11: Embedding 池化融合（28 次 segment_reduce → 1 次）
 **Files:**
 - Modify: `代码/code/infer.py`（`RepEncoder.forward`）
 - Modify: `代码/code/tests/test_equiv.py`
 - [ ] **Step 1: 写等价测试（先失败）**
 在 `test_equiv.py` 追加，对比融合实现与逐 slot 实现在同一输入上的输出 allclose（构造一个 28-slot 的小 batch dict，调用 `infer._rep_forward_perslot(enc, batch)` 参考实现 vs `enc(batch)`）。
 ```python
 def test_rep_fused_matches_perslot():
    torch.manual_seed(0)
    enc = infer.RepEncoder(vocab_size=1000, emb_dim=512, slot_num=28, d_model=512).cuda().eval()
    batch = {}
    for s in range(1, 29):
        n = torch.randint(1, 5, (10,))                      # 每样本 1~4 个 sign
        vals = torch.randint(0, 1000, (int(n.sum()),))
        offs = torch.cat([torch.zeros(1, dtype=torch.long), n.cumsum(0)])
        batch[s] = (vals.cuda(), offs.cuda())
    with torch.no_grad():
        ref = infer._rep_forward_perslot(enc, batch)
        new = enc(batch)
    assert torch.allclose(ref, new, atol=1e-4), (ref - new).abs().max()
 ```
 - [ ] **Step 2: 跑测试确认失败**
 Run：`!python -m pytest test_equiv.py::test_rep_fused_matches_perslot -v`
 Expected：FAIL（`_rep_forward_perslot` 未定义）。
 - [ ] **Step 3: 实现融合**
 把现有逐 slot 循环抽为 `_rep_forward_perslot(enc, batch)`（参考/回退）。新 `RepEncoder.forward` 把 28 个 slot 的 `values` 拼成一条，offsets 平移拼接成覆盖 `28*N` 段的单一 offsets，一次 `segment_reduce`，再 reshape `[28, N, emb]` → permute/cat 成 `[N, 28*emb]`：
 ```python
 def forward(self, batch):
    max_idx = self.emb.num_embeddings - 1
    target_dtype = self.input_norm.weight.dtype
    N = batch[1][1].numel() - 1                      # 样本数 = offsets 段数
    all_vals, seg_offsets, base = [], [0], 0
    for s in range(1, self.slot_num + 1):
        vals, offs = batch[s]
        if CONFIG["signid_mode"] == "modulo":
            vals = vals % self.emb.num_embeddings
        else:
            vals = vals.clamp(0, max_idx)
        all_vals.append(vals)
        seg_offsets.extend((offs[1:] + base).tolist())
        base += vals.numel()
    cat_vals = torch.cat(all_vals)
    seg = torch.tensor(seg_offsets, device=cat_vals.device, dtype=torch.long)
    emb = self.emb(cat_vals).to(target_dtype)
    pooled = torch.segment_reduce(emb, reduce="sum", offsets=seg, initial=0)  # [28*N, emb]
    pooled = pooled.view(self.slot_num, N, self.emb_dim).permute(1, 0, 2).reshape(N, -1)
    return self.linear(self.input_norm(pooled))
 ```
 > 验证点：`seg_offsets` 构造正确性强依赖每个 slot 的 offsets 含开头的 0 —— 测试里务必覆盖「某样本某 slot 为空」的情况（offsets 出现连续相等）。FP16 下放宽 atol。
 - [ ] **Step 4: 跑测试确认通过**
 Run：`!python -m pytest test_equiv.py::test_rep_fused_matches_perslot -v`
 Expected：PASS。
 - [ ] **Step 5: bench 确认 AUC 不变、延迟下降 + Commit**
 ```python
 import bench, importlib, infer; importlib.reload(infer); importlib.reload(bench)
 bench.run_once({})
 ```
 Expected：AUC 一致，延迟下降。记入 EXPERIMENTS.md。
 ```bash
 git add 代码/code/infer.py 代码/code/tests/test_equiv.py 代码/code/EXPERIMENTS.md
 git commit -m "perf: RepEncoder 融合 28 次 segment_reduce 为单次"
 ```
 ### Task 12: 确认 batch_size 控制权并（若可）扫描最优
 **Files:**
 - Modify: `代码/code/EXPERIMENTS.md`
 - [ ] **Step 1: 判断评测端是否固定 batch_size**
 查 `代码/任务提交接口说明.md` 与 baseline notebook：评测端自建 DataLoader 时 `batch_size` 是否由其设定。若由评测端固定 → 我们无法在评测改 batch（**跳过本任务**，只在本地扫描了解趋势）。若 infer.py 的 `main()` 才建 loader 而评测复用我们的某入口 → 记录可控。
 - [ ] **Step 2: 本地扫描 batch_size 的延迟趋势**
 ```python
 import bench
 for bs in [50, 100, 200, 400]:
    bench.run_once({}, batch_size=bs)
 ```
 Expected：延迟随 bs 变化曲线（注意显存）。记入 EXPERIMENTS.md，作为「若可控则用」的参考。
 - [ ] **Step 3: Commit**
 ```bash
 git add 代码/code/EXPERIMENTS.md
 git commit -m "exp: batch_size 控制权确认与延迟扫描"
 ```
 ### Task 13: 重估 torch.compile / CUDA Graph（图理干净后）
 **Files:**
 - Modify: `代码/code/infer.py`、`代码/code/build_env.sh`
 - Modify: `代码/code/EXPERIMENTS.md`
 - [ ] **Step 1: 对干净后的模型试 torch.compile**
 在 `load_model` 末尾（`model.eval()` 后）加可开关的：
 ```python
 if CONFIG.get("compile", False):
    model = torch.compile(model, mode="max-autotune", dynamic=True)
 ```
 `build_env.sh` 加预热（按 spec §11 模板）。bench 对比开/关。
 > FlexAttention 与 torch.compile 通常配合良好（flex 本就鼓励 compile）；这次重估可能与上次（失败）结果不同。
 - [ ] **Step 2: bench 对比 + 判定**
 ```python
 import bench
 bench.run_once({"compile": False})
 bench.run_once({"compile": True})
 ```
 若 compile 提速且 AUC 不变 → 保留并把 `compile` 默认设 True；否则关掉。CUDA Graph 仅在序列长度分桶后另行评估，本任务不强求。记入 EXPERIMENTS.md。
 - [ ] **Step 3: Commit**
 ```bash
 git add 代码/code/infer.py 代码/code/build_env.sh 代码/code/EXPERIMENTS.md
 git commit -m "exp: 图清理后重估 torch.compile"
 ```
 ---
 ## 阶段 C：收尾
 ### Task 14: PCOC 校准（可选，免费零头）
 **Files:**
 - Modify: `代码/code/infer.py`（输出处单调缩放）
 - Modify: `代码/code/EXPERIMENTS.md`
 - [ ] **Step 1: 在历史数据上估校准系数**
 用带标签的历史数据估一个对 logit 的温度/偏移 `(a, b)`，使 `mean(sigmoid(a*logit+b)) ≈ mean(label)`（只在历史上拟合，**不碰测试集**）。把系数写入 CONFIG（如 `"calib": (a, b)`），在 `CTRModel.forward` 输出前应用：`pred_logits = a * pred_logits + b`（单调，不改 AUC）。
 - [ ] **Step 2: bench 确认 PCOC 趋近 1、AUC 不变**
 ```python
 import bench
 bench.run_once({})
 ```
 Expected：PCOC 更接近 1.0，AUC 不变。记入 EXPERIMENTS.md。
 - [ ] **Step 3: Commit**
 ```bash
 git add 代码/code/infer.py 代码/code/EXPERIMENTS.md
 git commit -m "feat: 历史数据 PCOC 单调校准（不改 AUC）"
 ```
 ### Task 15: 最终提交 + 保底
 **Files:**
 - 无代码改动（打包提交）
 - [ ] **Step 1: 全测试 + bench 总确认**
 ```python
 %cd /home/aistudio/code/tests
 !python -m pytest -v
 %cd /home/aistudio/code
 !python bench.py
 ```
 Expected：所有等价测试 PASS；本地分为历史最高。
 - [ ] **Step 2: 打包并校验包内容**
 ```bash
 cd /home/aistudio/code
 rm -f predict.txt
 zip -y ../eval.zip infer.py requirements.txt build_env.sh
 unzip -l ../eval.zip   # 确认无 dataset/、ckpt.pt、bench.py、tests/
 ```
 - [ ] **Step 3: 提交并记录；保留保底版本**
 提交 `eval.zip`，把验证集分数记入 EXPERIMENTS.md。若新版翻车，立即回退到已知保底（当前 58.86 对应的 commit）。
 ```bash
 git add 代码/code/EXPERIMENTS.md
 git commit -m "exp: 最终版本提交结果"
 git tag best-$(date +%m%d)   # 标记当前最优，便于回退
 ```
 ---
 ## 自检（计划 vs spec）
 - spec §4 测量闭环 → Task 1–2 ✅
 - spec §5 阶段 A（sign-id/精度/expert合并/特征/上下文）→ Task 3–8 ✅
 - spec §6 阶段 B（注意力/MoE/embedding/batch/compile）→ Task 9–13 ✅
 - spec §7 PCOC 校准 → Task 14 ✅
 - spec §8 合规与提交纪律（10次/天、保底、包校验）→ Task 8/15 ✅
 - spec §9 成功标准（FP32 天花板、≥0.01 AUC 杠杆、延迟≤25s、PCOC∈[0.95,1.05]）→ Task 3/4-5/9-13/14 的关卡 ✅
 - spec §10 前提验证（验证集 AUC 是否 > 0.7526）→ Task 3 Step 2 判定门 ✅
 **已知风险/未决（继承自 spec §10）**：
 - 评测端是否固定 `batch_size`、传哪些截断参数 —— Task 7/12 先确认，控制权不在我方则相应任务降级为「仅本地参考」。
 - 核心前提（验证集 AUC 有上行空间）若被 Task 3 证伪，暂停阶段 B，回到与队友/官方答疑核对目标。
@@ -1,102 +0,0 @@
 # CTI 2026 推理优化 —— 冲击 80+ 设计文档
 > 日期：2026-06-14
 > 赛题：百度商业 AI 技术创新大赛 — 生成式推荐广告排序推理性能优化
 > 当前最优：58.86（延迟 86.5s / AUC 0.7526 / PCOC 1.059）
 > 目标：榜上 ≥ 80
 ---
 ## 1. 核心结论：80+ 必须靠 AUC，不能只靠延迟
 队伍重构的评分公式已用两次真实提交验证，几乎完全吻合：
 ```
 score_latency = max(0, (300 - latency) / 300)
 score_model   = ((AUC - 0.65) * 1000 + (0.15 - |PCOC - 1|) / 0.15 * 10) / 360
 score_all     = score_latency * 70 + score_model * 30      # 仅当两项 > 0
 ```
 | 提交 | 延迟 | AUC | PCOC | 公式算分 | 实际 |
 |------|------|-----|------|----------|------|
 | 基线 | 229s | 0.759 | 1.110 | 25.87 | 25.85 ✓ |
 | 最优 | 86.5s | 0.7526 | 1.059 | 58.88 | 58.86 ✓ |
 **硬推论：**
 - `score_latency` 上限 = 70（仅当 latency → 0，物理不可能）。
 - 以模型自然 AUC ≈ 0.759、PCOC 完美计，`score_model` 上限 ≈ 9.9。
 - 故**绝对天花板 ≈ 79.9**；现实里延迟压到 ~10s 也只有 ~77。
 因此 **80+ 必须有一部分来自比 0.7526 更高的 AUC**（在**验证集**上算）。榜上 80+ 的队伍一定是**又快、AUC 又更高**。当前队伍把全部精力投在延迟（58.86 中 49.8 来自延迟），而 30 分的模型桶几乎没动 —— 这正是通往 80+ 的缺口所在。
 **前提需被证实/证伪**：上述天花板说明验证集上模型真实可达 AUC 必然明显高于 0.7526，即当前推理把 AUC 压低了；否则若验证集真实 AUC 也仅 ~0.76，则「80」这一目标本身需与队友及官方答疑再核对。**阶段 A 第一步（FP32 参考跑）就是用来验证这个前提的。**
 ## 2. 策略：方案 C —— 两条腿一起，AUC 优先
 先做阶段 A（找回 / 最大化 AUC + PCOC 校准），再做阶段 B（结构性延迟重写），每一步都过本地测量关卡，确保不会用一次提交去赌一个回归。数学上**只有 A+B 一起**才能越过 80。
 ## 3. 约束与环境（来自官方规则）
 - **硬约束（违一即 0 分）**：延迟 < 300s（只计 `model(batch)` 逐 batch 累加）；AUC ∈ [0.65, 1.0]；PCOC ∈ [0.85, 1.15]；压缩包无 `dataset/`、无 `ckpt.pt`、文件在根目录、后缀为 `.zip/.tar.gz/.tar`；每天最多 10 次提交；`build_env.sh` ≤ 720s。
 - **允许**：量化（FP16/INT8）、Flash Attention（数学等价）、非结构化剪枝/稀疏（权重置零、形状不变）。
 - **禁止**：改层数 / 维度 / head 数 / FFN channel（结构化改动）；序列采样或截断；对测试集训练。
 - **评测环境**：NVIDIA A800（80GB, SM80），Python 3.10 + PyTorch 2.6.0。评测数据集 ≠ 本地基线数据集（AUC 天然有差异）。最终人工审核合规性。
 - **实验环境**：AI Studio notebook + GPU，可加载 dataset 与 ckpt.pt，可本地自评 AUC/PCOC 后再提交。
 ## 4. 设计 · 第 1 节：测量闭环（地基）
 在 notebook 里建一个带 instrumentation 的统一入口：
 - **诚实计时**：`model(batch)` 前后加 `torch.cuda.synchronize()`。当前代码未同步、CUDA 异步，本地延迟数字不可信。
 - **配置开关板**：独立开关每个变换 —— `fp16 开/关`、`expert_merge 开/关`、`signid clamp/取模`、`特征截断 开/关`；一次运行打印 AUC / PCOC / 延迟 / 总分。
 - **锁定 FP32 参考跑**：先复现官方基线（FP32、不合并 expert、不截断），确立模型真实可达 AUC，作为天花板目标。
 说明：本地测试集 AUC（~0.759）只是验证集 AUC（~0.7526）的代理，但改动**方向**可迁移 —— 本地是便宜信号，提交做最终确认。
 ## 5. 设计 · 第 2 节：阶段 A —— 找回 AUC（30 分桶）
 按顺序做消融，每步过闭环；凡能提升（或不降低）AUC 的就保留：
 1. **Sign-ID 处理（头号嫌疑）**：查 `max_sign_id` 与 5M 词表关系。`values.clamp(0, max_idx)` 把所有超界 ID 压到第 4,999,999 行；若训练用取模哈希，clamp 即与训练不一致、污染大量 embedding，可能是大幅 AUC 损失。对比 `clamp` vs `% vocab_size`。
 2. **精度摆放**：`Embedding`、最后 `linear` 头、`LayerNorm` 保留 FP32，仅大矩阵乘走 FP16；对比一刀切 `.half()` 找回多少 AUC。
 3. **Expert 合并代价**：测其真实 AUC delta；只换延迟，掉 AUC 即砍掉。
 4. **特征完整性**：核对 `max_feasign_per_slot={1:2}` 及任何 `max_ctx_len` 截断，确认没丢有信息量的特征/历史。
 5. **上下文完整性**：确认每条测试样本 attend 到该用户完整历史（因果 mask packing 正确、历史按 userid 正确挂上）。
 **目标**：把有效 AUC 从 0.7526 拉向真实天花板。每 +0.01 AUC ≈ +0.83 分，且是唯一突破 ~78 的杠杆。
 ## 6. 设计 · 第 3 节：阶段 B —— 结构性延迟重写（86.5s → ~15–25s）
 之前失败的是高层魔法（torch.compile、INT8）。真正的硬骨头是热点结构，按收益排序，**只碰计算顺序/内核，不碰数学结果**：
 1. **注意力 mask（最大单点）**：当前每 batch 现造稠密 `S×S` bool mask 喂 SDPA，**稠密 attn_mask 会让 Flash/cuDNN 退回低效路径**（Flash 名义开、实际没生效）。序列按用户 packing，应改为**块对角 + 块内因果**（per-user block-diagonal causal），让 SDPA 走快路径。
 2. **MoE 向量化**：消掉每层 8-expert 的 Python 循环、每 expert 的 `.nonzero()` 与隐含 GPU 同步，改分组 GEMM / 批量 expert 计算。
 3. **Embedding 池化融合**：每 batch 串行 28 次 `segment_reduce` → 融合为更少 kernel；处理 slot 19 重复 sign（去重 × 计数，等价省带宽）与 slot 28 瓶颈。
 4. **加大 batch**：50 → 更大（盯显存），摊薄 2039 batch 的 launch 开销。
 5. **重估 torch.compile / CUDA Graph**：图理干净后再试；CUDA Graph 用「按序列长度分桶」绕开变长形状限制。
 **目标**：~15–25s；每步仍用闭环验证 AUC 不变。
 ## 7. 设计 · 第 4 节：PCOC 校准（低优先、免费零头）
 PCOC 当前 1.059 已在区间内。对预测做单调缩放/偏移（temperature/bias），**不改 AUC**（单调变换不影响排序），把 PCOC 推向 1.0，约 +0.33 分并降低踩红线风险。**校准只在带标签的历史数据上做，绝不碰测试集**。收益小，标记为可选，提交前确认合规。
 ## 8. 设计 · 第 5 节：合规与提交纪律
 - **每个改动先分类**：改权重数值（量化/稀疏/剪枝 ✅）/ 改结构（❌）/ 用测试集训练（❌）。Sign-ID 处理与上下文组织必须与训练一致，否则不是「同一个模型」。
 - **提交预算**：10 次/天；先用本地闭环卡住，只提交本地确有提升的候选；维护提交日志。
 - **人工审核风险**：避开任何像「钻计时空子」的做法（如靠异步不同步虚报延迟）。
 - **保底**：永远留一个已知能跑、不为 0 的回退提交（当前 58.86 版本）。
 ## 9. 设计 · 第 6 节：成功标准
 - **主目标**：榜上 ≥ 80。
 - **过程关卡**：(a) 本地复现 FP32 基线 AUC，确立真实天花板；(b) 找到 ≥1 个值 ≥0.01 AUC 的找回杠杆；(c) 延迟 ≤ 25s；(d) PCOC ∈ [0.95, 1.05]。
 - **硬约束全程不破**：AUC ≥ 0.65、PCOC ∈ [0.85, 1.15]、延迟 < 300s、压缩包规范。
 ## 10. 风险与未决项
 - **核心前提待验证**：验证集真实可达 AUC 是否显著 > 0.7526。FP32 参考跑给出本地答案；首次「找回 AUC」候选的提交给出验证集答案。若证伪，需重新校准「80」目标并与队友/官方答疑核对。
 - **延迟与 AUC 的张力**：FP16、expert 合并等换延迟的手段可能掉 AUC；以 AUC 为先，延迟从不损精度的结构性重写中补。
 - **本地 ≠ 验证集**：本地分数仅作方向信号，最终以提交为准。
@@ -700,14 +700,18 @@ def load_model(ckpt_path, device='cuda:0'):
        if CONFIG["fp16"]:
            model = model.half()
-            # Embedding 始终保留 FP32（int 索引查表，不受浮点精度影响）
+            # Embedding FP16：省 ~50% 查表带宽（5M×512: 10GB→5GB），AUC 可能微降
            if not CONFIG.get("emb_fp16", False):
                model.rep_encoder.emb = model.rep_encoder.emb.to(torch.float32)
            # 额外保留 FP32 的精度敏感模块（输入/输出自动转换）
            for name, module in model.named_modules():
                if name and any(name.startswith(p) for p in CONFIG["keep_fp32_modules"]):
                    _force_fp32_io(module)
-            print(f"[INFO] FP16 on; FP32-kept: "
+            kept = []
-                  f"{('rep_encoder.emb',) + tuple(CONFIG['keep_fp32_modules'])}")
+            if not CONFIG.get("emb_fp16", False):
                kept.append("rep_encoder.emb")
            kept.extend(CONFIG["keep_fp32_modules"])
            print(f"[INFO] FP16 on; FP32-kept: {tuple(kept)}")
        else:
            model = model.float()
            print("[INFO] FP32 reference (no half)")
@@ -1,624 +0,0 @@
 # CTI 生成式推荐广告排序推理优化方案
 > 基于 baseline 代码分析、HSTU / GRAB 论文研究、官方提交规范
 ---
 ## 0. 前置修复：接口对齐（必须首先完成）
 ### 0.1 发现的问题
 官方 `任务提交接口说明.md` 定义了评测系统调用接口。baseline 代码与规范存在三处致命不匹配：
 | 接口 | 官方要求 | Baseline 实际 | 后果 |
 |------|----------|---------------|------|
 | 数据集类名 | `CTRTestSeqDataset` | `CTRUserDataset` | 评测 `from infer import CTRTestSeqDataset` 失败 |
 | 构造参数 | `test_logids_ordered`, `item_dict`, `user_seq`, `max_feasign_per_slot`, `max_ctx_len` | `item_dict`, `user_seq`, `max_feasign_per_slot`, `pred_logids` | 参数名和数量不匹配 |
 | `load_model` | `load_model(ckpt_path: Path) -> (model, device)` | `load_model(device='cuda:0', ckpt_path=None)` | 评测调用时 Path 会被错误赋给 `device` 参数 |
 评测系统会用 `python -c "from infer import CTRTestSeqDataset, load_model; ..."` 来加载你的代码。**这三处不改，任何优化都白费。**
 ### 0.2 修复步骤
 **修复 1：重命名类并调整构造参数**
 将 `CTRUserDataset` 改为 `CTRTestSeqDataset`，参数名改为 `test_logids_ordered`，增加 `max_ctx_len` 占位：
 ```python
 class CTRTestSeqDataset(Dataset):
    """按用户组织的 CTR 测试数据集（对齐评测接口）"""
    def __init__(self, test_logids_ordered, item_dict, user_seq=None,
                 max_feasign_per_slot=None, max_ctx_len=None):
        super().__init__()
        self.item_dict = item_dict
        self.user_seq = user_seq if user_seq else {}
        self.max_feasign_per_slot = max_feasign_per_slot
        self.max_ctx_len = max_ctx_len
        self.pred_logids = set(test_logids_ordered) if test_logids_ordered else set()
        # ... 其余逻辑不变
 ```
 **修复 2：修正 `load_model` 签名**
 ```python
 def load_model(ckpt_path, device='cuda:0'):
    """加载模型。签名对齐评测接口：第一个参数必须是 ckpt_path。"""
    # ... 其余逻辑不变
 ```
 ### 0.3 提交验证标准
 修改后必须在 AI Studio 提交一次，确认能跑通（得分 > 0），再开始做优化。这是所有优化的前提。
 ---
 ## 1. 优化起点（Baseline 数据）
 | 指标 | 当前值 | 说明 |
 |------|--------|------|
 | 推理耗时 | 229.18s | **只计 `model(batch)` 的逐 batch 累加时间** |
 | AUC | 0.759 | 阈值 ≥ 0.65 |
 | PCOC | 1.110 | 阈值 [0.85, 1.15] |
 | 综合得分 | 25.85 | `score_latency * 70 + score_model * 30` |
 技术栈：
 - Python 3.10.10 + PyTorch 2.6.0 + CUDA 12.4
 - 模型：RepEncoder（28 slot / 512 维 embedding）→ 8 层 Transformer（8 头 / 512 维）→ MoE FFN（8 个 expert，Top-2 gating）
 - 数据：已缓存为 9 个 shard 分片（shard_0000.pt ~ shard_0008.pt），共 2039 batch / 7774 条预测
 ---
 ## 2. 约束条件（全部来自官方规则）
 | 约束 | 来源 | 说明 |
 |------|------|------|
 | 不能改"组网" | 赛题说明 | 模型结构、层数、头数、维度不可改 |
 | 不能改参数（权重值） | 赛题说明 | 量化/稀疏化/剪枝**明确允许** |
 | 不能用测试集训练 | 赛题说明 | 仅推理，不做任何训练 |
 | 推理时限 ≤ 300s | 提交规范 §4.1 | 超时总分直接 0。**只计 `model(batch)` 时间，数据加载和模型加载不计** |
 | build_env.sh 时限 ≤ 720s | 提交规范 §3 | 超时或非 0 退出码直接失败 |
 | AUC ≥ 0.65 且 PCOC ∈ [0.85, 1.15] | 提交规范 §4.2 | 任一不满足，总分直接 0 |
 | 压缩包内不能有 `dataset/` 和 `ckpt.pt` | 提交规范 §2.2 | 评测系统自行提供 |
 | 压缩包后缀必须是 `.zip`/`.tar.gz`/`.tar` | 提交规范 §1 | 其他格式不识别 |
 | 解压后文件必须直接在根目录 | 提交规范 §1 | 不能多一层包裹文件夹 |
 ---
 ## 3. 优化方案总览（修订版）
 ```
 第〇步：接口对齐（不优化，先跑通）
  └── 确认能提交得分 > 0
       │
 第①步：FP16 量化 ←── 明确允许，收益最大
  └── 预期：229s → ~120s
       │
 第②步：Flash Attention ←── 数学等价，不改组网
  └── 预期：120s → ~90s
       │
 第③步：torch.compile ←── 编译器优化，不改组网
  └── 预期：90s → ~65s
       │
 第④步：数据流优化 ←── 减少 CPU→GPU 传输开销
  └── 预期：65s → ~55s
       │
 第⑤步：MoE 优化 ←── "剪枝"明确允许
  └── 预期：55s → ~50s
       │
 第⑥步：INT8 量化（可选） ←── 收益大但风险高
  └── 只有在①②③⑤之后仍不够时才尝试
 ```
 每个方案完成后在 AI Studio 提交验证，确认分数提升后再进入下一步。
 ---
 ## 4. 方案一：FP16 量化
 ### 4.1 合规性
 ✅ 比赛规则明确写有"量化除外"，属于允许范围。
 ### 4.2 原理
 当前 baseline 使用 FP32。FP16 将模型参数和激活值减半，GPU 的张量核心对 FP16 有原生加速。注意 `Embedding` 层保留 FP32（索引是整数，embedding 查表时再转换）。
 ### 4.3 实现
 修改 `load_model` 函数中的模型加载部分：
 ```python
 def load_model(ckpt_path, device='cuda:0'):
    # ... 模型初始化不变 ...
    dev = torch.device(device if torch.cuda.is_available() else "cpu")
    if ckpt_path is None:
        ckpt_path = Path(__file__).parent / 'ckpt.pt'
    else:
        ckpt_path = Path(ckpt_path)
    if ckpt_path.exists():
        ckpt = torch.load(ckpt_path, map_location='cpu', weights_only=False)
        model.load_state_dict(ckpt['model_state_dict'])
        # === FP16 优化：将模型转为半精度 ===
        model = model.half()
        # Embedding 层保留 FP32（索引是 int，不需要转）
        model.rep_encoder.emb = model.rep_encoder.emb.to(torch.float32)
        print(f"[INFO] Loaded checkpoint from {ckpt_path} (epoch={ckpt.get('epoch', '?')})")
    else:
        print(f"[WARNING] Checkpoint {ckpt_path} not found, using random weights")
    model.to(dev)
    model.eval()
    print(f"[INFO] Model ready. Device: {dev}")
    return model, dev
 ```
 `move_batch_to_device` 中同步处理输入数据精度：
 ```python
 def move_batch_to_device(batch, device):
    if isinstance(batch, dict):
        return {k: move_batch_to_device(v, device) for k, v in batch.items()}
    elif isinstance(batch, (list, tuple)):
        return [move_batch_to_device(x, device) for x in batch]
    elif torch.is_tensor(batch):
        x = batch.to(device)
        # 浮点 tensor → FP16，整数 tensor 保持不变
        if x.dtype == torch.float32:
            x = x.half()
        return x
    else:
        return batch
 ```
 同时修改 `main()` 中缓存 batch 的逻辑，在落地磁盘前就转 FP16，避免推理时逐 batch 转换：
 ```python
 for batch in test_loader:
    # 预转为 FP16
    batch = move_batch_to_device(batch, torch.device('cpu'))
    all_batches.append(batch)
 ```
 ### 4.4 风险
 - 极低。现代 NVIDIA GPU（V100/A100/H100 等）的 FP16 吞吐量是 FP32 的 2-8 倍
 - Embedding 保留 FP32 是因为 embedding 查表操作用 int 索引，不受浮点精度影响
 ### 4.5 预期收益
 | 指标 | 变化 |
 |------|------|
 | 推理时间 | 229s → ~115-150s |
 | AUC | 几乎不变（差异 < 0.0001） |
 ---
 ## 5. 方案二：Flash Attention
 ### 5.1 合规性
 ✅ Flash Attention 是**数学等价**的注意力计算。它用分块（tiling）算法计算 `softmax(QK^T/√d)V`，**输出结果与标准 attention 相同**（在浮点误差范围内）。不改变模型结构、不改变参数——只改变了内存访问模式和计算顺序。这属于编译器级优化，不是组网修改。
 ### 5.2 原理
 Baseline 的 `scaled_dot_product` 先计算完整的 `QK^T` 矩阵（O(L²) 显存），再做 softmax，再乘 V。Flash Attention 将 Q、K、V 分块加载到 SRAM，逐块计算 softmax 并累积结果，**避免完整 QK^T 驻留 HBM**。
 Baseline 用了 Sequence Packing（同一用户的多个 impression 拼成一条长序列），序列越长收益越大。
 ### 5.3 实现
 PyTorch 2.0+ 提供了 `F.scaled_dot_product_attention`，自动选择最优后端（Flash Attention / Memory Efficient Attention / 标准实现）：
 ```python
 import torch.nn.functional as F
 def scaled_dot_product(q, k, v, extension):
    """使用 PyTorch SDPA 后端（自动启用 Flash Attention）"""
    d = q.size(-1)
    if extension is not None and "mask" in extension:
        mask = extension["mask"]
        # mask 形状: [1, 1, S, S] 或 [B, 1, S, S]
        # 转换为 float mask，确保 device 和 dtype 一致
        attn_mask = mask.to(device=q.device, dtype=q.dtype)
    else:
        attn_mask = None
    return F.scaled_dot_product_attention(
        q, k, v,
        attn_mask=attn_mask,
        dropout_p=0.0,
        is_causal=False,
    )
 ```
 验证是否启用了 Flash Attention：
 ```python
 import torch
 # 在模型加载后运行，确认后端可用
 print("Flash SDP:", torch.backends.cuda.flash_sdp_enabled())
 print("Mem Efficient SDP:", torch.backends.cuda.mem_efficient_sdp_enabled())
 print("Math SDP:", torch.backends.cuda.math_sdp_enabled())
 ```
 ### 5.4 与 Baseline 输出的兼容性
 Baseline 中 mask 是 `torch.bool` 类型，原代码用 `scores.masked_fill(mask == 0, float("-inf"))` 处理。`F.scaled_dot_product_attention` 接受 bool mask 时自动做等价处理。数学等价，不会影响 AUC/PCOC。
 ### 5.5 预期收益
 | 序列长度 | 加速比 |
 |----------|--------|
 | < 512 | 1.1x - 1.3x |
 | 512 - 2048 | 1.5x - 2x |
 | > 2048 | 2x - 4x |
 ---
 ## 6. 方案三：torch.compile
 ### 6.1 合规性
 ✅ `torch.compile` 是纯粹的**编译器优化**（JIT 编译 + 算子融合）。它不改变模型结构、不改变权重值、不改变任何数学运算——只是把多个小 kernel 合并成一个大 kernel 以减少 GPU kernel launch 开销。
 ### 6.2 实现
 在 `load_model` 中，`model.eval()` 之后添加一行：
 ```python
 model = torch.compile(model, mode="reduce-overhead")
 ```
 `mode` 选择：
 | 模式 | 行为 | 适合场景 |
 |------|------|----------|
 | `"default"` | 平衡编译速度与运行时 | 不确定时先用这个 |
 | `"reduce-overhead"` | 更激进的融合，减少 kernel launch | **推理场景首选** |
 | `"max-autotune"` | 自动调优 Triton kernel（首次编译慢） | 最终提交时切换到此 |
 建议先用 `"reduce-overhead"` 快速验证，最终提交时换成 `"max-autotune"`。
 ### 6.3 已知限制
 - 首次运行会触发 JIT 编译（0.5-2 分钟），在评测环境可能计入推理时间
 - 解决：在 `build_env.sh` 中用一个小输入做一次预热编译：
 ```bash
 #!/bin/bash
 set -e
 pip install -r requirements.txt -i https://mirrors.aliyun.com/pypi/simple/
 # 预热 torch inductor，避免推理时编译
 python -c "
 import torch
@torch.compile(mode='max-autotune')
 def warmup(x):
    return x * 2
 x = torch.randn(100, 100, device='cuda')
 warmup(x)
 print('Inductor cache ready')
 "
 echo "build env success"
 ```
 ### 6.4 预期收益
 | 模式 | 加速比 |
 |------|--------|
 | reduce-overhead | 1.2x - 1.4x |
 | max-autotune | 1.3x - 1.5x（首次多花 1-2 分钟） |
 ---
 ## 7. 方案四：数据流优化
 ### 7.1 重要澄清：评测的计时逻辑
 从提交规范 §4.1：
 > 只统计模型前向时间（逐 batch 累加 `model(batch)` 耗时），数据加载、模型加载不计入。
 所以 **DataLoader 层面的优化（num_workers、pin_memory）不影响评分**。但这不代表数据流优化没用——以下两点仍然有效：
 1. **减少 `move_batch_to_device` 开销**：此函数在 `model(batch)` 之前调用，但如果它在推理循环里逐 batch 执行，仍会阻塞。解决方案：提前把所有 batch 搬到 GPU。
 2. **减少 FP32→FP16 转换开销**：在缓存阶段就转好，推理循环里无需重复转换。
 ### 7.2 实现
 在 `main()` 的数据加载部分，缓存时就完成设备搬运和类型转换：
 ```python
 # 原代码
 all_batches = [batch for batch in test_loader]
 # 优化：缓存时直接搬到 GPU + 转 FP16
 dev = torch.device('cuda:0')
 all_batches = []
 for batch in test_loader:
    batch = move_batch_to_device(batch, dev)
    all_batches.append(batch)
 ```
 这样推理循环中不需要再调用 `move_batch_to_device`：
 ```python
 with torch.no_grad():
    for batch in tqdm(all_batches, desc="Inference"):
        # batch 已在 GPU 上，无需 move_batch_to_device
        pred_mask = batch["pred_mask"].bool()
        t_start = time.time()
        logits, moe_loss = model(batch)
        logits = logits.squeeze(-1)
        probs = torch.sigmoid(logits)
        time_sum += time.time() - t_start
        # ...
 ```
 ### 7.3 潜在问题
 全部 batch 都在 GPU 上会占用大量显存。如果数据总量超过可用显存，会 OOM。安全做法：先测试单个 shard 的显存占用，若不够则分批预加载。
 如果显存不够，采用双缓冲策略（当前 batch 在 GPU 推理，下一个 batch 异步上传）。
 ### 7.4 预期收益
 有限（因为数据加载本来就不计分），但能消除循环内的不必要开销。
 ---
 ## 8. 方案五：MoE 推理优化
 ### 8.1 合规性
 ✅ "剪枝"是规则明确允许的三种优化之一（量化/稀疏/剪枝）。Expert 剪枝属于模型剪枝的子类。
 ### 8.2 当前状态
 ```python
 class SMoE(nn.Module):
    def __init__(self, d_model, dim_ff, num_experts=8, k=2):
        # 每层 8 个 FFN expert，每个 token 激活 2 个
 ```
 8 层 × 8 expert = 64 个 FFN 模块。推理时大多数 token 只会路由到少数 expert。
 ### 8.3 优化方向
 **a) Expert 负载统计 + 合并**
 对少量数据做一次前向，统计各 expert 的被激活次数：
 ```python
 expert_hits = torch.zeros(8, 8)  # [layers, experts]
 model.eval()
 with torch.no_grad():
    for batch in sample_batches[:10]:  # 只用 10 个 batch 采样
        batch = move_batch_to_device(batch, dev)
        for layer_idx, moe in enumerate(model.seq_encoder.moe):
            topk_idx, _, _ = moe.gate(x)  # x 需要从 forward 中间取
            for e in range(8):
                expert_hits[layer_idx, e] += (topk_idx == e).sum()
 ```
 如果某个 expert 激活次数 < 1%，可将其权重合并到最相似的 expert（通过权重余弦相似度找最近邻），或直接移除（需验证 AUC 不掉）。
 **b) 替换为静态 FFN（激进方案）**
 如果发现某些层的 expert 负载极度不均衡（例如 95% token 走同一个 expert），可直接把该层的 SMoE 替换为单个 Expert：
 ```python
 # 仅当某层 expert 负载极不均衡时
 # 找到最常用的 expert
 best = expert_hits[layer_idx].argmax().item()
 # 替换 SMoE 为单个 Expert
 model.seq_encoder.moe[layer_idx] = model.seq_encoder.moe[layer_idx].experts[best]
 ```
 此方案**必须提交验证 AUC/PCOC 不跌破阈值**。
 ### 8.4 风险
 - 负载统计需要从 Transformer forward 中间提取 gate 输出，需要修改 forward 添加 hook
 - Expert 合并可能影响 AUC 0.001-0.005
 ### 8.5 预期收益
 | 操作 | 加速比 |
 |------|--------|
 | 移除 1-2 个死 expert | 1.05x - 1.15x |
 | 替换 2-3 层为单 FFN | 1.2x - 1.4x |
 ---
 ## 9. 方案六：INT8 量化（可选）
 ### 9.1 合规性
 ✅ "量化除外"，明确允许。
 ### 9.2 适用条件
 只有在前 5 步做完后仍需进一步加速时才尝试。INT8 量化需要校准数据（可用测试集的一小部分做 calibration），有精度损失风险。
 ```python
 import torch.quantization as quant
 # 仅对 Transformer encoder 做 INT8 量化（Embedding 层跳过）
 model.seq_encoder.qconfig = quant.get_default_qconfig('qnnpack')
 model.seq_encoder = quant.quantize_dynamic(
    model.seq_encoder,
    {nn.Linear},  # 仅量化 Linear 层
    dtype=torch.qint8,
 )
 ```
 ### 9.3 风险
 - AUC 可能下降 0.005-0.02，需提交后验证
 - 如果评测环境无 GPU（CPU-only），QNNPACK 才有用；GPU 下需用 TensorRT 做 INT8
 ---
 ## 10. CUDA Graph（为什么不做）
 原方案中列了 CUDA Graph，审查后**移除**，理由如下：
 1. CUDA Graph 要求**所有输入形状完全相同**。Baseline 数据经过 Sequence Packing，不同 batch 的序列长度差异很大，不满足这一前提
 2. 每个 batch 的 `user_offsets` 长度不同，导致 mask 形状也不同
 3. 若要强行使用，需要对 batch 做 padding 对齐，反而引入额外开销
 **结论：不适用于本场景，放弃此方案。**
 ---
 ## 11. 部署要点
 ### 11.1 压缩包结构
 ```
 submit.zip
 ├── infer.py              # 主推理脚本（实现所有必需接口）
 ├── requirements.txt      # Python 依赖列表
 └── build_env.sh          # 环境构建脚本（可选但推荐）
 ```
 提交前务必验证：
 - [ ] 包内**没有** `dataset/` 目录
 - [ ] 包内**没有** `ckpt.pt` 文件
 - [ ] 包内**没有**多余的顶层文件夹
 - [ ] 后缀是 `.zip`（或 `.tar.gz`）
 ### 11.2 build_env.sh 设计
 ```bash
 #!/bin/bash
 set -e
 # 安装依赖（评测系统自动使用阿里云镜像）
 pip install -r requirements.txt
 # 预热 torch compile（如果方案三启用）
 python -c "
 import torch
@torch.compile(mode='max-autotune')
 def _warmup(x): return x * 2
 _warmup(torch.randn(100, 100, device='cuda'))
 print('Inductor ready')
 " 2>/dev/null || echo 'torch.compile not available, skipping'
 echo "build env success"
 ```
 ### 11.3 requirements.txt（最小化）
 ```
 torch==2.6.0
 triton==3.2.0
 numpy==2.2.6
 scikit-learn==1.7.2
 tqdm==4.67.3
 ```
 - 去掉所有 `nvidia-*` 包（评测环境已预装 CUDA）
 - 版本号精确锁定，避免安装时依赖冲突
 ---
 ## 12. 风险评估与底线策略
 ### 各方案对模型质量的影响
 | 方案 | AUC 影响 | PCOC 影响 | 0 分风险 |
 |------|----------|-----------|----------|
 | 接口修复 | 无 | 无 | **必须做，否则直接 0 分** |
 | FP16 | < 0.0001 | < 0.0001 | 极低 |
 | Flash Attention | < 0.0001 | 无 | 极低 |
 | torch.compile | 无 | 无 | 低（首次编译可能超时） |
 | GPU 预加载 | 无 | 无 | 低（OOM 风险） |
 | MoE 剪枝 | 0.001 - 0.005 | 微小 | 中（需提交验证） |
 | INT8 | 0.005 - 0.02 | 可能偏移 | 高（可能跌破阈值） |
 ### 安全策略（必须遵守）
 每完成一个优化：
 1. 在 AI Studio 提交，拿到新得分
 2. 记录本次得分变化
 3. 如果 AUC < 0.65 或 PCOC 不在 [0.85, 1.15]，立即回退该优化
 4. 如果得分上升，保留并进入下一步
 ### 保底策略
 - 至少完成接口修复 + FP16，能稳定拿到 > 25 分
 - 如果 Flash Attention / torch.compile 跑不通，回退不影响得分
 - **在截止日期前一天（6 月 25 日）停止实验**，提交当前最优版本
 ---
 ## 13. 实施检查清单
 ### 第〇周（立即）
 - [ ] 修复接口：`CTRTestSeqDataset`、`load_model(ckpt_path, ...)` 
 - [ ] 在 AI Studio 提交一次，确认得分 > 0（验证接口正确）
 ### 第一轮
 - [ ] FP16 量化：`model.half()` + embedding 保留 FP32
 - [ ] 数据预加载到 GPU + 预转 FP16
 - [ ] 提交验证
 ### 第二轮
 - [ ] Flash Attention：替换 `scaled_dot_product`
 - [ ] `torch.compile(mode="reduce-overhead")`
 - [ ] `build_env.sh` 写预热逻辑
 - [ ] 提交验证
 ### 第三轮（时间允许）
 - [ ] MoE expert 负载分析 + 合并
 - [ ] `torch.compile` 切换为 `"max-autotune"`
 - [ ] INT8 量化评估（如果得分仍不满意）
 ---
 ## 14. 预期效果（修订）
 | 阶段 | 预期推理时间 | 预期得分 | 主要贡献 |
 |------|-------------|----------|----------|
 | Baseline | 229s | 25.85 | — |
 | 接口修复 | 229s | 25.85 | 确保能跑 |
 | + FP16 + GPU 预加载 | ~120s | ~50 | 量化为主要贡献 |
 | + Flash Attention | ~90s | ~60 | 长序列受益 |
 | + torch.compile | ~65s | ~70 | 算子融合 |
 | + MoE 优化 | ~50s | ~78 | 剪枝 |
 | 极限（+INT8） | ~30s | ~87 | 有精度风险 |
 ---
 ## 附录 A：官方规则原文引用
 来自赛题说明页面：
 > 【由于是推理性能优化，组网不可进行策略性改动，不可对测试集进行训练】
 来自 baseline notebook 第三单元：
 > 选手不可对组网和相关参数进行修改。【违规为0分】
 > **量化稀疏剪枝除外**
 来自 `任务提交接口说明.md` §4-5：
 > - 延迟阈值：300 秒。只统计模型前向时间（逐 batch 累加 model(batch) 耗时）
 > - AUC ∈ [0.65, 1.0]、PCOC ∈ [0.85, 1.15]，任一不满足总分直接置 0
 > - 压缩包自带 dataset/ 或 ckpt.pt → 评测失败
 > - build_env.sh 超时 720 秒或返回码非 0 → 评测失败
 ## 附录 B：相关资源
 | 资源 | 链接 |
 |------|------|
 | GRAB 论文 | arXiv 2602.01865 |
 | HSTU 论文 | arXiv 2402.17152 (ICML 2024) |
 | 官方 Baseline 项目 | AI Studio project/10186630 |
 | 比赛主页 | aistudio.baidu.com/competition/detail/1461 |
 | 提交结果页 | aistudio.baidu.com/competition/detail/1461/0/submit-result |
Author	SHA1	Message	Date
Serendipity	f7f4966ef1	docs: 提交记录新增备注列，标注每次提交的优化细节 Co-Authored-By: Claude <noreply@anthropic.com>	2026-06-15 17:38:20 +08:00
Serendipity	34671a2a29	docs: 提交记录统一为 AI Studio 原始表格格式 Co-Authored-By: Claude <noreply@anthropic.com>	2026-06-15 17:36:45 +08:00
Serendipity	437e0b3f26	docs: 补充 06/12-06/13 完整提交记录 Co-Authored-By: Claude <noreply@anthropic.com>	2026-06-15 17:35:13 +08:00
Serendipity	887a8cff86	chore: 移除 emb_fp16 开关，暂不启用 Embedding FP16 Co-Authored-By: Claude <noreply@anthropic.com>	2026-06-15 17:33:54 +08:00
Serendipity	af1795d371	docs: 完整提交记录（06/12-06/15，含张君硕/刘航宇全部数据） Co-Authored-By: Claude <noreply@anthropic.com>	2026-06-15 17:31:50 +08:00
Serendipity	69f28f0673	docs: 张君硕记录并入提交表，移除竞品参考区块 Co-Authored-By: Claude <noreply@anthropic.com>	2026-06-15 17:30:06 +08:00
Serendipity	5634b04b00	feat: Embedding FP16 开关 + 团队成员信息完善 + gitignore 更新 - infer.py: 新增 emb_fp16 CONFIG 选项（默认 False），Embedding 权重可 FP16 省查表带宽 - CLAUDE.md: 补充团队成员表（AI Studio 用户名→真实姓名） - README.md: 新增团队区块，标注三人参赛身份 - .gitignore: 排除 DVC/HF 工具自动生成的元数据文件 Co-Authored-By: Claude <noreply@anthropic.com>	2026-06-15 17:26:25 +08:00
Serendipity	c5a1aedef1	docs: 更新 README、删除过时文档（推理优化方案/superpowers 计划） - README.md: 重写为简洁版（有效优化表、文件结构、评测环境） - 删除推理优化方案.md（内容已合并到 CLAUDE.md） - 删除 docs/superpowers/（过期实现计划） - 保留 EXPERIMENTS.md（实验记录模板）	2026-06-15 14:39:18 +08:00
Serendipity	cfacfda64e	docs: 更新优化路线（PR#1 三项新优化）、提交记录、竞品分析	2026-06-15 14:36:34 +08:00
Serendipity	22c91a9522	Merge pull request 'feat/auc-recovery-plan' (#1 ) from feat/auc-recovery-plan into main Reviewed-on: #1	2026-06-15 12:33:32 +08:00