深度学习中的反向传播：PyTorch 实现与原理详解

最新推荐文章于 2025-08-24 21:33:16 发布

小王Jacky

最新推荐文章于 2025-08-24 21:33:16 发布

阅读量601

点赞数 17

CC 4.0 BY-SA版权

分类专栏：机器学习深度学习 python学习文章标签：深度学习 pytorch 人工智能 python

本文链接：https://blog.csdn.net/m0_49844997/article/details/150698854

python学习同时被 3 个专栏收录

10 篇文章

订阅专栏

深度学习

9 篇文章

订阅专栏

机器学习

8 篇文章

订阅专栏

深度学习中的反向传播：PyTorch 实现与原理详解

反向传播（Backward Propagation）是训练神经网络的核心算法，它通过计算损失函数对各参数的梯度，实现了参数的高效更新。理解反向传播的工作原理，是掌握深度学习的关键一步。本文将通过一段 PyTorch 代码，直观展示反向传播的实现过程，并深入解析其背后的数学原理和计算机制。

代码功能概述

让我们先看这段展示反向传播基本原理的代码：

# backward_propagation_example.py

# Import necessary libraries
import torch
from torch.autograd import Variable

def main():
    # Define the equation y = x^2
    array = [2, 4]
    tensor = torch.Tensor(array)
    x = Variable(tensor, requires_grad=True)
    y = x**2
    print(" y =  ", y)

    # Define o equation o = 1/2*sum(y)
    o = (1/2)*sum(y)
    print(" o =  ", o)

    # Perform backward propagation
    o.backward()  # calculates gradients

    # Print gradients
    print("gradients: ", x.grad)

if __name__ == "__main__":
    main()

这段代码通过一个简单的数学模型，演示了反向传播的完整过程：

定义输入变量 x 并构建计算图（y = x² 和 o = 1/2·sum(y)）
执行反向传播计算梯度
输出梯度结果，验证计算正确性

运行代码后，输出结果如下：

 y =   tensor([ 4., 16.], grad_fn=<PowBackward0>)
 o =   tensor(10., grad_fn=<MulBackward0>)
 gradients:  tensor([2., 4.])

这个结果展示了通过反向传播计算出的梯度值，我们将在后面详细解释这个结果的由来和意义。

代码逐行解析

1. 导入必要的库

import torch
from torch.autograd import Variable

import torch：导入 PyTorch 主库，提供张量操作和自动求导功能。
from torch.autograd import Variable：导入Variable类（在现代 PyTorch 中已与 Tensor 合并，但这里为了清晰展示梯度计算过程仍使用传统方式）。Variable用于包装张量并追踪所有操作，为自动求导提供支持。

2. 定义输入与计算图：`y = x²`

# Define the equation y = x^2
array = [2, 4]
tensor = torch.Tensor(array)
x = Variable(tensor, requires_grad=True)
y = x**2
print(" y =  ", y)

这部分代码定义了计算图的第一个环节：

array = [2, 4]：定义输入数据，这里使用两个数值 2 和 4 作为示例。
tensor = torch.Tensor(array)：将 Python 列表转换为 PyTorch 张量，得到张量 tensor([2., 4.])。
x = Variable(tensor, requires_grad=True)：将张量包装为Variable，并设置requires_grad=True，表示需要计算x的梯度（这是启用反向传播的关键）。
y = x**2：定义函数关系 y = x²，对x中的每个元素进行平方运算。对于输入[2, 4]，计算结果为[4, 16]。
打印结果中的grad_fn=<PowBackward0>表明，PyTorch 已记录该操作，为后续梯度计算做准备。

3. 定义目标函数：`o = 1/2·sum(y)`

# Define o equation o = 1/2*sum(y)
o = (1/2)*sum(y)
print(" o =  ", o)

这部分定义了最终的目标函数（可以理解为简单的损失函数）：

sum(y)：计算y中所有元素的和。对于y = [4, 16]，求和结果为20。
o = (1/2)*sum(y)：目标函数定义为求和结果的一半，计算得o = 10。
打印结果中的grad_fn=<MulBackward0>表明，这一乘法操作也被记录在计算图中。

