0


【深度学习入门篇 ④ 】Pytorch实现手写数字识别

【🍊易编橙:一个帮助编程小伙伴少走弯路的终身成长社群🍊】

大家好,我是小森( ﹡ˆoˆ﹡ ) ! 易编橙·终身成长社群创始团队嘉宾,橙似锦计划领衔成员、阿里云专家博主、腾讯云内容共创官、CSDN人工智能领域优质创作者 。


通过前面的学习,我们已经掌握了PyTorch API的基本使用,今天我们使用PyTorch实现手写数字识别案例!

**通过前面的内容可知,调用MNIST返回的结果中图形数据是一个Image对象,需要对其进行处理,为了进行数据的处理,接下来学习

torchvision.transfroms

的方法~**

torchvision.transforms是PyTorch中用于图像预处理和增强的一个重要模块,它提供了多种对图像进行变换的方法,如裁剪、旋转、缩放、归一化等。这些方法可以单独使用,也可以通过transforms.Compose类组合起来,形成复杂的预处理流程。

torchvision.transforms.ToTensor💥

用于将 PIL 图像(PIL.Image.Image)或 NumPy ndarray(通常是形状为 (H, W, C) 的图像,其中 H 是高度,W 是宽度,C 是通道数,比如 RGB 图像的 C=3)转换为 PyTorch 张量(Tensor)。

黑白图片的通道数只有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()(img): 这里发生了两件事情,transforms.ToTensor() 创建了一个 ToTensor 转换对象。
  • 紧接着的 (img) 实际上是调用了这个 ToTensor 对象的 __call__ 方法,并将 img 作为参数传递给它。

回顾__call__方法:

它允许类的实例像函数一样被调用。当我们尝试对一个对象使用圆括号

()

进行调用时;Python会查找该对象的

__call__

方法并调用它。如果

__call__

方法被定义,那么它的实例就可以被当作函数来调用。

栗子:

class Adder:  
    def __init__(self, n):  
        self.n = n  
  
    def __call__(self, x):  
        return self.n + x  
  
# 创建一个Adder实例,将5作为n的值  
adder = Adder(5)  
  
# 使用圆括号调用adder实例,就像调用函数一样  
result = adder(3)  
  
print(result)  # 输出: 8

torchvision.transforms.Normalize(mean, std)💥

它用于对张量(Tensor)进行标准化处理。其中:

  • mean:一个序列,包含每个通道的均值。
  • std:一个序列,包含每个通道的标准差。
Normalize

方法会按照给定的均值和标准差对每个通道的数据进行标准化处理:

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中,默认上式中的std和mean为数据每列的std和mean,sklearn会在标准化之前算出每一列的std和mean。
  • 但是在这里:Normalize中并没有帮我们计算,所以我们需要手动计算

torchvision.transforms.Compose(transforms)💥

用于将多个

transform

组合起来使用。

Compose

类接受一个转换列表(transforms)作为输入,这个列表中的每个元素都是一个转换操作。当你创建一个

Compose

实例,并将其应用于图像时,它会按照列表中定义的顺序依次执行每个转换。

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

💦写一个小模版:

from torchvision import transforms  
  
# 定义转换步骤  
resize = transforms.Resize((256, 256))  # 将图像大小调整为256x256  
to_tensor = transforms.ToTensor()       # 将PIL图像或NumPy ndarray转换为Tensor  
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  # 标准化  
  
# 将这些转换组合成一个转换流程  
transform = transforms.Compose([  
    resize,  
    to_tensor,  
    normalize  
])  
  
# 假设你有一个PIL图像img  
# ...(这里省略了加载图像的代码)  
  
# 应用转换流程  
transformed_img = transform(img)  
  
# 现在transformed_img是经过调整大小、转换为Tensor并标准化的图像

准备MNIST数据集的Dataset和DataLoader

import torchvision

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)
  • '/data'指定了数据集下载和存储的根目录。
  • train=True表示加载的是训练集。
  • download=True表示如果数据集尚未下载,将自动从互联网上下载。如果数据集已经下载,这个参数不会再次触发下载。

