AI 论文精读、复现与撰写

"""最小可运行示例：按关键词检索 arXiv，打印标题、日期、摘要。

只用标准库：urllib 发请求，xml.etree 解析 Atom 返回，不装任何第三方包。
arXiv 的公开检索接口地址是 http://export.arxiv.org/api/query，无需申请 key。

用法：
    python3 arxiv_search_min.py
    python3 arxiv_search_min.py "contrastive language image pretraining" 5
"""

import sys
import urllib.parse
import urllib.request
import xml.etree.ElementTree as ET

API = "http://export.arxiv.org/api/query"
NS = {"a": "http://www.w3.org/2005/Atom"}


def search(keyword, max_results=5):
    # all: 表示在标题/摘要/作者等所有字段里找；想只搜标题就换成 ti:
    params = {
        "search_query": 'all:"%s"' % keyword,
        "start": 0,
        "max_results": max_results,
        "sortBy": "submittedDate",      # 按提交时间倒序，先看最新的
        "sortOrder": "descending",
    }
    url = API + "?" + urllib.parse.urlencode(params)
    # 官方要求带一个可识别的 User-Agent，不带容易被限流
    req = urllib.request.Request(url, headers={"User-Agent": "heima-notes-demo/1.0"})
    with urllib.request.urlopen(req, timeout=30) as resp:
        raw = resp.read().decode("utf-8")
    return parse(raw)


def parse(xml_text):
    """Atom feed -> 字典列表。字段名照 arXiv 返回的原样取。"""
    root = ET.fromstring(xml_text)
    papers = []
    for entry in root.findall("a:entry", NS):
        def text(tag):
            node = entry.find("a:" + tag, NS)
            return (node.text or "").strip() if node is not None else ""

        papers.append({
            "title": " ".join(text("title").split()),          # 标题里带换行，压成一行
            "published": text("published")[:10],               # 2021-02-26T...  取前 10 位
            "updated": text("updated")[:10],
            "summary": " ".join(text("summary").split()),
            "authors": [a.find("a:name", NS).text
                        for a in entry.findall("a:author", NS)],
            "link": text("id"),
        })
    return papers


def main():
    keyword = sys.argv[1] if len(sys.argv) > 1 else "diffusion model"
    n = int(sys.argv[2]) if len(sys.argv) > 2 else 5

    papers = search(keyword, n)
    print("关键词：%s    命中 %d 篇\n" % (keyword, len(papers)))
    for i, p in enumerate(papers, 1):
        print("[%d] %s" % (i, p["title"]))
        print("    提交 %s   更新 %s" % (p["published"], p["updated"]))
        print("    作者 %s" % ", ".join(p["authors"][:4]))
        print("    链接 %s" % p["link"])
        # 摘要截断到 220 字，第一遍筛选本来就只需要看开头几句
        print("    摘要 %s...\n" % p["summary"][:220])


if __name__ == "__main__":
    main()

"""案例一：批量检索 + 时间/关键词过滤，导出一份候选清单 Markdown。

它把「第一遍筛选」这件事做成流水线：
    多组关键词 -> 合并去重 -> 时间窗过滤 -> 必含词/排除词过滤 -> 导出带勾选框的清单

导出的 candidates.md 直接就是第一遍阅读的工作台：
每篇一个 checkbox，读完打勾并在「留/弃」一栏写一个字。

只用标准库。用法：
    python3 arxiv_survey.py
    python3 arxiv_survey.py --since 2024-01-01 --out /tmp/candidates.md
"""

import argparse
import re
import sys
import time
import urllib.parse
import urllib.request
import xml.etree.ElementTree as ET

API = "http://export.arxiv.org/api/query"
NS = {"a": "http://www.w3.org/2005/Atom"}

# ---- 检索配置：按主题拆成几组关键词，覆盖面比一条长查询好得多 ----
QUERIES = [
    "contrastive language image pretraining",
    "text to image diffusion",
    "classifier-free guidance",
]
MUST_INCLUDE = []                  # 标题或摘要必须命中其中之一，留空表示不限制
MUST_EXCLUDE = ["survey of surveys"]   # 命中即丢弃
PER_QUERY = 25


