有限算力下深度学习小论文：架构选型、Baseline复现与消融实验

研一研二最常问的问题，其实不是“哪个模型最强”，而是“我这点算力、这点时间，能做出什么”。把“水论文”这个词拆开看，它真实指向的是一套规范流程：在有限资源下选一个合适的架构，把公开基线跑通，找到一个说得清楚的增量，把实验做完整，把结论诚实地写出来。这套流程走得顺，一篇小论文的骨架两三个月就能立起来；走不顺，卡在环境配置和 baseline 复现上半年也很常见。

架构选择是第一道分水岭。CNN 便宜、稳定、收敛快，适合做小目标检测、分割、分类这类任务；Transformer 擅长长程建模和大数据拟合，但对显存和数据量都更挑；Diffusion 生成效果亮眼，训练和推理成本也最高，没有几张像样的卡很难做完整的对比实验。这三条路没有优劣，只有匹配度——你手上的 GPU 数量、能拿到的数据集规模、导师给的周期，基本就决定了该走哪条。

这篇文章给出一条从零到投稿的完整路径：先用一张表把三类架构的算力门槛和适用任务讲清楚，再给出环境准备和显存估算的方法，然后进入 baseline 复现的标准动作、四类可落地的创新点、消融实验的最小集合、训练代码模板、写作与投稿流程、性能观察方法，最后是排错清单和时间安排。目标读者是刚进组、手上有 1 到 4 张卡、需要在一年内产出一篇小论文的研一研二同学，也适合需要带学生做复现实验的青年教师参考。

有一点必须写在前面：下面所有关于“创新点”的讨论，前提都是实验真实、数据真实、对比公平、引用规范。改两个模块就宣称 SOTA、挑好看的单次结果、把自己没跑通的基线写成“效果不佳”，这些做法短期能过，长期一定出问题。流程可以提效，结论不能注水，这是底线。

1. 深度学习小论文的能力速览

先把这件事当成一个项目来做，看清楚它需要哪些能力、门槛在哪里。下面这张表是研一研二开始做课题前最该核对的一页纸，缺哪一项就先去补哪一项，不要带着短板硬上。

从材料角度看，绝大多数卡壳不是因为想法不够新，而是因为这些基础项里有明显短板。比如数据划分写死在代码里、随机种子没固定、验证集参与了调参，这些细节在写作阶段会集中爆发，导致实验要重跑。所以第一步不是找创新点，是把工程底子搭稳。

2. CNN、Transformer、Diffusion 怎么选

2.1 三类架构的本质差异

CNN 的归纳偏置是局部性和平移等变性，这两个先验让小数据集上的训练非常稳，参数量可控，推理速度快。它在图像分类、目标检测、语义分割、医学影像这些任务上依然是主流选择，尤其是数据量在几万张以内的时候，一个调好的 ResNet 或 ConvNeXt 系列往往能打赢没调好的 Transformer。

Transformer 的核心是自注意力，能把任意两个位置直接关联起来，长程依赖建模能力强，可扩展性好，数据量上去之后性能上限更高。代价是显存占用随序列长度增长明显，训练更依赖学习率调度、warmup、数据增强这些技巧，超参更敏感。ViT 系列在小数据集上不加强的正则和大量增强，效果经常不如 CNN。

Diffusion 走的是另一条路，通过逐步去噪建模数据分布，生成质量高、多样性好，但训练需要多步采样，推理慢，显存占用大。它适合图像生成、超分、图像编辑、医学图像合成这类任务，但如果你的课题是分类或检测，硬套 Diffusion 往往是给自己找麻烦。

2.2 按任务和数据规模选

判断标准可以简化成两条：任务输出是判别式还是生成式，数据量在什么量级。

判别式任务，数据在几千到几万量级，优先 CNN。判别式任务，数据在十万量级以上，或者需要建模全局关系（比如遥感大图、长文本、时序长依赖），可以上 Transformer。生成式任务，比如图像生成、图像修复、跨模态生成，再考虑 Diffusion，并且要提前算清楚训练成本。

混合结构是一个务实的折中：用 CNN 做主干提特征，在深层插入少量注意力模块，兼顾效率和建模能力。这类改动实现成本低，也容易在论文里讲清楚动机，是很多小论文的实际选择。

