错在把等变说成了不变。 卷积给的是平移等变：输入平移 $\Delta$，输出特征图跟着平移 $\Delta$（命题 3.1.1）。分类需要的平移不变要靠后续的池化 / 全局池化 / 大感受野逐步换来（3.3.1）。

正确表述两条：① 卷积具有平移等变——输入平移、输出特征图跟着平移；② 分类任务需要的平移不变由池化 / 全局平均池化 / 下采样等步骤换取，且只是局部的、有限的（平移几像素可能不变，平移半个感受野通常会变，受 padding 与下采样影响）。例 3.3.1 还说明局部 $2\times2$ 池化提供的不变性很弱且不连续。

前半句错：ViT 的归纳偏置比 CNN 弱，而不是没有。patchify 本身假设每个 token 是一个连续方块（局部性），线性投影等价于一个无重叠的 $P\times P$ 卷积，patch 内像素的相对排布由投影权重学到（定义 3.5.1）。

后半句错：这是条件性结论，而且「强过」必须有控制变量支撑。ViT-Large 只用 ImageNet-1k 时比 ViT-Base 更差，要到大得多的数据上才展现出规模收益；DeiT 证明差距很大程度来自训练配方（不蒸馏已达 $81.8\%$）；ConvNeXt 用逐步控制变量实验说明，把配方与微观设计对齐后纯卷积可与同规模 Transformer 持平（ConvNeXt-T $82.1\%$ 对 Swin-T $81.3\%$）。所以选型依据是数据量、延迟、部署工具链与是否需要多尺度输出，而不是「谁更新」（3.5.5）。

不准确，只说对了现象的一半。 残差的价值有两件互补的事：① 让恒等映射变便宜——如果某几层的最优行为是「什么都不做」，普通网络要拼出恒等映射（很难），残差块只需把 $F$ 学成 $\approx0$，因为 $y=F(x)+x$ 这条通路已经免费提供（优化视角）；② 让梯度有一条不经过任何变换的路——$\partial y/\partial x=I+\partial F/\partial x$，展开式 $\prod(I+J_i)=I+\sum J_i+\cdots$ 中唯一不含 $J$ 的项是 $I$。

对「更大」这个说法的两点纠正：① $I$ 是矩阵意义下的直通，一个具体参数收到的梯度是否真的大，还取决于后续层的组合方式与总深度——残差缓解梯度消失，不等于「梯度不会消失」；② 展开式里的高阶交叉项在深层会累积，这是残差网络并非「无条件可训」的原因之一，实践中通常还要配合归一化与合理初始化。所以准确表述是「让深网络在优化上变得可达」，而不是「让梯度变大」。

三个事实：

1. 它依赖批统计，与 batch size 强耦合：统计量在每个通道上、跨该批全部样本的 $B\times H\times W$ 个元素计算（定义 3.3.3）。检测 / 分割常以 $B=2$ 训练，统计噪声大、训练不稳，因此这些框架几乎默认换 GroupNorm（定义 3.3.4）。
2. 训练与推理必须用两套统计量：训练用当前批的 $(\mu_c,\sigma_c^2)$，推理用训练期累积的运行统计量（命题 (3.8) 与动量更新式）。若推理也按当前批算，同一条数据的输出会随它与谁同批而变——部署不可接受，且单样本时方差退化为 $0$。此外领域偏移时运行统计量本身成为误差来源。
3. 「哪里都加」会改变层的语义：把 BN 放在残差的加法之后会污染那条恒等通路（pre-activation 的动机，定义 3.4.4）；而紧跟 BN 的卷积层偏置是冗余的（例 3.3.3(b)），但 BN 自己的 $\beta$ 却必需。另外在逐像素回归类任务（去噪 / 超分）上，BN 曾被观察到反而有害（3.3.3 延伸阅读）。

反例（数字来自正文）：对 $$X=\begin{pmatrix}1&2&0&1\\0&4&3&0\\1&0&2&2\\0&1&1&3\end{pmatrix}$$ 做 $2\times2$ 最大池化得 $\begin{pmatrix}4&3\\1&3\end{pmatrix}$；把 $X$ 向右循环平移一格后，输出变化很小（本例中窗口内最大值的位置恰好未改变取值）——但这是「窗口内没有第二个同样强激活」这一条件下才成立的；一旦两个激活强度接近，池化输出会随平移在两者之间跳变（不连续、不可导）。所以这个不变性很弱且有条件。

更实际的三条理由：① 缩小特征图，省后续算力与显存；② 放大后续层的感受野（配合 命题 3.2.4 的递推）；③ 提供少许可学的非线性（取最大是一种非线性）。另外 命题 3.3.1 说明最大池化与单调激活可交换，所以「Conv → ReLU → MaxPool」与「Conv → MaxPool → ReLU」数值等价——但这与「提供不变性」是两件事。

把全部位置判为背景时，准确率 $$1-\frac{10}{1{,}000{,}000}=99.999\% ,$$ 但 recall $=0$（$10$ 个真实目标全部漏掉），precision 无意义。这就是极端类不平衡下准确率几乎无信息量的算术根源。