def fetch(keyword, max_results):
    params = {
        "search_query": 'all:"%s"' % keyword,
        "start": 0,
        "max_results": max_results,
        "sortBy": "submittedDate",
        "sortOrder": "descending",
    }
    url = API + "?" + urllib.parse.urlencode(params)
    req = urllib.request.Request(url, headers={"User-Agent": "heima-notes-survey/1.0"})
    with urllib.request.urlopen(req, timeout=40) as resp:
        return resp.read().decode("utf-8")


def parse(xml_text, source):
    root = ET.fromstring(xml_text)
    out = []
    for entry in root.findall("a:entry", NS):
        def text(tag):
            node = entry.find("a:" + tag, NS)
            return (node.text or "").strip() if node is not None else ""

        link = text("id")
        out.append({
            "id": link.rstrip("/").split("/")[-1],      # 2103.00020v1
            "title": " ".join(text("title").split()),
            "published": text("published")[:10],
            "summary": " ".join(text("summary").split()),
            "authors": [a.find("a:name", NS).text for a in entry.findall("a:author", NS)],
            "link": link,
            "source": source,
        })
    return out


def keep(paper, since, until):
    date = paper["published"]
    if since and date < since:
        return False
    if until and date > until:
        return False

    blob = (paper["title"] + " " + paper["summary"]).lower()
    if MUST_INCLUDE and not any(w.lower() in blob for w in MUST_INCLUDE):
        return False
    if any(w.lower() in blob for w in MUST_EXCLUDE):
        return False
    return True


def collect(since, until):
    seen, papers = set(), []
    for q in QUERIES:
        try:
            raw = fetch(q, PER_QUERY)
        except Exception as exc:                      # 网络波动不该让整轮白跑
            print("检索失败：%s（%s）" % (q, exc), file=sys.stderr)
            continue
        for p in parse(raw, q):
            base = re.sub(r"v\d+$", "", p["id"])      # 去掉版本号再去重
            if base in seen:
                continue
            seen.add(base)
            if keep(p, since, until):
                papers.append(p)
        time.sleep(3)                                 # 官方建议的请求间隔，别打太快
    papers.sort(key=lambda x: x["published"], reverse=True)
    return papers


def to_markdown(papers, since, until):
    lines = [
        "# 候选论文清单",
        "",
        "时间窗：%s ~ %s    共 %d 篇" % (since or "不限", until or "不限", len(papers)),
        "",
        "读法：一篇给 10 分钟，只看标题和摘要，决定「留」还是「弃」，在表格里写一个字。",
        "",
        "| 留/弃 | 日期 | 标题 | 一句话理由 |",
        "| :-: | :-: | --- | --- |",
    ]
    for p in papers:
        title = p["title"].replace("|", "/")
        lines.append("|  | %s | [%s](%s) |  |" % (p["published"], title, p["link"]))

    lines += ["", "---", "", "## 摘要速览", ""]
    for i, p in enumerate(papers, 1):
        lines += [
            "### %d. %s" % (i, p["title"]),
            "",
            "- 日期：%s ｜ 命中关键词：`%s`" % (p["published"], p["source"]),
            "- 作者：%s" % ", ".join(p["authors"][:5]),
            "- 链接：%s" % p["link"],
            "",
            "> %s" % p["summary"][:600],
            "",
        ]
    return "\n".join(lines)


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--since", default="", help="起始日期 YYYY-MM-DD")
    ap.add_argument("--until", default="", help="截止日期 YYYY-MM-DD")
    ap.add_argument("--out", default="candidates.md")
    args = ap.parse_args()

    papers = collect(args.since, args.until)
    md = to_markdown(papers, args.since, args.until)
    with open(args.out, "w", encoding="utf-8") as f:
        f.write(md)
    print("命中 %d 篇，已写入 %s" % (len(papers), args.out))


if __name__ == "__main__":
    main()

"""案例二：从 BibTeX 条目生成规范引用文本。

写论文时最琐碎又最容易出错的一步：同一批文献要在正文里写成 GB/T 7714、
在英文投稿里写成 IEEE 或 ACM 风格，手动排版必然漏标点、丢页码、作者顺序颠倒。
这个脚本把 .bib 解析成结构化字典，再按模板渲染成几种常见格式。

只用标准库。用法：
    python3 bibtex_cite.py refs.bib
    python3 bibtex_cite.py refs.bib --style ieee
    python3 bibtex_cite.py refs.bib --check      # 只做字段完整性体检
"""

import argparse
import re
import sys