2.3 按算力预算选

这一条最现实。单卡 8G 到 12G 显存，做 CNN 的检测分割或者小型 Transformer 分类是可行的；做 Diffusion 的完整训练基本不现实，只能做微调、推理或者小分辨率实验。单卡 24G 可以支撑中等规模的 Transformer 训练和 Diffusion 的 LoRA 类微调。多卡环境才有条件做完整的大模型对比实验。

下面这张表是选型时的快速对照，具体数值需要以实际模型版本和输入尺寸测试为准。

选型阶段有个实用建议：先看目标期刊或会议近两年同方向的文章用的什么 backbone，再结合自己的卡数做减法。跟着领域主流走，审稿人才有参照系；完全跳出去另起一套，除非动机极其充分，否则容易被质疑对比不公平。

3. 环境准备与算力规划

3.1 本地与服务器环境

深度学习实验建议在 Linux 服务器上跑，本地机器只做调试。Windows 下用 WSL2 也可以，但多卡训练和数据 IO 会遇到额外问题。基本环境包括 Python 3.9 到 3.11、PyTorch、CUDA 驱动、以及 conda 或 venv 做环境隔离。

环境一定要隔离。一个课题一个环境，不要把两个项目的依赖装在同一个 base 环境里，否则后面复现别人的仓库会因为版本冲突浪费大量时间。

bash复制# 创建独立环境，Python 版本按仓库要求调整
conda create -n paper_exp python=3.10 -y
conda activate paper_exp

# 安装 PyTorch，CUDA 版本需要和驱动匹配，建议查官方安装页确认
pip install torch torchvision torchaudio

# 常用辅助库
pip install numpy pandas matplotlib opencv-python tensorboard tqdm pyyaml scikit-learn

装完之后先做一次最基本的自检，确认 GPU 能被识别、CUDA 可用、矩阵乘法能跑通。

python复制import torch

print("torch:", torch.__version__)
print("cuda available:", torch.cuda.is_available())
print("device count:", torch.cuda.device_count())
if torch.cuda.is_available():
    print("device name:", torch.cuda.get_device_name(0))
    x = torch.randn(1024, 1024, device="cuda")
    y = x @ x
    torch.cuda.synchronize()
    print("matmul ok:", y.shape)
    print("allocated MB:", torch.cuda.memory_allocated() / 1024 ** 2)

torch.cuda.is_available() 返回 False 是最常见的第一个坑，通常是驱动版本和 CUDA 版本不匹配，或者装成了 CPU 版本的 wheel。用 nvidia-smi 看驱动支持的 CUDA 上限，再决定装哪个版本的 PyTorch。

3.2 算力规划与显存估算

不要等代码写完才发现 batch size 只能设成 2。开始训练前先做一次显存探测：固定模型和输入尺寸，从 batch size 1 开始逐步往上加，记录每次的峰值显存，找到不 OOM 的最大值，再留 20% 余量给验证阶段和梯度累积之外的开销。

python复制import torch
from torch import nn

def probe_memory(model, input_shape, device="cuda", max_bs=64):
    """粗略探测最大可用 batch size，实际结果需结合具体模型和优化器"""
    model = model.to(device)
    opt = torch.optim.AdamW(model.parameters(), lr=1e-4)
    bs = 1
    best = 0
    while bs <= max_bs:
        try:
            x = torch.randn(bs, *input_shape, device=device)
            y = model(x)
            loss = y.float().mean()
            loss.backward()
            opt.zero_grad(set_to_none=True)
            torch.cuda.synchronize()
            best = bs
            torch.cuda.empty_cache()
            bs *= 2
        except torch.cuda.OutOfMemoryError:
            torch.cuda.empty_cache()
            break
    return best

# 使用示例：实际替换成自己的模型和输入维度
# model = YourModel(num_classes=10)
# print("max batch size:", probe_memory(model, (3, 224, 224)))

时间估算同样重要。跑一个 epoch 需要多久，决定了你能做多少组对比实验。经验做法是先跑 100 个 iteration，记录耗时，乘以 总样本数 / batch_size 得到单 epoch 时间，再乘以计划 epoch 数。如果算下来一组实验要三天，而你需要十组，那就得先想清楚是不是要降分辨率、减 epoch、或者换更小的模型。

