深度学习|反向传播算法

最新推荐文章于 2024-08-15 09:37:39 发布

RRRRRoyal

最新推荐文章于 2024-08-15 09:37:39 发布

阅读量1.2k

点赞数 21

文章标签：深度学习算法人工智能

本文链接：https://blog.csdn.net/m0_73916791/article/details/134849691

版权

本文详细介绍了反向传播算法在深度学习中的核心作用，包括其理论基础、在PyTorch中的应用以及底层实现原理。重点讲解了神经网络结构、前向传播、梯度计算和权重更新的过程，并强调了理解链式法则对于深入学习的重要性。

摘要由CSDN通过智能技术生成

反向传播算法是深度学习中最核心的概念之一。它是一种有效的算法，用于计算神经网络中权重对损失函数的梯度。这个过程是神经网络学习过程的关键，因为这些梯度随后用于通过优化算法如梯度下降更新网络的权重，从而最小化损失函数。

理论基础

为了理解反向传播，我们需要理解以下几个重要概念：

神经网络架构：最基础的神经网络架构包括输入层、隐藏层和输出层。网络的每一层都由一系列的节点（称为神经元）组成。每个神经元都与下一层的每个神经元通过权重连接。
前向传播：输入数据通过网络的过程，从输入层通过隐藏层到输出层，并在每一层中生成激活值。
损失函数：用于评估模型预测与真实值之间的差异。
梯度：损失函数关于权重的导数，表明了权重改变时,损失函数增减的方向和大小。
链式法则：复合函数导数的计算方法，用于计算多层神经网络中权重对损失的梯度。

反向传播的步骤

在详细的实现之前，我们需要梳理一下反向传播的步骤：

前向传播：计算网络中所有神经元的输出和最终的损失值。
计算梯度：先对输出层的神经元计算梯度，然后反向通过网络，依次计算隐藏层的梯度。
权重更新：一旦我们得到梯度，我们就用这些梯度通过优化算法（如SGD）来更新网络的权重。

PyTorch简介

在深度学习框架PyTorch中，反向传播算法被封装得非常简洁。PyTorch提供了自动求导机制，这意味着我们不需要手动编写反向传播的代码，框架会自动计算梯度。

PyTorch反向传播的底层实现

尽管PyTorch为我们自动处理了细节，但了解底层的原理是很有帮助的。

假设我们有一个简单的全连接网络，有一个隐藏层，使用PyTorch代码可以这样表示：

import torch
import torch.nn as nn
import torch.optim as optim

# 一个简单的全连接网络，1个隐藏层
class SimpleNeuralNet(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(SimpleNeuralNet, self).__init__()
        self.layer1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.layer2 = nn.Linear(hidden_size, output_size)
        
    def forward(self, x):
        x = self.layer1(x)
        x = self.relu(x)
        x = self.layer2(x)
        return x

# 初始化网络
net = SimpleNeuralNet(input_size=3, hidden_size=5, output_size=1)
criterion = nn.MSELoss()  # 比如我们用MSE作为损失函数
optimizer = optim.SGD(net.parameters(), lr=0.01)  # 使用SGD优化器

# 假设我们有一些输入数据和目标数据
input_data = torch.randn(10, 3)
target = torch.randn(10, 1)

# 前向传播
outputs = net(input_data)
loss = criterion(outputs, target)

# 反向传播
optimizer.zero_grad()  # 清空过往梯度
loss.backward()  # 自动计算所有梯度

# 更新权重
optimizer.step()

在这个框架中，实际的反向传播算法的实现细节是隐藏的，因为当我们调用 loss.backward()，PyTorch将自动计算梯度，并且当我们调用 optimizer.step()，权重将自动更新。

底层的反向传播

如果我们想了解底层是如何计算的，我们需要手动实现前向传播和反向传播。以下是一个高度简化的例子，说明了这个过程：

import torch

# 假设我们的网络只有一个权重矩阵W，没有偏置，激活函数，损失函数是MSE
# 初始化权重
W = torch.randn(2, 2, requires_grad=True)

# 输入数据和目标数据
x = torch.tensor([[1.0, 2.0]], requires_grad=True)
target = torch.tensor([[0.0]])

# 前向传播
y_pred = x.mm(W)
loss = (y_pred - target).pow(2).sum()

# 手动反向传播
# 计算损失关于W的梯度
loss.backward()

print(W.grad)  # 查看W的梯度

# 更新权重，这里我们手动设置一个学习率
learning_rate = 0.01
with torch.no_grad():  # 不追踪这些操作的梯度
    W -= learning_rate * W.grad

# 清空梯度，为下一轮学习准备
W.grad.zero_()