[源码解析]深度学习利器之自动微分(3) --- 示例解读

2021-10-20 11:47:10 浏览数 (1)

​

0x00 摘要

本文从 PyTorch 两篇官方文档开始为大家解读两个示例。本文不会逐句翻译，而是选取重点并且试图加入自己的理解。

我们在前两篇文章学习了自动微分的基本概念，从本文开始，我们继续分析 PyTorch 如何实现自动微分。因为涉及内容太多太复杂，所以计划使用 2～3篇来介绍前向传播如何实现，用 3 ～ 4 篇来介绍后向传播如何实现。

系列前两篇连接如下：

深度学习利器之自动微分(1)

深度学习利器之自动微分(2)

0x01 概述

在训练神经网络时，最常用的算法是 反向传播。在该算法中根据损失函数相对于给定参数的梯度来对参数（模型权重）进行调整。为了计算这些梯度，PyTorch 实现了一个名为 torch.autograd的内置反向自动微分引擎。它支持任何计算图的梯度自动计算。

1.1 编码历史

从概念上讲，autograd 记录了一个计算图。在创建张量时，如果设置 requires_grad 为Ture，那么 Pytorch 就知道需要对该张量进行自动求导。于是PyTorch会记录对该张量的每一步操作历史，从而生成一个概念上的有向无环图，该无环图的叶子节点是模型的输入张量，其根为模型的输出张量。用户不需要对图的所有执行路径进行编码，因为用户运行的就是用户后来想微分的。通过从根到叶跟踪此图形，用户可以使用链式求导规则来自动计算梯度。

在内部实现上看，autograd 将此图表示为一个“Function” 或者说是"Node" 对象（真正的表达式）的图，该图可以使用apply方法来进行求值。

1.2 如何应用

在前向传播计算时，autograd做如下操作：

  • 运行请求的操作以计算结果张量。
  • 建立一个计算梯度的DAG图，在DAG图中维护所有已执行操作（包括操作的梯度函数以及由此产生的新张量）的记录 。每个tensor梯度计算的具体方法存放于tensor节点的grad_fn属性中。

当向前传播完成之后，我们通过在在 DAG 根上调用.backward() 来执行后向传播，autograd会做如下操作：

  • 利用.grad_fn计算每个张量的梯度，并且依据此构建出包含梯度计算方法的反向传播计算图。
  • 将梯度累积在各自的张量.grad属性中，并且使用链式法则，一直传播到叶张量。
  • 每次迭代都会重新创建计算图，这使得我们可以使用Python代码在每次迭代中更改计算图的形状和大小。

需要注意是，PyTorch 中 的DAG 是动态的，每次 .backward()调用后，autograd 开始填充新计算图，该图是从头开始重新创建。这使得我们可以使用Python代码在每次迭代中更改计算图的形状和大小。

0x02 示例

下面我们通过两个例子来进行解读，之所以使用两个例子，因为均来自于PyTorch 官方文档。

2.2 实例解读 1

我们首先使用 https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html 来进行演示和解读。

2.2.1 代码

示例代码如下：

代码语言：javascript复制
import torch

a = torch.tensor(2., requires_grad=True)
b = torch.tensor(6., requires_grad=True)
O = 3*a**3
P = b**2
Q = O - P
external_grad = torch.tensor(1.)
Q.backward(gradient=external_grad)
print(a.grad)
print(b.grad)

print("=========== grad")

a = torch.tensor(2., requires_grad=True)
b = torch.tensor(6., requires_grad=True)
Q = 3*a**3 - b**2
grads = torch.autograd.grad(Q, [a, b])
print(grads[0])
print(grads[1])

print(Q.grad_fn.next_functions)
print(O.grad_fn.next_functions)
print(P.grad_fn.next_functions)
print(a.grad_fn)
print(b.grad_fn)

输出为：

代码语言：javascript复制
tensor(36.)
tensor(-12.)
=========== grad
tensor(36.)
tensor(-12.)

((<MulBackward0 object at 0x000001374DE6C308>, 0), (<PowBackward0 object at 0x000001374DE6C288>, 0))
((<PowBackward0 object at 0x000001374DE6C288>, 0), (None, 0))
((<AccumulateGrad object at 0x000001374DE6C6C8>, 0),)
None
None

这里的Q运算方式如下：

[Q = 3a^3 - b^2 ]

