神经网络的认识（四）LeNet-5 模型

LeNet-5 模型是 Yann LeCun 教授于1998 年再论文Gradient“based learning applied to document recognition中提出的，它是第一个成功应用于数字识别问题的卷积神经网络。

第一层，卷积层

这一层的输入就是原始的图像像素，LeNet-5 模型接受的输入层大小为32*32*1。第一个卷积层过滤器的尺寸为5*5，深度为6，不使用全0填充，步长为1。因为没有使用全0填充，所以这一层的输出的尺寸为32-5+1=28，深度为6。这一个卷积层总共有5*5*1*6+6=156个参数，其中6个为偏置项参数。因为下一层的节点矩阵有28*28*6=4704个节点，每个节点和5*5=25个当前层节点相连，所以本层卷积层总共有4704*(25+1)=122304个连接 。

第二层，池化层

这一层的输入为第一层的输出，是一个28*28*6的节点矩阵。本层采用的过滤器大小为 2*2，长和宽的步长均为2，所以本层的输出矩阵大小为14*14*6。

第三层，卷积层

本层的输入矩阵大小为14*14*6，使用的过滤器大小为5*5，深度为16。本层不使用全0填充，步长为1。本层的输出矩阵大小为10*10*16 。按照标准的卷积层，本层应该有5*5*6*16+16=2416个参数，10*10*16*(25+1)=41600个连接。

C3的前6个特征图以S2中3个相邻的特征图子集为输入。接下来6个特征图以S2中4个相邻特征图子集为输入。然后的3个以不相邻的4个特征图子集为输入。最后一个将S2中所有特征图为输入。

第四层，池化层

本层的输入矩阵大小为10*10*16，采用的过滤器大小为2*2，步长为2。本层的输出矩阵大小为5*5*16。

第五层，全连接层

本层的输入矩阵大小为5*5*16，在 LeNet-5 模型的论文中将这一层称为卷积层，但是因为过滤器的大小就是 5×5，所以和全连接层没有区别，在之后的 TensorFlow 程序实现中也会将这一层看成全连接层。本层的输出节点个数为120，总共有5*5*16*120+120=48120 个参数。

第六层，全连接层

本层的输入节点个数为120个，输出节点个数为84个，总共参数为120*84+84=10164

第七层，全连接层

本层的输入节点个数为84个，输出节点个数为10个，总共参数为84*10+10=850个 。

扫描二维码关注公众号，回复： 9103684 查看本文章

MxNet的实现

import d2lzh as d2l
import mxnet as mx
from mxnet.gluon import nn, loss as gloss
from mxnet import autograd, gluon, init, nd
import time

net = nn.Sequential()
net.add(nn.Conv2D(channels=6, kernel_size=5, activation='sigmoid'),
        nn.MaxPool2D(pool_size=2, strides=2),
        nn.Conv2D(channels=16, kernel_size=5, activation='sigmoid'),
        nn.MaxPool2D(pool_size=2, strides=2),
        nn.Dense(120, activation='sigmoid'),
        nn.Dense(84, activation='sigmoid'),
        nn.Dense(10))

X = nd.random.uniform(shape=(1, 1, 28, 28))
net.initialize()
for layer in net:
    X = layer(X)
    print(layer.name, 'output shape:\t', X.shape)

batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size, root='./data')

ctx = d2l.try_gpu()

def evaluate_accuracy(data_iter, net, ctx):
    acc_sum, n = nd.array([0], ctx=ctx), 0
    for X, y in data_iter:
        X, y = X.as_in_context(ctx), y.as_in_context(ctx).astype('float32')
        acc_sum += (net(X).argmax(axis=1) == y).sum()
        n += y.size
    return acc_sum.asscalar() / n

lr, num_epochs = 0.9, 500
net.initialize(force_reinit=True, ctx=ctx, init=init.Xavier())
trainer = gluon.Trainer(net.collect_params(), 
                        'sgd',
                        {'learning_rate':lr})
def train_ch5(net, train_iter, test_iter, batch_size, trainer, ctx, num_epochs):
    print('training on', ctx)
    loss = gloss.SoftmaxCrossEntropyLoss()
    for epoch in range(num_epochs):
        train_l_sum, train_acc_sum, n, start = 0.0, 0.0, 0, time.time()
        for X, y in train_iter:
            X, y = X.as_in_context(ctx), y.as_in_context(ctx)
            with autograd.record():
                y_hat = net(X)
                l = loss(y_hat, y).sum()
            l.backward()
            trainer.step(batch_size)
            y = y.astype('float32')
            train_l_sum += l.asscalar()
            train_acc_sum += (y_hat.argmax(axis=1) == y).sum().asscalar()
            n += y.size
        test_acc = d2l.evaluate_accuracy(test_iter, net, ctx)
        print('epoch %d, loss %.4f, train acc %.3f, test acc %.3f,'
              'time %.1f sec'
              % (epoch + 1, train_l_sum / n, train_acc_sum / n, test_acc, time.time() - start))
d2l.train_ch5(net, train_iter, test_iter, batch_size, trainer, ctx, num_epochs)