PyTorch实现手写数字识别

Posted ZSYL

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了PyTorch实现手写数字识别相关的知识,希望对你有一定的参考价值。

使用Pytorch实现手写数字识别

学习目标

  1. 知道如何使用Pytorch完成神经网络的构建
  2. 知道Pytorch中激活函数的使用方法
  3. 知道Pytorch中torchvision.transforms中常见图形处理函数的使用
  4. 知道如何训练模型和如何评估模型

1. 思路和流程分析

流程:

  1. 准备数据,这些需要准备DataLoader
  2. 构建模型,这里可以使用torch构造一个深层的神经网络
  3. 模型的训练
  4. 模型的保存,保存模型,后续持续使用
  5. 模型的评估,使用测试集,观察模型的好坏

2. 准备训练集和测试集

准备数据集的方法前面已经讲过,但是通过前面的内容可知,调用MNIST返回的结果中图形数据是一个Image对象,需要对其进行处理

为了进行数据的处理,接下来学习torchvision.transfroms的方法

2.1 torchvision.transforms的图形数据处理方法

2.1.1 torchvision.transforms.ToTensor

把一个取值范围是[0,255]PIL.Image或者shape(H,W,C)numpy.ndarray,转换成形状为[C,H,W]

其中(H,W,C)意思为(高,宽,通道数),黑白图片的通道数只有1,其中每个像素点的取值为[0,255],彩色图片的通道数为(R,G,B),每个通道的每个像素点的取值为[0,255],三个通道的颜色相互叠加,形成了各种颜色

示例如下:

from torchvision import transforms
import numpy as np

data = np.random.randint(0, 255, size=12)
img = data.reshape(2,2,3)
print(img.shape)
img_tensor = transforms.ToTensor()(img) # 转换成tensor
print(img_tensor)
print(img_tensor.shape)

输出如下:

shape:(2, 2, 3)
img_tensor:tensor([[[215, 171],
                 [ 34,  12]],

                [[229,  87],
                 [ 15, 237]],

                [[ 10,  55],
                 [ 72, 204]]], dtype=torch.int32)
new shape:torch.Size([3, 2, 2])

注意:

transforms.ToTensor对象中有__call__方法,所以可以对其示例能够传入数据获取结果

2.1.2 torchvision.transforms.Normalize(mean, std)

给定均值:meanshape和图片的通道数相同(指的是每个通道的均值),方差:std,和图片的通道数相同(指的是每个通道的方差),将会把Tensor规范化处理。

即:Normalized_image=(image-mean)/std

例如:

from torchvision import transforms
import numpy as np
import torchvision

data = np.random.randint(0, 255, size=12)
img = data.reshape(2,2,3)
img = transforms.ToTensor()(img) # 转换成tensor
print(img)
print("*"*100)

norm_img = transforms.Normalize((10,10,10), (1,1,1))(img) #进行规范化处理

print(norm_img)

输出如下:

tensor([[[177, 223],
         [ 71, 182]],

        [[153, 120],
         [173,  33]],

        [[162, 233],
         [194,  73]]], dtype=torch.int32)
***************************************************************************************
tensor([[[167, 213],
         [ 61, 172]],

        [[143, 110],
         [163,  23]],

        [[152, 223],
         [184,  63]]], dtype=torch.int32)

注意:在sklearn中,默认上式中的stdmean为数据每列的stdmeansklearn会在标准化之前算出每一列的std和mean。

但是在apiNormalize中并没有帮我们计算,所以我们需要手动计算

  1. 当mean为全部数据的均值,std为全部数据的std的时候,才是进行了标准化。

  2. 如果mean(x)不是全部数据的mean的时候,std(y)也不是的时候,Normalize后的数据分布满足下面的关系

2.1.3 torchvision.transforms.Compose(transforms)

将多个transform组合起来使用。

例如

transforms.Compose([
     torchvision.transforms.ToTensor(), #先转化为Tensor
     torchvision.transforms.Normalize(mean,std) #在进行正则化
 ])

