PyTorch的自动微分(autograd)

最新推荐文章于 2024-02-06 16:26:29 发布

在路上的工程师

最新推荐文章于 2024-02-06 16:26:29 发布

阅读量1.1k

点赞数

分类专栏： pytorch 文章标签： pytorch 深度学习 autograd

本文链接：https://blog.csdn.net/qq_40691189/article/details/129433004

版权

pytorch 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

PyTorch的自动微分(autograd)

计算图

计算图是用来描述运算的有向无环图
计算图有两个主要元素：结点（Node）和边（Edge）
结点表示数据，如向量、矩阵、张量
边表示运算，如加减乘除卷积等

用计算图表示：y = (x + w) * (w + 1)
令 a = x + w，b = w + 1
则 y = a * b

在这里插入图片描述

使用计算图可以更方便的求导
在这里插入图片描述

在计算图中，y对w求导，就是找到所有y到w的边，然后分别进行求导。

w = torch.tensor([1.], requires_grad=True)
x = torch.tensor([2.], requires_grad=True)
a = torch.add(w, x)
b = torch.add(w, 1)
y = torch.mul(a, b)
y.backward()
print(w.grad)
tensor([5.])

叶子节点：用户创建的结点成为叶子结点，如X与W
is_leaf：指示张量是否为叶子结点

叶子结点的作用：节省内存，非叶子结点的梯度会被释放

print("is_leaf:\n", w.is_leaf, x.is_leaf, a.is_leaf, b.is_leaf, y.is_leaf)
is_leaf:
True True False False False

print("gradient:\n", w.grad, x.grad, a.grad, b.grad, y.grad)
gradient:
 tensor([5.]) tensor([2.]) None None None

如果想要保存非叶子结点的梯度，需要在反向传播前前，使用a.retain_grad()(以张量a为例)

grad_fn：记录创建该张量时所用的方法（函数）

print("grad_fn:\n", w.grad_fn, x.grad_fn, a.grad_fn, b.grad_fn, y.grad_fn)
grad_fn:
 None None <AddBackward0 object at 0x00000254C1C6C7B8> <AddBackward0 object at 0x00000254C334DDD8> <MulBackward0 object at 0x00000254C334D828>

这里w和x是用户创建的，所以grad_fn为None，a、b、y都是有grad_fn的，其grad_fn的作用主要是在求导时，可以知道其是使用哪种计算方式得到的，以便确认求导法则。

动态图 VS 静态图

根据计算图搭建方式，可将计算图分为动态图和静态图
动态图：运算和搭建同时进行，特点：灵活，易调解，以pytorch为代表
静态图：先搭建图，后运算，特点：高效，但不灵活，以tensorflow为代表

`autograd`–自动求导系统

`torch.autograd.backward`方法介绍

torch.autograd.backward：自动求取梯度，参数

inputs：用于求导的张量，如loss
retain_graph：保存计算图
create_graph：创建导数计算图，用于高阶求导
gradient：多梯度权重

tensor.backward()调用的就是torch.autograd.backward()

在梯度求导之后，计算图会被释放，无法执行两次backward(),要想执行两次backward(),就需要将retain_graph设置为True。
一般中间结点会遇到需要多次backward的情况

下面代码解释多梯度权重

w = torch.tensor([1.], requires_grad=True)
x = torch.tensor([2.], requires_grad=True)
a = torch.add(w, x)
b = torch.add(w, 1)
y = torch.mul(a ,b)
y1 = torch.add(a, b)  # dy1/dw = 2
loss = torch.cat([y, y1], dim=0)

grad_tensors = torch.tensor([1, 1])
loss.backward(gradient=grad_tensors)
print(w.grad)
tensor([7.])

这里同时求了dy/dw和dy1/dw，w.grad=(1 x dy/dw) + (1 x dy1/dw) = 5+2

grad_tensors = torch.tensor([1, 2])
loss.backward(gradient=grad_tensors)
print(w.grad)
tensor([7.])

w.grad = (1 x dy/dw) + (2 x dy1/dw) = 5 + 2x2 = 9

`torch.autograd.grad()`方法介绍

torch.autograd.grad()：求取梯度

outputs：用于求导的张量，如loss
inputs：需要梯度的张量
create_graph：创建导数计算图，用于高阶求导
retain_graph：保存计算图
grad_outputs：多梯度权重