应该看的指标：precision / recall / F1（或 AP）；并且必须分别报告漏检与误检，因为两者的业务代价通常不同（3.10.3 的评估清单）。若要报 AP，必须说明口径：VOC 11 点还是 COCO 101 点 $+$ 十个 IoU 阈值，跨不跨类别（方法 3.7.1）。

错。两者机制不同，且 LRN 不是 AlexNet 成功的关键。 LRN（局部响应归一化）只在相邻通道之间做局部的响应抑制，是当时受生物视觉启发的做法，已被 BatchNorm 取代（正文明确写「LRN 本身不是关键」）。BN 则是跨批、逐通道的标准化并带可学习仿射（定义 3.3.3）。

AlexNet 的 $95\%$ 参数在全连接层（卷积层仅占 $4.9\%$：卷积合计约 $3.0\times10^6$，全连接合计约 $5.86\times10^7$，总计 $61{,}640{,}936$）。原因是把 $256\times6\times6=9216$ 维特征直接展平接 $4096$ 维全连接，一层就是 $3.775\times10^7$ 个参数。这个事实催生了两条后续设计：① 全局平均池化 $+$ 小分类头（3.3.1）；② 全卷积网络（把全连接换成卷积用于分割，3.7.4）。VGG16 把这个缺陷放大到 $89\%$ 参数在分类器（例 3.4.2）。

逐句纠正：

1. 不是过拟合。对抗样本在训练集上也存在，而且能跨模型迁移（在一个模型上生成的扰动可能骗过结构相近的另一个模型）；把成因归给过拟合会导向「多训一会儿就好」的错误结论。
2. 「人看不出异常」不代表安全。模型的决策边界与人的语义边界不是同一条：ReLU 网络是高维分段线性函数，边界在部分方向上离数据点极近，而人眼对高频内容不敏感、浅层卷积却对高频模式敏感。所以靠肉眼审查输出保证安全是不可靠的。
3. 物理世界可行，但需要精心构造。打印图片、贴纸、眼镜等条件下的实现已被证明可行，但光照、视角、拍摄距离等条件比数字域苛刻得多——准确表述是「可行但需精心构造」，既不是「随手就能攻击任何系统」，也不是「不可能」。
4. 附带纠正：鲁棒性永远相对于攻击模型与预算（$\epsilon$、范数、步数），任何「某某模型已经鲁棒」的表述都必须附攻击设置，否则没有意义。

推导：窗口左边界只能取整数。设最后一个合法窗口的左边界为 $j$，其右边界 $j+k-1$ 必须落在填充后的输入范围内（长度 $W_{in}+2p$），故 $j\le W_{in}+2p-k$。$j$ 从 $0$ 出发每次加 $s$，可取个数为 $$W_{out}=\left\lfloor\frac{W_{in}+2p-k_{\text{eff}}}{s}\right\rfloor+1,\qquad k_{\text{eff}}=k+(k-1)(d-1).$$ 向下取整的来源：边界处剩余像素不足 $s$ 个、放不下完整窗口时该位置被丢弃；框架（如 PyTorch Conv2d）不会补齐不完整位置，$W_{in}+2p-k<0$ 时直接报错。

手算（一维，二维逐轴独立）：

• (a) $\lfloor(32+0-3)/1\rfloor+1=30$ —— valid 约定，边界丢两圈信息。
• (b) $\lfloor(32+2-3)/1\rfloor+1=32$ —— same 约定，尺寸不变。
• (c) $\lfloor(32+2-3)/2\rfloor+1=\lfloor31/2\rfloor+1=16$ —— 精确减半，骨干降采样常用。
• (d) $k_{\text{eff}}=3+(3-1)(2-1)=5$，$\lfloor(32+4-5)/1\rfloor+1=32$ —— 空洞卷积保尺寸扩视野，参数仍是 9 个而视野变 $5\times5$。
• (e) $\lfloor(224+6-7)/2\rfloor+1=112$ —— 这就是 ResNet 首层输出（再接 $3\times3,s=2,p=1$ 最大池化得 $56$）。

三条随手可得的规律：$s=1$ 且 $p=(k-1)/2$（$k$ 奇）→ 尺寸不变；$s=2$ → 大致减半；$d>1$ → 核撑大而参数不变。

公式：Params $=C_{out}C_{in}k^2+C_{out}$；MACs $=H_{out}W_{out}C_{out}C_{in}k^2$。

(a)

• ① $1\times1$，$256\to64$：Params $=64\cdot256+64=16{,}448$；MACs $=56\cdot56\cdot64\cdot256=5.14\times10^{7}$。
• ② $3\times3$，$64\to64$：Params $=64\cdot64\cdot9+64=36{,}928$；MACs $=56\cdot56\cdot64\cdot64\cdot9=1.156\times10^{8}$。
• ③ $1\times1$，$64\to256$：Params $=256\cdot64+256=16{,}640$；MACs $=56\cdot56\cdot256\cdot64=5.14\times10^{7}$。