4. 跑通 Baseline 的标准流程

4.1 挑选基线仓库的四个标准

开源仓库质量参差不齐，选错了后面全是坑。四个判断标准：第一，有没有完整的训练脚本和配置文件，而不只是一个推理 demo；第二，README 里有没有给出可复现的命令和预期指标；第三，最近半年有没有人提 issue 并且有回复；第四，依赖版本有没有写死或者给出 requirements。

优先选领域内被引用次数多的官方实现，其次选复现过该论文并公开了指标的第三方仓库。不要一上来就选一个 star 很高但只支持推理的仓库，那对你没有任何帮助。

4.2 目录与配置管理

工程目录建议一开始就分清楚，数据、代码、配置、输出、日志各归各位。下面是一个可以直接套用的结构。

text复制project/
├── configs/
│   ├── baseline.yaml
│   └── exp_attention.yaml
├── data/
│   ├── raw/
│   └── processed/
├── src/
│   ├── datasets/
│   ├── models/
│   ├── losses/
│   └── utils/
├── scripts/
│   ├── train.sh
│   └── eval.sh
├── outputs/
│   ├── baseline/
│   └── exp_attention/
└── logs/

配置文件用 YAML 管理，把随机种子、学习率、batch size、数据路径、增强策略全部外置，不要在代码里写死。这样后面做消融实验只需要复制一份配置改几个字段。

yaml复制# configs/baseline.yaml
seed: 42
device: cuda:0

data:
  root: ./data/processed
  image_size: 224
  num_classes: 10
  batch_size: 32
  num_workers: 4

model:
  name: resnet50
  pretrained: true
  dropout: 0.1

train:
  epochs: 100
  optimizer: adamw
  lr: 0.0003
  weight_decay: 0.05
  scheduler: cosine
  warmup_epochs: 5
  amp: true

output:
  dir: ./outputs/baseline
  save_every: 10

4.3 复现实验的三个必做动作

第一，固定随机种子，并且要把 Python、NumPy、PyTorch、CUDA 的种子一起设，torch.backends.cudnn.deterministic 也要打开。第二，先关闭所有自定义增强和数据采样策略，用最朴素的方式跑一遍，确认能到论文报告的量级。第三，把训练日志、验证指标、损失曲线全部落盘，方便后面判断问题出在数据还是模型。

python复制import os
import random
import numpy as np
import torch

def set_seed(seed: int = 42):
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)
    os.environ["PYTHONHASHSEED"] = str(seed)
    torch.backends.cudnn.deterministic = True
    torch.backends.cudnn.benchmark = False

set_seed(42)

4.4 判断“跑通”的标准

跑通不是 loss 在降就算完。四条硬标准：一，训练集和验证集指标都收敛，曲线没有异常震荡；二，最终指标与论文报告值的差距在可解释范围内，比如 1 到 2 个点，差距过大就要查数据划分和预处理；三，同一种子重复跑两次，结果基本一致；四，换一到两个种子，结果的波动范围可以接受。

如果第二条差距很大，先别急着怀疑自己的实现，按顺序排查：数据划分方式是否一致、输入归一化的均值方差是否一致、评测脚本是否用了同一个指标实现、预训练权重是否同一版本。这四项对齐之后，大部分复现问题都会消失。

5. 从 Baseline 到创新点：四类可落地的增量

5.1 模块替换与结构改进

最直接的一类增量是替换主干中的某个模块。比如把卷积块换成带注意力的混合块，把特征融合从相加改成带权拼接，把上采样换成可学习的方式。这类工作实现成本低，风险是创新性被质疑“只是拼模块”，所以动机必须讲清楚：原来的结构在什么场景下失效，你的改动针对性地解决了什么。

一个通用模板是残差加轻量注意力，插入到现有主干的指定阶段，不改变整体结构。下面是一个可直接改写的示例，具体通道数和插入位置需要按任务调。

python复制import torch
from torch import nn