# x需要设置requires_grad=True才可以后续求导
x = torch.tensor([3.], requires_grad=True)
y = torch.pow(x, 2)
# 创建导数计算图，用于高阶求导，即后续可以求二阶导数
grad_1 = torch.autograd.grad(y, x, create_graph=True)
print(grad_1)
(tensor([6.], grad_fn=<MulBackward0>),)
# 求2阶导数
grad_2 = torch.autograd.grad(grad_1[0], x)
print(grad_2)
(tensor([2.]),)

autograd小贴士：

梯度不会自动清零（比如w会一直叠加），手动清零：w.grad.zero_()；
依赖于叶子结点的结点(比如a, b, y)，其requires_grad=True；
叶子结点不可以执行in-place操作（原地操作，在原始内存地址中改变数据）。

自动求导系统实现

torch.Tensor 是包的核心类。如果将其属性 .requires_grad 设置为 True，则会开始跟踪针对 tensor 的所有操作。完成计算后，您可以调用 .backward() 来自动计算所有梯度。该张量的梯度将累积到 .grad 属性中。

如果你想计算导数，你可以调用 Tensor.backward()。如果 Tensor 是标量（即它包含一个元素数据），则不需要指定任何参数backward()，但是如果它有更多元素，则需要指定一个gradient 参数来指定张量的形状。

这两段话非常重要，我们借助下面这个例子来帮助理解

import torch

x = torch.ones(2, 2, requires_grad=True)
print(x)

tensor([[1., 1.],
 [1., 1.]], requires_grad=True)

y = x + 2
print(y)

tensor([[3., 3.],
 [3., 3.]], grad_fn=<AddBackward0>)

print(x.grad_fn)  # None
print(y.grad_fn)  # y 作为操作的结果被创建，所以它有 grad_fn 

None
<AddBackward0 object at 0x000001F7739B1BB0>

每个张量都有一个 .grad_fn属性保存着创建了张量的 Function 的引用，（如果用户自己创建张量，则grad_fn 是 None ）。

针对y做更多的操作

z = y*y*3
out = z.mean()
print(z)
print(out)
print(out.backward())  # 这里是没有返回值的
print(x.grad)  # 需要先backward，才能得到x的grad

tensor([[27., 27.],
        [27., 27.]], grad_fn=<MulBackward0>)
tensor(27., grad_fn=<MeanBackward0>)
None
tensor([[4.5000, 4.5000],
        [4.5000, 4.5000]])

这里的重点是x.grad的计算

在这里插入图片描述

通过这个例子，理解上面的两段话就是，这里x的requires_grad 属性为True，后续跟踪针对x的所有操作，之后调用backward自动计算所有梯度，x的梯度累积到.grad属性中。

接下来我们再看一个pytorch自动微分的例子，如果对于张量手动计算梯度的话，代码是这样的：

import torch


dtype = torch.float
device = torch.device("cpu")
# device = torch.device("cuda:0")  # 取消注释以在GPU上运行

# N是批量大小，D_in是输入维度，H是隐藏层维度，D_out是输出维度
N, D_in, H, D_out = 64, 1000, 100, 10

# 创建随机输入和输出数据
x = torch.randn(N, D_in, device=device, dtype=dtype)
y = torch.randn(N, D_out, device=device, dtype=dtype)

# 随机初始化权重
w1 = torch.randn(D_in, H, device=device, dtype=dtype)
w2 = torch.randn(H, D_out, device=device, dtype=dtype)

learning_rate = 1e-6
for t in range(500):
    # 前向传递：计算预测y
    h = x.mm(w1)  # mm表示tensor相乘
    # 将输入input张量的每个元素夹紧到区间[min, max]
    h_relu = h.clamp(min=0)
    y_pred = h_relu.mm(w2)

    # 计算和打印损失
    loss = (y_pred - y).pow(2).sum().item()  # 求平方和
    print(t, loss)

    # Backprop计算w1和w2相对于损耗的梯度
    grad_y_pred = 2.0 * (y_pred - y)
    grad_w2 = h_relu.t().mm(grad_y_pred)
    grad_h_relu = grad_y_pred.mm(w2.t())
    grad_h = grad_h_relu.clone()
    grad_h[h < 0] = 0
    grad_w1 = x.t().mm(grad_h)

    # 使用梯度下降更新权重
    w1 -= learning_rate * grad_w1
    w2 -= learning_rate * grad_w2

这段代码最核心的点在于Backprop部分，首先根据

loss=(y_pred-y)^2

