神经网络反向传播算法-阿里云开发者社区

神经网络反向传播算法

2024-06-22 44

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： 神经网络中的反向传播算法是用于训练的关键步骤，通过计算损失函数梯度更新权重。它始于前向传播，即输入数据通过网络得出预测输出，接着计算预测与实际值的误差。反向传播利用链式法则从输出层开始逐层计算误差，更新每一层的权重和偏置。例如，一个包含隐藏层的网络，初始权重随机设定，通过反向传播计算损失函数梯度，如sigmoid激活函数的网络，调整权重以减小预测误差。在Python的PyTorch框架中，可以使用`nn.Linear`定义层，`optimizer`进行参数优化，通过`backward()`计算梯度，`step()`更新参数。

今天我们来看一下神经网络中的反向传播算法，之前介绍了梯度下降与正向传播~ 神经网络的反向传播

专栏：💎实战PyTorch💎

反向传播算法（Back Propagation，简称BP）是一种用于训练神经网络的算法。

反向传播算法是神经网络中非常重要的一个概念，它由Rumelhart、Hinton和Williams于1986年提出。这种算法基于梯度下降法来优化误差函数，利用了神经网络的层次结构来有效地计算梯度，从而更新网络中的权重和偏置。

基本工作流程：

通过正向传播得到误差，所谓正向传播指的是数据从输入到输出层，经过层层计算得到预测值，并利用损失函数得到预测值和真实值之前的误差。
通过反向传播把误差传递给模型的参数，从而对网络参数进行适当的调整，缩小预测值和真实值之间的误差。
反向传播算法是利用链式法则进行梯度求解，然后进行参数更新。对于复杂的复合函数，我们将其拆分为一系列的加减乘除或指数，对数，三角函数等初等函数，通过链式法则完成复合函数的求导。

我们通过一个例子来简单理解下 BP 算法进行网络参数更新的过程🧧：

如图我们在最下边输入两个维度的值进入神经网络：0.05、0.1 ，经过两个隐藏层(每层两个神经元)，每个神经元有两个值，左边为输入值，右边是经过激活函数后的输出值；经过这个神经网络后的输出值为：m1、m2，实际值为0.01、0.99 🌠

设置的初始权重w1，w2，...w8分别为0.15、0.20、0.25、0.30、0.30、0.35、0.55、0.60

我们通过计算得到损失函数Error = 1/2 ((m1- target1)2 + (m2 - target2)2) = 0.2988

w5和w7均可以通过求三次导来求梯度，而w1，w3则不能直接通过L降序求导，我们需要求从L到m1，m1到o1，o1到k1，k1到h1，h1到w1：

由于w1是输出两个方向分别到o1和o2，所以是两个方向的梯度求和~

我们也发现所以激活函数都是要可微的~

其他的网络参数更新过程和上面的求导过程是一样的，这里就不过多赘述，我们直接看一下代码。

反向传播代码

我们先来回顾一些Python中类的一些小细节：

🌈在Python中，使用super()函数可以调用父类的方法。这在子类中重写父类方法时非常有用，因为它允许你调用父类的实现，而不是完全覆盖它

class Parent:
    def __init__(self):
        print("Parent init")
 
class Child(Parent):
    def __init__(self):
        super().__init__()
        print("Child init")
 
c = Child()
 
# 输出
Parent init
Child init

🌈当我们创建一个Child类的实例时，它会首先调用Parent类的__init__方法（通过super().__init__()），然后执行Child类的__init__方法，与类的__init__方法（构造方法）对应的类关闭时自动调用的方法是__del__方法。对象不再被使用时，Python解释器会自动调用这个方法。通常在这个方法中进行一些清理工作，比如释放资源、关闭文件等。

反向传播实现

import torch
import torch.nn as nn
import torch.optim as optim
 
 
class Net(nn.Module):
 
    def __init__(self):
        super(Net, self).__init__()
        self.linear1 = nn.Linear(2, 2)
        self.linear2 = nn.Linear(2, 2)
 
        # 网络参数初始化w1/w2/w3/w4
        self.linear1.weight.data = torch.tensor([[0.15, 0.20], [0.25, 0.30]])
        # w5/w6/w7/w8
        self.linear2.weight.data = torch.tensor([[0.40, 0.45], [0.50, 0.55]])
        # 截距b
        self.linear1.bias.data = torch.tensor([0.35, 0.35])
        self.linear2.bias.data = torch.tensor([0.60, 0.60])
    # 定义前向传播的行径
    def forward(self, x):
 
        x = self.linear1(x)
        x = torch.sigmoid(x)
        x = self.linear2(x)
        x = torch.sigmoid(x)
 
        return x
 
 
if __name__ == '__main__':
 
    inputs = torch.tensor([[0.05, 0.10]])
    target = torch.tensor([[0.01, 0.99]])
 
    # 获得网络输出值
    net = Net()
    output = net(inputs)
    # print(output)  # tensor([[0.7514, 0.7729]], grad_fn=<SigmoidBackward>)
 
    # 计算误差
    loss = torch.sum((output - target) ** 2) / 2
    # print(loss)  # tensor(0.2984, grad_fn=<DivBackward0>)
 
    # 优化方法
    optimizer = optim.SGD(net.parameters(), lr=0.5)
 
    # 梯度清零
    optimizer.zero_grad()
 
    # 反向传播
    loss.backward()
 
    # 打印 w5、w7、w1 的梯度值
    print(net.linear1.weight.grad.data)
    # tensor([[0.0004, 0.0009],
    #         [0.0005, 0.0010]])
 
    print(net.linear2.weight.grad.data)
    # tensor([[ 0.0822,  0.0827],
    #         [-0.0226, -0.0227]])
 
    # 打印网络参数
    optimizer.step()
    print(net.state_dict())
    # OrderedDict([('linear1.weight', tensor([[0.1498, 0.1996], [0.2498, 0.2995]])),
    #              ('linear1.bias', tensor([0.3456, 0.3450])),
    #              ('linear2.weight', tensor([[0.3589, 0.4087], [0.5113, 0.5614]])),
    #              ('linear2.bias', tensor([0.5308, 0.6190]))])

optimizer.step() 相当于是将w和b所有参数更新一步的过程

🌈关于nn.Linear的使用

import torch
import torch.nn.functional as F
import torch.nn as nn
 
# 均匀分布随机初始化
 
linear = nn.Linear(5, 3)
# 从0-1均匀分布产生参数
nn.init.uniform_(linear.weight)
print(linear.weight.data)