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

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

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

通过前面的内容可知，调用MNIST返回的结果中图形数据是一个Image对象,需要对其进行处理，为了进行数据的处理，接下来学习<code>torchvision.transfroms的方法~

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

<code>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

<code>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中并没有帮我们计算，所以我们需要手动计算

<code>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

<code>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分类中我们有正类和负类，正类的概率为

，那么负类的概率为1 - P(x)

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

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

假如softmax之前的输出结果是<code>2.3, 4.1, 5.6,那么经过softmax之后的结果是 ：

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

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

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

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

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

<code>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()code>

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"))

模型的评估