# 每种条目类型的必填字段。缺字段的引用在审稿人眼里等同于「没读过原文」。
REQUIRED = {
    "article": ["author", "title", "journal", "year"],
    "inproceedings": ["author", "title", "booktitle", "year"],
    "book": ["author", "title", "publisher", "year"],
    "misc": ["author", "title", "year"],
}


def parse_bib(text):
    """极简 BibTeX 解析：按 @type{key, ...} 切块，再按 field = {value} 取字段。

    只处理花括号包裹的值，够应付 Google Scholar / arXiv / DBLP 导出的条目。
    真项目里文献量大、格式杂，建议直接用 bibtexparser 库。
    """
    entries = []
    for m in re.finditer(r"@(\w+)\s*\{\s*([^,]+),(.*?)\n\}", text, re.S):
        etype, key, body = m.group(1).lower(), m.group(2).strip(), m.group(3)
        fields = {}
        for fm in re.finditer(r"(\w+)\s*=\s*\{(.*?)\}\s*,?\s*(?=\n\s*\w+\s*=|\s*$)",
                              body, re.S):
            name = fm.group(1).lower()
            value = " ".join(fm.group(2).split())
            fields[name] = value
        entries.append({"type": etype, "key": key, "fields": fields})
    return entries


def split_authors(raw):
    """BibTeX 作者用 and 分隔，姓名可能写成 "Last, First" 或 "First Last"。"""
    people = []
    for person in re.split(r"\s+and\s+", raw):
        person = person.strip()
        if not person:
            continue
        if "," in person:
            last, first = [x.strip() for x in person.split(",", 1)]
        else:
            parts = person.split()
            last, first = parts[-1], " ".join(parts[:-1])
        people.append((last, first))
    return people


def initials(first):
    return " ".join(p[0] + "." for p in first.split() if p)


def fmt_gbt(entry):
    """GB/T 7714 风格：作者用全大写姓 + 名首字母，三人以上加「等」。"""
    f = entry["fields"]
    people = split_authors(f.get("author", ""))
    names = ["%s %s" % (last.upper(), initials(first).replace(".", "").replace(" ", ""))
             for last, first in people[:3]]
    author = ", ".join(names) + ("，等" if len(people) > 3 else "")
    venue = f.get("journal") or f.get("booktitle") or f.get("publisher", "")
    tail = ", ".join(x for x in [f.get("volume", ""), f.get("pages", "")] if x)
    return "%s. %s[J/OL]. %s, %s%s." % (
        author, f.get("title", ""), venue, f.get("year", ""),
        (", " + tail) if tail else "")


def fmt_ieee(entry):
    f = entry["fields"]
    people = split_authors(f.get("author", ""))
    names = ["%s %s" % (initials(first), last) for last, first in people]
    if len(names) > 6:
        author = names[0] + " et al."
    elif len(names) > 1:
        author = ", ".join(names[:-1]) + " and " + names[-1]
    else:
        author = names[0] if names else ""
    venue = f.get("journal") or f.get("booktitle") or f.get("publisher", "")
    bits = ['%s, "%s,"' % (author, f.get("title", "")), "%s," % venue]
    if f.get("volume"):
        bits.append("vol. %s," % f["volume"])
    if f.get("pages"):
        bits.append("pp. %s," % f["pages"].replace("--", "-"))
    bits.append("%s." % f.get("year", ""))
    return " ".join(bits)


def fmt_inline(entry):
    """正文里的作者-年份引用，用来快速检查「引了但没在正文出现」。"""
    people = split_authors(entry["fields"].get("author", ""))
    year = entry["fields"].get("year", "n.d.")
    if not people:
        return "(%s)" % year
    if len(people) == 1:
        return "(%s, %s)" % (people[0][0], year)
    if len(people) == 2:
        return "(%s & %s, %s)" % (people[0][0], people[1][0], year)
    return "(%s et al., %s)" % (people[0][0], year)


STYLES = {"gbt": fmt_gbt, "ieee": fmt_ieee, "inline": fmt_inline}


