《动手学深度学习》Paddle 版源码-5.08章（NIN）

新闻中心 NEWS CENTER

您当前位置：首页 > 新闻中心 > 行业资讯

《动手学深度学习》Paddle 版源码-5.08章（NIN）

2025-08-01

浏览次数：次

返回列表

网络中的网络（NiN）不同于LeNet、AlexNet和VGG，它串联多个含卷积层和1×1卷积层（替代全连接层）的NiN块构建深层网络。其用输出通道数等于标签类别数的NiN块加全局平均池化层替代全连接输出层，可减小参数、缓解过拟合，训练类似AlexNet但学习率更大，思想影响后续卷积神经网络设计。

☞☞☞AI 智能聊天, 问答助手, AI 智能搜索, 免费无限量使用 DeepSeek R1 模型☜☜☜

《动手学深度学习》paddle 版源码-5.08章（nin） -

网络中的网络（NiN）

前几节介绍的LeNet、AlexNet和VGG在设计上的共同之处是：先以由卷积层构成的模块充分抽取空间特征，再以由全连接层构成的模块来输出分类结果。其中，AlexNet和VGG对LeNet的改进主要在于如何对这两个模块加宽（增加通道数）和加深。本节我们介绍网络中的网络（NiN）[1]。它提出了另外一个思路，即串联多个由卷积层和“全连接”层构成的小网络来构建一个深层网络。

NiN块

我们知道，卷积层的输入和输出通常是四维数组（样本，通道，高，宽），而全连接层的输入和输出则通常是二维数组（样本，特征）。如果想在全连接层后再接上卷积层，则需要将全连接层的输出变换为四维。回忆在“多输入通道和多输出通道”一节里介绍的 $1 \times 1$ 1×1卷积层。它可以看*连接层，其中空间维度（高和宽）上的每个元素相当于样本，通道相当于特征。因此，NiN使用 $1 \times 1$ 1×1卷积层来替代全连接层，从而使空间信息能够自然传递到后面的层中去。图5.7对比了NiN同AlexNet和VGG等网络在结构上的主要区别。

《动手学深度学习》Paddle 版源码-5.08章（NIN） -

NiN块是NiN中的基础块。它由一个卷积层加两个充当全连接层的 $1 \times 1$ 1×1卷积层串联而成。其中第一个卷积层的超参数可以自行设置，而第二和第三个卷积层的超参数一般是固定的。

In [ ]

import paddleimport paddle.nn as nnimport numpy as npimport warnings
warnings.filterwarnings("ignore", category=Warning) # 过滤报警信息class Nin(nn.Layer):
    def __init__(self, num_channels, num_filters, kernel_size, strides, padding):
        super(Nin, self).__init__()
        model = [
            nn.Conv2D(num_channels, num_filters, kernel_size, stride=strides, padding=padding),
            nn.ReLU(),
            nn.Conv2D(num_filters, num_filters, 1),
            nn.ReLU(),
            nn.Conv2D(num_filters, num_filters, 1),
            nn.ReLU()
        ]
        self.model = nn.Sequential(*model)    def forward(self, X):
        return self.model(X)

NiN模型

NiN是在AlexNet问世不久后提出的。它们的卷积层设定有类似之处。NiN使用卷积窗口形状分别为 $11 \times 11$ 11×11、 $5 \times 5$ 5×5和 $3 \times 3$ 3×3的卷积层，相应的输出通道数也与AlexNet中的一致。每个NiN块后接一个步幅为2、窗口形状为 $3 \times 3$ 3×3的最大池化层。

Motiff妙多

Motiff妙多是一款AI驱动的界面设计工具，定位为“AI时代设计工具”

334 查看详情 Motiff妙多

除使用NiN块以外，NiN还有一个设计与AlexNet显著不同：NiN去掉了AlexNet最后的3个全连接层，取而代之地，NiN使用了输出通道数等于标签类别数的NiN块，然后使用全局平均池化层对每个通道中所有元素求平均并直接用于分类。这里的全局平均池化层即窗口形状等于输入空间维形状的平均池化层。NiN的这个设计的好处是可以显著减小模型参数尺寸，从而缓解过拟合。然而，该设计有时会造成获得有效模型的训练时间的增加。

In [ ]

class Net(nn.Layer):
    def __init__(self, num_channels, class_dim):
        super(Net, self).__init__()
        model = [
            Nin(num_channels, 96, 11, strides=4, padding=0),
            nn.MaxPool2D(kernel_size=3, stride=2),
            Nin(96, 256, 5, strides=1, padding=2),
            nn.MaxPool2D(kernel_size=3, stride=2),
            Nin(256, 384, 3, strides=1, padding=1),
            nn.MaxPool2D(kernel_size=3, stride=2),
            nn.Dropout(),            # 标签类别数是10
            Nin(384, 10, 3, strides=1, padding=1),
            paddle.fluid.dygraph.Pool2D(pool_type='max', global_pooling=True)
        ]
        self.model = nn.Sequential(*model)    def forward(self, X):
        Y = self.model(X)
        Y = paddle.flatten(Y, start_axis=1)        return Y

net = Net(3, 10)
X = paddle.to_tensor(np.random.uniform(-1., 1., [5, 3, 224, 224]).astype('float32'))
Y = net(X)print(Y.shape)

[5, 10]

我们构建一个数据样本来查看每一层的输出形状。

In [ ]

net = Net(1, 10)
param_info = paddle.summary(net, (1, 1, 224, 224))print(param_info)

