深度学习笔记--pytorch从梯度下降到反向传播BP到线性回归实现,以及API调用和手写数据集的实现
梯度下降和反向传播
目标
- 知道什么是梯度下降
- 知道什么是反向传播
1. 梯度是什么?
梯度:是一个向量,导数+变化最快的方向(学习的前进方向)
回顾机器学习
收集数据 x x x ,构建机器学习模型 f f f,得到 f ( x , w ) = Y p r e d i c t f(x,w) = Y_{predict} f(x,w)=Ypredict
判断模型好坏的方法:
目标:通过调整(学习)参数 w w w,尽可能的降低 l o s s loss loss,那么我们该如何调整 w w w呢?
随机选择一个起始点 w 0 w_0 w0,通过调整 w 0 w_0 w0,让loss函数取到最小值
w w w的更新方法:
- 计算 w w w的梯度(导数)
- 更新 w w w
w = w − α ∇ w w = w - \alpha \nabla w w=w−α∇w
其中:
- $\nabla w <0 $ ,意味着w将增大
- $\nabla w >0 $ ,意味着w将减小
总结:梯度就是多元函数参数的变化趋势(参数学习的方向),只有一个自变量时称为导数
2. 偏导的计算
2.1 常见的导数计算
多项式求导数: f ( x ) = x 5 f(x) = x^5 f(x)=x5 , f ′ ( x ) = 5 x ( 5 − 1 ) f^{'}(x) = 5x^{(5-1)} f′(x)=5x(5−1)
基本运算求导: f ( x ) = x y f(x) = xy f(x)=xy , f ′ ( x ) = y f^{'}(x) = y f′(x)=y
指数求导: f ( x ) = 5 e x f(x) = 5e^x f(x)=5ex , f ′ ( x ) = 5 e x f^{'}(x) = 5e^x f′(x)=5ex
对数求导: f ( x ) = 5 l n x f(x) = 5lnx f(x)=5lnx , f ′ ( x ) = 5 x f^{'}(x) = \frac{5}{x} f′(x)=x5,ln 表示log以e为底的对数
导数的微分形式:
那么:如何求 f ( x ) = ( 1 + e − x ) − 1 f(x) = (1+e^{-x})^{-1} f(x)=(1+e−x)−1 的导数呢?那就可以使用
f ( x ) = ( 1 + e − x ) − 1 f(x) = (1+e^{-x})^{-1} f(x)=(1+e−x)−1 ==> f ( a ) = a − 1 , a ( b ) = ( 1 + b ) , b ( c ) = e c , c ( x ) = − x f(a) = a^{-1},a(b) = (1+b),b(c) = e^c,c(x) = -x f(a)=a−1,a(b)=(1+b),b(c)=ec,c(x)=−x
则有:
2.2 多元函数求偏导
一元函数,即有一个自变量。类似 f ( x ) f(x) f(x)
多元函数,即有多个自变量。类似 f ( x , y , z ) , 三 个 自 变 量 x , y , z f(x,y,z),三个自变量x,y,z f(x,y,z),三个自变量x,y,z
多元函数求偏导过程中:对某一个自变量求导,其他自变量当做常量即可
$$
练习:
已知 J ( a , b , c ) = 3 ( a + b c ) , 令 u = a + v , v = b c J(a,b,c) = 3(a+bc),令u=a+v,v = bc J(a,b,c)=3(a+bc),令u=a+v,v=bc,求a,b,c各自的偏导数。
3. 反向传播算法
3.1 计算图和反向传播
计算图:通过图的方式来描述函数的图形
在上面的练习中, J ( a , b , c ) = 3 ( a + b c ) , 令 u = a + v , v = b c J(a,b,c) = 3(a+bc),令u=a+v,v = bc J(a,b,c)=3(a+bc),令u=a+v,v=bc,把它绘制成计算图可以表示为:
绘制成为计算图之后,可以清楚的看到向前计算的过程
之后,对每个节点求偏导可有:
那么反向传播的过程就是一个上图的从右往左的过程,自变量 a , b , c a,b,c a,b,c各自的偏导就是连线上的梯度的乘积:
3.2 神经网络中的反向传播
3.2.1 神经网络的示意图
w 1 , w 2 , . . . . w n w1,w2,....wn w1,w2,....wn表示网络第n层权重
w n [ i , j ] w_n[i,j] wn[i,j]表示第n层第i个神经元,连接到第n+1层第j个神经元的权重。
3.2.2 神经网络的计算图
其中:
- ∇ o u t \nabla out ∇out是根据损失函数对预测值进行求导得到的结果
- f函数可以理解为激活函数
**问题:**那么此时 w 1 [ 1 , 2 ] w_1[1,2] w1[1,2]的偏导该如何求解呢?
通过观察,发现从 o u t out out 到 w 1 [ 1 , 2 ] w_1[1,2] w1[1,2]的来连接线有两条
结果如下:
d o u t d W 1 [ 1 , 2 ] = x 1 ∗ f ′ ( a 2 ) ∗ ( W 2 [ 2 , 1 ] ∗ f ′ ( b 1 ) ∗ W 3 [ 1 , 1 ] ∗ ∇ o u t + W 2 [ 2 , 2 ] ∗ f ′ ( b 2 ) ∗ W 3 [ 2 , 1 ] ∗ ∇ o u t ) \frac{dout}{dW_1[1,2]} = x1*f^{'}(a2)*(W_2[2,1]*f^{'}(b1)*W_3[1,1]*\nabla out +W_2[2,2]*f^{'}(b2)*W_3[2,1]*\nabla out) dW1[1,2]dout=x1∗f′(a2)∗(W2[2,1]∗f′(b1)∗W3[1,1]∗∇out+W2[2,2]∗f′(b2)∗W3[2,1]∗∇out)
公式分为两部分:
- 括号外:左边红线部分
- 括号内
- 加号左边:右边红线部分
- 加号右边:蓝线部分
但是这样做,当模型很大的时候,计算量非常大
所以反向传播的思想就是对其中的某一个参数单独求梯度,之后更新,如下图所示:
计算过程如下
更新参数之后,继续反向传播
计算过程如下:
继续反向传播
计算过程如下:
通用的描述如下
∇ w i , j l = f ( a i l ) ∗ ∇ a j i + 1 ∇ a i l = f ′ ( a i l ) ∗ ( ∑ j = 1 m w i , j ∗ ∇ a j l + 1 ) \nabla w^{l}_{i,j} = f(a^l_i)* \nabla a^{i+1}_{j}\\ \nabla a^{l}_i = f'(a^l_i)*(\sum_{j=1}^{m}w_{i,j}*\nabla a_j^{l+1}) ∇wi,jl=f(ail)∗∇aji+1∇ail=f′(ail)∗(j=1∑mwi,j∗∇ajl+1)
Pytorch完成线性回归
目标
知道
requires_grad
的作用知道如何使用
backward
知道如何手动完成线性回归
1. 向前计算
对于pytorch中的一个tensor,如果设置它的属性 .requires_grad
为True
,那么它将会追踪对于该张量的所有操作。或者可以理解为,这个tensor是一个参数,后续会被计算梯度,更新该参数。
1.1 计算过程
假设有以下条件(1/4表示求均值,xi中有4个数),使用torch完成其向前计算的过程
如果x为参数,需要对其进行梯度的计算和更新
那么,在最开始随机设置x的值的过程中,需要设置他的requires_grad属性为True,其默认值为False
import torch
x = torch.ones(2, 2, requires_grad=True) #初始化参数x并设置requires_grad=True用来追踪其计算历史
print(x)
#tensor([[1., 1.],
# [1., 1.]], requires_grad=True)y = x+2
print(y)
#tensor([[3., 3.],
# [3., 3.]], grad_fn=<AddBackward0>)z = y*y*3 #平方x3
print(x)
#tensor([[27., 27.],
# [27., 27.]], grad_fn=<MulBackward0>) out = z.mean() #求均值
print(out)
#tensor(27., grad_fn=<MeanBackward0>)
从上述代码可以看出:
- x的requires_grad属性为True
- 之后的每次计算都会修改其
grad_fn
属性,用来记录做过的操作- 通过这个函数和grad_fn能够组成一个和前一小节类似的计算图
1.2 requires_grad和grad_fn
a = torch.randn(2, 2)
a = ((a * 3) / (a - 1))
print(a.requires_grad) #False
a.requires_grad_(True) #就地修改
print(a.requires_grad) #True
b = (a * a).sum()
print(b.grad_fn) # <SumBackward0 object at 0x4e2b14345d21>
with torch.no_gard():c = (a * a).sum() #tensor(151.6830),此时c没有gard_fnprint(c.requires_grad) #False
注意:
为了防止跟踪历史记录(和使用内存),可以将代码块包装在with torch.no_grad():
中。在评估模型时特别有用,因为模型可能具有requires_grad = True
的可训练的参数,但是我们不需要在此过程中对他们进行梯度计算。
2. 梯度计算
对于1.1 中的out而言,我们可以使用backward
方法来进行反向传播,计算梯度
out.backward()
,此时便能够求出导数 d o u t d x \frac{d out}{dx} dxdout,调用x.gard
能够获取导数值
得到
tensor([[4.5000, 4.5000],[4.5000, 4.5000]])
因为:
d ( O ) d ( x i ) = 3 2 ( x i + 2 ) \frac{d(O)}{d(x_i)} = \frac{3}{2}(x_i+2) d(xi)d(O)=23(xi+2)
在 x i x_i xi等于1时其值为4.5
注意:在输出为一个标量的情况下,我们可以调用输出tensor
的backword()
方法,但是在数据是一个向量的时候,调用backward()
的时候还需要传入其他参数。
很多时候我们的损失函数都是一个标量,所以这里就不再介绍损失为向量的情况。
loss.backward()
就是根据损失函数,对参数(requires_grad=True)的去计算他的梯度,并且把它累加保存到x.gard
,此时还并未更新其梯度
注意点:
tensor.data
:在tensor的require_grad=False,tensor.data和tensor等价
require_grad=True时,tensor.data仅仅是获取tensor中的数据
tensor.numpy()
:require_grad=True
不能够直接转换,需要使用tensor.detach().numpy()
3. 线性回归实现
下面,我们使用一个自定义的数据,来使用torch实现一个简单的线性回归
假设我们的基础模型就是y = wx+b
,其中w和b均为参数,我们使用y = 3x+0.8
来构造数据x、y,所以最后通过模型应该能够得出w和b应该分别接近3和0.8
- 准备数据
- 计算预测值
- 计算损失,把参数的梯度置为0,进行反向传播
- 更新参数
import torch
import numpy as np
from matplotlib import pyplot as plt#1. 准备数据 y = 3x+0.8,准备参数
x = torch.rand([50])
y = 3*x + 0.8w = torch.rand(1,requires_grad=True)
b = torch.rand(1,requires_grad=True)def loss_fn(y,y_predict):loss = (y_predict-y).pow(2).mean()for i in [w,b]:#每次反向传播前把梯度置为0if i.grad is not None:i.grad.data.zero_()# [i.grad.data.zero_() for i in [w,b] if i.grad is not None]loss.backward()return loss.datadef optimize(learning_rate):# print(w.grad.data,w.data,b.data)w.data -= learning_rate* w.grad.datab.data -= learning_rate* b.grad.datafor i in range(3000):#2. 计算预测值y_predict = x*w + b#3.计算损失,把参数的梯度置为0,进行反向传播 loss = loss_fn(y,y_predict)if i%500 == 0:print(i,loss)#4. 更新参数w和boptimize(0.01)# 绘制图形,观察训练结束的预测值和真实值
predict = x*w + b #使用训练后的w和b计算预测值plt.scatter(x.data.numpy(), y.data.numpy(),c = "r")
plt.plot(x.data.numpy(), predict.data.numpy())
plt.show()print("w",w)
print("b",b)
图形效果如下:
打印w和b,可有
w tensor([2.9280], requires_grad=True)
b tensor([0.8372], requires_grad=True)
可知,w和b已经非常接近原来的预设的3和0.8
Pytorch完成基础的模型
目标
- 知道Pytorch中Module的使用方法
- 知道Pytorch中优化器类的使用方法
- 知道Pytorch中常见的损失函数的使用方法
- 知道如何在GPU上运行代码
- 能够说出常见的优化器及其原理
1. Pytorch完成模型常用API
在前一部分,我们自己实现了通过torch的相关方法完成反向传播和参数更新,在pytorch中预设了一些更加灵活简单的对象,让我们来构造模型、定义损失,优化损失等
那么接下来,我们一起来了解一下其中常用的API
1.1 nn.Module
nn.Modul
是torch.nn
提供的一个类,是pytorch中我们自定义网络
的一个基类,在这个类中定义了很多有用的方法,让我们在继承这个类定义网络的时候非常简单
当我们自定义网络的时候,有两个方法需要特别注意:
__init__
需要调用super
方法,继承父类的属性和方法farward
方法必须实现,用来定义我们的网络的向前计算的过程
用前面的y = wx+b
的模型举例如下:
from torch import nn
class Lr(nn.Module):def __init__(self):super(Lr, self).__init__() #继承父类init的参数self.linear = nn.Linear(1, 1) def forward(self, x):out = self.linear(x)return out
注意:
nn.Linear
为torch预定义好的线性模型,也被称为全链接层,传入的参数为输入的数量,输出的数量(in_features, out_features),是不算(batch_size的列数)nn.Module
定义了__call__
方法,实现的就是调用forward
方法,即Lr
的实例,能够直接被传入参数调用,实际上调用的是forward
方法并传入参数
# 实例化模型
model = Lr()
# 传入数据,计算结果
predict = model(x)
1.2 优化器类
优化器(optimizer
),可以理解为torch为我们封装的用来进行更新参数的方法,比如常见的随机梯度下降(stochastic gradient descent,SGD
)
优化器类都是由torch.optim
提供的,例如
torch.optim.SGD(参数,学习率)
torch.optim.Adam(参数,学习率)
注意:
- 参数可以使用
model.parameters()
来获取,获取模型中所有requires_grad=True
的参数 - 优化类的使用方法
- 实例化
- 所有参数的梯度,将其值置为0
- 反向传播计算梯度
- 更新参数值
示例如下:
optimizer = optim.SGD(model.parameters(), lr=1e-3) #1. 实例化
optimizer.zero_grad() #2. 梯度置为0
loss.backward() #3. 计算梯度
optimizer.step() #4. 更新参数的值
1.3 损失函数
前面的例子是一个回归问题,torch中也预测了很多损失函数
- 均方误差:
nn.MSELoss()
,常用于回归问题 - 交叉熵损失:
nn.CrossEntropyLoss()
,常用于分类问题
使用方法:
model = Lr() #1. 实例化模型
criterion = nn.MSELoss() #2. 实例化损失函数
optimizer = optim.SGD(model.parameters(), lr=1e-3) #3. 实例化优化器类
for i in range(100):y_predict = model(x_true) #4. 向前计算预测值loss = criterion(y_true,y_predict) #5. 调用损失函数传入真实值和预测值,得到损失结果optimizer.zero_grad() #5. 当前循环参数梯度置为0loss.backward() #6. 计算梯度optimizer.step() #7. 更新参数的值
1.4 把线性回归完整代码
import torch
from torch import nn
from torch import optim
import numpy as np
from matplotlib import pyplot as plt# 1. 定义数据
x = torch.rand([50,1])
y = x*3 + 0.8#2 .定义模型
class Lr(nn.Module):def __init__(self):super(Lr,self).__init__()self.linear = nn.Linear(1,1)def forward(self, x):out = self.linear(x)return out# 2. 实例化模型,loss,和优化器
model = Lr()
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=1e-3)
#3. 训练模型
for i in range(30000):out = model(x) #3.1 获取预测值loss = criterion(y,out) #3.2 计算损失optimizer.zero_grad() #3.3 梯度归零loss.backward() #3.4 计算梯度optimizer.step() # 3.5 更新梯度if (i+1) % 20 == 0:print('Epoch[{}/{}], loss: {:.6f}'.format(i,30000,loss.data))#4. 模型评估
model.eval() #设置模型为评估模式,即预测模式
predict = model(x)
predict = predict.data.numpy()
plt.scatter(x.data.numpy(),y.data.numpy(),c="r")
plt.plot(x.data.numpy(),predict)
plt.show()
输出如下:
注意:
model.eval()
表示设置模型为评估模式,即预测模式
model.train(mode=True)
表示设置模型为训练模式
在当前的线性回归中,上述并无区别
但是在其他的一些模型中,训练的参数和预测的参数会不相同,到时候就需要具体告诉程序我们是在进行训练还是预测,比如模型中存在Dropout,BatchNorm的时候
2. 在GPU上运行代码
当模型太大,或者参数太多的情况下,为了加快训练速度,经常会使用GPU来进行训练
此时我们的代码需要稍作调整:
判断GPU是否可用
torch.cuda.is_available()
torch.device("cuda:0" if torch.cuda.is_available() else "cpu") >>device(type='cuda', index=0) #使用gpu >>device(type='cpu') #使用cpu
把模型参数和input数据转化为cuda的支持类型
model.to(device) x_true.to(device)
在GPU上计算结果也为cuda的数据类型,需要转化为numpy或者torch的cpu的tensor类型
predict = predict.cpu().detach().numpy()
detach()
的效果和data的相似,但是detach()
是深拷贝,data是取值,是浅拷贝
修改之后的代码如下:
import torch
from torch import nn
from torch import optim
import numpy as np
from matplotlib import pyplot as plt
import time# 1. 定义数据
x = torch.rand([50,1])
y = x*3 + 0.8#2 .定义模型
class Lr(nn.Module):def __init__(self):super(Lr,self).__init__()self.linear = nn.Linear(1,1)def forward(self, x):out = self.linear(x)return out# 2. 实例化模型,loss,和优化器device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
x,y = x.to(device),y.to(device)model = Lr().to(device)
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=1e-3)#3. 训练模型
for i in range(300):out = model(x)loss = criterion(y,out)optimizer.zero_grad()loss.backward()optimizer.step()if (i+1) % 20 == 0:print('Epoch[{}/{}], loss: {:.6f}'.format(i,30000,loss.data))#4. 模型评估
model.eval() #
predict = model(x)
predict = predict.cpu().detach().numpy() #转化为numpy数组
plt.scatter(x.cpu().data.numpy(),y.cpu().data.numpy(),c="r")
plt.plot(x.cpu().data.numpy(),predict,)
plt.show()
3. 常见的优化算法介绍
3.1 梯度下降算法(batch gradient descent BGD)
每次迭代都需要把所有样本都送入,这样的好处是每次迭代都顾及了全部的样本,做的是全局最优化,但是有可能达到局部最优。
3.2 随机梯度下降法 (Stochastic gradient descent SGD)
针对梯度下降算法训练速度过慢的缺点,提出了随机梯度下降算法,随机梯度下降算法算法是从样本中随机抽出一组,训练后按梯度更新一次,然后再抽取一组,再更新一次,在样本量及其大的情况下,可能不用训练完所有的样本就可以获得一个损失值在可接受范围之内的模型了。
torch中的api为:torch.optim.SGD()
3.3 小批量梯度下降 (Mini-batch gradient descent MBGD)
SGD相对来说要快很多,但是也有存在问题,由于单个样本的训练可能会带来很多噪声,使得SGD并不是每次迭代都向着整体最优化方向,因此在刚开始训练时可能收敛得很快,但是训练一段时间后就会变得很慢。在此基础上又提出了小批量梯度下降法,它是每次从样本中随机抽取一小批进行训练,而不是一组,这样即保证了效果又保证的速度。
3.4 动量法
mini-batch SGD算法虽然这种算法能够带来很好的训练速度,但是在到达最优点的时候并不能够总是真正到达最优点,而是在最优点附近徘徊。
另一个缺点就是mini-batch SGD需要我们挑选一个合适的学习率,当我们采用小的学习率的时候,会导致网络在训练的时候收敛太慢;当我们采用大的学习率的时候,会导致在训练过程中优化的幅度跳过函数的范围,也就是可能跳过最优点。我们所希望的仅仅是网络在优化的时候网络的损失函数有一个很好的收敛速度同时又不至于摆动幅度太大。
所以Momentum优化器刚好可以解决我们所面临的问题,它主要是基于梯度的移动指数加权平均,对网络的梯度进行平滑处理的,让梯度的摆动幅度变得更小。
(注:t+1的的histroy_gradent 为第t次的gradent)
3.5 AdaGrad
AdaGrad算法就是将每一个参数的每一次迭代的梯度取平方累加后在开方,用全局学习率除以这个数,作为学习率的动态更新,从而达到自适应学习率的效果
3.6 RMSProp
Momentum优化算法中,虽然初步解决了优化中摆动幅度大的问题,为了进一步优化损失函数在更新中存在摆动幅度过大的问题,并且进一步加快函数的收敛速度,RMSProp算法对参数的梯度使用了平方加权平均数。
3.7 Adam
Adam(Adaptive Moment Estimation)算法是将Momentum算法和RMSProp算法结合起来使用的一种算法,能够达到防止梯度的摆幅多大,同时还能够加开收敛速度
torch中的api为:torch.optim.Adam()
3.8 效果演示:
Pytorch中的数据加载
目标
- 知道数据加载的目的
- 知道pytorch中Dataset的使用方法
- 知道pytorch中DataLoader的使用方法
- 知道pytorch中的自带数据集如何获取
1. 模型中使用数据加载器的目的
在前面的线性回归模型中,我们使用的数据很少,所以直接把全部数据放到模型中去使用。
但是在深度学习中,数据量通常是都非常多,非常大的,如此大量的数据,不可能一次性的在模型中进行向前的计算和反向传播,经常我们会对整个数据进行随机的打乱顺序,把数据处理成一个个的batch,同时还会对数据进行预处理。
所以,接下来我们来学习pytorch中的数据加载的方法
2. 数据集类
2.1 Dataset基类介绍
在torch中提供了数据集的基类torch.utils.data.Dataset
,继承这个基类,我们能够非常快速的实现对数据的加载。
torch.utils.data.Dataset
的源码如下:
class Dataset(object):"""An abstract class representing a Dataset.All other datasets should subclass it. All subclasses should override``__len__``, that provides the size of the dataset, and ``__getitem__``,supporting integer indexing in range from 0 to len(self) exclusive."""def __getitem__(self, index):raise NotImplementedErrordef __len__(self):raise NotImplementedErrordef __add__(self, other):return ConcatDataset([self, other])
可知:我们需要在自定义的数据集类中继承Dataset类,同时还需要实现两个方法:
__len__
方法,能够实现通过全局的len()
方法获取其中的元素个数__getitem__
方法,能够通过传入索引的方式获取数据,例如通过dataset[i]
获取其中的第i
条数据
2.2 数据加载案例
下面通过一个例子来看看如何使用Dataset来加载数据
数据来源:http://archive.ics.uci.edu/ml/datasets/SMS+Spam+Collection
数据介绍:SMS Spam Collection是用于骚扰短信识别的经典数据集,完全来自真实短信内容,包括4831条正常短信和747条骚扰短信。正常短信和骚扰短信保存在一个文本文件中。 每行完整记录一条短信内容,每行开头通过ham和spam标识正常短信和骚扰短信
数据实例:
实现如下:
from torch.utils.data import Dataset,DataLoader
import pandas as pddata_path = r"data\SMSSpamCollection"class CifarDataset(Dataset):def __init__(self):lines = open(data_path,"r")#对数据进行处理,前4个为label,后面的为短信内容lines = [[i[:4].strip(),i[4:].strip()] for i in lines]#转化为dataFrameself.df = pd.DataFrame(lines,columns=["label","sms"])def __getitem__(self, index):single_item = self.df.iloc[index,:]return single_item.values[0],single_item.values[1]def __len__(self):return self.df.shape[0]
之后对Dataset进行实例化,可以跌倒获取其中的数据
d = CifarDataset()
for i in range(len(d)):print(i,d[i])
输出如下:
....
5571 ('ham', 'Pity, * was in mood for that. So...any other suggestions?')
5572 ('ham', "The guy did some bitching but I acted like i'd be interested in buying something else next week and he gave it to us for free")
5573 ('ham', 'Rofl. Its true to its name')
3. 迭代数据集
使用上述的方法能够进行数据的读取,但是其中还有很多内容没有实现:
- 批处理数据(Batching the data)
- 打乱数据(Shuffling the data)
- 使用多线程
multiprocessing
并行加载数据。
在pytorch中torch.utils.data.DataLoader
提供了上述的所用方法
DataLoader
的使用方法示例:
from torch.utils.data import DataLoaderdataset = CifarDataset()
data_loader = DataLoader(dataset=dataset,batch_size=10,shuffle=True,num_workers=2)#遍历,获取其中的每个batch的结果
for index, (label, context) in enumerate(data_loader):print(index,label,context)print("*"*100)
其中参数含义:
- dataset:提前定义的dataset的实例
- batch_size:传入数据的batch的大小,常用128,256等等
- shuffle:bool类型,表示是否在每次获取数据的时候提前打乱数据
num_workers
:加载数据的线程数
数据迭代器的返回结果如下:
555 ('spam', 'ham', 'spam', 'ham', 'ham', 'ham', 'ham', 'spam', 'ham', 'ham') ('URGENT! We are trying to contact U. Todays draw shows that you have won a £800 prize GUARANTEED. Call 09050003091 from....", 'swhrt how u dey,hope ur ok, tot about u 2day.love n miss.take care.')
***********************************************************************************
556 ('ham', 'ham', 'ham', 'ham', 'ham', 'ham', 'ham', 'ham', 'ham', 'spam') ('He telling not to tell any one. If so treat for me hi hi hi', 'Did u got that persons story', "Don kn....1000 cash prize or a prize worth £5000')
注意:
len(dataset) = 数据集的样本数
len(dataloader) = math.ceil(样本数/batch_size) 即向上取整
4 pytorch自带的数据集
pytorch中自带的数据集由两个上层api提供,分别是torchvision
和torchtext
其中:
torchvision
提供了对图片数据处理相关的api和数据- 数据位置:
torchvision.datasets
,例如:torchvision.datasets.MNIST
(手写数字图片数据)
- 数据位置:
torchtext
提供了对文本数据处理相关的API和数据- 数据位置:
torchtext.datasets
,例如:torchtext.datasets.IMDB(电影
评论文本数据)
- 数据位置:
下面我们以Mnist手写数字为例,来看看pytorch如何加载其中自带的数据集
使用方法和之前一样:
- 准备好Dataset实例
- 把dataset交给dataloder 打乱顺序,组成batch
4.1 torchversion.datasets
torchversoin.datasets
中的数据集类(比如torchvision.datasets.MNIST
),都是继承自Dataset
意味着:直接对torchvision.datasets.MNIST
进行实例化就可以得到Dataset
的实例
但是MNIST API中的参数需要注意一下:
torchvision.datasets.MNIST(root='/files/', train=True, download=True, transform=)
root
参数表示数据存放的位置train:
bool类型,表示是使用训练集的数据还是测试集的数据download:
bool类型,表示是否需要下载数据到root目录transform:
实现的对图片的处理函数
4.2 MNIST数据集的介绍
数据集的原始地址:http://yann.lecun.com/exdb/mnist/
MNIST是由Yann LeCun
等人提供的免费的图像识别的数据集,其中包括60000个训练样本和10000个测试样本,其中图拍了的尺寸已经进行的标准化的处理,都是黑白的图像,大小为28X28
执行代码,下载数据,观察数据类型:
import torchvisiondataset = torchvision.datasets.MNIST(root="./data",train=True,download=True,transform=None)print(dataset[0])
下载的数据如下:
代码输出结果如下:
Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz
Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz
Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz
Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz
Processing...
Done!
(<PIL.Image.Image image mode=L size=28x28 at 0x18D303B9C18>, tensor(5))
可以其中数据集返回了两条数据,可以猜测为图片的数据和目标值
返回值的第0个为Image类型,可以调用show() 方法打开,发现为手写数字5
import torchvisiondataset = torchvision.datasets.MNIST(root="./data",train=True,download=True,transform=None)print(dataset[0])img = dataset[0][0]
img.show() #打开图片
图片如下:
由上可知:返回值为(图片,目标值)
,这个结果也可以通过观察源码得到
# 使用Pytorch实现手写数字识别
使用Pytorch实现手写数字识别
目标
- 知道如何使用Pytorch完成神经网络的构建
- 知道Pytorch中激活函数的使用方法
- 知道Pytorch中
torchvision.transforms
中常见图形处理函数的使用 - 知道如何训练模型和如何评估模型
1. 思路和流程分析
流程:
- 准备数据,这些需要准备DataLoader
- 构建模型,这里可以使用torch构造一个深层的神经网络
- 模型的训练
- 模型的保存,保存模型,后续持续使用
- 模型的评估,使用测试集,观察模型的好坏
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 npdata = 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 torchvisiondata = 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后的数据分布满足下面的关系
KaTeX parse error: No such environment: align* at position 8: \begin{̲a̲l̲i̲g̲n̲*̲}̲ &new\_mean = \…
2.1.3 torchvision.transforms.Compose(transforms)
将多个transform
组合起来使用。
例如
transforms.Compose([torchvision.transforms.ToTensor(), #先转化为Tensortorchvision.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,即矩阵的乘法,实现对前一层的数据的变换
模型的构建使用了一个三层的神经网络,其中包括两个全连接层和一个输出层,第一个全连接层会经过激活函数的处理,将处理后的结果交给下一个全连接层,进行变换后输出结果
那么在这个模型中有两个地方需要注意:
- 激活函数如何使用
- 每一层数据的形状
- 模型的损失函数
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 FIn [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 Fclass 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分类的损失一样,多分类的损失只需要再把这个结果进行对数似然损失的计算即可
即:
KaTeX parse error: No such environment: align* at position 8: \begin{̲a̲l̲i̲g̲n̲*̲}̲ & J = -\sum 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作为权重
4. 模型的训练
训练的流程:
- 实例化模型,设置模型为训练模式
- 实例化优化器类,实例化损失函数
- 获取,遍历dataloader
- 梯度置为0
- 进行向前计算
- 计算损失
- 反向传播
- 更新参数
mnist_net = MnistNet()
optimizer = optim.Adam(mnist_net.parameters(),lr= 0.001)
def train(epoch):mode = Truemnist_net.train(mode=mode) #模型设置为训练模型train_dataloader = get_dataloader(train=mode) #获取训练数据集for idx,(data,target) in enumerate(train_dataloader):optimizer.zero_grad() #梯度置为0output = 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()))
5. 模型的保存和加载
5.1 模型的保存
torch.save(mnist_net.state_dict(),"model/mnist_net.pt") #保存模型参数
torch.save(optimizer.state_dict(), 'results/mnist_optimizer.pt') #保存优化器参数
5.2 模型的加载
mnist_net.load_state_dict(torch.load("model/mnist_net.pt"))
optimizer.load_state_dict(torch.load("results/mnist_optimizer.pt"))
6. 模型的评估
评估的过程和训练的过程相似,但是:
- 不需要计算梯度
- 需要收集损失和准确率,用来计算平均损失和平均准确率
- 损失的计算和训练时候损失的计算方法相同
- 准确率的计算:
- 模型的输出为[batch_size,10]的形状
- 其中最大值的位置就是其预测的目标值(预测值进行过sotfmax后为概率,sotfmax中分母都是相同的,分子越大,概率越大)
- 最大值的位置获取的方法可以使用
torch.max
,返回最大值和最大值的位置 - 返回最大值的位置后,和真实值(
[batch_size]
)进行对比,相同表示预测成功
def test():test_loss = 0correct = 0mnist_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)))
7. 完整的代码如下:
import torch
from torch import nn
from torch import optim
import torch.nn.functional as F
import torchvisiontrain_batch_size = 64
test_batch_size = 1000
img_size = 28def get_dataloader(train=True):assert isinstance(train,bool),"train 必须是bool类型"#准备数据集,其中0.1307,0.3081为MNIST数据的均值和标准差,这样操作能够对其进行标准化#因为MNIST只有一个通道(黑白图片),所以元组中只有一个值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_sizedataloader = torch.utils.data.DataLoader(dataset,batch_size=batch_size,shuffle=True)return dataloaderclass 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 xreturn 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 = Truemnist_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 = 0correct = 0mnist_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(5): #模型训练5轮train(i)test()
深度学习笔记--pytorch从梯度下降到反向传播BP到线性回归实现,以及API调用和手写数据集的实现相关推荐
- 神经网络与深度学习笔记(三)python 实现反向传播算法
1.BP方程式 2.计算步骤 3.代码 def backprop(self, x, y): """Return a tuple "(nabla_b, nabla ...
- 深度学习的优化算法——梯度下降和随机梯度下降
深度学习的优化算法--梯度下降和随机梯度下降 优化算法在深度学习中存在的问题 优化在深度学习中有很多挑战,下面描述其中两个,局部最小值和鞍点. 1.局部最小值 深度学习模型的目标函数可能存在若干极点- ...
- 深度学习与计算机视觉教程(4) | 神经网络与反向传播(CV通关指南·完结)
作者:韩信子@ShowMeAI 教程地址:https://www.showmeai.tech/tutorials/37 本文地址:https://www.showmeai.tech/article-d ...
- 独家 | 数据科学家指南:梯度下降与反向传播算法
作者:Richmond Alake 翻译:陈之炎 校对:zrx本文约3300字,建议阅读5分钟 本文旨在为数据科学家提供一些基础知识,以理解在训练神经网络时所需调用的底层函数和方法. 标签:神经网络, ...
- 深度学习的数学-卷积神经网络的误差反向传播
文章目录 前言 正文 卷积神经网络中的关系式 卷积层 池化层 输出层 平方误差(损失函数) 梯度下降法 卷积层和输出层的神经单元误差(重点) 输出层的神经单元误差计算 输出层的神经单元与其权重偏置的关 ...
- 深度学习的数学-神经单元误差和反向传播
文章目录 前言 正文 神经单元误差 梯度下降算法在实际应用中的难点 神经单元误差的定义和含义 神经单元误差关于权重和偏置的偏导数(重点) 关于权重的偏导数推导 偏置的偏导数推导 公式一般化 误差反向传 ...
- 深度学习必备:随机梯度下降(SGD)优化算法及可视化
补充在前:实际上在我使用LSTM为流量基线建模时候,发现有效的激活函数是elu.relu.linear.prelu.leaky_relu.softplus,对应的梯度算法是adam.mom.rmspr ...
- 深度学习系列之随机梯度下降(SGD)优化算法及可视化
补充在前:实际上在我使用LSTM为流量基线建模时候,发现有效的激活函数是elu.relu.linear.prelu.leaky_relu.softplus,对应的梯度算法是adam.mom.rmspr ...
- 【深度学习】梯度下降和反向传播
声明:本博客只是小白博主自己的记录博客,仅供参考. 导数到底是什么? 引用知乎上的一个回答 那么导数的本质是什么?就是变化率呗,例如小王今年卖了100头猪,去年90头,前年80头,,,也就是说每年增加 ...
最新文章
- KoalaUI的DateTimePicker的若干问题解答
- python 12306查询不到车次_python实现自动抢12306火车票,妈妈再也不用担心我没有车回去了...
- jQuery实现文字向上滚动
- 大剑无锋之Kafka的Patition的作用【面试推荐】
- 电子商务应用课程知识整理 第一章-电子商务概述与类型
- 真正释放Maven和Java EE的强大功能
- SQLite数据库的特性
- 计算机关于word试题及答案,职称计算机考试Word操作试题及答案
- PDI(Kettle)加速插入数据的速度
- OpenCV-Python实战(18)——深度学习简介与入门示例
- 解决 Office 2007/2010 安装错误:1402 安装程序无法打开注册表项 UNKNOWN\Components\“随机数字”
- Win10屏幕自带的截图,同时保存多个截图
- 《艺技回忆录》 ——观《达芬奇的人生密码》有感
- linux工作区切换到桌面,linux切换桌面环境 gnome kde
- “知识付费”的分类及传播特征
- 2021年机器学习及R应用 陈强老师 应用于领域 经济管理 人文社科 医学卫生领域等
- 兼容低版本IE浏览器的一些技巧分享
- 解密android日志xlog,安卓开发技巧2:自定义日志工具类XLog的实现
- MySQL查询分析器EXPLAIN或DESC用法
- 新零售未来的发展趋势怎么样?