def check(entries):
    bad = 0
    for e in entries:
        need = REQUIRED.get(e["type"], REQUIRED["misc"])
        missing = [k for k in need if not e["fields"].get(k)]
        if missing:
            bad += 1
            print("缺字段  %-28s %s -> %s" % (e["key"], e["type"], ", ".join(missing)))
        if e["type"] == "misc" and "arxiv" in e["fields"].get("title", "").lower():
            print("提示    %-28s 正式发表版优先于 arXiv 预印本" % e["key"])
    print("\n体检完成：%d 条，其中 %d 条字段不全" % (len(entries), bad))
    return bad


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("bib")
    ap.add_argument("--style", default="gbt", choices=sorted(STYLES))
    ap.add_argument("--check", action="store_true")
    args = ap.parse_args()

    with open(args.bib, encoding="utf-8") as f:
        entries = parse_bib(f.read())
    if not entries:
        print("没解析到任何条目，检查一下 .bib 是不是花括号风格", file=sys.stderr)
        return

    if args.check:
        check(entries)
        return

    render = STYLES[args.style]
    for i, e in enumerate(entries, 1):
        print("[%d] %s" % (i, render(e)))


if __name__ == "__main__":
    main()

"""案例三：把精读模板批量实例化成一人一篇的笔记文件。

读一份候选清单（arxiv_survey.py 导出的 candidates.md，或自己写的 papers.json），
按 templates/reading-note.md 逐篇生成 notes/<日期>-<短标题>.md，
并额外生成一个 INDEX.md 汇总表，记录每篇的读到第几遍。

顺手解决三个真实痛点：
    ① 不会覆盖已有笔记（改过的内容永远不丢，除非显式 --force）
    ② 文件名统一，按日期排序就是你的阅读时间线
    ③ 模板一改，新生成的笔记全部跟着改，老笔记不动

只用标准库。用法：
    python3 make_reading_notes.py --from candidates.md
    python3 make_reading_notes.py --from papers.json --out notes --force
"""

import argparse
import json
import os
import re
from datetime import date

HERE = os.path.dirname(os.path.abspath(__file__))
TEMPLATE = os.path.join(HERE, "templates", "reading-note.md")


def load_from_markdown(path):
    """从 candidates.md 的表格行里抓 | 日期 | [标题](链接) |。"""
    papers = []
    row = re.compile(r"^\|.*?\|\s*(\d{4}-\d{2}-\d{2})\s*\|\s*\[(.+?)\]\((\S+?)\)\s*\|")
    with open(path, encoding="utf-8") as f:
        for line in f:
            m = row.match(line.strip())
            if m:
                papers.append({"date": m.group(1), "title": m.group(2), "link": m.group(3)})
    return papers


def load_from_json(path):
    with open(path, encoding="utf-8") as f:
        data = json.load(f)
    out = []
    for item in data:
        out.append({
            "date": item.get("published") or item.get("date") or str(date.today()),
            "title": item["title"],
            "link": item.get("link", ""),
        })
    return out


def slugify(title, limit=48):
    """标题转文件名：去掉标点、空格换连字符、限长，避免路径过长与非法字符。"""
    s = re.sub(r"[^\w\u4e00-\u9fff]+", "-", title.lower())
    s = re.sub(r"-+", "-", s).strip("-")
    return s[:limit] or "untitled"


def render(template, paper):
    out = template.replace("__TITLE__", paper["title"])
    out = out.replace("__LINK__", paper["link"] or "TODO")
    return out


def write_index(outdir, records):
    lines = [
        "# 精读进度",
        "",
        "| 日期 | 标题 | 笔记 | 读到第几遍 | 结论 |",
        "| :-: | --- | :-: | :-: | --- |",
    ]
    for r in records:
        lines.append("| %s | %s | [笔记](%s) |  |  |"
                     % (r["date"], r["title"].replace("|", "/"), r["file"]))
    lines += ["", "说明：第一遍填「留/弃」，第二遍填三句话结论，第三遍填复现清单完成度。", ""]
    path = os.path.join(outdir, "INDEX.md")
    with open(path, "w", encoding="utf-8") as f:
        f.write("\n".join(lines))
    return path


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--from", dest="src", required=True, help="candidates.md 或 papers.json")
    ap.add_argument("--out", default="notes")
    ap.add_argument("--force", action="store_true", help="覆盖已存在的笔记")
    ap.add_argument("--template", default=TEMPLATE)
    args = ap.parse_args()

    if not os.path.exists(args.template):
        raise SystemExit("模板不存在：" + args.template)
    with open(args.template, encoding="utf-8") as f:
        template = f.read()

    papers = (load_from_json(args.src) if args.src.endswith(".json")
              else load_from_markdown(args.src))
    if not papers:
        raise SystemExit("没有从 %s 解析出任何论文" % args.src)

    os.makedirs(args.out, exist_ok=True)
    created, skipped, records = 0, 0, []

    for p in papers:
        fname = "%s-%s.md" % (p["date"], slugify(p["title"]))
        path = os.path.join(args.out, fname)
        records.append({"date": p["date"], "title": p["title"], "file": fname})

        if os.path.exists(path) and not args.force:
            skipped += 1
            continue
        with open(path, "w", encoding="utf-8") as f:
            f.write(render(template, p))
        created += 1

    index = write_index(args.out, records)
    print("共 %d 篇：新建 %d，跳过已存在 %d" % (len(papers), created, skipped))
    print("汇总表：", index)