**准备测试集💫 **

import torchvision

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)

构建模型💫

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

  • 全连接层中的每一个神经元都与前一层中的所有神经元相连接,核心操作就是y = wx,即矩阵的乘法,实现对前一层的数据的变换。
  • 全连接层能够学习输入数据的特征表示,通过多个全连接层的组合,使网络能够学习输入数据的高层次抽象表示,从而帮助网络完成分类、回归等任务。

常用的激活函数为Relu激活函数,他的使用非常简单

Relu激活函数由

import torch.nn.functional as F

提供,

F.relu(x)

即可对x进行处理

import torch.nn.functional as F
b = tensor([-2, -1,  0,  1,  2])
F.relu(b)

# 输出
tensor([0, 0, 0, 1, 2])
  • 激活函数选用

**构建模型代码 **

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]
  
  • nn.Linear 层为线性层,数据会经过 out = input * w + b

模型的损失函数

首先,手写字体识别的问题是一个多分类的问题

在逻辑回归中,使用sigmoid进行计算对数似然损失,来定义2分类的损失。在2分类中我们有正类和负类,正类的概率为 $P(x) = \frac{1}{1+e^{-x}} = \frac{e^x}{1+e^x}$,那么负类的概率为1 - P(x)

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

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

假如softmax之前的输出结果是

2.3, 4.1, 5.6

,那么经过softmax之后的结果是 :

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}} \\

对于这个softmax输出的结果,是在[0,1]区间,我们可以把它当做概率;和前面2分类的损失一样,多分类的损失只需要再把这个结果进行对数似然损失的计算即可

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

softmax函数将logits转换为概率分布,而对数似然损失则衡量了这些概率分布与真实标签之间的差异。

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

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

criterion = nn.CrossEntropyLoss()
loss = criterion(input,target)
  • nn.CrossEntropyLoss() 内部首先会对 input 应用softmax函数,然后计算交叉熵损失。我们就不需要在模型输出上应用softmax函数了。

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

模型的训练

mnist_net = MnistNet()
optimizer = optim.Adam(mnist_net.parameters(),lr= 0.001)
def train(epoch):
    mode = True
    mnist_net.train(mode=mode) #模型设置为训练模型
    
    train_dataloader = get_dataloader(train=mode) #获取训练数据集
    for idx,(data,target) in enumerate(train_dataloader):
        optimizer.zero_grad() #梯度置为0
        output = mnist_net(data) 
        loss = F.nll_loss(output,target) #带权损失
        loss.backward()  #进行反向传播,计算梯度
        optimizer.step() #参数更新
        if idx % 10 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, idx * len(data), len(train_dataloader.dataset),
                       100. * idx / len(train_dataloader), loss.item()))

模型的保存和加载

def test():
    test_loss = 0
    correct = 0
    mnist_net.eval()  #设置模型为评估模式
    test_dataloader = get_dataloader(train=False) #获取评估数据集
    with torch.no_grad(): #不计算其梯度
        for data, target in test_dataloader:
            output = mnist_net(data)
            test_loss += F.nll_loss(output, target, reduction='sum').item()
            pred = output.data.max(1, keepdim=True)[1] #获取最大值的位置,[batch_size,1]
            correct += pred.eq(target.data.view_as(pred)).sum()  #预测准备样本数累加
    test_loss /= len(test_dataloader.dataset) #计算平均损失
    print('\nTest set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\n'.format(
        test_loss, correct, len(test_dataloader.dataset),
        100. * correct / len(test_dataloader.dataset)))
torch.save(mnist_net.state_dict(),"model/mnist_net.pt") #保存模型参数
torch.save(optimizer.state_dict(), 'results/mnist_optimizer.pt') #保存优化器参数

模型加载:

mnist_net.load_state_dict(torch.load("model/mnist_net.pt"))
optimizer.load_state_dict(torch.load("results/mnist_optimizer.pt"))

模型的评估

评估的过程和训练的过程相似,但是不需要计算梯度了。