(b) Params $=16{,}448+36{,}928+16{,}640=69{,}016\approx6.9\times10^{4}$；MACs $\approx2.18\times10^{8}$。

(c) 单层 $3\times3$、$256\to256$：Params $=256\cdot256\cdot9+256=590{,}080$；MACs $=56\cdot56\cdot256\cdot256\cdot9=1.85\times10^{9}$。比值：参数 $\approx1/8.6$、算力 $\approx1/8.5$。

(d) 换成了深度：ResNet-50 用 $m=C/4$ 的瓶颈把「同宽度堆叠」压到约 $1/8.5$ 的预算，从而在同代预算下把总深度从十几层量级推到五十层量级，同时每块内多出两层非线性（3.4.5）。

注意易错点：$1\times1$ 卷积也有偏置，漏掉 $+64$ / $+256$ 会以为公式算错（例 3.2.2 的核对）。

(a) 由 $x_{i+1}=x_i+F_i(x_i)$， $$\frac{\partial x_{i+1}}{\partial x_i}=I+\frac{\partial F_i}{\partial x_i}\quad\Longrightarrow\quad \frac{\partial x_L}{\partial x_l}=\prod_{i=l}^{L-1}\Bigl(I+\frac{\partial F_i}{\partial x_i}\Bigr),$$ 再由 $\partial\mathcal L/\partial x_l=(\partial\mathcal L/\partial x_L)(\partial x_L/\partial x_l)$ 即得 (3.10)。

(b) 记 $J_i=\partial F_i/\partial x_i$，则 $$\prod_{i=l}^{L-1}(I+J_i)=I+\sum_i J_i+\sum_{i<j}J_iJ_j+\cdots+J_l\cdots J_{L-1}.$$ 展开式里每一项都含至少一个 $J$，唯一不含 $J$ 的项是 $I$——它就是直通项（它给出 $\partial\mathcal L/\partial x_L\cdot I=\partial\mathcal L/\partial x_L$，即从深层原样带回的一份梯度）。

(c) 取 $n=L-l=10$、$\lVert J\rVert=0.1$：

• 无残差：$\lVert\prod J_i\rVert=0.1^{10}=10^{-10}$ —— 已经彻底消失。
• 有残差：$\lVert(I+J)^{10}\rVert$(近似按标量 $(1+0.1)^{10}=2.59$) 与 $\lVert I\rVert=1$ 同量级，不会降到零。

（注意这里是量级估计：矩阵情形下非交换性会使确切的范数依赖结构，但「有一项恒为 $I$」这一点不依赖结构。）

(d) $I$ 不依赖于任何权重，所以它不可能被梯度下降「学掉」；类比是给梯度修了一条无需维护的高架桥。

不能推出什么：① 不能说「梯度一定很大」——$I$ 是矩阵意义的直通，具体参数收到的梯度大小还取决于后续层的组合与总深度；② 不能忽略展开式里的高阶交叉项在深层的累积，这正是残差网络并非「无条件可训」的原因之一，实践中还需归一化与合理初始化；③ 不能推出「更深一定更好」——原文里千层网络能训起来，但精度并不比百层更好。