class LightAttention(nn.Module):
    """即插即用的轻量通道-空间注意力模块，作为示例使用，需按任务调整"""

    def __init__(self, channels, reduction=8):
        super().__init__()
        hidden = max(channels // reduction, 8)
        self.channel_gate = nn.Sequential(
            nn.AdaptiveAvgPool2d(1),
            nn.Conv2d(channels, hidden, 1),
            nn.SiLU(inplace=True),
            nn.Conv2d(hidden, channels, 1),
            nn.Sigmoid(),
        )
        self.spatial_gate = nn.Sequential(
            nn.Conv2d(2, 1, kernel_size=7, padding=3),
            nn.Sigmoid(),
        )

    def forward(self, x):
        c = self.channel_gate(x)
        x = x * c
        avg_map = torch.mean(x, dim=1, keepdim=True)
        max_map = torch.max(x, dim=1, keepdim=True)[0]
        s = self.spatial_gate(torch.cat([avg_map, max_map], dim=1))
        return x * s

class ResidualBlockWithAttn(nn.Module):
    def __init__(self, in_ch, out_ch, stride=1):
        super().__init__()
        self.conv1 = nn.Conv2d(in_ch, out_ch, 3, stride, 1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_ch)
        self.conv2 = nn.Conv2d(out_ch, out_ch, 3, 1, 1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_ch)
        self.attn = LightAttention(out_ch)
        self.act = nn.SiLU(inplace=True)
        self.short = nn.Sequential()
        if stride != 1 or in_ch != out_ch:
            self.short = nn.Sequential(
                nn.Conv2d(in_ch, out_ch, 1, stride, bias=False),
                nn.BatchNorm2d(out_ch),
            )

    def forward(self, x):
        out = self.act(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        out = self.attn(out)
        return self.act(out + self.short(x))

5.2 损失函数与训练策略改进

这一类增量在写作上更容易讲动机，实现也更轻。常见方向包括：针对类别不平衡的重加权损失、针对边界的分割损失组合、对比学习辅助损失、蒸馏损失、课程学习式的样本调度、以及学习率与数据增强的联合策略。

写这类工作需要特别注意公平性：加了辅助损失之后，训练成本可能上升，对比实验要在相同 epoch 或相同训练时间下比较，并且要报告推理阶段的开销，说明辅助分支在推理时可以去掉。

5.3 数据层面与预处理改进

数据侧的改进常被低估。针对特定任务的增强策略、半监督或自监督预训练、伪标签迭代、跨域数据的对齐，都可以成为论文的核心贡献，尤其是当你的算力不足以做结构创新时，这条路更现实。

这类工作的关键是消融要干净：把增强单独开、单独关，把伪标签的轮数作为变量，把数据量的影响画成曲线。审稿人对数据侧工作最常见的问题是“提升是不是仅仅来自更多数据”，所以必须设计等数据量对比。

5.4 跨任务迁移与适配

把一个在大型数据集上预训练的模型，迁移到你的小领域任务上，做适配和微调，再针对领域特性做改动。这类工作在医学影像、遥感、工业质检领域非常常见，实用价值明确，但要注意说明预训练数据是否可比，避免对比不公平。

5.5 创新点自检表

定下想法之后，用下面这张表过一遍，能省掉后面很多返工。

6. 实验设计与消融：让审稿人信服的最小集合

6.1 主实验

主实验要回答一个问题：你的方法在标准基准上表现如何。至少两个数据集，至少五到八个对比方法，其中必须包含近两年的强基线。表格里除了主指标，建议附上参数量和推理耗时，让读者判断性价比。

6.2 消融实验

消融要回答：每个改动各自贡献多少。做加法消融，从 baseline 开始逐个加入模块，每一步都报告指标；如果模块之间有交互，再加一组组合消融。不要只报完整模型的最终结果，那样审稿人一定会要求补。

6.3 可视化与定性分析

定量指标之外，给出一到两张可视化对比图，标出你的方法在哪些区域改善了。分割任务给掩码对比，检测任务给框对比，生成任务给细节放大对比。可视化不是装饰，是解释机制的辅助材料。

6.4 多次运行与统计

单次结果不可信。至少跑三个种子，报告均值和标准差。如果提升幅度小于标准差，这个提升就不能作为主要卖点。有条件的话做一次显著性检验，成本很低，但能显著提升论文的严谨度。

python复制import numpy as np
from scipy import stats

# 三个种子的主指标，实际请替换为真实实验结果
baseline_scores = np.array([82.1, 82.6, 81.9])
ours_scores = np.array([84.3, 84.8, 84.0])

print("baseline mean±std: %.2f±%.2f" % (baseline_scores.mean(), baseline_scores.std(ddof=1)))
print("ours mean±std: %.2f±%.2f" % (ours_scores.mean(), ours_scores.std(ddof=1)))

t_stat, p_val = stats.ttest_ind(ours_scores, baseline_scores, equal_var=False)
print("t=%.3f, p=%.4f" % (t_stat, p_val))

7. 训练脚本与实验管理代码模板

一套能复用的训练骨架比十份临时脚本更值钱。下面这个模板包含混合精度、梯度裁剪、学习率调度、日志记录和断点续训，可以直接改成自己的任务。

python复制import os
import time
import yaml
import torch
from torch import nn
from torch.utils.data import DataLoader
from torch.cuda.amp import autocast, GradScaler
from torch.utils.tensorboard import SummaryWriter

def load_config(path):
    with open(path, "r", encoding="utf-8") as f:
        return yaml.safe_load(f)

def train_one_epoch(model, loader, optimizer, criterion, scaler, device, writer, epoch):
    model.train()
    total_loss, correct, total = 0.0, 0, 0
    for step, (images, targets) in enumerate(loader):
        images = images.to(device, non_blocking=True)
        targets = targets.to(device, non_blocking=True)

        optimizer.zero_grad(set_to_none=True)
        with autocast(enabled=True):
            logits = model(images)
            loss = criterion(logits, targets)

        scaler.scale(loss).backward()
        scaler.unscale_(optimizer)
        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=5.0)
        scaler.step(optimizer)
        scaler.update()

        total_loss += loss.item() * images.size(0)
        pred = logits.argmax(dim=1)
        correct += (pred == targets).sum().item()
        total += images.size(0)

        if step % 50 == 0:
            writer.add_scalar("train/loss_step", loss.item(), epoch * len(loader) + step)

    return total_loss / total, correct / total

@torch.no_grad()
def evaluate(model, loader, criterion, device):
    model.eval()
    total_loss, correct, total = 0.0, 0, 0
    for images, targets in loader:
        images = images.to(device, non_blocking=True)
        targets = targets.to(device, non_blocking=True)
        logits = model(images)
        loss = criterion(logits, targets)
        total_loss += loss.item() * images.size(0)
        correct += (logits.argmax(dim=1) == targets).sum().item()
        total += images.size(0)
    return total_loss / total, correct / total

def main(config_path):
    cfg = load_config(config_path)
    device = torch.device(cfg["device"] if torch.cuda.is_available() else "cpu")
    os.makedirs(cfg["output"]["dir"], exist_ok=True)
    writer = SummaryWriter(log_dir=os.path.join(cfg["output"]["dir"], "tb"))

    # 这里替换成自己的数据集与模型构建逻辑
    # train_set, val_set = build_dataset(cfg)
    # model = build_model(cfg)
    # train_loader = DataLoader(train_set, batch_size=cfg["data"]["batch_size"], shuffle=True,
    #                           num_workers=cfg["data"]["num_workers"], pin_memory=True)

    criterion = nn.CrossEntropyLoss(label_smoothing=0.1)
    optimizer = torch.optim.AdamW(model.parameters(), lr=cfg["train"]["lr"],
                                  weight_decay=cfg["train"]["weight_decay"])
    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=cfg["train"]["epochs"])
    scaler = GradScaler()

    best_acc = 0.0
    for epoch in range(cfg["train"]["epochs"]):
        t0 = time.time()
        train_loss, train_acc = train_one_epoch(model, train_loader, optimizer,
                                                criterion, scaler, device, writer, epoch)
        val_loss, val_acc = evaluate(model, val_loader, criterion, device)
        scheduler.step()

        writer.add_scalar("train/loss", train_loss, epoch)
        writer.add_scalar("train/acc", train_acc, epoch)
        writer.add_scalar("val/loss", val_loss, epoch)
        writer.add_scalar("val/acc", val_acc, epoch)
        writer.add_scalar("lr", optimizer.param_groups[0]["lr"], epoch)

        print("epoch %d | train %.4f/%.4f | val %.4f/%.4f | %.1fs"
              % (epoch, train_loss, train_acc, val_loss, val_acc, time.time() - t0))

        if val_acc > best_acc:
            best_acc = val_acc
            torch.save({"model": model.state_dict(), "epoch": epoch, "acc": val_acc},
                       os.path.join(cfg["output"]["dir"], "best.pth"))

    writer.close()
    print("best val acc: %.4f" % best_acc)