2.2 准备MNIST数据集的Dataset和DataLoader

准备训练集

import torchvision

#准备数据集,其中0.1307,0.3081为MNIST数据的均值和标准差,这样操作能够对其进行标准化
#因为MNIST只有一个通道(黑白图片),所以元组中只有一个值
dataset = torchvision.datasets.MNIST('/data', train=True, download=True,
                             transform=torchvision.transforms.Compose([
                               torchvision.transforms.ToTensor(),
                               torchvision.transforms.Normalize(
                                 (0.1307,), (0.3081,))
                             ]))
#准备数据迭代器                          
train_dataloader = torch.utils.data.DataLoader(dataset,batch_size=64,shuffle=True)

准备测试集

import torchvision

#准备数据集,其中0.1307,0.3081为MNIST数据的均值和标准差,这样操作能够对其进行标准化
#因为MNIST只有一个通道(黑白图片),所以元组中只有一个值
dataset = torchvision.datasets.MNIST('/data', train=False, download=True,
                             transform=torchvision.transforms.Compose([
                               torchvision.transforms.ToTensor(),
                               torchvision.transforms.Normalize(
                                 (0.1307,), (0.3081,))
                             ]))
#准备数据迭代器                          
train_dataloader = torch.utils.data.DataLoader(dataset,batch_size=64,shuffle=True)

3. 构建模型

补充:全连接层:当前一层的神经元和前一层的神经元相互链接,其核心操作就是 y = w x ​ y = wx​ y=wx,即矩阵的乘法,实现对前一层的数据的变换

模型的构建使用了一个三层的神经网络,其中包括两个全连接层和一个输出层,第一个全连接层会经过激活函数的处理,将处理后的结果交给下一个全连接层,进行变换后输出结果

那么在这个模型中有两个地方需要注意:

  1. 激活函数如何使用
  2. 每一层数据的形状
  3. 模型的损失函数

3.1 激活函数的使用

前面介绍了激活函数的作用,常用的激活函数为Relu激活函数,他的使用非常简单

Relu激活函数import torch.nn.functional as F提供,F.relu(x)即可对x进行处理

例如:

In [30]: b
Out[30]: tensor([-2, -1,  0,  1,  2])

In [31]: import torch.nn.functional as F

In [32]: F.relu(b)
Out[32]: tensor([0, 0, 0, 1, 2])

3.2 模型中数据的形状(【添加形状变化图形】)

  1. 原始输入数据为的形状:[batch_size,1,28,28]
  2. 进行形状的修改:[batch_size,28*28] ,(全连接层是在进行矩阵的乘法操作)
  3. 第一个全连接层的输出形状:[batch_size,28],这里的28是个人设定的,你也可以设置为别的
  4. 激活函数不会修改数据的形状
  5. 第二个全连接层的输出形状:[batch_size,10],因为手写数字有10个类别

构建模型的代码如下:

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

class MnistNet(nn.Module):
    def __init__(self):
        super(MnistNet,self).__init__()
        self.fc1 = nn.Linear(28*28*1,28)  #定义Linear的输入和输出的形状
        self.fc2 = nn.Linear(28,10)  #定义Linear的输入和输出的形状

    def forward(self,x):
        x = x.view(-1,28*28*1)  #对数据形状变形,-1表示该位置根据后面的形状自动调整
        x = self.fc1(x) #[batch_size,28]
        x = F.relu(x)  #[batch_size,28]
        x = self.fc2(x) #[batch_size,10]
  

可以发现:pytorch在构建模型的时候形状上并不会考虑batch_size

3.3 模型的损失函数

首先,我们需要明确,当前我们手写字体识别的问题是一个多分类的问题,所谓多分类对比的是之前学习的2分类

