torch.nn神经网络（2）--池化层+非线性激活函数（ReLU和Sigmiod）+Sequential()函数的使用_池化层后面加激活函数吗

nn.Module神经网络

4.池化层

池化层：池化函数使用某一位置的相邻输出的总体统计特征来代替网络在该位置的输出。 本质是降采样，减少网络的参数量

还是老规矩，导入模块及数据集，CIFAR10,batchsize=64：

import torch
import torchvision
from torch import nn
from torch.nn import MaxPool2d
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10('./dataset',train=False,transform=torchvision.transforms.ToTensor(),download=True)

dataloader = DataLoader(dataset,batch_size=64)
1
2
3
4
5
6
7
8
9
10

我们本次采用的式MaxPool2d的池化函数，其输入和输出的类型如下：
input（batchsize，channel，高H，宽W）
output（batchsize，channel，高H，宽W）

因此，首先根据下图中的信息，构造一个input为tensor数据类型的二维矩阵，在使用reshape函数将其转化为MaxPool2d函数所需的size类型：

input = torch.tensor([[1,2,0,3,1],
                      [0,1,2,3,1],
                      [1,2,1,0,0],
                      [5,2,3,1,1],
                      [2,1,0,1,1]],dtype=torch.float32)
input = torch.reshape(input,(-1,1,5,5)) batchsize自己计算，channel为1，5*5的高宽大小
1
2
3
4
5
6

定义类，继承nn.Module，构造神经网络，其中包含池化层：

class Chenyu(nn.Module):
    def __init__(self):
        super(Chenyu, self).__init__()
        self.maxpool1=MaxPool2d(kernel_size=3,ceil_mode=False)     池化函数

    def forward(self,input):
        output = self.maxpool1(input)
        return output
1
2
3
4
5
6
7
8

将数据集放入神经网络中完成池化后，结果在tensorboard上进行可视化展示：

writer=SummaryWriter('logs_maxpool')
step = 0
for data in dataloader:
    imgs, target =data
    writer.add_images("input",imgs,step)
    output =chenyu(imgs)
    writer.add_images('output',output,step)
    step = step+1

writer.close()
1
2
3
4
5
6
7
8
9
10

展示结果：
我们可以看到经过池化层的处理后，输出的图片变得像马赛克一样，这就是池化层的特点，使用某一位置的相邻输出的总体统计特征来代替网络在该位置的输出。

5.非线性激活函数

非线性激活：目的是为了给神经网络赋予更多的非线性特征，以此达到我们所需要的目的。
通常使用的ReLU,Sigmoid等激活函数函数.

①以ReLU为例:
input值大于0时为其本身，小于0时设置其为0

首先导入模块，定义tensor类型变量的二维矩阵，使用reshape对其进行修改：

import  torch
from torch import nn
from torch.nn import ReLU
input = torch.tensor([[1,-0.5],
                      [-1,3]])
torch.reshape(input,(-1,1,2,2))
1
2
3
4
5
6

定义类，继承nn.Module类，创建神经网络，其中包含非线性激活函数ReLU：

class ChenYu(nn.Module):
    def __init__(self):
        super(ChenYu, self).__init__()
        self.relu1=ReLU()
        #Inplace为False时可以保持原始数据  默认为False

    def forward(self,input):
        output = self.relu1(input)
        return output
1
2
3
4
5
6
7
8
9

运行：`

chenyu=ChenYu()
output = chenyu(input)
print(output)
1
2
3

运行结果：

tensor([[1., 0.],
        [0., 3.]])
1
2

②以Sigmoid为例：
Sigmoid函数常被用作神经网络的激活函数，将变量映射到0,1之间。

使用数据集CIFAR10为例，batchsize设置为64，创建神经网络，其中包含sigmoid激活函数：

class ChenYu(nn.Module):
    def __init__(self):
        super(ChenYu, self).__init__()
        self.sigmoid1=Sigmoid()
        #Inplace为False时可以保持原始数据  默认为False

    def forward(self,input):
        output = self.sigmoid1(input)
        return output
1
2
3
4
5
6
7
8
9

将数据集中的样本输入至神经网络中：

chenyu=ChenYu()
writer = SummaryWriter('./logs_sigmoid')
step =0

for data in dataloader:
    imgs, target = data
    writer.add_images('input',imgs,global_step=step)
    output = chenyu(imgs)
    writer.add_images('output',output,step)
    step=step+1

writer.close()
1
2
3
4
5
6
7
8
9
10
11
12

输出结果在tensorboard上进行展示：
（可以观察到经过网络输出后的图片蒙上了一层灰}

6.VGG16的样例模型实现及Sequential()函数的使用：

以下将按照该图片进行神经网络构建

导入模块：

import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.tensorboard import SummaryWriter
1
2
3
4

构造神经网络（三个卷积，三个池化，一个flatten，两个线性层）：
此处使用Sequential（）函数：Sequential 内的模块需要按照顺序排列，要保证相邻层的输入输出大小相匹配，内部 forward 功能已经实现，可以使代码更加整洁。

class ChenYu(nn.Module):
    def __init__(self):
        super(ChenYu, self).__init__()
        self.model1 =Sequential(              Sequential函数
        Conv2d(3,32,5,padding=2),   第一个卷积层
        MaxPool2d(2),				第一个池化层
        Conv2d(32,32,5,padding=2),		第二个卷积层
        MaxPool2d(2),					第二个池化层
        Conv2d(32,64,5,padding=2),		第三个卷积层
        MaxPool2d(2),					第三个池化层
        Flatten(),						将数据进行展平 flatten（）函数
        Linear(1024,64),				第一个线性层
        Linear(64,10)					第二个线性层转化
        )

    def forward(self,x):
        x=self.model1(x)					可以直接调用该模型，按照模型内设计的网络结构依次执行
        return x
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

检查神经网络是否正确，并在tensorboard上展示该网路的设计结构：
创建假象的数据 input= torch.ones()

chenyu=ChenYu()
print(chenyu)

#判断网络是否正确
input = torch.ones((64,3,32,32))
output = chenyu(input)
print(output.shape)

writer =SummaryWriter('logs_seq')
writer.add_graph(chenyu,input)
writer.close()
1
2
3
4
5
6
7
8
9
10
11

设计结构展示：