目录
- 目标
- 一、思路和流程分析
- 二、准备训练集和测试集
- 2.1、图形数据处理方法
- 2.1.1、torchvision.transforms.ToTensor
- 2.1.2、torchvision.transforms.Normalize(mean, std)
- 2.1.3、torchvision.transforms.Compose(transforms)
- 2.2、准备MNIST数据集的Dataset和DataLoader
- 三、构建模型
- 3.1、激活函数的使用
- 3.2、模型中数据的形状
- 3.3、模型的损失函数
- 四、模型的训练
- 五、模型的保存和加载
- 5.1 模型的保存
- 5.2 模型的加载
- 六、模型的评估
- 七、完整代码
- 八、运行效果
- 8.1、训练效果
- 8.2、评估效果
目标
- 知道如何使用Pytorch完成神经网络的构建
- 知道Pytorch中激活函数的使用方法
- 知道Pytorch中
torchvision.transforms中常见图形处理函数的使用 - 知道如何训练模型和如何评估模型
一、思路和流程分析
流程：
- 准备数据，这些需要准备DataLoader
- 构建模型，这里可以使用torch构造一个深层的神经网络
- 模型的训练
- 模型的保存，保存模型，后续持续使用
- 模型的评估，使用测试集，观察模型的好坏
二、准备训练集和测试集
本次使用的数据集是pytorch自带的图像数据集MNIST
from torchvision.datasets import MNIST #自带数据集
2.1、图形数据处理方法
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)
给定均值mean，shape和图片的通道数相同(指的是每个通道的均值)，方差：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中，默认上式中的std和mean为数据每列的std和mean，sklearn会在标准化之前算出每一列的std和mean。
但是在api：Normalize中并没有帮我们计算，所以我们需要手动计算
-
当mean为全部数据的均值，std为全部数据的std的时候，才是进行了标准化。
-
如果mean(x)不是全部数据的mean的时候，std(y)也不是的时候，Normalize后的数据分布满足下面的关系
n e w _ m e a n = m e a n − x y ， m e a n 为原数据的均值， x 为传入的均值 x n e w _ s t d = s t d y ， y 为传入的标准差 y \begin{align*} &new\_mean = \frac{mean-x}{y}&， mean为原数据的均值，x为传入的均值x \\ &new\_std = \frac{std}{y} &，y为传入的标准差y\\ \end{align*} new_mean=ymean−xnew_std=ystd，mean为原数据的均值，x为传入的均值x，y为传入的标准差y
2.1.3、torchvision.transforms.Compose(transforms)
将多个transform组合起来使用。
例如
transforms.Compose([
torchvision.transforms.ToTensor(), #先转化为Tensor
torchvision.transforms.Normalize(mean,std) #在进行正则化
])
2.2、准备MNIST数据集的Dataset和DataLoader
准备训练集和测试集
from torchvision.datasets import MNIST #自带数据集
def get_dataloader(train=True,batch_size=BATCH_SIZE): #train为True加载训练数据，False加载测试数据
#数据集标准化
transform_fn = Compose([
ToTensor(),
Normalize(mean=(0.1307,),std=(0.3081,)) #mean和std的形状和通道数相同
])
#加载数据集
dataset = MNIST(root="./data",train=train,download=True,transform=transform_fn)
#使用数据加载器
data_loader = DataLoader(dataset=dataset,batch_size=batch_size,shuffle=True)
return data_loader
当train==True为训练数据集，train==False为测试数据集
三、构建模型
全连接层：当前一层的神经元和前一层的神经元相互链接，其核心操作就是 y = w x y = wx y=wx，即矩阵的乘法，实现对前一层的数据的变换。
模型的构建使用了一个三层的神经网络，其中包括两个全连接层和一个输出层，第一个全连接层会经过激活函数的处理，将处理后的结果交给下一个全连接层，进行变换后输出结果
那么在这个模型中有两个地方需要注意：
- 激活函数如何使用
- 每一层数据的形状
- 模型的损失函数
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、模型中数据的形状
- 原始输入数据为的形状:
[batch_size,1,28,28] - 进行形状的修改：
[batch_size,28*28],(全连接层是在进行矩阵的乘法操作) - 第一个全连接层的输出形状：
[batch_size,28]，这里的28是个人设定的，你也可以设置为别的 - 激活函数不会修改数据的形状
- 第二个全连接层的输出形状：
[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+e−x1=1+exex,那么负类的概率为 1 − P ( x ) 1-P(x) 1−P(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=1⋯k
例如下图：
假如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分类的损失一样，多分类的损失只需要再把这个结果进行对数似然损失的计算即可
即：
J
=
−
∑
Y
l
o
g
(
P
)
,
其中
P
=
e
z
j
∑
k
=
1
K
e
z
K
,
Y
表示真实值
\begin{align*} & J = -\sum Y log(P) &, 其中 P = \frac{e^{z_j}}{\sum^K_{k=1}e^{z_K}} ,Y表示真实值 \end{align*}
J=−∑Ylog(P),其中P=∑k=1KezKezj,Y表示真实值
最后，会计算每个样本的损失，即上式的平均值
我们把softmax概率传入对数似然损失得到的损失函数称为交叉熵损失
在pytorch中有两种方法实现交叉熵损失
-
criterion = nn.CrossEntropyLoss() loss = criterion(input,target) -
#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作为权重
四、模型的训练
训练的流程：
- 实例化模型，设置模型为训练模式
- 实例化优化器类，实例化损失函数
- 获取，遍历dataloader
- 梯度置为0
- 进行向前计算
- 计算损失
- 反向传播
- 更新参数
代码如下：
#实现训练过程
#实例化模型
model = MnistModel()
# 实例化优化器
optimizer = Adam(model.parameters(),lr=0.001)
#加载以前保存的模型(如果有的话)
if os.path.exists("./model/model.pkl"):
model.load_state_dict(torch.load("./model/model.pkl"))
#加载以前保存的优化器
optimizer.load_state_dict(torch.load("./model/optimizer.pkl"))
def train(epoch):
# 获取训练数据加载器
data_loader = get_dataloader()
# 训练
for idx,(input,target) in enumerate(data_loader):
# 梯度置零，防止累加
optimizer.zero_grad()
# 计算损失
output = model(input)
loss = F.nll_loss(output,target)
# 反向传播
loss.backward()
# 梯度更新
optimizer.step()
#每训练100次就保存模型,并输出结果
if idx%100 == 0:
print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
epoch, idx * len(input), len(data_loader.dataset),
100. * idx / len(data_loader), loss.item()))
#保存模型
torch.save(model.state_dict(), "./model/model.pkl")
torch.save(optimizer.state_dict(), "./model/optimizer.pkl")
五、模型的保存和加载
5.1 模型的保存
torch.save(model.state_dict(), "./model/model.pkl") #保存模型参数
torch.save(optimizer.state_dict(), "./model/optimizer.pkl") #保存优化器参数
5.2 模型的加载
model.load_state_dict(torch.load("./model/model.pkl"))
optimizer.load_state_dict(torch.load("./model/optimizer.pkl"))
六、模型的评估
评估的过程和训练的过程相似，但是：
- 不需要计算梯度
- 需要收集损失和准确率，用来计算平均损失和平均准确率
- 损失的计算和训练时候损失的计算方法相同
- 准确率的计算：
- 模型的输出为[batch_size,10]的形状
- 其中最大值的位置就是其预测的目标值（预测值进行过sotfmax后为概率，sotfmax中分母都是相同的，分子越大，概率越大）
- 最大值的位置获取的方法可以使用
torch.max,返回最大值和最大值的位置 - 返回最大值的位置后，和真实值（
[batch_size]）进行对比，相同表示预测成功
代码如下：
def test():
loss_list = []
acc_list = []
test_dataloader = get_dataloader(False,TEST_BATCH_SIZE)
for idx,(input,target) in enumerate(test_dataloader):
with torch.no_grad(): #不需要计算梯度
output = model(input)
cur_loss = F.nll_loss(output,target)
loss_list.append(cur_loss)
#计算准确率
pred = output.max(dim=-1)[-1]#获取最大值的位置,[batch_size,1]
cur_acc = pred.eq(target).float().mean()
acc_list.append(cur_acc)
print("平均准确率，平均损失",np.mean(acc_list),np.mean(loss_list))
七、完整代码
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import torch
from torchvision.datasets import MNIST #自带数据集
from torchvision.transforms import Compose,ToTensor,Normalize
from torch.utils.data import DataLoader
import torch.nn as nn
import torch.nn.functional as F #激活函数
from torch.optim import Adam
import os
import numpy as np
BATCH_SIZE = 128
TEST_BATCH_SIZE = 1000
#1、使用数据集
#我们使用pytorch中自带的数据集
def get_dataloader(train=True,batch_size=BATCH_SIZE): #train为True加载训练数据，False加载测试数据
#数据集标准化
transform_fn = Compose([
ToTensor(),
Normalize(mean=(0.1307,),std=(0.3081,)) #mean和std的形状和通道数相同
])
#加载数据集
dataset = MNIST(root="./data",train=train,download=True,transform=transform_fn)
#使用数据加载器
data_loader = DataLoader(dataset=dataset,batch_size=batch_size,shuffle=True)
return data_loader
#2、构建模型
class MnistModel(nn.Module):
def __init__(self):
super(MnistModel, self).__init__()
self.fc1 = nn.Linear(1*28*28,28)
self.fc2 = nn.Linear(28,10) #手写数字为0—9一共10个数字，所有输出大小为10
def forward(self,input):
"""
:param input:[batch_size,1,28,28]
:return:
"""
#1、修改形状
x = input.view([input.size(0),1*28*28])
#input = view([-1,1*28*28])
#2、进行全连接操作
x = self.fc1(x)
#3、进行激活函数的处理，形状没有变化
x = F.relu(x)
#4、输出层
out = self.fc2(x)
return F.log_softmax(out,dim=-1)
#实现训练过程
model = MnistModel()
# 实例化优化器
optimizer = Adam(model.parameters(),lr=0.001)
#加载以前保存的模型(如果有的话)
if os.path.exists("./model/model.pkl"):
model.load_state_dict(torch.load("./model/model.pkl"))
#加载以前保存的优化器
optimizer.load_state_dict(torch.load("./model/optimizer.pkl"))
def train(epoch):
# 获取训练数据加载器
data_loader = get_dataloader()
# 训练
for idx,(input,target) in enumerate(data_loader):
# 梯度置零，防止累加
optimizer.zero_grad()
# 计算损失
output = model(input)
loss = F.nll_loss(output,target)
# 反向传播
loss.backward()
# 梯度更新
optimizer.step()
#每训练100次就保存模型,并输出结果
if idx%100 == 0:
print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
epoch, idx * len(input), len(data_loader.dataset),
100. * idx / len(data_loader), loss.item()))
#保存模型
torch.save(model.state_dict(), "./model/model.pkl")
torch.save(optimizer.state_dict(), './model/optimizer.pkl')
def test():
loss_list = []
acc_list = []
test_dataloader = get_dataloader(False,TEST_BATCH_SIZE)
for idx,(input,target) in enumerate(test_dataloader):
with torch.no_grad(): #不需要计算梯度
output = model(input)
cur_loss = F.nll_loss(output,target)
loss_list.append(cur_loss)
#计算准确率
pred = output.max(dim=-1)[-1]#获取最大值的位置,[batch_size,1]
cur_acc = pred.eq(target).float().mean()
acc_list.append(cur_acc)
print("平均准确率，平均损失",np.mean(acc_list),np.mean(loss_list))
if __name__ == '__main__':
#训练
for i in range(3):
train(i)
#评估
# test()
八、运行效果
8.1、训练效果
8.2、评估效果
