卷积神经网络-LeNet

卷积神经网络层数不包括输入层，故LeNet总共7层，即C1层卷积层，S2层池化层，C3层卷积层，S4层池化层，C5层全连接层，F6层全连接层，G7输出层。

（1）C1层卷积层：

输入大小：32*32

卷积核大小：5*5

卷积核数量（深度）：6

padding填充：0

stride步长：1

输出大小：28*28    #(32-5+2*0)/1 + 1

神经元数量：28*28*6

可训练参数：（5*5+1）*6    #滑动窗口大小是5*5个权重，外加一个偏置。

连接数：28*28*6*（5*5+1）   #因为下一层的节点矩阵有 28*28*6=4704 个节点，每个节点和 5*5=25 个当前层节点相连。

（2）S2层池化层：

输入大小：28*28

采样方式： 2*2区域的4个值相加，乘以一个可训练参数，再加上一个偏置参数，结果通过Sigmoid非线性化

卷积核大小：2*2

卷积核数量：6

输出大小：14*14

神经元数量：14*14*6

可训练参数：6*（1+1）（采样的权重+一个偏置参数）

连接数：14*14*6*（2*2+1）

（3）C3层卷积层：

1.输入大小：14*14*6

卷积核大小：5*5

卷积核数量（深度）：16

padding填充：0

stride步长：1

输出大小：10*10    #(14-5+2*0)/1 + 1

神经元数量：10*10*16

全连接的可训练参数：（5*5+1）*16    #滑动窗口大小是5*5个权重，外加一个偏置。

连接数：10*10*16*（5*5+1）

2. 输入大小：S2中所有6个或者几个特征map组合

可训练参数：C3跟S2并不是全连接的，具体连接方式是： C3的前6个特征图以S2中3个相邻的特征图子集为输入。接下来6个特征图以S2中4个相邻特征图子集为输入。然后的3个以不相邻的4个特征图子集为输入。最后一个将S2中所有特征图为输入。

故6*（3*5*5+1）+6*（4*5*5+1）+3*（4*5*5+1）+1*（6*5*5+1）=1516

连接数：10*10*1516

（4）S4层池化层：

输入大小：10*10

采样方式： 2*2区域的4个值相加，乘以一个可训练参数，再加上一个偏置参数，结果通过Sigmoid非线性化

卷积核大小：2*2

卷积核数量：16

输出大小：5*5

神经元数量：5*5*16

可训练参数：16*（1+1）（采样的权重+一个偏置参数）

连接数：5*5*16*（2*2+1）=2000

（5）C5层全连接层：

输入大小：5*5

卷积核大小：5*5

卷积核数量：120

输出大小：1*1

神经元数量：1*1*120

可训练参数：（5*5+1）*120

连接数：1*1*（5*5+1）*120

（6）C6层全连接层：

输入大小：120

计算方式：计算输入向量和权重向量之间的点积，再加上一个偏置，结果通过sigmoid函数

输出大小：84

可训练参数：84*（120+1）=10164

（7）G7层输出层：

输入大小：84

输出大小：10

import torch.nn as nn
import torch.nn.functional as F

class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self).__init__()
        #定义卷积层，1个输入通道，6个输出通道，5*5的卷积filter，外层补上了两圈0,因为输入的是32*32
        self.conv1 = nn.Conv2d(1, 6, 5, padding = 2)
        #第二个卷积层，6个输入，16个输出，5*5的卷积filter 
        self.conv2 = nn.Conv2d(6, 16, 5, padding = 2)
        
         #最后是三个全连接层
        self.fc1 = nn.Linear(16*5*5, 120)#class torch.nn.Linear(in_features, out_features, bias=True)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)
        
    def forward(self, x):
        x = F.max_pool2d(F.relu(self.conv1(x)),(2,2))
        x = F.max_pool2d(F.relu(self.conv2(x)),(2,2))
           
        # nn.Linear()的输入输出都是维度为一的值，所以要把多维度的tensor展平成一维
        x = x.view(x.size()[0], -1)
        print('size', x.size())
        x = F.relu(self.fc1(x))
        print('size', x.size())
        x = F.relu(self.fc2(x))
        print('size', x.size())
        x = self.fc3(x)
        return x

net = LeNet()
print(net)

class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self).__init__()
        self.layer1 = nn.Sequential()
        self.layer1.add_module('conv1', nn.Conv2d(1,6,3,padding=1))
        self.layer1.add_module('pool1', nn.MaxPool2d(2,2))
        
        self.layer2 = nn.Sequential()
        self.layer2.add_module('conv2', nn.Conv2d(6,16,5,padding=1))
        self.layer2.add_module('pool2', nn.MaxPool2d(2,2))
        
        self.layer3 = nn.Sequential()
        self.layer3.add_module('fc1', nn.Linear(400,120))
        self.layer3.add_module('fc2', nn.Linear(120,84))
        self.layer3.add_module('fc2', nn.Linear(84,10))
        
    def forward(self, x):
        x = self.layer1(x)
        x = self.layer2(x)
        x = x.view(x.size(0), -1)
        x = self.layer3(x)
        return x

model = LeNet()
print(model)