敞开成长之旅！这是我参加「日新方案 12 月更文挑战」的第19天，点击检查活动概况

目录

demo的流程

1. model.py

卷积 Conv2d

公式

池化 MaxPool2d

特色如果输入是三维的，那么输出也是三维的

Tensor的展平：view()

全衔接 Linear

2. train.py

导包

下载数据集：

导入、加载 练习集

导入、加载 测验集

类别

开端练习

名词解释

练习成果

3. predict.py

猜测成果

---

pytorch官网:Training a Classifier — PyTorch Tutorials 1.10.1+cu102 documentation

瑰宝博主：响雷吧啦Wz_太阳花的小绿豆_CSDN博客-深度学习,Tensorflow,软件装置领域博主

demo的流程

1. model.py ——界说LeNet网络模型
2. train.py ——加载数据集并练习，练习集核算loss（损失值），测验集核算accuracy，保存练习好的网络参数
3. predict.py——得到练习好的网络参数后，用自己找的图画进行分类测验

1. model.py

先给出代码，模型是根据LeNet做简单修改，很简单了解：

import torch.nn as nn
import torch.nn.functional as F
class LeNet(nn.Module):                    # 继承于nn.Module这个父类
    def __init__(self):
        super(LeNet, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, 5)
        self.pool1 = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(16, 32, 5)
        self.pool2 = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(32*5*5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)
    def forward(self, x):
        x = F.relu(self.conv1(x))    # input(3, 32, 32) output(16, 28, 28)
        x = self.pool1(x)            # output(16, 14, 14)
        x = F.relu(self.conv2(x))    # output(32, 10, 10)
        x = self.pool2(x)            # output(32, 5, 5)
        x = x.view(-1, 32*5*5)       # output(32*5*5)
        x = F.relu(self.fc1(x))      # output(120)
        x = F.relu(self.fc2(x))      # output(84)
        x = self.fc3(x)              # output(10)
        return x

进程如下

• pytorch 中 tensor（也便是输入输出层）的 通道排序为：[batch, channel, height, width]

nn.Conv2d 卷积层

nn.MaxPool2d 下采样层

nn.Linear 全衔接层

卷积 Conv2d

咱们常用的卷积 （Conv2d）在pytorch中对应的函数是：

torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros')

一般运用时关注以下几个参数即可：

in_channels：输入特征矩阵的深度。如输入一张RGB彩色图画，那in_channels=3（三通道）

out_channels：输入特征矩阵的深度。也等于卷积核的个数，运用n个卷积核输出的特征矩阵深度便是n

kernel_size：卷积核的尺寸（巨细） 。可所以int类型，如3 代表卷积核的height=width=3，也可所以tuple类型如(3, 5)代表卷积核的height=3，width=5

stride： 卷积核的步长。默认为1，和kernel_size相同输入可所以int型，也可所以tuple类型

padding：补零操作，默认为0。可认为int型如1即补一圈0，如果输入为tuple型如(2, 1) 代表在上下补2行，左右补1列。

公式

输入图片巨细 WW（一般情况下Width=Height）

Filter巨细 FF

步长 S

padding的像素数 P

参阅：pytorch中的卷积操作详解_响雷吧啦Wz-CSDN博客_pytorch 卷积

池化 MaxPool2d

最大池化（MaxPool2d）的意思便是卷积网络也常常运用池化层来缩减模型的巨细，进步核算速度，同时进步所提取特征的鲁棒性

self.pool1 = nn.MaxPool2d(2, 2)

特色如果输入是三维的，那么输出也是三维的

参阅卷积神经网络——池化层学习——最大池化_Alex-CSDN博客_最大池化

Tensor的展平：view()

注意到，在经过第二个池化层后，数据仍是一个三维的Tensor (32, 5, 5)，需要先经过展平后(3255)再传到全衔接层：

x = self.pool2(x)            # output(32, 5, 5)
  x = x.view(-1, 32*5*5)       # output(32*5*5)

