autograd.grad#

示例：

使用损失函数为均方差

原函数形式为： $y = wx+b$

1
import torch.nn.functional as F
2
import torch
3

4
x = torch.tensor(2)
5
# 可以在初始化时声明需要参数
6
# 即设置 requires_grad=True
7
# 若此时不声明，则需要执行 w.requires_grad_() 声明
8
w = torch.full([1], 2, requires_grad=True, dtype=torch.float)
9
b = torch.tensor([1], dtype=torch.float)
10

11
# 需要执行 requires_grad_() 方法表示需要梯度
12
# 否则会报错
13
# RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn
14
# w.requires_grad_()
15
b.requires_grad_()
16

17
# 想要获得梯度，必须在计算误差之间声明需要梯度
18
y_ = x*w+b
19
# 这里 data 表示只输出数据
20
# 若不加，则会输出 tensor([5.], grad_fn=<AddBackward0>)
21
print("x*w+b = ", y_.data)
22

23
# 假设真实 y = 1
24
mse = F.mse_loss(torch.ones(1), y_)
25
print("mse:", mse.data)
26

27
w_grad, b_grad = torch.autograd.grad(mse, [w, b])
28
print("w_grad:", w_grad)
29
print("b_grad:", b_grad)

在这里插入图片描述

loss.backward#

backward方法会将梯度直接应用在变量上，通过 .grad 来获得梯度

示例：

1
import torch.nn.functional as F
2
import torch
3

4
x = torch.tensor(2)
5
w = torch.full([1], 2, requires_grad=True, dtype=torch.float)
6
b = torch.tensor([1], dtype=torch.float)
7

8
b.requires_grad_()
9

10
y_ = x*w+b
11
print("x*w+b = ", y_.data)
12

13
mse = F.mse_loss(torch.ones(1), y_)
14
print("mse:", mse.data)
15

16
# 使用backword来自动求导
17
mse.backward()
18

19
# 通过 .grad 获得梯度
20
print("w_grad:", w.grad)
21
print("b_grad:", b.grad)

在这里插入图片描述

其他操作#

使用 .requires_gard_() 可以改变张量的 requires_gard 属性。

1
import torch
2

3
a = torch.randn(2, 2)
4
a = ((a * 3) / (a - 1))
5
print(a.requires_grad)
6
a.requires_grad_(True)
7
print(a.requires_grad)

在这里插入图片描述

一些其他示例#

softmax自动求导#

1
import torch.nn.functional as F
2
import torch
3

4
x = torch.tensor([2, 1, 0.1], requires_grad=True)
5
print("x:", x)
6
output_ = F.softmax(x, dim=0)
7
print("output_:", output_)
8

9
# 会报错，显示：只能为标量输出隐式创建梯度
10
# o.backward()
11

12
# 会报错，显示：只能为标量输出隐式创建梯度
13
# 不能直接写 torch.autograd.grad(output_, x)
14

15
# 对 softmax[0] 求梯度
16
# 因为 x 有三个数，所以会有 3 个梯度
17
o0_grad = torch.autograd.grad(output_[0], x)
18
print(o0_grad)
19
print("p0 * (1 - p0) = ", (output_[0] * (1 - output_[0])).data)
20
print("-(p0 * p1) = ", (- output_[0] *  output_[1]).data)
21
print("-(p0 * p2) = ", (- output_[0] *  output_[2]).data)

在这里插入图片描述

链式法则#

1
import torch.nn.functional as F
2
import torch
3

4
x = torch.tensor(3)
5
b1 = torch.tensor(1)
6
w1 = torch.tensor(2., requires_grad=True)
7
b2 = torch.tensor(1)
8
w2 = torch.tensor(2., requires_grad=True)
9

10
u = x*w1 + b1
11
y = u*w2 + b2
12

13
def d(y, x):
14
    # retain_graph=True 表示可以反复求导，否则只能求一次
15
    return torch.autograd.grad(y, x, retain_graph=True)
16

17
# 通过 pytorch 直接求导
18
print("dy_dw1 = ", d(y, w1))
19
# 通过链式法则求导
20
print("dy_du * du_dw1 = %s * %s" % (d(y, u), d(u, w1)))

在这里插入图片描述

原文链接：CSDN