容易到loss对于y_pred的偏导数，即grad_y_pred

而loss对于w2的偏导数，即grad_w2就稍复杂一些，涉及到矩阵求导、雅可比矩阵和链式法则。

根据在网上查阅资料得到，查到一个矩阵求导相关的文章：

https://blog.sina.com.cn/s/blog_51c4baac0100xuww.html

说实话没怎么看懂，以前没有学过矩阵求导。

关于雅可比矩阵和链式法则：

在这里插入图片描述

上面的内容简而言之，雅可比矩阵是一阶偏导数以一定方式排列成的矩阵，根据求导的链式法则，(y对x的偏导)x(l对y的偏导) = (l对x的偏导)。

现在可以想到

grad_w2 = y_pred对w2的偏导 x loss对y_pred的偏导

y_pred对w2的偏导 = h_relu的转置

即 grad_w2 = h_relu.t().mm(grad_y_pred)
这里两个矩阵的前后顺序我不知道有没有什么规则，但是根据其size可以pytorch官方文档给出前后顺序是合理的
h_relue.t()的size是(100, 64)
grad_y_pred的size是(64, 10)

grad_h_relu = loss对y_pred的偏导 x y_pred对h_relu的偏导
y_pred对h_relue的偏导 = w2的转置
即grad_h_relue = grad_y_pred.mm(w2.t())
而且你看，这里相乘的两个矩阵顺序调整了，调整的原因是因为
grad_y_pred的size是(64, 10)
w2.t()的size是(10, 100)
只有按照给出的位置才能得到相乘，而且正好得到(64, 100)的grad_h_relu

同理对于loss对于w1的偏导

grad_w1 = h_relu对于w1的偏导 x y_pred对h_relu的偏导 x loss对y_pred的偏导
后两项的乘积就是grad_h_relu
h_relue对w1的偏导 = x.t()
而x.t()的size为(1000, 64)
所以grad_w1 = x.t().mm(grad_h)

现在我们已经理解了上述求导和反向传播的过程，如果使用pytorch的自动求导，则可以利用下述方式来实现。

import torch


dtype = torch.float
device = torch.device("cpu")
# device = torch.device("cuda:0")  # 取消注释以在GPU上运行

# N是批量大小，D_in是输入维度，H是隐藏层维度，D_out是输出维度
N, D_in, H, D_out = 64, 1000, 100, 10

# 创建随机输入和输出数据
x = torch.randn(N, D_in, device=device, dtype=dtype)
y = torch.randn(N, D_out, device=device, dtype=dtype)

# 随机初始化权重
w1 = torch.randn(D_in, H, device=device, dtype=dtype, requires_grad=True)
w2 = torch.randn(H, D_out, device=device, dtype=dtype, requires_grad=True)

learning_rate = 1e-6
for t in range(500):
    # 前向传播：使用tensors上的操作计算预测值y;
    # 由于w1和w2有requires_grad=True，涉及这些张量的操作将让PyTorch构建计算图，
    # 从而允许自动计算梯度。由于我们不再手工实现反向传播，所以不需要保留中间值的引用。
    y_pred = x.mm(w1).clamp(min=0).mm(w2)
    # 使用Tensors上的操作计算和打印丢失。
    # loss是一个形状为(1,)的张量
    # loss.item() 得到这个张量对应的python数值
    loss = (y_pred - y).pow(2).sum()
    print(t, loss.item())

    # 使用autograd计算反向传播。这个调用将计算loss对所有requires_grad=True的tensor的梯度。
    # 这次调用后，w1.grad和w2.grad将分别是loss对w1和w2的梯度张量。
    loss.backward()

    # 使用梯度下降更新权重。对于这一步，我们只想对w1和w2的值进行原地改变；不想为更新阶段构建计算图，
    # 所以我们使用torch.no_grad()上下文管理器防止PyTorch为更新构建计算图
    with torch.no_grad():
        w1 -= learning_rate * w1.grad
        w2 -= learning_rate * w2.grad

        # 反向传播后手动将梯度设置为零
        w1.grad.zero_()
        w2.grad.zero_()

在路上的工程师

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
PyTorch的自动微分(autograd)

torch.Tensor 是包的核心类。如果将其属性 .requires_grad 设置为 True，则会开始跟踪针对 tensor 的所有操作。完成计算后，您可以调用 .backward() 来自动计算所有梯度。该张量的梯度将累积到 .grad 属性中。
复制链接

扫一扫