pytorch实战案例-手写数字分类-全链接模型——深度AI科普团队_pytorch数字分类

文章目录

• • @[TOC]
• 数据准备
• • 导入需要的模块
  • 将数据转换为tensor
  • 导入训练集和测试集
• 数据加载器
• 数据展示
• 创建模型
• • 定义损失函数
  • 定义优化函数
• 定义训练和测试函数
• • 开始训练

源码已经上传：手写数字识别参考代码和数据集

---

数据准备

导入需要的模块

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt
import torchvision
from torchvision import datasets, transforms
%matplotlib inline
1
2
3
4
5
6
7
8
9

torch.nn为我们提供了更多的类和模块来实现和训练神经网络。具体函数可参考：http://www.srcmini.com/31857.html

torch.optim是一个实现了多种优化算法的包，大多数通用的方法都已支持，提供了丰富的接口调用，未来更多精炼的优化算法也将整合进来。

torchvision内置了常用数据集和最常见的模型。

vision.datasets : 几个常用视觉数据集，可以下载和加载，这里主要的高级用法就是可以看源码如何自己写自己的Dataset的子类
vision.models : 流行的模型，例如 AlexNet, VGG, ResNet 和 Densenet 以及 与训练好的参数。
vision.transforms : 常用的图像操作，例如：随机切割，旋转，数据类型转换，图像到tensor ,numpy 数组到tensor , tensor 到 图像等。
vision.utils : 用于把形似 (3 x H x W) 的张量保存到硬盘中，给一个mini-batch的图像可以产生一个图像格网。

将数据转换为tensor

这是一个数据处理函数，transforms.Compose可以组合几个变换连续一起操作，这里只是将数据转换为tensor

transformation = transforms.Compose([
                                transforms.ToTensor(), 
])
1
2
3

导入训练集和测试集

datasets.MNIST(
root,
train=True,
transform=None,
target_transform=None,
download=False,
)
root 取数据的地址
train 设置是读取train数据集 还是test lecun的数据集有4个
transform就是对图像数据进行处理 传入dataloader的transform类型
target_transform（可调用，可选）–接受目标并对其进行转换的函数/转换。
download 设置 强调是否一定要download
1
2
3
4
5
6
7
8
9
10
11
12

这里用了上面定义的数据处理函数，对读取的minist数据进行totensor操作。

train_ds = datasets.MNIST(
                          'data/',
                          train=True,
                          transform=transformation,
                          download=True  
)
test_ds = datasets.MNIST(
                          'data/',
                          train=False,
                          transform=transformation,
                          download=True  
)
1
2
3
4
5
6
7
8
9
10
11
12

数据加载器

torch.utils.data.DataLoader数据加载器，结合了数据集和取样器，并且可以提供多个线程处理数据集。

在训练模型时使用到此函数，用来把训练数据分成多个小组，此函数每次抛出一组数据。直至把所有的数据都抛出。就是做一个数据的初始化。

如下第一个函数就是将训练集生成迭代数据，每次迭代的数据为64个，shuffle为洗牌操作，即打乱顺序。

train_dl = torch.utils.data.DataLoader(train_ds, batch_size=64, shuffle=True)
test_dl = torch.utils.data.DataLoader(test_ds, batch_size=256)
1
2

train_dl本质上是一个可迭代对象，可以使用iter()进行访问，采用iter(dataloader)返回的是一个迭代器，然后可以使用next()访问。
也可以使用enumerate(dataloader)的形式访问。

imgs, labels = next(iter(train_dl))
imgs.shape ,labels.shape

(torch.Size([64, 1, 28, 28]), torch.Size([64]))
1
2
3
4

数据展示

img = imgs[0]
img.shape 

# torch.Size([1, 28, 28])
1
2
3
4

# 将tensor转换为numpy
img = img.numpy()
# 从数组的形状中删除单维条目，即把shape中为1的维度去掉
img = np.squeeze(img)
img.shape

(28, 28)
1
2
3
4
5
6
7

plt.imshow(img)
1

