5.8--Network IN Network（NIN）

摘要

NiN模型主要有两个创新点，一个是1×1的卷积核代替全连接层，另一个是提出global average pooling layer(GAP)。

1. 对1×1卷积核定义和优点介绍：链接地址
2. 另一个是全局平均池化层，定义是对特征图所有像素求平均值，作用有将空间维度降为1、减少参数、位置不敏感，其优点为：

• 全局平均池化相比较于全连接层更适用于卷积结构，因为它增强了特征映射和种类之间的关联性。
• 全局平均池化不用优化参数，因此避免了过拟合现象。
• 这种方法总结了空间信息，因此对于输入数据中特征的空间转换有更好的鲁棒性。

一、导入相关库

import time
import torch
from torch import nn, optim
import torchvision
import sys
sys.path.append("..") 
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

print(torch.__version__)
print(device)

二、NIN块

这里要自己先去了解一下1×1卷积核的作用

def nin_block(in_channels, out_channels, kernel_size, stride, padding):
    blk = nn.Sequential(nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding),
                        nn.ReLU(),
                        nn.Conv2d(out_channels, out_channels, kernel_size=1),
                        nn.ReLU(),
                        nn.Conv2d(out_channels, out_channels, kernel_size=1),
                        nn.ReLU())
    return blk

三、NIN模型

下面这个类的作用是将四维输出（1，10，1，1）转成二维输出（1，10）

class FlattenLayer(torch.nn.Module):
    def __init__(self):
        super(FlattenLayer, self).__init__()
    def forward(self, x): # x shape: (batch, *, *, ...)
        return x.view(x.shape[0], -1)

net = nn.Sequential(
    nin_block(1, 96, kernel_size=11, stride=4, padding=0),
    nn.MaxPool2d(kernel_size=3, stride=2),
    nin_block(96, 256, kernel_size=5, stride=1, padding=2),
    nn.MaxPool2d(kernel_size=3, stride=2),
    nin_block(256, 384, kernel_size=3, stride=1, padding=1),
    nn.MaxPool2d(kernel_size=3, stride=2), 
    nn.Dropout(0.5),
    # 标签类别数是10
    nin_block(384, 10, kernel_size=3, stride=1, padding=1),
    # 全局平均池化层可通过将窗口形状设置成输入的高和宽实现
    nn.AvgPool2d(kernel_size=5),
    # 将四维的输出转成二维的输出，其形状为(批量大小, 10)
    FlattenLayer())

观察每个模块后特征图的大小

X = torch.rand(1, 1, 224, 224)

for name, blk in net.named_children(): 
    X = blk(X)
    print(name, 'output shape: ', X.shape)

下面是我自己计算的特征图流程

四、获取数据和训练模型

这一步和之前的AlexNet、VGG11等模型类似，使用的还是FashionMNIST数据集，如果要使用其他数据集，修改load_data_fashion_mnist()方法中的torchvision.datasets.FashionMNIST就可以。
评估函数

def evaluate_accuracy(data_iter, net, device=None):
    if device is None and isinstance(net, torch.nn.Module):
        # 如果没指定device就使用net的device
        device = list(net.parameters())[0].device 
    acc_sum, n = 0.0, 0
    with torch.no_grad():
        for X, y in data_iter:
            if isinstance(net, torch.nn.Module):
                net.eval() # 评估模式, 这会关闭dropout
                acc_sum += (net(X.to(device)).argmax(dim=1) == y.to(device)).float().sum().cpu().item()
                net.train() # 改回训练模式
            else: # 自定义的模型, 3.13节之后不会用到, 不考虑GPU
                if('is_training' in net.__code__.co_varnames): # 如果有is_training这个参数
                    # 将is_training设置成False
                    acc_sum += (net(X, is_training=False).argmax(dim=1) == y).float().sum().item() 
                else:
                    acc_sum += (net(X).argmax(dim=1) == y).float().sum().item() 
            n += y.shape[0]
    return acc_sum / n

加载数据和处理数据方法