def test():
    test_loss = 0
    correct = 0
    mnist_net.eval()  # 设置模型为评估模式
    test_dataloader = get_dataloader(train=False) 
    with torch.no_grad(): # 不计算梯度
        for data, target in test_dataloader:
            output = mnist_net(data)
            test_loss += F.nll_loss(output, target, reduction='sum').item()
            pred = output.data.max(1, keepdim=True)[1] #获取最大值的位置,[batch_size,1]
            correct += pred.eq(target.data.view_as(pred)).sum()  #预测准备样本数累加
    test_loss /= len(test_dataloader.dataset) # 计算平均损失
    print('\nTest set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\n'.format(
        test_loss, correct, len(test_dataloader.dataset),
        100. * correct / len(test_dataloader.dataset)))

完整的代码

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

train_batch_size = 64
test_batch_size = 1000
img_size = 28

def get_dataloader(train=True):
    assert isinstance(train,bool),"train 必须是bool类型"

   
    dataset = torchvision.datasets.MNIST('/data', train=train, download=True,
                                         transform=torchvision.transforms.Compose([
                                         torchvision.transforms.ToTensor(),
                                         torchvision.transforms.Normalize((0.1307,), (0.3081,)),]))

    batch_size = train_batch_size if train else test_batch_size
    dataloader = torch.utils.data.DataLoader(dataset,batch_size=batch_size,shuffle=True)
    return dataloader

class MnistNet(nn.Module):
    def __init__(self):
        super(MnistNet,self).__init__()
        self.fc1 = nn.Linear(28*28*1,28)
        self.fc2 = nn.Linear(28,10)

    def forward(self,x):
        x = x.view(-1,28*28*1)
        x = self.fc1(x) #[batch_size,28]
        x = F.relu(x)  #[batch_size,28]
        x = self.fc2(x) #[batch_size,10]
        # return x
        return F.log_softmax(x,dim=-1)

mnist_net = MnistNet()
optimizer = optim.Adam(mnist_net.parameters(),lr= 0.001)
# criterion = nn.NLLLoss()
# criterion = nn.CrossEntropyLoss()
train_loss_list = []
train_count_list = []

def train(epoch):
    mode = True
    mnist_net.train(mode=mode)
    train_dataloader = get_dataloader(train=mode)
    print(len(train_dataloader.dataset))
    print(len(train_dataloader))
    for idx,(data,target) in enumerate(train_dataloader):
        optimizer.zero_grad()
        output = mnist_net(data)
        loss = F.nll_loss(output,target) 
        loss.backward()
        optimizer.step()
        if idx % 10 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, idx * len(data), len(train_dataloader.dataset),
                       100. * idx / len(train_dataloader), loss.item()))

            train_loss_list.append(loss.item())
            train_count_list.append(idx*train_batch_size+(epoch-1)*len(train_dataloader))
            torch.save(mnist_net.state_dict(),"model/mnist_net.pkl")
            torch.save(optimizer.state_dict(), 'results/mnist_optimizer.pkl')

def test():
    test_loss = 0
    correct = 0
    mnist_net.eval()
    test_dataloader = get_dataloader(train=False)
    with torch.no_grad():
        for data, target in test_dataloader:
            output = mnist_net(data)
            test_loss += F.nll_loss(output, target, reduction='sum').item()
            pred = output.data.max(1, keepdim=True)[1] #获取最大值的位置,[batch_size,1]
            correct += pred.eq(target.data.view_as(pred)).sum()
    test_loss /= len(test_dataloader.dataset)
    print('\nTest set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\n'.format(
        test_loss, correct, len(test_dataloader.dataset),
        100. * correct / len(test_dataloader.dataset)))

if __name__ == '__main__':

    test()  
    for i in range(10): #模型训练10轮
        train(i)
        test()

本文转载自: https://blog.csdn.net/qq_64685283/article/details/140340655
版权归原作者 小森( ﹡ˆoˆ﹡ ) 所有, 如有侵权,请联系我们删除。

“【深度学习入门篇 ④ 】Pytorch实现手写数字识别”的评论:

还没有评论