标签：tensor True torch requires 微分 pytorch print grad
文章目录
引言
在训练神经网络时，最常用的算法是 反向传播。在该算法中，参数（模型权重）根据损失函数相对于给定参数的梯度进行调整。
为了计算这些梯度，PyTorch 有一个名为 的内置微分引擎torch.autograd。它支持任何计算图的梯度自动计算。
主要用到的包和类：
- autograd
- torch.Tensor
- torch.Tensor 是包的核心类。如果将其属性 .requires_grad 设置为 True，则会开始跟踪针对 tensor的所有操作。
- backward() 来自动计算所有梯度
- detach()停止 tensor 历史记录的跟踪
- 要停止跟踪历史记录（和使用内存），您还可以将代码块使用 with torch.no_grad(): 包装起来
如果你想计算导数，你可以调用 Tensor.backward()。如果 Tensor 是标量（即它包含一个元素数
据），则不需要指定任何参数backward()，但是如果它有更多元素，则需要指定一个gradient 参数
来指定张量的形状。
注意：一个类对于 autograd 实现非常重要那就是 Function。Tensor 和 Function 互相连接并构建一
个非循环图，它保存整个完整的计算过程的历史信息。每个张量都有一个 .grad_fn 属性保存着创
建了张量的 Function 的引用，（如果用户自己创建张量，则grad_fn 是 None)
一些小测试
创建一个张量，设置 requires_grad=True 来跟踪与它相关的计算
import torch
x = torch.ones(2, 2, requires_grad=True)
print(x)
y = x + 2
print(y) # 观察到grad_fn 存在且不为None
tensor([[1., 1.],
[1., 1.]], requires_grad=True)
tensor([[3., 3.],
[3., 3.]], grad_fn=<AddBackward0>)
z = y * y * 3
out = z.mean()
print(z, out)
tensor([[27., 27.],
[27., 27.]], grad_fn=<MulBackward0>) tensor(27., grad_fn=<MeanBackward0>)
小tip：requires_grad_( … ) 会改变张量的 requires_grad 标记。输入的标记默认为 False ，如果没有提供相应的参数。
a = torch.randn(2, 2)
a = ((a * 3) / (a - 1))
print(a.requires_grad)
a.requires_grad_(True)
print(a.requires_grad)
b = (a * a).sum()
print(b.grad_fn)
False
True
<SumBackward0 object at 0x0000013BF769FDF0>
梯度
我们现在后向传播，因为输出包含了一个标量，out.backward() 等同于 out.backward(torch.tensor(1.))。
out.backward()
print(x.grad)
tensor([[4.5000, 4.5000],
[4.5000, 4.5000]])
梯度下降的实战例子-考虑最简单的一层神经网络
具有输入x、参数w和b，以及一些损失函数。它可以通过以下方式在 PyTorch 中定义：
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)
在这个网络中，w和b是我们需要优化的参数。因此，我们需要能够计算关于这些变量的损失函数的梯度。为了做到这一点，我们为w,b设置了requires_grad=True属性。
我们应用于张量以构建计算图的函数实际上是类的对象Function。该对象知道如何在前向计算函数，以及如何在反向传播步骤中计算其导数。对反向传播函数的引用存储在grad_fn张量的属性中。
print('Gradient function for z =', z.grad_fn)
print('Gradient function for loss =', loss.grad_fn)
Gradient function for z = <AddBackward0 object at 0x0000013BF02FF2E0>
Gradient function for loss = <BinaryCrossEntropyWithLogitsBackward0 object at 0x0000013BF02FF8B0>
计算梯度
为了优化神经网络中参数的权重，我们需要计算损失函数关于参数的导数，即我们需要
∂
l
o
s
s
∂
w
\frac{\partial loss}{\partial w}
∂w∂loss 和
∂
l
o
s
s
∂
b
\frac{\partial loss}{\partial b}
∂b∂loss 下的一些固定值 x和y。为了计算这些导数，我们调用 loss.backward()，然后从w.grad和 中 检索值b.grad：
loss.backward()
print(w.grad)
print(b.grad)
tensor([[0.0853, 0.0053, 0.2184],
[0.0853, 0.0053, 0.2184],
[0.0853, 0.0053, 0.2184],
[0.0853, 0.0053, 0.2184],
[0.0853, 0.0053, 0.2184]])
tensor([0.0853, 0.0053, 0.2184])
张量梯度和雅可比积
在很多情况下，我们有一个标量损失函数，我们需要计算一些参数的梯度。但是，有些情况下输出函数是任意张量。在这种情况下，PyTorch 允许您计算所谓的Jacobian 乘积，而不是实际的梯度。
对于向量函数
y
⃗
=
f
(
x
⃗
)
\vec{y}=f\left( \vec{x} \right)
y
=f(x
),其中
x
⃗
=
<
x
1
,
.
.
.
,
x
n
>
\vec{x}=\left< x_1,...,x_n \right>
x
=⟨x1,...,xn⟩ ,
y
⃗
=
<
y
1
,
.
.
.
,
y
m
>
\vec{y}=\left< y_1,...,y_m \right>
y
=⟨y1,...,ym⟩,利用 Jacobian matrix给出
y
⃗
\vec{y}
y
关于
x
⃗
\vec{x}
x
的偏导：
J
=
(
∂
y
1
∂
x
1
⋯
∂
y
1
∂
x
n
⋮
⋱
⋮
∂
y
m
∂
x
1
⋯
∂
y
m
∂
x
n
)
\ J=\left( \begin{matrix} \frac{\partial y_1}{\partial x_1}& \cdots& \frac{\partial y_1}{\partial x_n}\\ \vdots& \ddots& \vdots\\ \frac{\partial y_m}{\partial x_1}& \cdots& \frac{\partial y_m}{\partial x_n}\\ \end{matrix} \right)
J=⎝⎜⎛∂x1∂y1⋮∂x1∂ym⋯⋱⋯∂xn∂y1⋮∂xn∂ym⎠⎟⎞
PyTorch 允许您对于给定的输入向量 v ⃗ = < v 1 , . . . , v m > \vec{v}=\left< v_1,...,v_m \right> v =⟨v1,...,vm⟩计算雅可比乘积 v T ⋅ J v^T\cdot J vT⋅J，而不是计算雅可比矩阵本身。这是通过使用v作为参数向后调用来实现的。(v的大小应该和原始张量的大小相同，我们要用它来计算乘积)：
inp = torch.eye(5, requires_grad=True)
out = (inp+1).pow(2)
out.backward(torch.ones_like(inp), retain_graph=True)
print("First call\n", inp.grad)
out.backward(torch.ones_like(inp), retain_graph=True)
print("\nSecond call\n", inp.grad)
inp.grad.zero_()
out.backward(torch.ones_like(inp), retain_graph=True)
print("\nCall after zeroing gradients\n", inp.grad)
First call
tensor([[4., 2., 2., 2., 2.],
[2., 4., 2., 2., 2.],
[2., 2., 4., 2., 2.],
[2., 2., 2., 4., 2.],
[2., 2., 2., 2., 4.]])
Second call
tensor([[8., 4., 4., 4., 4.],
[4., 8., 4., 4., 4.],
[4., 4., 8., 4., 4.],
[4., 4., 4., 8., 4.],
[4., 4., 4., 4., 8.]])
Call after zeroing gradients
tensor([[4., 2., 2., 2., 2.],
[2., 4., 2., 2., 2.],
[2., 2., 4., 2., 2.],
[2., 2., 2., 4., 2.],
[2., 2., 2., 2., 4.]])
标签：tensor,True,torch,requires,微分,pytorch,print,grad 来源： https://blog.csdn.net/pylittlebrat/article/details/121731114
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。