if __name__ == "__main__":
    main()

# 精读笔记 · __TITLE__

> 读完第三遍再回头把这张表填满。空着的格子就是你还没读懂的地方。

| 字段 | 内容 |
| :-- | :-- |
| 标题 | __TITLE__ |
| 作者 / 单位 | TODO |
| 发表于 | TODO（会议或期刊 + 年份 + 是否正式发表） |
| 链接 / DOI | __LINK__ |
| 代码仓库 | TODO（没有就写「未公开」，别留空） |
| 读的版本 | TODO（arXiv v2 / 会议 camera-ready，版本不同实验可能不同） |
| 我读它的目的 | TODO（找方法 / 找 baseline / 找数据集 / 补背景） |

---

## 1. 一句话贡献

TODO：不超过 40 字，写「它把什么做成了什么」，不要抄摘要。

## 2. 问题定义

- **输入是什么：** TODO
- **输出是什么：** TODO
- **它认为现有方法差在哪：** TODO
- **这个问题为什么值得做：** TODO

## 3. 方法框架

TODO：按数据流写 3~6 步，每步一行，能对着画出框架图为准。

1. TODO
2. TODO
3. TODO

**每一步的输入输出张量形状 / 数据格式：**

| 模块 | 输入 | 输出 | 作用 |
| :-- | :-- | :-- | :-- |
| TODO | TODO | TODO | TODO |

## 4. 关键公式

| 编号 | 公式在做什么 | 符号含义 | 我推导过吗 |
| :-: | :-- | :-- | :-: |
| 式(1) | TODO | TODO | 是 / 否 |
| 式(2) | TODO | TODO | 是 / 否 |

> 推不动的那一步单独记下来，它往往是全文真正的创新点，也常是后面复现失败的根源。

## 5. 数据集与指标

| 数据集 | 规模 | 划分方式 | 指标 | 这个指标衡量什么 |
| :-- | :-- | :-- | :-- | :-- |
| TODO | TODO | TODO | TODO | TODO |

## 6. baseline 与对比结果

| 方法 | 主指标 | 相对提升 | 参数量 / 算力 | 是否同等条件 |
| :-- | :-: | :-: | :-: | :-: |
| baseline A | TODO | — | TODO | — |
| 本文方法 | TODO | TODO | TODO | 是 / 否 |

**对比是否公平：** TODO（同数据集？同训练量？同 backbone？对手是否用了原论文最优配置？）

## 7. ablation study 说明了什么

| 去掉的部件 | 指标变化 | 能得出的结论 | 能不能换个解释 |
| :-- | :-: | :-- | :-- |
| TODO | TODO | TODO | TODO |

> 判定标准：每一个宣称的创新点，都应该有一行 ablation 对应。对不上的创新点就是没被证明的创新点。

## 8. 局限与我的疑问

- **作者自己承认的局限：** TODO
- **作者没说但我觉得站不住的地方：** TODO
- **我读不懂的地方（写清楚卡在哪一句）：** TODO
- **需要回头查的引文：** TODO

## 9. 可复用的点

| 能拿走什么 | 用到我的哪个环节 | 需要改什么 |
| :-- | :-- | :-- |
| TODO | TODO | TODO |

## 10. 复现清单

- [ ] 官方仓库能否 clone，README 是否给了环境版本
- [ ] demo / inference 脚本能跑通
- [ ] 预训练权重是否公开（否 → 只能从头训）
- [ ] 主实验的最小配置需要多少显存、多少小时
- [ ] 数据集能否下载，是否需要申请
- [ ] 随机种子与评测脚本是否给出
- [ ] 复现结果与论文报告差多少，差距能否解释