if __name__ == "__main__":
    main("configs/baseline.yaml")

批量跑消融实验用 shell 脚本管理，把配置文件名作为变量传进去，输出目录自动分离，日志统一重定向。这样一组实验挂上去就可以去写论文的其他部分。

bash复制#!/usr/bin/env bash
set -e

CONFIGS=(
  "configs/baseline.yaml"
  "configs/exp_module_a.yaml"
  "configs/exp_module_b.yaml"
  "configs/exp_full.yaml"
)

for cfg in "${CONFIGS[@]}"; do
  name=$(basename "$cfg" .yaml)
  echo "===== running $name ====="
  python src/train.py --config "$cfg" 2>&1 | tee "logs/${name}.log"
done

实验跑完，用一个脚本把所有日志里的最优指标抽出来汇总成表，避免手工抄错。这一步在写论文阶段会省掉大量时间。

python复制import glob
import os
import re
import pandas as pd

rows = []
pattern = re.compile(r"best val acc:\s*([0-9.]+)")

for log_path in glob.glob("logs/*.log"):
    with open(log_path, "r", encoding="utf-8", errors="ignore") as f:
        text = f.read()
    matches = pattern.findall(text)
    if matches:
        rows.append({
            "experiment": os.path.basename(log_path).replace(".log", ""),
            "best_acc": float(matches[-1]),
        })