因此Q对a, b 的求导如下：

[frac{∂Q}{∂a} = 9a^2 \frac{∂Q}{∂b} = -2b ]

2.2.2 分析

动态图是在前向传播的时候建立。前向传播时候，Q是最终的输出，但是在反向传播的时候，Q 却是计算的最初输入，就是反向传播图的Root。

示例中，对应的张量是：

  • a 是 2，b 是 6， Q 是 tensor(-12., grad_fn=<SubBackward0>)。

对应的积分是：

  • Q对于 a 的积分是：
frac{∂Q}{∂a} = 9a^2

= 36。

  • Q对于b的积分是
frac{∂Q}{∂b} = -2b

= -12。

当我们调用.backward()时，backward()只是通过将其参数传递给已经生成的反向图来计算梯度。autograd 计算这些梯度并将它们存储在各自的张量.grad属性中。

我们需要显式地给Q.backward()传入一个gradient参数，因为它是一个向量。 gradient是与 形状相同的张量Q，它表示 Q 本身的梯度，即

[frac{∂Q}{∂Q} = 1 ]

等效地，我们也可以将 Q 聚合为一个标量并隐式地向后调用，例如Q.sum().backward()。

代码语言：javascript复制
external_grad = torch.tensor([1., 1.])
Q.backward(gradient=external_grad)

下面是我们示例中 DAG 的可视化表示。在图中，箭头指向前向传递的方向。节点代表前向传递中每个操作的后向函数。蓝色的叶子节点代表我们的叶子张量a和b。

2.3 实例解读 2

这次以https://pytorch.org/tutorials/beginner/basics/autogradqs_tutorial.html为例子说明。

2.3.1 示例代码

考虑最简单的一层神经网络，具有输入x、参数w和b，以及一些损失函数。它可以通过以下方式在 PyTorch 中定义：

代码语言：javascript复制
import torch

x = torch.ones(5)  # input tensor
y = torch.zeros(3)  # expected output
w = torch.randn(5, 3, requires_grad=True)
b = torch.randn(3, requires_grad=True)
z = torch.matmul(x, w) b
loss = torch.nn.functional.binary_cross_entropy_with_logits(z, y)
2.3.2 张量、函数和计算图

上述代码定义了以下计算图：

图片来源是：https://pytorch.org/tutorials/_images/comp-graph.png

在这个网络中，w和b是我们需要优化的参数。因此，我们需要计算关于这些变量的损失函数的梯度。为了做到这一点，我们设置了这些张量的requires_grad属性。

注意，您可以在创建张量时设置requires_grad的值，也可以稍后使用x.requires_grad_(True)方法设置。

我们应用于张量来构建计算图的函数实际上是一个Function类的对象。该对象知道如何在前向计算函数，以及如何在反向传播步骤中计算其导数。对反向传播函数的引用存储在grad_fn张量的属性中。

代码语言：javascript复制
print('Gradient function for z =', z.grad_fn)
print('Gradient function for loss =', loss.grad_fn)

输出如下：

代码语言：javascript复制
Gradient function for z = <AddBackward0 object at 0x7f4dbd4d3080>
Gradient function for loss = <BinaryCrossEntropyWithLogitsBackward object at 0x7f4dbd4d3080>
2.3.3 计算梯度

为了优化神经网络中参数的权重，我们需要计算损失函数关于参数的导数，即我们需要在限定一些 x和y时候得到 frac{partial loss}{partial w} 和 frac{partial loss}{partial b} 。为了计算这些导数，我们调用 loss.backward()，然后从w.grad和 b.grad 之中获得数值：

代码语言：javascript复制
loss.backward()
print(w.grad)
print(b.grad)

得出：

代码语言：javascript复制
tensor([[0.1881, 0.1876, 0.0229],
        [0.1881, 0.1876, 0.0229],
        [0.1881, 0.1876, 0.0229],
        [0.1881, 0.1876, 0.0229],
        [0.1881, 0.1876, 0.0229]])
tensor([0.1881, 0.1876, 0.0229])

注意

  • 我们只能获取在计算图叶子节点的requires_grad属性设置为True时候得到该节点的grad属性。我们没法得到们图中的所有其他节点的梯度。
  • 出于性能原因，我们只能在给定的计算图之上使用backward执行一次梯度计算 。如果我们需要在同一个图上多次调用backward，则需要在backward调用时候设置 retain_graph=True。
