NNDL 作业四

最新推荐文章于 2024-09-13 20:20:44 发布

02（网络界泥石流）

最新推荐文章于 2024-09-13 20:20:44 发布

阅读量49

点赞数 1

文章标签： python

本文链接：https://blog.csdn.net/m0_63591032/article/details/133838503

版权

作业

一、过程推导 - 了解BP原理
二、数值计算 - 手动计算，掌握细节
三、代码实现 - numpy手推 + pytorch自动
1.对比【numpy】和【pytorch】程序，总结并陈述。
2.激活函数Sigmoid用PyTorch自带函数torch.sigmoid()，观察、总结并陈述。
3.激活函数Sigmoid改变为Relu，观察、总结并陈述。
4.损失函数MSE用PyTorch自带函数 t.nn.MSELoss()替代，观察、总结并陈述。
待解决的问题
5.损失函数MSE改变为交叉熵，观察、总结并陈述。
6.改变步长，训练次数，观察、总结并陈述。
7.权值w1-w8初始值换为随机数，对比“指定权值”的结果，观察、总结并陈述。
8.权值w1-w8初始值换为0，观察、总结并陈述。
9.全面总结反向传播原理和编码实现，认真写心得体会。

一、过程推导 - 了解BP原理--数值计算 - 手动计算，掌握细节

BP是一种通过反向传播算法训练神经网络的方法，下面是用数学公式表达BP原理的推导过程：
设有一个包含n个神经元的神经网络，输入层有m个神经元，隐藏层有l个神经元，输出层有k个神经元。假设神经网络中有wij表示从第j个神经元到第i个神经元的权重，bi表示第i个神经元的偏置，ai表示第i个神经元的激活值，σ表示激活函数，xj表示第j个神经元的输入，oi表示第i个神经元的输出，y表示网络的输出。则，神经网络的输入为：x = [x1, x2, . . . , xm]T
网络的输出为：y = [y1, y2, . . . , yk]T
对于给定的输入数据，网络的输出可以表示为：
o = sigmoid(Wx + b)
其中，W=[w1,w2,...,wn]∈Rl×m，b=[b1,b2,...,bn]∈Rl。
现在我们考虑如何训练网络的参数，即权重和偏置。为了简化起见，我们使用平方误差作为损失函数，即：E = 12(y−o)T(y−o)
其中，y^是期望的输出。
我们使用梯度下降算法来最小化损失函数，即：
ΔW = −∂E∂W=−(σ(Wx+b)−y)xT
Δb = −∂E∂b=−(σ(Wx+b)−y)
其中，ΔW∈Rl×m和Δb∈Rl分别表示权重和偏置的变化量。
通过求解偏导数并将其应用于权重和偏置的更新，我们可以得到：
ΔW = xT(σ(Wx+b)−y)
Δb = (σ(Wx+b)−y)
使用小批量梯度下降算法，我们可以将损失函数表示为：
E = 12m−1∑m−1i=1(y(i)−o(i))T(y(i)−o(i))
其中，m是每个小批次中的样本数。
因此，我们可以得到：
ΔW = 1m∑m−1i=1x(i)T(σ(Wx(i)+b)−y(i))
Δb = 1m∑m−1i=1(σ(Wx(i)+b)−y(i))
通过迭代更新权重和偏置，我们可以逐渐降低损失函数的值并提高网络的准确性。

二、代码实现 - numpy手推 + pytorch自动

1.对比【numpy】和【pytorch】程序，总结并陈述。

numpy程序实现

import numpy as np

w1,w2,w3,w4,w5,w6,w7,w8=0.2, -0.4, 0.5, 0.6, 0.1, -0.5, -0.3, 0.8
x1,x2=0.5,0.3
y1,y2=0.23,-0.07

#sigmoid激活函数
def sigmoid(X):
    result=1/(1+np.exp(-X))
    return result
#前向传播
def Forward_propagation(x1, x2, y1, y2, w1, w2, w3, w4, w5, w6, w7, w8):
    h1=x2*w3+x1*w1
    h2=x1*w2+x2*w4
    outh1=sigmoid(h1)#激活
    outh2=sigmoid(h2)
    o1=outh2*w7+outh1*w5#激活
    o2=outh1*w6+outh2*w8
    outo1=sigmoid(o1)
    outo2=sigmoid(o2)
    error=(1/2)*(outo1-y1)**2+(1/2)*(outo2-y2)**2
    print("前向传播_隐藏层h1,h2:",round(outh1, 5), round(outh2, 5))
    print("前向传播_预测值o1,o2:",round(outo1, 5), round(outo2, 5))
    print("损失函数：", round(error, 5))
    return outo1, outo2, outh1, outh2