---------------------------------------------------------------------------
 Layer (type)       Input Shape          Output Shape         Param #    
===========================================================================
   Conv2D-13     [[1, 1, 224, 224]]    [1, 96, 54, 54]        11,712     
    ReLU-13      [[1, 96, 54, 54]]     [1, 96, 54, 54]           0       
   Conv2D-14     [[1, 96, 54, 54]]     [1, 96, 54, 54]         9,312     
    ReLU-14      [[1, 96, 54, 54]]     [1, 96, 54, 54]           0       
   Conv2D-15     [[1, 96, 54, 54]]     [1, 96, 54, 54]         9,312     
    ReLU-15      [[1, 96, 54, 54]]     [1, 96, 54, 54]           0       
     Nin-5       [[1, 1, 224, 224]]    [1, 96, 54, 54]           0       
  MaxPool2D-4    [[1, 96, 54, 54]]     [1, 96, 26, 26]           0       
   Conv2D-16     [[1, 96, 26, 26]]     [1, 256, 26, 26]       614,656    
    ReLU-16      [[1, 256, 26, 26]]    [1, 256, 26, 26]          0       
   Conv2D-17     [[1, 256, 26, 26]]    [1, 256, 26, 26]       65,792     
    ReLU-17      [[1, 256, 26, 26]]    [1, 256, 26, 26]          0       
   Conv2D-18     [[1, 256, 26, 26]]    [1, 256, 26, 26]       65,792     
    ReLU-18      [[1, 256, 26, 26]]    [1, 256, 26, 26]          0       
     Nin-6       [[1, 96, 26, 26]]     [1, 256, 26, 26]          0       
  MaxPool2D-5    [[1, 256, 26, 26]]    [1, 256, 12, 12]          0       
   Conv2D-19     [[1, 256, 12, 12]]    [1, 384, 12, 12]       885,120    
    ReLU-19      [[1, 384, 12, 12]]    [1, 384, 12, 12]          0       
   Conv2D-20     [[1, 384, 12, 12]]    [1, 384, 12, 12]       147,840    
    ReLU-20      [[1, 384, 12, 12]]    [1, 384, 12, 12]          0       
   Conv2D-21     [[1, 384, 12, 12]]    [1, 384, 12, 12]       147,840    
    ReLU-21      [[1, 384, 12, 12]]    [1, 384, 12, 12]          0       
     Nin-7       [[1, 256, 12, 12]]    [1, 384, 12, 12]          0       
  MaxPool2D-6    [[1, 384, 12, 12]]     [1, 384, 5, 5]           0       
   Dropout-2      [[1, 384, 5, 5]]      [1, 384, 5, 5]           0       
   Conv2D-22      [[1, 384, 5, 5]]      [1, 10, 5, 5]         34,570     
    ReLU-22       [[1, 10, 5, 5]]       [1, 10, 5, 5]            0       
   Conv2D-23      [[1, 10, 5, 5]]       [1, 10, 5, 5]           110      
    ReLU-23       [[1, 10, 5, 5]]       [1, 10, 5, 5]            0       
   Conv2D-24      [[1, 10, 5, 5]]       [1, 10, 5, 5]           110      
    ReLU-24       [[1, 10, 5, 5]]       [1, 10, 5, 5]            0       
     Nin-8        [[1, 384, 5, 5]]      [1, 10, 5, 5]            0       
   Pool2D-2       [[1, 10, 5, 5]]       [1, 10, 1, 1]            0       
===========================================================================
Total params: 1,992,166
Trainable params: 1,992,166
Non-trainable params: 0
---------------------------------------------------------------------------
Input size (MB): 0.19
Forward/backward pass size (MB): 28.08
Params size (MB): 7.60
Estimated Total Size (MB): 35.87
---------------------------------------------------------------------------

{'total_params': 1992166, 'trainable_params': 1992166}

训练模型

我们依然使用Fashion-MNIST数据集来训练模型。NiN的训练与AlexNet和VGG的类似，但这里使用的学习率更大。

In [ ]

import paddleimport paddle.vision.transforms as Tfrom paddle.vision.datasets import FashionMNIST# 数据集处理transform = T.Compose([
    T.Resize(64),
    T.Transpose(),
    T.Normalize([127.5], [127.5]),
])
train_dataset = FashionMNIST(mode='train', transform=transform)
val_dataset = FashionMNIST(mode='test', transform=transform)# 模型定义model = paddle.Model(Net(1, 10))# 设置训练模型所需的optimizer, loss, metricmodel.prepare(
    paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()),
    paddle.nn.CrossEntropyLoss(),
    paddle.metric.Accuracy(topk=(1, 5)))# 启动训练、评估model.fit(train_dataset, val_dataset, epochs=2, batch_size=64, log_freq=100)

The loss value printed in the log is the current step, and the metric is the *erage value of previous step.
Epoch 1/2
step 100/938 - loss: 2.0404 - acc_top1: 0.1755 - acc_top5: 0.6389 - 353ms/step
step 200/938 - loss: 1.9281 - acc_top1: 0.1902 - acc_top5: 0.6545 - 355ms/step
step 300/938 - loss: 1.9774 - acc_top1: 0.2047 - acc_top5: 0.6621 - 355ms/step
step 400/938 - loss: 2.0007 - acc_top1: 0.2241 - acc_top5: 0.6729 - 356ms/step
step 500/938 - loss: 1.9303 - acc_top1: 0.2351 - acc_top5: 0.6763 - 357ms/step