创建模型

class Model(nn.Module):
    def __init__(self):
        # 继承model的所有父类
        super().__init__()
        # 第一个全连接层，输入为28*28的tensor（这个是不可以变的，大小必须为输入数据的大小），
        # 第一个隐藏层为120个神经元（这个可以自己更换）
        self.liner_1 = nn.Linear(28*28, 120)
        # 本层的输入必须与前一层的输出shape一样，下一层的神经元个数可以自定义
        self.liner_2 = nn.Linear(120, 84)
        # 最后是输出层，其输出必须为10，因为我们是进行0-9的10分类
        self.liner_3 = nn.Linear(84, 10)
    # 定义前向传播函数
    def forward(self, input):
        # view()函数作用是将一个多行的Tensor,拼接成一行。
        x = input.view(-1, 28*28)
        # nn.function 中封装了很多函数，比如relu这个激活函数
        x = F.relu(self.liner_1(x))
        x = F.relu(self.liner_2(x))
        x = self.liner_3(x)
        return x
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

这里可以看到定义的模型的网络结构

model = Model()
model

Model(
  (liner_1): Linear(in_features=784, out_features=120, bias=True)
  (liner_2): Linear(in_features=120, out_features=84, bias=True)
  (liner_3): Linear(in_features=84, out_features=10, bias=True)
)
1
2
3
4
5
6
7
8

定义损失函数

nn.CrossEntropyLoss()函数计算交叉熵损失

loss_fn = torch.nn.CrossEntropyLoss()  # 损失函数
1

定义优化函数

torch.optim是一个实现了多种优化算法的包，大多数通用的方法都已支持，提供了丰富的接口调用，未来更多精炼的优化算法也将整合进来。

optim = torch.optim.Adam(model.parameters(), lr=0.001)
1

定义训练和测试函数

def fit(epoch, model, trainloader, testloader):
    correct = 0
    total = 0
    running_loss = 0
    for x, y in trainloader:
        # x是数值特征，y是lebel，y_pred是x的预测值
        y_pred = model(x)
        # 得到损失值
        loss = loss_fn(y_pred, y)
        # 将梯度置为0
        optim.zero_grad()
        # 反向传播
        loss.backward()
        # 优化
        optim.step()
        # torch.no_grad() 是一个上下文管理器，被该语句包起来的部分将不会追踪梯度。
        with torch.no_grad():
            # 这里是找预测值最大的那个数的位置，如果在第五个位置上，该预测值就是5
            y_pred = torch.argmax(y_pred, dim=1)
            # 一个元素张量可以用item得到元素值
            # 所有正确的加起来
            correct += (y_pred == y).sum().item()
            total += y.size(0)
            # 损失值加起来
            running_loss += loss.item()
        
    epoch_loss = running_loss / len(trainloader.dataset)
    epoch_acc = correct / total
        
        
    test_correct = 0
    test_total = 0
    test_running_loss = 0 
    # 测试集的操作
    with torch.no_grad():
        for x, y in testloader:
            y_pred = model(x)
            loss = loss_fn(y_pred, y)
            y_pred = torch.argmax(y_pred, dim=1)
            test_correct += (y_pred == y).sum().item()
            test_total += y.size(0)
            test_running_loss += loss.item()
    
    epoch_test_loss = test_running_loss / len(testloader.dataset)
    epoch_test_acc = test_correct / test_total
    
    
    print('epoch: ', epoch, 
          'loss： ', round(epoch_loss, 3),
          'accuracy:', round(epoch_acc, 3),
          'test_loss： ', round(epoch_test_loss, 3),
          'test_accuracy:', round(epoch_test_acc, 3)
             )
        
    return epoch_loss, epoch_acc, epoch_test_loss, epoch_test_acc
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

开始训练

for epoch in range(epochs):
    epoch_loss, epoch_acc, epoch_test_loss, epoch_test_acc = fit(epoch,
                                                                 model,
                                                                 train_dl,
                                                                 test_dl)
1
2
3
4
5