2.3.4 禁用梯度跟踪

默认情况下，所有设置requires_grad=True 的张量都会跟踪其计算历史并支持梯度计算。但是，有些情况下我们不需要这样做，例如，当我们已经训练了模型并且只想将其应用于某些输入数据时，即我们只想通过网络进行前向计算，这时候我们可以通过用torch.no_grad()块包围我们的计算代码以停止跟踪计算 ：

代码语言：javascript复制
z = torch.matmul(x, w) b
print(z.requires_grad)

with torch.no_grad():
    z = torch.matmul(x, w) b
print(z.requires_grad)

输出：

代码语言：javascript复制
True
False

实现相同结果的另一种方法是在张量上使用detach()方法：

代码语言：javascript复制
z = torch.matmul(x, w) b
z_det = z.detach()
print(z_det.requires_grad)

输出：

代码语言：javascript复制
False

您可能想要禁用梯度跟踪的原因有：

  • 将神经网络中的某些参数标记为冻结参数。这是微调预训练网络的一个非常常见的场景。
  • 在仅进行前向传递时加快计算速度，因为对不跟踪梯度的张量进行计算会更有效。

0x03 逻辑关系

如果从计算图角度来看前向计算的过程，就是在构建图和执行图。"构建图"描述的是节点运算之间的关系。"执行图"则是在会话中执行这个运算关系，就是张量在计算图之中进行前向传播的过程。

前向计算依赖一些基础类，在具体分析前向传播之前，我们先要看看这些基础类之间的逻辑关系。从DAG角度来分析 PyTorch 这个系统，其具体逻辑如下。

  • 图表示计算任务。PyTorch把计算都当作是一种有向无环图，或者说是计算图，但这是一种虚拟的图，代码中没有真实的数据结构。
  • 计算图由节点（Node）和边（Edge）组成。
  • 节点（Node）代表了运算操作。
    • 一个节点通过边来获得 0 个或多个 Tensor，节点执行计算之后会产生 0 个或多个 Tensor。
    • 节点的成员变量 next_functions 是一个 tuple 列表，此列表就代表本节点要输出到哪些其他 Function。列表个数就是这个 grad_fn 的 Edge 数目，列表之中每一个 tuple 对应一条 Edge 信息，内容就是 (Edge.function, Edge.input_nr)。
  • 边（Edge）就是运算操作之间的流向关系。
    • Edge.function ：表示此 Edge 需要输出到哪一个其他 Function。
    • Edge.input_nr ：指定本 Edge 是 Function 的第几个输入。
  • 使用张量（ Tensor） 表示数据，就是在节点间流动的数据，如果没有数据，计算图就没有任何意义。

具体可以参见下图：

代码语言：javascript复制
 ---------------------                ---------------------- 
| SubBackward0        |              | PowBackward0         |
|                     |      Edge    |                      |  Edge
|   next_functions   ----- --------> |     next_functions  ----------> ...
|                     |   |          |                      |
 ---------------------    |           ---------------------- 
                          |
                          |
                          |           ---------------------- 
                          |  Edge    | MulBackward0         |
                           --------> |                      |  Edge
                                     |     next_functions  ----------> ...
                                     |                      |
                                      ----------------------

至此，示例解析结束，我们下一篇介绍PyTorch 微分引擎相关的一些基础类。

0xFF 参考

https://github.com/KeithYin/read-pytorch-source-code/

pytorch学习笔记（十三）：backward过程的底层实现解析

PyTorch的初始化

pytorch的自动求导机制 - 计算图的建立

How autograd encodes the history

https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html

pytorch笔记(计算图 autograd)-Node(1)

详解Pytorch中的网络构造

PyTorch的优化器

PyTorch的分布式

PyTorch的Tensor（下）

PyTorch的Tensor(中)

PyTorch的Tensor（上）

PyTorch的动态图(下)

PyTorch的动态图(上)

计算图——用Pytorch解释李宏毅老师PPT中的实例

如何使用pytorch自动求梯度

PyTorch自动求导（Autograd）原理解析

pytorch自动求导Autograd系列教程（一）

PyTorch核心开发者亲自揭秘其内部机制

PyTorch自动微分基本原理

https://towardsdatascience.com/pytorch-autograd-understanding-the-heart-of-pytorchs-magic-2686cd94ec95

pytorch https 网络安全

0 人点赞