(a) 设 $x'_i=x_i+c$（$i$ 遍历该通道全部元素）。则 $\mu'=\mu+c$，且 $x'_i-\mu'=x_i-\mu$，故 $\sigma'^2=\sigma^2$，于是 $$\hat x'_i=\frac{x'_i-\mu'}{\sqrt{\sigma'^2+\epsilon}}=\frac{x_i-\mu}{\sqrt{\sigma^2+\epsilon}}=\hat x_i.$$ （推理时用运行统计量同理：训练与推理的常数一致则抵消，不一致会引入系统性偏移——这正是领域偏移下 BN 成为误差源的原因。）

(b) 设卷积输出 $z=W*x+b_{\text{conv}}$。训练时 BN 算 $(z-\mu_{\text{batch}}(z))/\sigma(z)$，而 $$\mu_{\text{batch}}(z)=\mu_{\text{batch}}(W*x)+b_{\text{conv}},$$ 故分子中 $b_{\text{conv}}$ 被完全减掉；既然结果与 $b_{\text{conv}}$ 无关，该参数永远冗余（其作用可由 BN 的 $\beta$ 承担）。推理时运行统计量 $\mu^{\text{run}}$ 同样吸收了等量偏移，抵消关系不变。工程含义：紧跟 BN 的卷积可以设 bias=False，省参数也省一次加法。

(c) BN 在每个激活值上做：一次减法 $+$ 一次乘以预计算好的 $\gamma/\sqrt{\sigma^2+\epsilon}$，约 $2$ 次逐元素运算。对照一层 $3\times3$、$C_{in}=C_{out}=64$ 卷积：每个输出元素要 $C_{in}k^2=576$ 次 MAC。故 BN 相对卷积约 $0.3\%$，FLOPs 上可忽略。但它需要两次全张量归约与读写（求均值、求方差），访存量与激活张量同阶——所以「BN 拖慢小模型推理」的观感来自内存带宽而非 FLOPs（例 3.3.3(c)）。

(a) 由 $q_k=\exp(s_{ik})/Z$、$Z=\sum_{j\ne i}\exp(s_{ij})$，得 $\log q_k=s_{ik}-\log Z$，于是 $$\frac{\partial\log q_k}{\partial s_{ik}}=1-\frac{\partial\log Z}{\partial s_{ik}}=1-q_k,\qquad \frac{\partial\log q_k}{\partial s_{il}}=-\frac{\partial\log Z}{\partial s_{il}}=-q_l\ (l\ne k).$$

(b) 由 $\mathcal L_i=-\log q_{j(i)}$： $$\frac{\partial\mathcal L_i}{\partial s_{ik}}=\begin{cases}-\bigl(1-p_{i,j(i)}\bigr), & k=j(i)\\[4pt] +\,p_{ik}, & k\ne i,\ j(i)\end{cases}$$ 其中 $p_{ik}$ 是负样本上的 softmax 分布（$p_{ii}:=0$）。

(c) 换回 $s_{ik}=\cos\theta_{ik}/\tau$ 后，$-\partial\mathcal L_i/\partial z_i$ 是梯度下降方向，它把 $z_i$ 往正样本拉、从负样本推开，权重分别是 $(1-p_{\text{pos}})$ 与 $p_{ik}$：

• 难负样本主导学习：$p_{ik}$ 大（当前被判得越像正样本）的负样本被推得越用力；
• 正样本已分对时不再贡献：$p_{\text{pos}}\approx1\Rightarrow(1-p_{\text{pos}})\to0$，吸引项消失；
• $\tau$ 越小梯度越大：$\tau$ 在分母上，整体缩放因子是 $1/\tau$，因此需要配合更小的学习率。

附带的等价性：这一切正是「在表示空间做 $2N-1$ 类分类」的梯度——(3.11) 与交叉熵同形。

(a) 总错误 $=90+120=210$，总体准确率 $=1-210/10000=\mathbf{97.9\%}$；群体 A $=1-0.01=\mathbf{99.0\%}$，群体 B $=1-0.12=\mathbf{88.0\%}$。

(b) 错误拒绝人数：群体 A $9000\times1\%=90$ 人；群体 B $1000\times12\%=120$ 人。绝对人数接近（90 对 120），但相对概率相差 $12$ 倍——意味着群体 B 的每个个体被挡在门外的概率是群体 A 的 $12$ 倍。这是个体层面的差别对待；而从系统层面看，占比 $10\%$ 的 B 群体的高错误率在总体平均里被「稀释」了，这个偏差不会出现在任何只看总体准确率的报表上。

(c) 报告必须包含分组混淆矩阵（分组 precision / recall / FPR / FNR），并且要检查各组样本量是否足够得出有意义的区间估计——小样本子群上的指标方差很大，「看起来有差异」也可能只是噪声。这两条要同时做。

(d) 三条例由（3.9.2）：① 该数据集本身可能不代表部署环境；② 错误率相近不等于特定阈值下的误识比例相近（阈值选择会放大或缩小差异）；③ 不同地区的采集、光照、摄像头质量差异没有被覆盖。所以这类结论必须带条件陈述，不能作为普遍保证。

import torch, torch.nn as nn, torch.nn.functional as F
def conv2d_via_unfold(x, weight, bias=None, stride=1, padding=1):
    # x: (B,C_in,H,W); weight: (C_out,C_in,k,k) —— 关键：核的第 0 维是输出通道
    B, C, H, W = x.shape
    C_out, _, k, _ = weight.shape
    if padding:
        x = F.pad(x, (padding,) * 4)
    cols = F.unfold(x, kernel_size=k, stride=stride)   # (B, C*k*k, L)
    out = weight.view(C_out, -1) @ cols                # (B, C_out, L)
    if bias is not None:
        out = out + bias.view(1, -1, 1)
    Ho = (H + 2 * padding - k) // stride + 1           # 与公式 (3.2) 一致
    Wo = (W + 2 * padding - k) // stride + 1
    return out.view(B, C_out, Ho, Wo), cols
torch.manual_seed(0)
x = torch.randn(2, 3, 224, 224)
conv = nn.Conv2d(3, 64, 3, stride=2, padding=1)
y = conv(x)
assert y.shape == (2, 64, 112, 112)                                  # 验收 1
assert sum(p.numel() for p in conv.parameters()) == 1792             # 验收 1
y2, cols = conv2d_via_unfold(x, conv.weight, conv.bias, stride=2, padding=1)
print("最大误差 =", (y - y2).abs().max().item())                      # 验收 2：期望 <1e-5
print("cols", tuple(cols.shape), "放大倍数 C_in*k^2 =", 3 * 9)         # 验收 3
# 验收 4：翻转核 → 数学卷积
w_flip = torch.flip(conv.weight, dims=[2, 3])
y_math, _ = conv2d_via_unfold(x, w_flip, conv.bias, stride=2, padding=1)
print("与翻转核输出的差 =", (y - y_math).abs().max().item())          # 不为 0，说明两者不同约定

def trace(layers, first=True):
    """layers: [('conv'|'pool', k, s), ...]；首层直接作用输入时取初始条件 r1=k, j1=s。"""
    r = j = 0; out = []
    for kind, k, s in layers:
        r, j, first = (k, s, False) if first else (r + (k - 1) * j, j * s, False)
        out.append((kind, k, s, r, j))     # r_{l+1}=r_l+(k-1)j_l, j_{l+1}=j_l*s
    return out
assert all(trace([('conv', 3, 1)] * L)[-1][3] == 2 * L + 1 for L in range(1, 21))   # 验收 1
assert trace([('conv', 7, 2), ('pool', 3, 2)] + [('conv', 3, 1)] * 12)[-1][3:] == (107, 4)  # 验收 2
assert [x[3:] for x in trace([('pool', 3, 2)] * 4)] == [(5, 2), (9, 4), (17, 8), (33, 16)]  # 验收 3
assert trace([('conv', 3, 2)] * 4)[-1][4] == 16 and trace([('conv', 1, 1)])[-1][3] == 1     # 验收 4、5

（注：验收 4 中「4 次 $3\times3,s=2$ 卷积」的 $r$ 与池化版不同，原因是首层的初始条件不同——池化版首层 $r_1=k$ 直接作用于输入，卷积版按 例 3.3.2 的记法给出 $31$。）

import torch, torch.nn as nn
x = torch.randn(2, 64, 56, 56)
std = nn.Conv2d(64, 64, 3, padding=1)                     # 标准
grp = nn.Conv2d(64, 64, 3, padding=1, groups=4)           # 分组 g=4
dw  = nn.Conv2d(64, 64, 3, padding=1, groups=64)          # 逐通道 groups=C_in=C_out
pw  = nn.Conv2d(64, 64, 1)                                # 逐点
n = lambda m: sum(p.numel() for p in m.parameters())
assert (n(std), n(grp), n(dw) + n(pw)) == (36928, 9280, 4800)      # 验收 1、2
assert all(m(x).shape == (2, 64, 56, 56) for m in (std, grp, dw, pw))  # 验收 4
assert abs((1 / 64 + 1 / 9) - 0.127) < 1e-3                        # 验收 3
r = [n(nn.Conv2d(64, 64, 3, padding=1, groups=g)) for g in [1, 2, 4, 8, 16, 32, 64]]
assert r == sorted(r, reverse=True)                                 # 验收 5：单调不增
print("sep/std =", round(4800 / 36928, 3), " grp/std =", round(9280 / 36928, 3))

import torch, torch.nn as nn
# 验收 1：与例 3.3.4 的手算逐元素对齐
x = torch.tensor([1., 2., 3., 4., 10., 20., 30., 40.]).view(2, 4, 1, 1)
bn = nn.BatchNorm2d(4, eps=0, affine=False, momentum=None, track_running_stats=False).train()
assert torch.allclose(bn(x).view(2, 4), torch.tensor([[-1., -1., -1., -1.], [1., 1., 1., 1.]]))
gn = nn.GroupNorm(2, 4, eps=0, affine=False)                       # g=2：每样本两组
assert torch.allclose(gn(x).view(2, 4, 2), torch.tensor([[[-1., 1.], [-1., 1.]]] * 2))
# 验收 2、5：train/eval 差异 + batch=1 时统计退化
bn2 = nn.BatchNorm2d(4)
for _ in range(5): _ = bn2(torch.randn(8, 4, 4, 4))                # 让 running stats 离开初值
z = torch.randn(1, 4, 4, 4)
bn2.train(); a = bn2(z); bn2.eval(); b = bn2(z)
assert (a - b).abs().max().item() > 1e-4 and a.var().item() < 1e-6  # 方差≈0 → 必须 eval()
# 验收 3：卷积偏置被 BN 吃掉（必须对同一个固定输入比较两次输出）
conv = nn.Conv2d(3, 8, 3, bias=True); bn3 = nn.BatchNorm2d(8).eval()
bn3.running_mean.zeros_(); bn3.running_var.fill_(1.0)
a_in = torch.randn(2, 3, 8, 8)
with torch.no_grad():
    conv.bias.data.normal_();  y1 = bn3(conv(a_in))
    conv.bias.data.add_(100.0); y2 = bn3(conv(a_in))
assert (y1 - y2).abs().max().item() < 1e-4
# 验收 4：手动复算 running stats
bn4 = nn.BatchNorm2d(4, momentum=0.1); d = torch.randn(6, 4, 5, 5); _ = bn4(d)
mu, var = d.mean(dim=(0, 2, 3)), d.var(dim=(0, 2, 3), unbiased=False)
assert torch.allclose(bn4.running_mean, 0.1 * mu, atol=1e-5)
assert torch.allclose(bn4.running_var, 0.9 * 1 + 0.1 * var, atol=1e-5)

（提醒：running_mean 的初值是 $0$、running_var 的初值是 $1$，所以第一轮的更新式写出来是 $0.1\mu$ 与 $0.9\times1+0.1\sigma^2$——把这两个初值写错是最常见的实现级错误。）

def iou(a, b):
    ix1, iy1 = max(a[0], b[0]), max(a[1], b[1])
    ix2, iy2 = min(a[2], b[2]), min(a[3], b[3])
    iw, ih = max(0.0, ix2 - ix1), max(0.0, iy2 - iy1)     # 连续坐标：x2 - x1，不加 1
    inter = iw * ih
    union = (a[2]-a[0])*(a[3]-a[1]) + (b[2]-b[0])*(b[3]-b[1]) - inter
    return inter / union if union > 0 else 0.0
G = (40, 40, 120, 120)
cands = {"A": (44, 44, 116, 116), "B": (80, 80, 152, 152), "C": (0, 0, 40, 40), "D": (40, 32, 124, 132)}
exp = {"A": 0.81, "B": 0.160, "C": 0.0, "D": 0.762}
for k, box in cands.items():
    assert abs(iou(G, box) - exp[k]) < 1e-3, (k, iou(G, box))     # 验收 1
assert abs(iou((0,0,10,10), (5,5,15,15)) - 25/175) < 1e-6          # 验收 2
def nms(dets, thr=0.5):
    dets = sorted(dets, key=lambda d: -d[4])
    kept = []
    while dets:
        best = dets.pop(0); kept.append(best)
        dets = [d for d in dets if iou(best, d) <= thr]            # 大于阈值才抑制
    return kept
dets = [(0, 0, 20, 20, 0.9), (1, 1, 21, 21, 0.8), (2, 2, 22, 22, 0.7), (3, 3, 23, 23, 0.6), (4, 4, 24, 24, 0.5)]
assert len(nms(dets, thr=0.5)) == 1                                # 验收 3
def ap_11pt(judgements, n_gt):
    tp = fp = 0; prec = []; rec = []
    for j in judgements:
        tp += (j == "TP"); fp += (j == "FP")
        if tp + fp == 0: continue
        prec.append(tp / (tp + fp)); rec.append(tp / n_gt)
    out = []
    for r in [i / 10 for i in range(11)]:
        cand = [p for p, rr in zip(prec, rec) if rr >= r - 1e-12]
        out.append(max(cand) if cand else 0.0)
    return sum(out) / 11, out
J = ["TP","TP","FP","TP","FP","TP","TP","FP","TP","FP","TP","FP"]
ap, pts = ap_11pt(J, 10)
assert 0.58 <= ap <= 0.60, ap                                     # 验收 4（正文 0.589）
print("11 点 AP =", round(ap, 4), "各点 =", [round(x, 3) for x in pts])
print("全部判背景的准确率 =", 1 - 10 / 1_000_000, " recall =", 0)   # 验收 5

import torch, torch.nn as nn, torch.nn.functional as F
from torchvision.models import resnet50
# 验收 1：可训练参数量与显存量级（对应例 3.6.1）
m = resnet50(weights=None); m.fc = nn.Linear(2048, 20)
head = sum(p.numel() for p in m.fc.parameters())
for p in m.parameters(): p.requires_grad_(False)
for p in m.fc.parameters(): p.requires_grad_(True)
trainable = sum(p.numel() for p in m.parameters() if p.requires_grad)
assert 3e4 < head < 5e4 and trainable == head
full = 25_500_000
assert 500 < full / head < 800                       # ≈622 倍
print("梯度显存 ≈", head * 4 / 1e6, "MB；含 Adam ≈", head * 12 / 1e6, "MB")
print("全网络：≈", full * 4 / 1e6, "MB；含 Adam ≈", full * 12 / 1e6, "MB")
# 验收 4：FGSM（对输入求导，不是对参数）
def fgsm(model, x, y, eps=8/255):
    model.eval()
    x = x.clone().detach().requires_grad_(True)
    loss = F.binary_cross_entropy_with_logits(model(x).squeeze(1), y.float())  # 二分类人脸/背景
    (g,) = torch.autograd.grad(loss, x)
    x_adv = (x + eps * g.sign()).clamp(0, 1)          # clamp 到合法像素范围
    return x_adv.detach(), g
x, y = torch.rand(64, 3, 32, 32), torch.randint(0, 2, (64,))
# 用一个已训好的 model；此处只演示流程与断言
class Net(nn.Module):
    def __init__(s):
        super().__init__(); s.net = nn.Sequential(
            nn.Conv2d(3, 32, 3, 2, 1), nn.ReLU(), nn.Conv2d(32, 64, 3, 2, 1), nn.ReLU(),
            nn.AdaptiveAvgPool2d(1), nn.Flatten(), nn.Linear(64, 1))
    def forward(s, v): return s.net(v)
model = Net()
x_adv, g = fgsm(model, x, y)
assert x_adv.min() >= 0 and x_adv.max() <= 1           # 验收 4：合法像素
print("‖δ‖∞ =", (x_adv - x).abs().max().item(), "（期望 = 8/255 ≈", 8/255, "）")
print("扰动放大 32 倍后可可视化：", ((x_adv - x)[0] * 32).abs().max().item())  # 有结构、非白噪声
# 验收 5：简单防御在自适应攻击下仍大部分成功
def jpeg_like(x, k=8):                                # 用低通近似「压缩」这个预处理
    return F.avg_pool2d(F.pad(x, (k, k, k, k), mode="reflect"), 2 * k + 1, 1)
# 正确做法：在攻击时把这个 k 纳入前向（自适应），再比较成功率下降幅度

方案（分层）：

1. 数据层：先做子群样本量统计（性别 / 年龄段 / 肤色区间 / 采集设备 / 光照条件），对样本过少的子群明确标注「无法评估」而不是并入总体；记录数据来源、授权范围与保留期限；对网络爬取部分标注潜在偏差。
2. 模型与阈值层：不用默认阈值，按业务代价选择阈值（门禁误识代价高 → 提高阈值，宁可拒识）；报告分组混淆矩阵（各组 precision / recall / FPR / FNR）与置信区间；分组校准作为有争议的备选，需法务与伦理评审后再决定。
3. 系统层：人在回路（高风险判定必须复核）、可追溯日志与申诉通道、数据最小化（只存不可逆模板，且模板按用途绑定）、明确用途与时限。

理由：偏见有四个进入点（采集、标注、任务定义、部署），不能只治一处；放大会通过反馈回路自我强化，因此必须在数据进模型之前和模型出结论之后两端设卡。

失败判据（可测量）：① 任一分组样本量 $<200$ 时该组的结论视为不可靠，不得写成「已评估」；② 分组 FPR 相对差 $>3$ 倍时必须停止上线流程重新设计（正文 例 3.9.1 的反例是 $12$ 倍）；③ 总体准确率与最差子群准确率之差 $>0.05$ 时必须给出书面风险说明与缓解计划。

验证计划：① 分群评估复现（含样本量与置信区间）；② 用「阈值—代价曲线」为门禁场景选定工作点，并记录选择依据；③ 在一批留出的、按实体划分的数据上做一次盲测（防止同一人多张照片跨划分造成虚高）；④ 上线后按周监控被拒样本的分布漂移。

明确不做的：① 不把「只存特征模板」当隐私解决方案（模板可被反演、且不可撤销，3.9.4）；② 不用总体准确率作为验收依据；③ 不在样本不足的子群上宣称公平性。

评分要点：分层清单 $4$ 分；失败判据可测量 $3$ 分；验证计划含防泄漏设计 $2$ 分；风险与「不做什么」的自觉 $1$ 分。

方案：

• 数据：统计目标尺寸分布并对小目标增采样；按批次/设备分层划分（避免同批相似图跨划分造成泄漏）；正负样本比极高，用加权采样或 focal loss（3.7.3）。
• 模型：骨干用与域接近的自监督预训练权重（3.6.5 第 2 步），先冻结只训头再解冻；小目标必须用多尺度特征（FPN 类结构，3.7.3）或特征金字塔式的多尺度推理，不能只靠全局注意力 + 粗网格（3.7.5 已说明这类架构天然对小目标不友好）。
• 评估：报 AP 并说明口径（IoU 阈值集合、是否跨类别）；按目标尺寸分组统计召回（3.7.4 的分组表：小目标 $<1\%$ 面积是最易崩的一组）；漏检与误检分开计数；固定随机种子并报多轮均值与方差。
• 上线：置信度下限以下拒答（交给人工）；保留被拒样本日志；按周抽查漂移。

上线门槛数字（示例，需按产线确认）：① 小目标分组召回 $\ge0.90$、整体误检率 $\le0.02$/图；② 单图 P99 延迟 $\le40$ ms；③ 拒答率 $\le5\%$（超过说明数据或阈值需要重设）。

失败判据：① 小目标分组召回低于大目标 $0.10$ 以上 → 回退到更高分辨率特征或多尺度推理；② 拒答率 $>5\%$ 或人工复检负载超预算 → 重新标定阈值；③ 连续两批生产的漏检率超阈值 → 立即回滚到上一版模型并冻结产线该工序。

验证计划：① 先过拟合 10 个样本确认实现无误（3.10.3）；② 按尺寸分组的 PR 曲线与工作点选择；③ 与上一代方案的同一测试集盲测；④ 上线后按批做分组召回监控，并维护「被拒 / 低置信 / 异常大小框」三类日志。

评分要点：清单覆盖数据—模型—评估—上线四层 $4$ 分；门槛与回滚条件可测量 $4$ 分；识别小目标与口径两处陷阱 $2$ 分。

选择：目标域自监督预训练（能拿到大量无标签影像的话）→ 冻结骨干只训头 → 解冻后段微调（小学习率），即「自监督（可选）$+$ 两阶段迁移」；不选全参数微调作为起点，也不把 LoRA 作为首选（它更适合显存受限的大模型场景，在 $1{,}200$ 张图、小骨干上收益有限）。

理由：

• 目标域与自然图像差异大 → 浅层特征也不再通用，迁移收益下降，故先做领域适配（最便宜的版本是重估归一化统计量：冻结全部参数，用目标域无标签数据重跑前向重新累积 running stats，几十到几百个 batch 即可，3.6.2）；有条件则做目标域自监督预训练。
• $1{,}200$ 张图很危险：全网络微调的可训练参数是「只训头」的约 $622$ 倍（例 3.6.1 的量级），小数据下应把可训练参数压到 $10^4$ 量级起步。
• 骨干学习率需比头小约一个量级，或使用分层衰减 $\eta_l=\eta_{\text{head}}\alpha^{K-l}$（$\alpha$ 取 $0.5\sim0.8$）。
• 延迟 $<50$ ms → 选小骨干并量化；迁移策略本身不影响推理结构（冻结 / 微调是训练期的事）。
• 可审计 → 记录骨干来源与版本、预处理统计量、随机种子与划分文件。

失败判据：① 冻结版与解冻版的验证 AUC 差 $<0.01$ → 保持冻结（解冻没带来收益却增加了过拟合风险）；② 解冻后验证指标反而下降 $>0.02$ → 回退并把骨干学习率再降 $10$ 倍；③ 分组（按设备 / 中心 / 性别）指标相对差 $>2$ 倍 → 进入 3.9 的治理流程；④ 单张延迟实测 $>50$ ms → 换更小骨干或量化，不接受把延迟转嫁给临床流程。

验证计划：① 按患者（实体）划分，断然不能按图划分——同一患者的多张影像跨划分是最典型的泄漏（3.10.5 的「验证指标远低于训练」一行的正解）；② 患者级别的 $k$ 折交叉验证（小数据下比单一划分更可信）；③ 预处理一致性核对（分辨率、归一化统计量、通道顺序必须与骨干匹配，否则初始 loss 会异常高）；④ 报告多轮运行均值与方差，并明确「没做什么」。

评分要点：路线选择与理由 $4$ 分（必须出现「先冻结后解冻」「重估统计量」「骨干学习率小一个量级」中至少两点）；失败判据可测量 $3$ 分；验证计划含患者级划分 $2$ 分；可复现 / 审计要求 $1$ 分。

(a) 可检验定义：鲁棒性必须写成「在 $\lVert\delta\rVert_\infty\le\epsilon$（或 $\ell_2$）且攻击算法为 PGD-$k$（步长 $\alpha$、重启次数 $n$）的攻击下，分组召回率的下降不超过某阈值」。示例：$\epsilon=4/255$、PGD-$10$、单次重启，要求「行人分组召回下降 $\le0.05$」。没有攻击设置的「已鲁棒」不构成陈述。

(b) 方案与预算分配：把有限的一轮训练预算分给三件事——

1. 对抗训练（选最小代价的版本）：用 FGSM 或 PGD-2/3 而不是 PGD-10 做内层最大化，只对正样本与难负样本做（检测任务里全量对抗训练成本过高）；明确接受「只对训练时的 $\epsilon$ 与范数有效」。
2. 输入侧与系统侧的纵深：多尺度一致性检查（同一目标在不同尺度下应给出相近分数）、更大感受野的上下文特征、把「不确定」变成一次拒答 / 复核而不是一次错误告警——这条最便宜且不会被自适应攻击绕过。
3. 不做：不做「堆一层检测器来识别对抗样本」的方案——攻击是自适应的，攻击者只需找到一个漏洞，防御要堵住所有漏洞，成本不对称（3.9.5 的 think 框）。

失败判据：① 干净精度下降 $>0.03$ → 减小对抗训练比例或降低 $\epsilon$；② 攻击预算升到 $2\epsilon$ 或换成 $\ell_2$ 范数后成功率没有明显上升 → 先怀疑评测脚本有 bug（正常鲁棒性都是相对的，换预算应当变弱）；③ 自适应攻击（攻击者知道你的预处理 / 多尺度检查）下成功率下降幅度 $<30\%$ → 说明该防御当前不成立，不能写进验收报告。

(c)/(d) 验证计划：① 固定攻击脚本与随机种子，报告攻击成功率、$\ell_\infty$ 与平均扰动、置信度变化、扰动可视化（把 $\delta$ 放大若干倍显示，让评审自己判断可见性——3.10.4 要求三件事缺一不可）；② 迁移测试：在模型 A 上生成的扰动去攻击结构不同的模型 B，若成功率仍显著，说明这是模型无关的弱点；③ 分组评估：鲁棒性差距也要按子群报告，因为鲁棒性增益在不同子群上不均。

评分要点：定义带攻击设置 $3$ 分；方案与预算分配合理（含「最便宜的系统侧纵深」）$3$ 分；失败判据可测量 $2$ 分；验证计划含自适应攻击与迁移测试 $2$ 分。