def load_data_fashion_mnist(batch_size, resize=None, root='~/Datasets/FashionMNIST'):
    """Download the fashion mnist dataset and then load into memory."""
    trans = []
    if resize:
        trans.append(torchvision.transforms.Resize(size=resize))
    trans.append(torchvision.transforms.ToTensor())
    
    transform = torchvision.transforms.Compose(trans)
    mnist_train = torchvision.datasets.FashionMNIST(root=root, train=True, download=True, transform=transform)
    mnist_test = torchvision.datasets.FashionMNIST(root=root, train=False, download=True, transform=transform)
    if sys.platform.startswith('win'):
        num_workers = 0  # 0表示不用额外的进程来加速读取数据
    else:
        num_workers = 4
    train_iter = torch.utils.data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True, num_workers=num_workers)
    test_iter = torch.utils.data.DataLoader(mnist_test, batch_size=batch_size, shuffle=False, num_workers=num_workers)

    return train_iter, test_iter

训练函数

def train_ch5(net, train_iter, test_iter, batch_size, optimizer, device, num_epochs):
    net = net.to(device)
    print("training on ", device)
    loss = torch.nn.CrossEntropyLoss()
    for epoch in range(num_epochs):
        train_l_sum, train_acc_sum, n, batch_count, start = 0.0, 0.0, 0, 0, time.time()
        for X, y in train_iter:
            X = X.to(device)
            y = y.to(device)
            y_hat = net(X)
            l = loss(y_hat, y)
            optimizer.zero_grad()
            l.backward()
            optimizer.step()
            train_l_sum += l.cpu().item()
            train_acc_sum += (y_hat.argmax(dim=1) == y).sum().cpu().item()
            n += y.shape[0]
            batch_count += 1
        test_acc = evaluate_accuracy(test_iter, net)
        print('epoch %d, loss %.4f, train acc %.3f, test acc %.3f, time %.1f sec'
              % (epoch + 1, train_l_sum / batch_count, train_acc_sum / n, test_acc, time.time() - start))

最后进行训练

batch_size = 128
# 如出现“out of memory”的报错信息，可减小batch_size或resize
train_iter, test_iter = load_data_fashion_mnist(batch_size, resize=224)

lr, num_epochs = 0.002, 5
optimizer = torch.optim.Adam(net.parameters(), lr=lr)
train_ch5(net, train_iter, test_iter, batch_size, optimizer, device, num_epochs)

将NIN块中的两个1×1卷积层删除一个

从训练结果可以看出，模型在训练集和测试集上的效果都有所提升，这是因为FashionMNIST数据集比较简单，降低模型复杂度有利于效果提升。

总结

观察发现NIN网络模型训练出来的效果没有VGG11的效果好，这是因为

1. 模型架构的差异

• VGG11 ：VGG网络具有较深的层次，且每一层使用相对简单的卷积和池化操作，能够提取丰富的特征信息。
• NIN：核心思想是使用1×1卷积代替传统的卷积层，意在增强卷积层的表达能力，使其在局部区域内可以更好地捕捉非线性特征。虽然NIN能精细化局部特征，但在FashionMNIST这种简单数据集上，深度和特征抽取能力可能不如VGG这种层次分明、逐渐提取高级特征的网络。

2. 数据集特性
   FashionMNIST是一个相当简单的数据集，由28×28灰度图组成，主要用于衣物分类。故深度较深，有较大感受野的VGG模型在提取全局特征时表现得更好。NIN在更复杂的数据集（如CIFAR-10）上可能效果更佳，因为它更适合处理复杂的纹理特征和局部信息。
3. 模型的深度与容量

• VGG11比NIN网络更深，包含更多的卷积层，使得它可以逐层提取到更高层次的特征。
• NIN网络使用1×1卷积提升模型非线性能力，但其网络较浅，适合提取局部特征，对更高层次的特征提取能力不强。

4. 感受野的差异

• VGG的卷积池化层设计，使其具备较大的感受野，能更好地提取全局特征。
• NIN使用1×1卷积能提升局部特征提取能力，但对于FashionMNIST这种简单数据，过度关注局部特征可能不是最优的。

原论文提出两个新模块

• MLPConv layers：这层本质上是卷积层，其中有多层小的全连接神经网络被应用于局部感受野内，而不仅仅是一个线性滤波器加一个激活函数。优点是相比较于卷积层，这使得网络能学习到更复杂、更抽象的表示，使得模型更具有表达能力。
• Global Average Pooling (GAP)：用特征图平均值预测输出。优点是极大减少了参数量、防止模型过拟合，同时使得网络更具有解释性。