Pytorch入门中 —— 搭建网络模型

本节内容参照小土堆的

pytorch

pytorch

TORCH.NN

nn

Neural Netwark

通常，我们定义的神经网络模型会继承

torch.nn.Module

卷积层

对于图像处理来说，我们通常使用二维卷积，即使用

torch.nn.Conv2d

创建该类时，我们通常只需要传入以下几个参数，其他不常用参数入门时可以不做了解，使用默认值即可，以后需要时再查询文档：

in_channels (int)：输入数据的通道数，图片通常为3
out_channels (int)：输出数据的通道数，也是卷积核的个数
kernel_size (int or tuple)：卷积核大小，传入int表示正方形，传入tuple代表高和宽
stride (int or tuple, optional)：卷积操作的步长，传入int代表横向和纵向步长相同，默认为1
padding (int, tuple or str, optional)：填充厚度，传入int代表上下左右四个边填充厚度相同，默认为0，即不填充
padding_mode (string, optional)：填充模式，默认为'zeros'，即0填充

卷积操作后输出的张量的高和宽计算公式如下：

其中

input

output

N

BatchSize

C

H

W

dilation

1

池化层

常用的二维最大池化定义在

torch.nn.MaxPool2d

创建该类时，我们通常只需要传入以下几个参数，其他不常用参数入门时可以不做了解，使用默认值即可，以后需要时再查询文档：

kernel_size：池化操作时的窗口大小
stride：池化操作时的步长，默认为kernel_size
padding：每个边的填充厚度（0填充）

池化操作后输出的张量的高和宽计算公式与卷积操作后的计算公式相同。

非线性激活

常见的

ReLU

torch.nn.ReLU

参数

inplace

ouput

input

线性层

线性层的定义在

torch.nn.Linear

创建线性层使用的参数如下：

in_features：输入特征大小
out_features：输出特征大小
bias：是否添加偏置，默认为True

模型搭建示例

下图是一个

CIFAR10

1.由于

CIFAR10

3*32*32

2.使用

5*5

32

32

in_channels = 3
out_channels = 32
kernel_size = 5
stride = 1
padding = 2

注：将 Hin = 32，Hout  = 32 以及

kernal_size[0] = 5

有：

发现

stride[0] = 1

padding[0] = 2

stride[1] = 1

padding[1] = 2

3.使用

2*2

32

16

kernel_size = 2
stride = 2
padding = 0

注：

stride

padding

4.使用

5*5

32

16

in_channels = 32
out_channels = 32
kernel_size = 5
stride = 1
padding = 2

5.使用

2*2

32

8

kernel_size = 2
stride = 2
padding = 0

6.使用

5*5

64

8

in_channels = 32
out_channels = 64
kernel_size = 5
stride = 1
padding = 2

7.使用

2*2

64

4

kernel_size = 2
stride = 2
padding = 0

8.将

64*4*4

1024

9.将长为

1024

64

in_features：1024
out_features：64

10.将长为

64

10

in_features：64
out_features：10

因此，模型代码如下：

from torch import nn

class MyModel(nn.Module):
def __init__(self):
super(MyModel, self).__init__()
self.conv1 = nn.Conv2d(3, 32, 5, padding=2)
self.max_pool1 = nn.MaxPool2d(2)
self.conv2 = nn.Conv2d(32, 32, 5, padding=2)
self.max_pool2 = nn.MaxPool2d(2)
self.conv3 = nn.Conv2d(32, 64, 5, padding=2)
self.max_pool3 = nn.MaxPool2d(2)
self.flatten = nn.Flatten()
self.linear1 = nn.Linear(1024, 64)
self.linear2 = nn.Linear(64, 10)

# 必须覆盖该方法，该方法会在实例像函数一样调用时被调用，后面会有示例
def forward(self, x):
x = self.conv1(x)
x = self.max_pool1(x)
x = self.conv2(x)
x = self.max_pool2(x)
x = self.conv3(x)
x = self.max_pool3(x)
x = self.flatten(x)
x = self.linear1(x)
x = self.linear2(x)
return x

sequential

使用

torch.nn.sequential

Module

sequential

Module

Module

Module

使用

sequential

from torch import nn

class MyModel(nn.Module):
def __init__(self):
super.__init__(MyModel, self)
self.model = nn.Sequential(
nn.Conv2d(3, 32, 5, padding=2),
nn.MaxPool2d(2),
nn.Conv2d(32, 32, 5, padding=2),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 5, padding=2),
nn.MaxPool2d(2),
nn.Flatten(),
nn.Linear(1024, 64),
nn.Linear(64, 10)
)

def forward(self, x):
x = self.model(x)
return x

损失函数、反向传播以及优化器

上面两节我们已经将

CIFAR10

模型训练代码如下：

import torch
from torch.optim import SGD
import torchvision
from torch.utils.data import DataLoader
from cifar10_model import MyModel
from torch import nn
from torch.utils import tensorboard

def train():
# 获取 cifar10 数据集
root = "./dataset"
transform = torchvision.transforms.Compose([
torchvision.transforms.ToTensor()
])
train_cifar10 = torchvision.datasets.CIFAR10(root=root, train=True,
transform=transform,
download=True)

# 创建dataloader
train_dataloader = DataLoader(dataset=train_cifar10, batch_size=64,
shuffle=True,
num_workers=16)

# 创建模型
model = MyModel()
# 创建交叉熵损失函数
loss = nn.CrossEntropyLoss()
# 创建优化器，传入需要更新的参数，以及学习率
optim = SGD(model.parameters(), lr=0.01)

# 创建 SummaryWriter
writer = tensorboard.SummaryWriter("logs")
# 写入模型图，随机生成一个输入
writer.add_graph(model, torch.randn(64, 3, 32, 32))

for epoch in range(20):
loss_temp = 0.0

for batch_num, batch_data in enumerate(train_dataloader):
images, targets = batch_data
# 像调用方法一样调用实例
outputs = model(images)
loss_res = loss(outputs, targets)
loss_temp = loss_res
# 清空前一次计算的梯度
optim.zero_grad()
# 反向传播求梯度
loss_res.backward()
# 更新参数
optim.step()
# 记录每个epoch之后的loss
writer.add_scalar("Loss/train", loss_temp, epoch)

writer.close()

if __name__ == "__main__":
train()

模型图如下：

损失函数随训练周期的下降情况如下：