---

**读完时间：** TODO  ｜  **三遍各花了：** TODO / TODO / TODO

# __TITLE__

<!-- 骨架文件：每个 TODO 都是一句话提示，写完就把提示行删掉。
     写作顺序建议：方法 → 实验 → 引言 → 相关工作 → 结论 → 摘要 → 标题。
     摘要和标题最后写，因为那时你才真正知道自己做出了什么。 -->

## 标题

TODO：一行，兼顾准确与吸引力。让「做了什么 + 用什么做的」两件事都出现。
写三个候选，念给不做这个方向的人听，选他能复述出来的那个。

- 候选 A：TODO
- 候选 B：TODO
- 候选 C：TODO

## 摘要（Abstract）

TODO 目的：这个领域当前卡在什么地方，本文要解决哪个具体问题。（2~3 句）

TODO 方法：用一句话说清方法的核心机制，不堆术语，不写公式。（2~3 句）

TODO 结果：在哪个数据集、哪个指标上、比谁提升了多少，给具体数字。（2~3 句）

> 自检：不看正文，只读摘要，读者能答出「做什么、怎么做、好多少」三个问题吗？

## 1 引言（Introduction）

### 1.1 研究现状与问题

TODO：从大背景收到具体问题，三到四段，每段一个层次。最后一段要把问题收窄到一句话。

### 1.2 研究意义

TODO：解决这个问题之后，谁会受益、能带来什么变化。

### 1.3 方法概述

TODO：用三到五句话把方法讲一遍，让读者不看第 3 节也知道你干了什么。

### 1.4 创新点与贡献

TODO 用分条列出，与正文小节一一对应：

1. 我们提出了 TODO，解决了 TODO；
2. 我们设计了 TODO，使得 TODO；
3. 在 TODO 数据集上，本文方法相比 TODO 提升 TODO。

## 2 相关工作（Related Work）

### 2.1 TODO 主题一

TODO：这一类方法的代表工作、共同思路、共同的不足。

### 2.2 TODO 主题二

TODO：同上。

### 2.3 与本文的关系

TODO：明确写出「上述方法在 TODO 上受限，本文通过 TODO 填补这一空白」。

## 3 方法（Method）

### 3.1 问题定义与符号

TODO：先把输入输出形式化。给一张符号表，全文符号含义唯一。

### 3.2 整体框架

TODO：先放框架图（图 1），再用一段话按数据流向把图讲一遍，图里每个框都要在正文出现。

### 3.3 TODO 模块一

TODO：先说这个模块要解决什么，再给公式，再逐项解释符号，最后说它为什么比现有做法好。

$$ \text{TODO 公式 (1)} $$

### 3.4 TODO 模块二

TODO：同上。

### 3.5 创新点小结

TODO：一句话点明「本节中 TODO 与 TODO 是本文新提出的，其余沿用已有工作」。审稿人最看重这句的诚实。

## 4 实验（Experiments）

### 4.1 实验设置

- **数据集：** TODO（规模、划分、来源、许可）
- **评价指标：** TODO（指标定义、实现来源）
- **硬件：** TODO（显卡型号、数量）
- **超参数：** TODO（优化器、学习率、batch size、训练轮数）
- **训练细节：** TODO（收敛情况、loss 曲线见图 TODO）

### 4.2 定量对比

TODO：主结果表，本文方法与 baseline 同条件对比。最优值加粗，说明标记规则。

| 方法 | 指标 A | 指标 B | 参数量 |
| :-- | :-: | :-: | :-: |
| TODO | TODO | TODO | TODO |

TODO：一段文字解读表格，说明提升来自哪里，而不是复述数字。

### 4.3 ablation study

TODO：每个创新点对应一行，一次只去掉一个部件。

| 配置 | 指标 A | 相对完整模型 |
| :-- | :-: | :-: |
| 完整模型 | TODO | — |
| 去掉 TODO | TODO | TODO |

TODO：解释每一行掉点的原因，把结论落到机制上。

### 4.4 定性分析

TODO：给可视化样例，包括失败样例。只放成功样例会被追问。

## 5 结论（Conclusion）

TODO 定性总结：用文字概括本文做了什么、得到了什么结论，不重复罗列数字。

TODO 局限：诚实写出方法在什么条件下会退化。