df = pd.DataFrame(rows).sort_values("best_acc", ascending=False)
df.to_csv("outputs/summary.csv", index=False)
print(df)

8. 资源占用与性能观察

显存和速度是决定实验节奏的关键变量，训练过程中要养成持续观察的习惯。最直接的方式是另开一个终端跑 nvidia-smi -l 2，每两秒刷新一次，观察显存占用和 GPU 利用率。如果显存占满但利用率长期低于 50%，说明瓶颈在数据加载，应该调大 num_workers、开启 pin_memory、或者把数据预处理提前做成离线缓存。

影响显存的主要变量有四个：输入分辨率、batch size、模型深度、是否开启混合精度。分辨率翻倍，特征图显存大约翻四倍，这是最容易失控的一项。batch size 线性影响激活值显存。混合精度通常能省下可观的显存，同时提升吞吐，建议默认开启。

降低显存占用的常见手段包括：梯度累积代替大 batch、梯度检查点、混合精度、减小输入尺寸、冻结主干前几层。需要注意梯度累积不改变显存峰值里参数和优化器状态的部分，只影响激活值，所以对超大模型的帮助有限。

CPU 推理和 GPU 推理的差异也要心里有数。小模型单张图片推理，CPU 可能只慢几倍，但批量推理时 GPU 的优势会迅速放大。论文里如果要报告推理耗时，必须写清楚硬件型号、batch size、是否包含预处理，否则数字没有可比性。

还有一个容易忽略的点是进程残留。训练中断之后显存没释放，往往是 Python 进程还挂着。用 nvidia-smi 找到进程号，确认是自己的一批任务之后再结束，不要顺手清空整张卡，避免误伤同实验室其他人的实验。

9. 论文写作与 SCI 投稿流程

9.1 写作顺序

不要从引言开始写。推荐的顺序是：先定图和表，再写方法，再写实验，最后写引言和摘要。图表定下来，整篇文章的逻辑骨架就定了；方法部分写清楚每个模块的输入输出和动机；实验部分对照表格逐条解释；引言最后写，因为你这时才真正知道自己贡献了什么。

引言的结构可以固定成四段：任务背景与意义、现有方法的进展、现有方法的不足、本文方法与贡献列表。贡献列表建议三条，动词开头，每条对应一个可验证的实验结果，不要写“提出了一种新颖的框架”这种无法验证的表述。

9.2 图表规范

表格用三线表，指标加粗要一致，单位写清楚。对比方法按年份或类型排序，不要按效果排序制造视觉暗示。图的字体大小要保证缩放到单栏宽度后仍然可读，坐标轴标签不能缺失，颜色在灰度打印下要能区分。