全衔接 Linear

全衔接（ Linear）在 pytorch 中对应的函数是：

bias 偏置

Linear(in_features, out_features, bias=True)

2. train.py

导包

import torch
import torchvision
import torch.nn as nn
from model import LeNet
import torch.optim as optim
import torchvision.transforms as transforms

下载数据集：

CIFAR-10 数据集可视化详细解说（附代码）_G果的博客-CSDN博客_cifar10数据集

导入、加载 练习集

def main():
    transform = transforms.Compose(
        [transforms.ToTensor(),
         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
   # 50000张练习图片
     # 第一次运用时要将download设置为True才会主动去下载数据集
    train_set = torchvision.datasets.CIFAR10(root='./data', train=True,
                                              download=False, transform=transform)
    train_loader = torch.utils.data.DataLoader(train_set, batch_size=36,
                                                shuffle=True, num_workers=0)

导入、加载 测验集

# 10000张验证图片
     # 第一次运用时要将download设置为True才会主动去下载数据集
    val_set = torchvision.datasets.CIFAR10(root='./data', train=False,
                                           download=False, transform=transform)
    val_loader = torch.utils.data.DataLoader(val_set, batch_size=5000,
                                              shuffle=False, num_workers=0)
# 获取测验会集的图画和标签，用于accuracy核算
    val_data_iter = iter(val_loader)
    val_image, val_label = val_data_iter.next()

类别

classes = ('plane', 'car', 'bird', 'cat',
                'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

开端练习

net = LeNet()
    loss_function = nn.CrossEntropyLoss()
    optimizer = optim.Adam(net.parameters(), lr=0.001)
    for epoch in range(5):  # loop over the dataset multiple times
        running_loss = 0.0
        for step, data in enumerate(train_loader, start=0):
            # get the inputs; data is a list of [inputs, labels]
            inputs, labels = data
            # zero the parameter gradients
            optimizer.zero_grad()
            # forward + backward + optimize
            outputs = net(inputs)
            loss = loss_function(outputs, labels)
            loss.backward()
            optimizer.step()
            # print statistics
            running_loss += loss.item()
            if step % 500 == 499:    # print every 500 mini-batches
                with torch.no_grad():
                    outputs = net(val_image)  # [batch, 10]
                    predict_y = torch.max(outputs, dim=1)[1]
                    accuracy = torch.eq(predict_y, val_label).sum().item() / val_label.size(0)
                    print('[%d, %5d] train_loss: %.3f  test_accuracy: %.3f' %
                          (epoch + 1, step + 1, running_loss / 500, accuracy))
                    running_loss = 0.0
    print('Finished Training')
    save_path = './Lenet.pth'
    torch.save(net.state_dict(), save_path)
if __name__ == '__main__':
    main()

名词解释

练习成果

这个是咱们看咱们的目录多出个pth文件类型（这个便是咱们的模型）

3. predict.py

用来猜测，根据练习的模型猜测东西

import torch
import torchvision.transforms as transforms
from PIL import Image
from model import LeNet
def main():   #咱们首要需resize成跟练习集图画相同的巨细
    transform = transforms.Compose(
        [transforms.Resize((32, 32)),
         transforms.ToTensor(),
         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
    classes = ('plane', 'car', 'bird', 'cat',
               'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
# 实例化网络，加载练习好的模型参数
    net = LeNet()
    net.load_state_dict(torch.load('Lenet.pth'))
# 导入要测验的图画（自己找的，不在数据会集），放在源文件目录下
    im = Image.open('3.jpeg')
    im = transform(im)  # [C, H, W]
    im = torch.unsqueeze(im, dim=0)  '''对数据增加一个新维度，由于tensor的参数是[batch,         
                                         channel, height, width]'''
#猜测
    with torch.no_grad():
        outputs = net(im)
        predict = torch.max(outputs, dim=1)[1].data.numpy()
    print(classes[int(predict)])
if __name__ == '__main__':
    main()

图片3.jepg

猜测成果