NiN:把全连接层干掉
这一课在哪
上一课把 1×1 卷积搞明白了。这一课看它能干什么大事。
先看一个数字:
网络 | 参数 | 全连接占比 |
|---|---|---|
AlexNet | 61,100,840 | 96.0% |
VGG11 | 132,868,840 | 93.1% |
NiN | 1,992,166 | 0% |
比 AlexNet 少 96.7%,一个全连接层都没有。
全连接层为什么那么大
VGG 的分界线那一步:
512@7×7 ──Flatten──► 25088 ──Linear──► 409625088 × 4096 = 102,760,448——一层就一亿参数。
问题出在「拉平」
512@7×7 是一个有空间结构的张量。
Flatten 把它变成 25088 个互不相干的数, 然后全连接层给每一个都配 4096 个权重。
参数爆炸就爆在这里。
NiN 的思路:不要拉平
既然拉平才出事,那就在保持四维的情况下把通道数变成类别数。
上一课学过的 1×1 卷积正好能做这件事——它改通道,不改尺寸。
NiN 块
NiN 块 = conv k×k 普通卷积,提空间特征 1×1 conv 逐像素全连接(改通道) 1×1 conv 再来一次 每个后面都跟 ReLUimport torch.nn as nn def nin_block(in_channels, out_channels, kernel_size, padding, stride=1): return nn.Sequential( nn.Conv2d(in_channels, out_channels, kernel_size, padding=padding, stride=stride), nn.ReLU(inplace=True), nn.Conv2d(out_channels, out_channels, kernel_size=1), nn.ReLU(inplace=True), nn.Conv2d(out_channels, out_channels, kernel_size=1), nn.ReLU(inplace=True), )第一个卷积的核由用户定,后面两个永远固定 1×1。
名字的由来
普通的「卷积 + ReLU」块有个限制: 它在空间上混合,但通道之间只是线性组合。
加两层 1×1 卷积 + ReLU,相当于在每个像素位置插了两层隐藏层的小全连接网络。
所以叫 Network in Network——网络里套小网络。
和 VGG 块对比
VGG 块 | NiN 块 | |
|---|---|---|
构造 | n 个 3×3 卷积 → 池化 | 1 个 k×k 卷积 → 2 个 1×1 |
通道何时变 | 每个卷积都可以变 | 块内不变,块间变 |
在混什么 | 空间 + 通道 | 空间一次,之后只混通道 |
整个网络
class NiN(nn.Module): def __init__(self, num_classes=10, in_channels=1): super().__init__() self.features = nn.Sequential( nin_block(in_channels, 96, kernel_size=11, padding=0, stride=4), nn.MaxPool2d(kernel_size=3, stride=2), nin_block(96, 256, kernel_size=5, padding=2), nn.MaxPool2d(kernel_size=3, stride=2), nin_block(256, 384, kernel_size=3, padding=1), nn.MaxPool2d(kernel_size=3, stride=2), nn.Dropout(p=0.5), # 关键:通道数直接变成类别数 nin_block(384, num_classes, kernel_size=3, padding=1), nn.AdaptiveAvgPool2d((1, 1)), nn.Flatten(), ) def forward(self, x): return self.features(x)最后那个 nin_block(384, num_classes, ...) 直接把通道数变成类别数。
全局平均池化
网络的最后是 num_classes @ 某个尺寸, AdaptiveAvgPool2d((1,1)) 把它压成 num_classes @ 1×1。
做法 | 参数量 | 依赖输入尺寸吗 |
|---|---|---|
Flatten + 全连接 |
| 强依赖 |
全局平均池化 | 0 | 不依赖 |
为什么「求平均」能当分类器
前面的 NiN 块已经让每个通道对应一个类别了。
10 @ 4×4 的意思是:在 16 个位置上,各自给出这个类别的分数。
求平均 = 综合所有位置的判断,比只看一个位置更稳。
而且它对输入尺寸完全不敏感——这点和全连接层正好相反。
跑一遍
先看形状(输入 96×96):
model = NiN(num_classes=10, in_channels=1) x = torch.randn(1, 1, 96, 96) for layer in model.features: x = layer(x) print(f"{layer.__class__.__name__:<20} {tuple(x.shape)}")Sequential (1, 96, 22, 22) MaxPool2d (1, 96, 10, 10) Sequential (1, 256, 10, 10) MaxPool2d (1, 256, 4, 4) Sequential (1, 384, 4, 4) MaxPool2d (1, 384, 1, 1) Dropout (1, 384, 1, 1) Sequential (1, 10, 1, 1) AdaptiveAvgPool2d (1, 10, 1, 1) Flatten (1, 10)为什么必须放大到 96
def out_size(n, k, s=1, p=0): return (n + 2 * p - k) // s + 1 for size in [28, 32, 64, 96]: a = out_size(size, 11, s=4) b = out_size(a, 3, s=2) d = out_size(out_size(b, 5, p=2), 3, s=2) f = out_size(out_size(d, 3, p=1), 3, s=2) print(f"{size:>3} → {a:>2} → {b:>2} → {d:>2} → {f:>2}") 28 → 5 → 2 → 0 → -1 32 → 6 → 2 → 0 → -1 64 → 14 → 6 → 2 → 0 96 → 22 → 10 → 4 → 128×28 直接跑会报错
Given input size: (256x2x2). Calculated output size: (256x0x0).
2×2 的图用 3×3 窗口池化,输出是 0。
所以要先 transforms.Resize((96, 96))。
数参数
0 Sequential 30,336 1.5% 2 Sequential 746,240 37.5% 4 Sequential 1,180,800 59.3% 7 Sequential 34,790 1.7% 合计 1,992,166为什么块 3 最贵,块 1 最便宜
块 1:1 × 96 × 11 × 11 = 11,616——输入只有 1 个通道。
块 3:256 × 384 × 3 × 3 = 884,736——输入通道 256。
核面积只差 13 倍(121 vs 9),但通道差 256 倍。
参数量由「输入通道 × 输出通道 × 核面积」决定。
真实训练结果
transform = transforms.Compose([ transforms.Resize((96, 96)), transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)), ]) # ... 建 DataLoader,和前面几章一样 model = NiN(num_classes=10, in_channels=1).to(device) loss_fn = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=1e-3) for epoch in range(1, 6): model.train() for images, labels in train_loader: logits = model(images.to(device)) loss = loss_fn(logits, labels.to(device)) optimizer.zero_grad() loss.backward() optimizer.step() model.eval() correct, seen = 0, 0 with torch.no_grad(): for images, labels in val_loader: correct += (model(images.to(device)).argmax(dim=1) == labels.to(device)).sum().item() seen += labels.size(0) print(f"{epoch} val {100*correct/seen:.2f}%")1 train_loss 1.2240 val 67.02% 2 train_loss 0.7902 val 68.00% 3 train_loss 0.7690 val 68.23% 4 train_loss 0.7562 val 68.12% 5 train_loss 0.7555 val 68.10% 测试集 68.47%这个结果很差,值得研究
网络 | 参数 | 测试 |
|---|---|---|
LeNet | 61,706 | 98.78% |
AlexNet 小图版 | 3,777,226 | 97.82% |
NiN | 1,992,166 | 68.47% |
而且第 2 轮之后几乎不动了——train_loss 还在降,val 卡在 68%。 不是过拟合。
三个原因
# | 原因 |
|---|---|
① |
|
② | MNIST 放大到 96 是插值出来的,笔画糊了 |
③ | 池化 3 次后只剩 |
这一课真正要记住的
结构要和数据的规模匹配。
NiN 是为 224×224 的 ImageNet 设计的:大核 + 大步长, 是为了在大图上快速缩小、省算力。
搬到 96×96 的灰度图上,这套设计反而成了负担。
这和上一章 AlexNet 小图版不如 LeNet 是同一个现象。
那 NiN 白做了吗
没有。它的两个想法都活下来了,而且用得比它自己广:
想法 | 今天用在哪 |
|---|---|
1×1 卷积改通道 | ResNet 的 Bottleneck、几乎所有的升降维 |
全局平均池化代替全连接 | 几乎所有现代分类网络 |
想法比网络本身活得久,这在深度学习里很常见。
这一课留下的三个数
数 | 值 | 含义 |
|---|---|---|
参数量 | 1,992,166 | 比 AlexNet 少 96.7% |
全连接层 | 0 个 | 完全取消 |
实测 | 68.47% | 架构与数据规模不匹配 |
下一课
习题:算 1×1 卷积参数、判断最小输入尺寸、做对照实验。