所有图必须能由代码重新生成，并且把生成脚本和原始数据一起归档。这不只是好习惯，很多期刊现在要求提交可复现材料。

9.3 选刊与投稿

选刊先看三个维度：范围匹配、审稿周期、版面费用。范围匹配最优先，把近两年该刊发表的同方向文章翻十篇，看它们的方法复杂度和实验规模，判断自己的工作是否在同一量级。审稿周期可以看期刊官网公布的平均时间，也可以参考同组师兄师姐的实际经验。

投稿前准备好这些材料：投稿信、作者贡献声明、利益冲突声明、数据可用性声明、以及所有作者的确认。格式按期刊模板调整，参考文献用文献管理工具统一，不要手工排版。

9.4 审稿意见回复

收到意见后先分类：需要补实验的、需要澄清表述的、需要修改格式的。补实验的部分优先处理，因为最耗时。回复信采用逐条对应的格式，先复述审稿人问题，再写修改说明，最后指出修改位置（页码和行号）。不同意的意见要礼貌地给出理由和证据，不要情绪化。

被拒稿是常态，不要把它当成对个人能力的判断。根据意见修改后转投下一家，很多论文都是在第二轮甚至第三轮才被接收。

10. 常见问题与排查方法

11. 最佳实践与避坑清单

第一条，先小后大。任何新想法都先在十分之一规模的数据上跑通，确认 loss 能降、指标能动，再上全量数据。直接全量跑三天然后发现代码有 bug，是最常见的浪费。

第二条，保留一套最小可运行配置。一个能在十分钟内跑完的 mini 配置，用于快速验证代码改动；一个全量配置，用于出最终结果。两套配置都进版本管理。

第三条，实验记录必须自动化。每次运行自动记录配置、git commit、开始时间、最终指标，写进一个 CSV 或者用实验管理工具。靠记忆和文件名管理实验，一个月后一定乱。

第四条，数据、代码、输出严格分目录，输出目录按实验名和时间戳命名，绝不覆盖。论文里的每个数字都要能追溯到具体的输出目录。

第五条，批量任务加重试和超时。集群上跑几十组实验，偶发的 OOM 和 IO 错误很常见，脚本里加上失败重试和日志落盘，比守着屏幕强。

第六条，涉及人脸、医疗影像、语音、版权素材的课题，必须先确认数据授权和使用范围，遵守所在机构的数据管理规定，涉及人类受试者的研究要走伦理审查流程。这部分在论文的方法和声明里也要写清楚。

第七条，投稿前做一次完整复现。把代码从干净的 clone 开始，按 README 重跑一遍主实验，确认别人能复现你的结果。这一步能发现大量隐藏的本地依赖问题。

第八条，写作不要等到实验全部结束。实验跑到一半就可以开始画表格框架、写方法初稿，等结果出来直接填数字，能省下不少时间。

12. 接下来四周可以怎么安排

第一周把方向和环境定下来。读五到十篇近两年的同方向论文，确定任务和数据集，装好环境，跑通一个最基础的分类或检测 demo，确认 GPU、数据加载、日志记录这条链路是通的。

第二周复现 baseline。选一个仓库，按前文的四条标准对齐数据和评测，跑出与论文接近的指标。这一周的目标不是超越，是确认你的实验环境和评测流程可信。

第三周做第一个增量。从模块替换、损失改进、数据策略、迁移适配四类里选一个最容易实现的，写成可开关的配置项，跑通消融，看增益是否稳定。如果增益不稳定，先别急着加大改动，回头查数据划分和评测一致性。

第四周整理实验并开始写作。把主实验和消融的表框架搭起来，把方法部分写出来，同时补跑缺失的种子实验。到这一步你会清楚知道这个想法能不能撑起一篇论文，如果不能，及早换方向比硬撑更划算。

这套流程不保证一定中稿，但能保证你每一步都踩在实处：架构选得有理有据，baseline 复现得可信，创新点有动机可讲，实验有消融可查，写作有结构可依。对研一研二来说，把这条链路完整走通一次，比追一个热点模型更有长期价值。建议把这篇的表格和代码模板存下来，开题和写作的时候直接对照使用。