使用Pytorch复现课上例题
对比【作业3】和【作业2】的程序,观察两种方法结果是否相同?如果不同,哪个正确?
【作业2】程序更新(保留【作业2中】的错误答案,留作对比。新程序到作业3。)
对比【作业2】与【作业3】的反向传播的实现方法。总结并陈述。
激活函数Sigmoid用PyTorch自带函数torch.sigmoid(),观察、总结并陈述
激活函数Sigmoid改变为Relu,观察、总结并陈述。
损失函数MSE用PyTorch自带函数 t.nn.MSELoss()替代,观察、总结并陈述。
损失函数MSE改变为交叉熵,观察、总结并陈述。
改变步长,训练次数,观察、总结并陈述。
权值w1-w8初始值换为随机数,对比【作业2】指定权值结果,观察、总结并陈述。
全面总结反向传播原理和编码实现,认真写心得体会。
1.使用Pytorch复现课上例题
import torch
x1, x2 = torch.Tensor([0.5]), torch.Tensor([0.3])
y1, y2 = torch.Tensor([0.23]), torch.Tensor([-0.07])
print("=====输入值:x1, x2;真实输出值:y1, y2=====")
print(x1, x2, y1, y2)
w1, w2, w3, w4, w5, w6, w7, w8 = torch.Tensor([0.2]), torch.Tensor([-0.4]), torch.Tensor([0.5]), torch.Tensor(
[0.6]), torch.Tensor([0.1]), torch.Tensor([-0.5]), torch.Tensor([-0.3]), torch.Tensor([0.8]) # 权重初始值
w1.requires_grad = True
w2.requires_grad = True
w3.requires_grad = True
w4.requires_grad = True
w5.requires_grad = True
w6.requires_grad = True
w7.requires_grad = True
w8.requires_grad = True
def sigmoid(z):
a = 1 / (1 + torch.exp(-z))
return a
def forward_propagate(x1, x2):
in_h1 = w1 * x1 + w3 * x2
out_h1 = sigmoid(in_h1) # out_h1 = torch.sigmoid(in_h1)
in_h2 = w2 * x1 + w4 * x2
out_h2 = sigmoid(in_h2) # out_h2 = torch.sigmoid(in_h2)
in_o1 = w5 * out_h1 + w7 * out_h2
out_o1 = sigmoid(in_o1) # out_o1 = torch.sigmoid(in_o1)
in_o2 = w6 * out_h1 + w8 * out_h2
out_o2 = sigmoid(in_o2) # out_o2 = torch.sigmoid(in_o2)
print("正向计算:o1 ,o2")
print(out_o1.data, out_o2.data)
return out_o1, out_o2
def loss_fuction(x1, x2, y1, y2): # 损失函数
y1_pred, y2_pred = forward_propagate(x1, x2) # 前向传播
loss = (1 / 2) * (y1_pred - y1) ** 2 + (1 / 2) * (y2_pred - y2) ** 2 # 考虑 : t.nn.MSELoss()
print("损失函数(均方误差):", loss.item())
return loss
def update_w(w1, w2, w3, w4, w5, w6, w7, w8):
# 步长
step = 1
w1.data = w1.data - step * w1.grad.data
w2.data = w2.data - step * w2.grad.data
w3.data = w3.data - step * w3.grad.data
w4.data = w4.data - step * w4.grad.data
w5.data = w5.data - step * w5.grad.data
w6.data = w6.data - step * w6.grad.data
w7.data = w7.data - step * w7.grad.data
w8.data = w8.data - step * w8.grad.data
w1.grad.data.zero_() # 注意:将w中所有梯度清零
w2.grad.data.zero_()
w3.grad.data.zero_()
w4.grad.data.zero_()
w5.grad.data.zero_()
w6.grad.data.zero_()
w7.grad.data.zero_()
w8.grad.data.zero_()
return w1, w2, w3, w4, w5, w6, w7, w8
if __name__ == "__main__":
print("=====更新前的权值=====")
print(w1.data, w2.data, w3.data, w4.data, w5.data, w6.data, w7.data, w8.data)
for i in range(1):
print("=====第" + str(i) + "轮=====")
L = loss_fuction(x1, x2, y1, y2) # 前向传播,求 Loss,构建计算图
L.backward() # 自动求梯度,不需要人工编程实现。反向传播,求出计算图中所有梯度存入w中
print("\tgrad W: ", round(w1.grad.item(), 2), round(w2.grad.item(), 2), round(w3.grad.item(), 2),
round(w4.grad.item(), 2), round(w5.grad.item(), 2), round(w6.grad.item(), 2), round(w7.grad.item(), 2),
round(w8.grad.item(), 2))
w1, w2, w3, w4, w5, w6, w7, w8 = update_w(w1, w2, w3, w4, w5, w6, w7, w8)
print("更新后的权值")
print(w1.data, w2.data, w3.data, w4.data, w5.data, w6.data, w7.data, w8.data)
运行结果如下:
2.对比【作业3】和【作业2】的程序,观察两种方法结果是否相同?如果不同,哪个正确?
首先给出作业二的运行结果如下:
可以发现结果不一样,经过分析,作业二中的梯度计算函数和作业三中的 并不一样。因为作业三中的使用了pytorch自带的back_propagate,是正确的,而作业二中的结果就不对了。
3.【作业2】程序更新
经分析,作业二中mooc上对w1~w4的计算发生错误,因此应做出修改。
修改后代码:
def back_propagate(out_o1, out_o2, out_h1, out_h2):
# 反向传播
d_o1 = out_o1 - y1
d_o2 = out_o2 - y2
d_w5 = d_o1 * out_o1 * (1 - out_o1) * out_h1
d_w7 = d_o1 * out_o1 * (1 - out_o1) * out_h2
d_w6 = d_o2 * out_o2 * (1 - out_o2) * out_h1
d_w8 = d_o2 * out_o2 * (1 - out_o2) * out_h2
d_w1 = (d_o1 * out_h1 * (1 - out_h1) * w5 + d_o2 * out_o2 * (1 - out_o2) * w6) * out_h1 * (1 - out_h1) * x1
d_w3 = (d_o1 * out_h1 * (1 - out_h1) * w5 + d_o2 * out_o2 * (1 - out_o2) * w6) * out_h1 * (1 - out_h1) * x2
d_w2 = (d_o1 * out_h1 * (1 - out_h1) * w7 + d_o2 * out_o2 * (1 - out_o2) * w8) * out_h2 * (1 - out_h2) * x1
d_w4 = (d_o1 * out_h1 * (1 - out_h1) * w7 + d_o2 * out_o2 * (1 - out_o2) * w8) * out_h2 * (1 - out_h2) * x2
print("w的梯度:",round(d_w1, 2), round(d_w2, 2), round(d_w3, 2), round(d_w4, 2), round(d_w5, 2), round(d_w6, 2),
round(d_w7, 2), round(d_w8, 2))
return d_w1, d_w2, d_w3, d_w4, d_w5, d_w6, d_w7, d_w8
参考的指导公式见下图,mooc上最后一步推导时出现错误,所以我们使用倒数第二步的结果进行下一步计算。
修改后再次运行程序,结果与作业三运行结果结果相同
4.对比【作业2】与【作业3】的反向传播的实现方法。总结并陈述。
作业2中的方法通过手动计算,得到反向传播过程中各参数梯度;
作业3通过张量Tensor求Loss,构建计算图,在最后通过backword()自动求梯度。由于使用了Pytorch当中的Tensor张量,使用前向传播建立计算图,即可根据传播结果利用back_propagate
自动计算梯度。激活函数使用Pytorch自带的torch.sigmoid()
在此我们小小总结一下。
反向传播算法的精髓就是就是采用梯度下降(grediant decent)的算法进行模型参数更新;梯度下降本质就是用目标方程对模型参数求偏导运算,得到的结果再与学习率(learing rate,通常小于1)相乘,再乘以负1,整个结果加上模型初始化或者前一迭代步骤更新后的模型的参数,我们这样就完成了参数的更新,从模型层面讲,完成了模型训练。当然,对于损失函数的处理,也可采用牛顿法或类牛顿法,但最为常见,应用最广仍旧是梯度下降算法
可以参看这篇文章,对我们课程内容的补充很详细。模型训练与测试---梯度下降与牛顿法与优化器与反向传播 ·1.
里边很多内容我也只是一知半解,希望在继续学习之后能慢慢理解其中的内容。
5.激活函数Sigmoid用PyTorch自带函数torch.sigmoid(),观察、总结并陈述。
原来的激活函数:
def sigmoid(z):
a = 1 (1 + torch.exp(-z))
return a
使用PyTorch自带的激活函数:
def sigmoid(z):
return torch.sigmoid(z)
自带的函数易于求导,但是在计算量方面有点繁琐。
二者时间效率不同。经查询资料,了解了很多pytorch自带函数,在PyTorch中,我们可以随心所欲地定义模型——不必在代码中保留占位符。这就是为什么PyTorch框架是动态的原因。经过对比,发现自带函数时间效率高低需要逐个测试,可参见:PyTorch教程(5)激活函数。
6.激活函数Sigmoid改变为Relu,观察、总结并陈述。
在数据挖掘和分析中,专业人员经常使用sigmoid函数,因为它更容易解释和实现。它是一个非线性函数。当我们将权值从神经网络的输入层传递到隐含层时,我们希望我们的模型能够捕获数据中呈现的所有非线性;因此,建议在神经网络的隐层中使用sigmoid函数。非线性函数有助于泛化数据集。用非线性函数计算函数的梯度比较容易。
sigmoid函数是一种特殊的非线性激活函数。sigmoid函数的输出总是限制在0和1之内;因此,它主要用于执行基于分类的任务。sigmoid函数的局限性之一是它可能会陷入局部极小值。这样做的好处是,它提供了属于这类的可能性。下面是它的方程。
ReLU函数是目前比较火的一个激活函数,函数公式:,函数图像如下
相比sigmod函数与tanh函数有以下几个优点
1)克服梯度消失的问题
2)加快训练速度
注:正因为克服了梯度消失问题,训练才会快
缺点:
1)输入负数,则完全不激活,ReLU函数无法继续运行。
2)ReLU函数输出要么是0,要么是正数,也就是ReLU函数不是以0为中心的函数
深度学习中最大的问题是梯度消失问题,使用tanh、sigmod等饱和激活函数情况下特别严重(神经网络在进行方向误差传播时,各个层都要乘以激活函数的一阶导数,梯度每传递一层就会衰减一层,网络层数较多时,梯度G就会不停衰减直到消失),使得训练网络收敛越来越慢,而ReLU函数凭借其线性、非饱和的形式,训练速度则快很多。
7.损失函数MSE用PyTorch自带函数 t.nn.MSELoss()替代,观察、总结并陈述。
loss_func = torch.nn.MSELoss() #自带函数
y_pred = torch.cat((y1_pred, y2_pred), dim=0)
y = torch.cat((y1, y2), dim=0)
loss = loss_func(y_pred, y)
nn.MSELoss()参数介绍
(1)如果 reduction = ‘none’,直接返回向量形式的 loss
(2)如果 reduction ≠ ‘none’,那么 loss 返回的是标量
a)如果 reduction=‘mean’,返回 loss.mean(); 注意:默认情况下, reduction=‘mean’
b)如果 reduction=‘sum’,返回 loss.sum();
我测试感觉差别不大。
8.损失函数MSE改变为交叉熵,观察、总结并陈述。
def loss_fuction(x1, x2, y1, y2):
y1_pred, y2_pred = forward_propagate(x1, x2)
loss_func = torch.nn.CrossEntropyLoss() # 创建交叉熵损失函数
y_pred = torch.stack([y1_pred, y2_pred], dim=1)
y = torch.stack([y1, y2], dim=1)
loss = loss_func(y_pred, y) # 计算
print("损失函数(均方误差):", loss.item())
return loss
1、均值平方差(MSE):指参数估计值与参数真实值之差平方的期望值。
在神经网络计算时,预测值要与真实值控制在同样的数据分布内,假设将预测值经过Sigmoid激活函数得到取值范围在0~1之间,那么真实值也归一化到0~1之间。
2、交叉熵:预测输入样本属于某一类的概率。
其中y代表真实值分类(0或1),a代表预测值,交叉熵值越小,预测结果越准。
9.改变步长,训练次数,观察、总结并陈述。
=====第999轮=====
正向计算:o1 ,o2
tensor([0.2296]) tensor([0.0098])
损失函数(均方误差): 0.003185197012498975
grad W: -0.0 -0.0 -0.0 -0.0 -0.0 0.0 -0.0 0.0
更新后的权值
tensor([1.6515]) tensor([0.1770]) tensor([1.3709]) tensor([0.9462]) tensor([-0.7798]) tensor([-4.2741]) tensor([-1.0236]) tensor([-2.1999])
=====第999轮=====
正向计算:o1 ,o2
tensor([0.2299]) tensor([0.0020])
损失函数(均方误差): 0.002591301454231143
grad W: -0.0 -0.0 -0.0 -0.0 -0.0 0.0 -0.0 0.0
更新后的权值
tensor([2.0871]) tensor([0.5032]) tensor([1.6323]) tensor([1.1419]) tensor([-0.7079]) tensor([-5.2478]) tensor([-0.9722]) tensor([-2.9524])
=====第999轮=====
正向计算:o1 ,o2
tensor([0.2389]) tensor([0.0001])
损失函数(均方误差): 0.0024988993536680937
grad W: -0.0 -0.0 -0.0 -0.0 0.0 0.0 0.0 0.0
更新后的权值
tensor([1.1752]) tensor([-1.9685]) tensor([1.0851]) tensor([-0.3411]) tensor([-0.9945]) tensor([-10.1541]) tensor([-2.1901]) tensor([-7.0080])
10.权值w1-w8初始值换为随机数,对比【作业2】指定权值结果,观察、总结并陈述。
随机生成权值:
w1, w2, w3, w4, w5, w6, w7, w8 = torch.rand(1, 1), torch.rand(1, 1), torch.rand(1, 1), torch.rand(1, 1), torch.rand(1, 1), torch.rand(1, 1), torch.rand(1, 1), torch.rand(1, 1) # 权重初始值
观测结果,前后存在差别,但大部分参数改变不大。
11.全面总结反向传播原理和编码实现,认真写心得体会。
反向传播算法是训练神经网络的经典算法,是深度学习的最重要的基础,适合于多层神经元网络的一种学习算法,它建立在梯度下降法的基础上,通过迭代的方法求出目标损失函数(loss function)的近似最小值。
在参数选择时,只通过直觉无法判断怎样选取最优参数。我个人选择多次选取相近数据,逐步找到规律。反向传播不同于一般的数学规律,必须要反复尝试。