#反向传播并参数更新
def back_propagate(outo1, outo2, outh1, outh2,w1, w2, w3, w4, w5, w6, w7, w8):
    step = 1
    do1 = outo1-y1
    do2=outo2-y2
    dw5 = do1 * outo1 * (1 - outo1) * outh1
    dw7 = do1 * outo1 * (1 - outo1) * outh2
    dw6 = do2 * outo2 * (1 - outo2) * outh1
    dw8 = do2 * outo2 * (1 - outo2) * outh2
    dw1 = (do1 * outh1 * (1 - outh1) * w5 + do2 * outo2 * (1 - outo2) * w6) * outh1 * (1 - outh1) * x1
    dw3 = (do1 * outh1 * (1 - outh1) * w5 + do2 * outo2 * (1 - outo2) * w6) * outh1 * (1 - outh1) * x2
    dw2 = (do1 * outh1 * (1 - outh1) * w7 + do2 * outo2 * (1 - outo2) * w8) * outh2 * (1 - outh2) * x1
    dw4 = (do1 * outh1 * (1 - outh1) * w7 + do2 * outo2 * (1 - outo2) * w8) * outh2 * (1 - outh2) * x2
    print("w的梯度：",round(dw1, 2), round(dw2, 2), round(dw3, 2), round(dw4, 2), round(dw5, 2), round(dw6, 2),round(dw7, 2), round(dw8, 2))
    w1 = w1-step*dw1
    w2 = w2-step*dw2
    w3 = w3-step*dw3
    w4 = w4-step*dw4
    w5 = w5-step*dw5
    w6 = w6-step*dw6
    w7 = w7-step*dw7
    w8 = w8-step*dw8
    return w1, w2, w3, w4, w5, w6, w7, w8,dw1,dw2,dw3,dw4,dw5,dw6,dw7,dw8
if __name__ == "__main__":
    print("权值w0-w7:", round(w1, 2), round(w2, 2), round(w3, 2), round(w4, 2), round(w5, 2), round(w6, 2),round(w7, 2),round(w8, 2))
    for i in range(100):
        print("=====第" + str(i + 1) + "轮=====")
        outo1, outo2, outh1, outh2 = Forward_propagation(x1, x2, y1, y2, w1, w2, w3, w4, w5, w6, w7, w8)
        w1, w2, w3, w4, w5, w6, w7, w8,dw1, dw2, dw3, dw4, dw5, dw6, dw7, dw8 = back_propagate(outo1, outo2, outh1, outh2,1, w2, w3, w4, w5, w6, w7, w8)
    print("更新后的权值w:", round(w1, 2), round(w2, 2), round(w3, 2), round(w4, 2), round(w5, 2), round(w6, 2), round(w7, 2),round(w8, 2))

pytorch实现

import torch

# 定义输入输出数据
x = torch.tensor([0.5, 0.3])
y = torch.tensor([0.23, -0.07])

print(f"输入值 x0, x1: {x[0]}, {x[1]}")
print(f"输出值 y0, y1: {y[0]}, {y[1]}")

# 定义模型参数
w = [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)]
for param in w:
    param.requires_grad = True
print("权值w0-w7:")
for param in w:
    print(param.data, end=" ")
# 定义前向传播过程
def forward(x):
    h1 = torch.sigmoid(w[0] * x[0] + w[2] * x[1])
    h2 = torch.sigmoid(w[1] * x[0] + w[3] * x[1])
    o1 = torch.sigmoid(w[4] * h1 + w[6] * h2)
    o2 = torch.sigmoid(w[5] * h1 + w[7] * h2)
    print(f"\n正向计算,隐藏层h1, h2: {h1.data}, {h2.data}")
    print(f"正向计算,预测值o1, o2: {o1.data}, {o2.data}")
    return o1, o2
# 定义损失函数
def loss_fn(x, y):
    y_pred = forward(x)
    loss = 0.5 * (y_pred[0] - y[0]) ** 2 + 0.5 * (y_pred[1] - y[1]) ** 2
    print(f"\n损失函数(均方误差): {loss.item()}")
    return loss
# 主训练循环
for k in range(1):
    print(f"\n=====第{k + 1}轮训练=====")
    loss = loss_fn(x, y)
    loss.backward()
    print("w的梯度: ", end=" ")
    for param in w:
        print(round(param.grad.item(), 2), end=" ")
    step = 1
    for param in w:
        param.data -= step * param.grad.data
        param.grad.data.zero_()
    print("\n更新后的权值w: ")
    for param in w:
        print(param.data, end=" ")

numpy结果

10轮测试结果：

100轮测试结果：

1000轮测试结果：

pytorch结果

10轮测试结果：

100轮测试结果：

1000轮测试结果：

2.激活函数Sigmoid用PyTorch自带函数torch.sigmoid()，观察、总结并陈述。

从上图的运算结果中对比：在十轮训练时略有差异，但到一百轮与一千轮训练时，差异不断减小，torch.sigmoid()精度更高一些。

3.激活函数Sigmoid改变为Relu，观察、总结并陈述。

改为Relu激活函数后

def Relu(X):
    result=max(0,X)
    return result

10轮测试结果：

100轮测试结果：

1000轮测试结果：

和sigmoid函数形成对比的是，均方误差在前十轮里迅速降了下来，运算速度比sigmoid快。并且解决了sigmoid函数中梯度消失的问题

4.损失函数MSE用PyTorch自带函数 t.nn.MSELoss()替代，观察、总结并陈述。

def loss_fuction(x1, x2, y1, y2):
    s, l = forward(x[0],x[1])
    t = torch.nn.MSELoss()
    loss = t(s,y[0]) + (l,y[1])
    print("损失函数（交叉熵）：", loss.item())
    return loss

10轮测试：

100轮测试：

1000轮测试：

待解决的问题

torch.nn.MSELoss不能在源程序直接替换使用，要报错，这里参考一些其余文章改动即可

5.损失函数MSE改变为交叉熵，观察、总结并陈述。

def loss_fuction(x1, x2, y1, y2):
    m1, m2= forward(x[0], x[1])
    loss_func = torch.nn.CrossEntropyLoss()
    s = torch.stack([m1, m2], dim=1)
    l= torch.stack([y[0], y[1]], dim=1)
    loss = loss_func(s, l)
    print("损失函数（交叉熵）：", loss.item())
    return loss

结果