TODO 未来工作：给出具体的下一步，不要写「进一步提升性能」这类空话。

## 参考文献

TODO：格式统一，逐条核对卷号页码年份。每一条都应是你真正读过的。

## 附录（可选）

- A. 完整超参数表
- B. 更多可视化结果
- C. 公式推导细节

# 投稿前 checklist

> 全部打勾再点提交。每一条都是审稿意见里真实出现过的扣分项。

## 一、内容完整性

- [ ] 摘要严格覆盖「目的—方法—结果」三段，且结果里有具体数字
- [ ] 引言最后一段用分条列出了贡献，条数与正文实际做的事一一对应
- [ ] 每一个宣称的创新点，在方法一节都有对应小节，在实验一节都有对应验证
- [ ] related work 不只是罗列，每一类都写清了不足，并说明本文如何填补
- [ ] 结论没有出现引言里没提过的新结论
- [ ] 局限与未来工作单独成段，不是一句「效果还有提升空间」

## 二、公式与符号

- [ ] 所有公式连续编号，正文引用的编号与实际编号一致
- [ ] 同一个符号全文含义唯一，没有 N 一会儿是样本数一会儿是维度
- [ ] 所有新引入的符号在首次出现处有定义
- [ ] 向量、矩阵、标量的字体区分一致（粗体 / 斜体规则全文统一）
- [ ] 公式末尾的标点符合目标期刊要求

## 三、图与表

- [ ] 每张图表脱离正文也能看懂：坐标轴有单位、图例完整、caption 自足
- [ ] 图里的字号放到单栏宽度仍然可读（打印一页出来看一眼）
- [ ] 表格的最优值加粗，次优值有标记，标记规则写在 caption 里
- [ ] 折线图给出误差范围或多次运行的标准差，不是单次跑的结果
- [ ] 所有图表在正文中都被引用过，且引用顺序与出现顺序一致
- [ ] 彩色图转灰度后仍能区分（部分期刊黑白印刷）

## 四、实验可信度

- [ ] baseline 采用其原论文的最优配置，或说明了为何用别的配置
- [ ] 本文方法与 baseline 的训练数据、训练量、backbone 规模一致
- [ ] 主实验报告了多次运行的均值与方差，而不是挑最好的一次
- [ ] ablation study 覆盖了每一个创新点，且一次只改一个变量
- [ ] 超参搜索范围与选定值写清楚了，包括 baseline 的
- [ ] 硬件、训练时长、显存占用有交代
- [ ] 评测指标的实现来源写明（官方脚本 / 自己实现）

## 五、引用与诚信

- [ ] 每一条引用都读过原文，不存在只看摘要就引的条目
- [ ] 引用的事实与原文说法一致，没有断章取义
- [ ] 参考文献格式统一，卷号、页码、年份、出版方完整
- [ ] 预印本已正式发表的，引用正式版本
- [ ] 他人成果、图表、代码均已注明出处并符合其许可
- [ ] 所有数据与结果均来自真实运行，未经过任何修饰
- [ ] 合作者贡献、资助来源、利益冲突已按要求声明
- [ ] 使用辅助工具的情况已按目标会议或期刊的政策如实披露

## 六、可复现性

- [ ] 数据与代码的可得性有明确声明（公开 / 申请后可得 / 不可公开及原因）
- [ ] 数据集划分方式、预处理脚本写清楚了
- [ ] 随机种子与环境版本（框架版本、CUDA 版本）有记录
- [ ] 换一台机器、由另一个人照着论文能跑出同一量级的结果

## 七、格式与提交

- [ ] 使用目标会议或期刊的官方模板，未私自改行距、页边距、字号
- [ ] 页数、参考文献是否计入页数，均符合要求
- [ ] 双盲要求下，正文、致谢、图表、代码链接中无任何作者身份线索
- [ ] 自引改写为第三人称（「文献 [12] 提出」而非「我们之前提出」）
- [ ] 补充材料单独打包，正文不依赖补充材料才能读懂
- [ ] 文件名、投稿系统的元数据未泄漏身份（双盲时）
- [ ] 全文过一遍拼写检查，专有名词大小写统一
- [ ] 距离 deadline 至少留 24 小时，避开系统拥堵

---

**提交时间：** TODO  ｜  **投稿目标：** TODO  ｜  **最后自查人：** TODO