回顾之前的课程,我们在逻辑回归中,我们使用sigmoid进行计算对数似然损失,来定义我们的2分类的损失。

  • 在2分类中我们有正类和负类,正类的概率为 P ( x ) = 1 1 + e − x = e x 1 + e x P(x) = \\frac{1}{1+e^{-x}} = \\frac{e^x}{1+e^x} P(x)=1+ex1=1+exex,那么负类的概率为 1 − P ( x ) ​ 1-P(x)​ 1P(x)

  • 将这个结果进行计算对数似然损失 − ∑ y l o g ( P ( x ) ) ​ -\\sum y log(P(x))​ ylog(P(x))就可以得到最终的损失

那么在多分类的过程中我们应该怎么做呢?

  • 多分类和2分类中唯一的区别是我们不能够再使用sigmoid函数来计算当前样本属于某个类别的概率,而应该使用softmax函数。

  • softmax和sigmoid的区别在于我们需要去计算样本属于每个类别的概率,需要计算多次,而sigmoid只需要计算一次

softmax的公式如下:
σ ( z ) j = e z j ∑ k = 1 K e z K , j = 1 ⋯ k \\sigma(z)_j = \\frac{e^{z_j}}{\\sum^K_{k=1}e^{z_K}} ,j=1 \\cdots k σ(z)j=k=1KezKezj,j=1k

例如下图:

假如softmax之前的输出结果是2.3, 4.1, 5.6,那么经过softmax之后的结果是多少呢?
Y 1 = e 2.3 e 2.3 + e 4.1 + e 5.6 Y 2 = e 4.1 e 2.3 + e 4.1 + e 5.6 Y 3 = e 5.6 e 2.3 + e 4.1 + e 5.6 Y1 = \\frac{e^{2.3}}{e^{2.3}+e^{4.1}+e^{5.6}} \\\\ Y2 = \\frac{e^{4.1}}{e^{2.3}+e^{4.1}+e^{5.6}} \\\\ Y3 = \\frac{e^{5.6}}{e^{2.3}+e^{4.1}+e^{5.6}} \\\\ Y1=e2.3+e4.1+e5.6e2.3Y2=e2.3+e4.1+e5.6e4.1Y3=e2.3+e4.1+e5.6e5.6

对于这个softmax输出的结果,是在[0,1]区间,我们可以把它当做概率

和前面2分类的损失一样,多分类的损失只需要再把这个结果进行对数似然损失的计算即可

即:

最后,会计算每个样本的损失,即上式的平均值

我们把softmax概率传入对数似然损失得到的损失函数称为交叉熵损失

在pytorch中有两种方法实现交叉熵损失

  1. criterion = nn.CrossEntropyLoss()
    loss = criterion(input,target)
    
  2. #1. 对输出值计算softmax和取对数
    output = F.log_softmax(x,dim=-1)
    #2. 使用torch中带权损失
    loss = F.nll_loss(output,target)
    

带权损失定义为: l n = − ∑ w i x i l_n = -\\sum w_{i} x_{i} ln=wixi,其实就是把 l o g ( P ) log(P) log(P)作为 x i x_i xi,把真实值Y作为权重。

4. 模型的训练

训练的流程:

  1. 实例化模型,设置模型为训练模式
  2. 实例化优化器类,实例化损失函数
  3. 获取,遍历dataloader
  4. 梯度置为0
  5. 进行向前计算
  6. 计算损失
  7. 反向传播
  8. 更新参数
mnist_net = MnistNet()
optimizer = optim.Adam(mnist_net.parameters(),lr= 0.001)
def train以上是关于PyTorch实现手写数字识别的主要内容,如果未能解决你的问题,请参考以下文章

AI常用框架和工具丨13. PyTorch实现基于CNN的手写数字识别

卷积神经网络 手写数字识别(包含Pytorch实现代码)

PyTorch实现手写数字识别

图像分类基于PyTorch搭建LSTM实现MNIST手写数字体识别(双向LSTM,附完整代码和数据集)

PyTorch基于 LSTM 的手写数字识别(MNIST)

pyTorch使用mnist数据集实现手写数字识别