4. 执行反向传播

# Perform backward propagation
o.backward()  # calculates gradients

这行代码是整个过程的核心，触发反向传播算法：

o.backward()：从目标函数o开始，沿着计算图反向传播，自动计算所有requires_grad=True的变量（这里即x）的梯度（导数）。
反向传播的本质是应用链式法则（Chain Rule），从最终输出开始，逐层计算对输入的导数。

5. 输出梯度结果

# Print gradients
print("gradients: ", x.grad)

这行代码输出计算得到的梯度：

x.grad：存储通过反向传播计算出的o对x的梯度值，结果为tensor([2., 4.])。
这个结果的数学意义是：o对x₁（值为 2）的导数为 2，o对x₂（值为 4）的导数为 4。

关键概念解析

1. 计算图（Computational Graph）

计算图是理解反向传播的基础，它是一种用节点和边表示数学运算的有向图：

节点：表示变量（如x、y、o）
边：表示变量之间的运算（如平方、求和、乘法）

我们代码中的计算图可以表示为：

x → [平方] → y → [求和] → sum(y) → [乘以1/2] → o

计算图的作用是：

前向传播（Forward Pass）：从输入x开始，沿着图的方向计算到输出o
反向传播（Backward Pass）：从输出o开始，逆着图的方向计算各变量的梯度

2. 梯度（Gradient）的数学意义

梯度本质上是多变量函数的导数，表示函数在某一点的变化率。在我们的例子中：

目标函数是 o = 1/2·(x₁² + x₂²)（因为y = x²且o = 1/2·sum(y)）
我们需要计算的是o对x₁和x₂的偏导数：
- ∂o/∂x₁ = ∂/∂x₁ [1/2·(x₁² + x₂²)] = x₁
- ∂o/∂x₂ = ∂/∂x₂ [1/2·(x₁² + x₂²)] = x₂

当x₁=2、x₂=4时，梯度为[2, 4]，这与代码输出的x.grad结果完全一致，验证了反向传播的正确性。

3. 反向传播的工作原理

反向传播通过链式法则实现梯度的高效计算，步骤如下：

前向传播：计算从输入x到输出o的所有中间变量（这里是y和sum(y)）
初始化梯度：输出o对自身的梯度为 1（∂o/∂o = 1）
反向遍历计算图：从o开始，按照链式法则计算每个变量的梯度：
- 计算o对sum(y)的梯度：∂o/∂sum(y) = 1/2
- 计算o对y的梯度：∂o/∂y = ∂o/∂sum(y) · ∂sum(y)/∂y = 1/2 · 1 = 1/2（对每个y_i）
- 计算o对x的梯度：∂o/∂x = ∂o/∂y · ∂y/∂x = 1/2 · 2x = x

这个过程展示了链式法则如何将复杂函数的梯度分解为简单步骤，使计算效率大幅提升。

4. `requires_grad`参数的作用

requires_grad是控制梯度计算的关键参数：

当设置为True时，PyTorch 会记录该变量的所有操作，为反向传播做准备
当设置为False时（默认值），该变量不参与梯度计算，适用于输入数据等不需要更新的量
在神经网络中，我们通常为权重和偏置设置requires_grad=True（需要更新），为输入数据和标签设置requires_grad=False（不需要更新）

5. 现代 PyTorch 中的写法

在 PyTorch 0.4.0 及以上版本中，Variable已与Tensor合并，无需显式使用Variable类。等效的现代写法如下：

import torch

def main():
    x = torch.tensor([2., 4.], requires_grad=True)  # 直接创建支持梯度的张量
    y = x**2
    o = (1/2) * torch.sum(y)  # 使用torch.sum更高效
    o.backward()
    print("gradients: ", x.grad)  # 结果相同：tensor([2., 4.])

if __name__ == "__main__":
    main()

这种写法更简洁，但背后的自动求导机制与使用Variable时完全一致。