pytorch_course3

wenxingxingxing

已于 2022-09-27 09:04:25 修改

阅读量101

点赞数

分类专栏： Deep learning Pytorch 文章标签： pytorch python 深度学习

于 2022-09-26 22:27:49 首次发布

本文链接：https://blog.csdn.net/wenxingxingxing/article/details/127062338

版权

Deep learning 同时被 2 个专栏收录

12 篇文章 0 订阅

订阅专栏

Pytorch

6 篇文章 0 订阅

订阅专栏

PyTorch autograd基础

3.2 autograd
3.2.1 requires_grad
3.2.2 计算图
- autograd.grad函数 && hook
- variable中grad属性和backward函数grad_variables参数

3.2 autograd

用Tensor训练网络很方便，但从上一小节最后的线性回归例子来看，反向传播过程需要手动实现。这对于像线性回归等较为简单的模型来说，还可以应付，但实际使用中经常出现非常复杂的网络结构，此时如果手动实现反向传播，不仅费时费力，而且容易出错，难以检查。torch.autograd就是为方便用户使用，而专门开发的一套自动求导引擎，它能够根据输入和前向传播过程自动构建计算图，并执行反向传播。

计算图(Computation Graph)是现代深度学习框架如PyTorch和TensorFlow等的核心，其为高效自动求导算法——反向传播(Back Propogation)提供了理论支持，了解计算图在实际写程序过程中会有极大的帮助

3.2.1 requires_grad

PyTorch在autograd模块中实现了计算图的相关功能，autograd中的核心数据结构是Variable。从v0.4版本起，Variable和Tensor合并。我们可以认为需要求导(requires_grad)的tensor即Variable. autograd记录对tensor的操作记录用来构建计算图。

Variable提供了大部分tensor支持的函数，但其不支持部分inplace函数，因这些函数会修改tensor自身，而在反向传播中，variable需要缓存原来的tensor来计算反向传播梯度。如果想要计算各个Variable的梯度，只需调用根节点variable的backward方法，autograd会自动沿着计算图反向传播，计算每一个叶子节点的梯度。

variable.backward(gradient=None, retain_graph=None, create_graph=None)主要有如下参数：

grad_variables：形状与variable一致，对于y.backward()，grad_variables相当于链式法则
中的 dz/dy。grad_variables也可以是tensor或序列。
retain_graph：反向传播需要缓存一些中间结果，反向传播之后，这些缓存就被清空，可通过指定这个参数不清空缓存，用来多次反向传播。
create_graph：对反向传播过程再次构建计算图，可通过backward of backward实现求高阶导数。

# from __future__ import print_function
import torch as t

# 在创建tensor的时候制定requires_grad
a = t.randn(3,4, requires_grad=True)
# 或者
a = t.randn(3,4).requires_grad_()
# 或者
a = t.randn(3,4)
a.requires_grad=True
a

tensor([[-3.0393,  0.8160,  1.3115,  0.2984],
        [ 0.1549,  0.5478,  1.3529,  1.6063],
        [-0.2353, -1.6256,  0.7341, -0.0788]], requires_grad=True)

b = t.zeros(3,4).requires_grad_()
b

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

# 也可写成c = a + b
c = a.add(b)
c

tensor([[-3.0393,  0.8160,  1.3115,  0.2984],
        [ 0.1549,  0.5478,  1.3529,  1.6063],
        [-0.2353, -1.6256,  0.7341, -0.0788]], grad_fn=<AddBackward0>)

d = c.sum()
d.backward() # 反向传播

d # d还是一个requires_grad=True的tensor,对它的操作需要慎重
d.requires_grad

True

a.grad

tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]])

# 此处虽然没有指定c需要求导，但c依赖于a，而a需要求导，
# 因此c的requires_grad属性会自动设为True
a.requires_grad, b.requires_grad, c.requires_grad

(True, True, True)

# 由用户创建的variable属于叶子节点，对应的grad_fn是None
a.is_leaf, b.is_leaf, c.is_leaf

(True, True, False)

# c.grad是None, 因c不是叶子节点，它的梯度是用来计算a的梯度
# 所以虽然c.requires_grad = True,但其梯度计算完之后即被释放
c.grad is None

True

计算下面这个函数的导函数：

在这里插入图片描述

它的导数是：

在这里插入图片描述

来看看autograd的计算结果与手动求导计算结果的误差。

def f(x):
    '''计算y'''
    y = x**2 * t.exp(x)
    return y

def gradf(x):
    '''手动求导函数'''
    dx = 2*x*t.exp(x) + x**2*t.exp(x)
    return dx

x = t.randn(3,4, requires_grad=True)
y = f(x)
y

tensor([[ 0.5317,  1.4318, 24.2927, 11.4674],
        [ 0.3465,  1.4001,  1.7359,  0.2039],
        [ 2.8158,  0.3726,  0.0364,  6.5242]], grad_fn=<MulBackward0>)

y.backward(t.ones(y.size())) # gradient形状与y一致
x.grad

tensor([[-0.0780,  5.0048, 49.8215, 26.2100],
        [ 1.8328,  4.9220,  5.7824, -0.4606],
        [ 8.3818, -0.3631,  0.4527, 16.4087]])

# autograd的计算结果与利用公式手动计算的结果一致
gradf(x)

tensor([[-0.0780,  5.0048, 49.8215, 26.2100],
        [ 1.8328,  4.9220,  5.7824, -0.4606],
        [ 8.3818, -0.3631,  0.4527, 16.4087]], grad_fn=<AddBackward0>)

3.2.2 计算图

PyTorch中autograd的底层采用了计算图，计算图是一种特殊的有向无环图（DAG），用于记录算子与变量之间的关系。一般用矩形表示算子，椭圆形表示变量
。
如表达式 z = wx + b可分解为 y = wx 和 z = y + b，其计算图如图3-3所示，图中MUL，ADD都是算子，w, x, b即变量。
在这里插入图片描述

如上有向无环图中，x 和 b 是叶子节点（leaf node），这些节点通常由用户自己创建，不依赖于其他变量。称为根节点，是计算图的最终目标。利用链式法则很容易求得各个叶子节点的梯度。
在这里插入图片描述

在PyTorch实现中，autograd会随着用户的操作，记录生成当前variable的所有操作，并由此建立一个有向无环图。用户每进行一个操作，相应的计算图就会发生改变。更底层的实现中，图中记录了操作Function，每一个变量在图中的位置可通过其grad_fn属性在图中的位置推测得到。在反向传播过程中，autograd沿着这个图从当前变量（根节点）溯源，可以利用链式求导法则计算所有叶子节点的梯度。每一个前向传播操作的函数都有与之对应的反向传播函数用来计算输入的各个variable的梯度，这些函数的函数名通常以Backward结尾。下面结合代码学习autograd的实现细节。

x = t.ones(1)
b = t.rand(1, requires_grad = True)
w = t.rand(1, requires_grad = True)
y = w * x # 等价于y=w.mul(x)
z = y + b # 等价于z=y.add(b)

x.requires_grad, b.requires_grad, w.requires_grad

(False, True, True)

# 虽然未指定y.requires_grad为True，但由于y依赖于需要求导的w
# 故而y.requires_grad为True
y.requires_grad

True

x.is_leaf, w.is_leaf, b.is_leaf

(True, True, True)

y.is_leaf, z.is_leaf

(False, False)

# grad_fn可以查看这个variable的反向传播函数，
# z是add函数的输出，所以它的反向传播函数是AddBackward
z.grad_fn , y.grad_fn

(<AddBackward0 at 0x1ce24b421c0>, <MulBackward0 at 0x1ce24b40ca0>)

# next_functions保存grad_fn的输入，是一个tuple，tuple的元素也是Function
# 第一个是y，它是乘法(mul)的输出，所以对应的反向传播函数y.grad_fn是MulBackward
# 第二个是b，它是叶子节点，由用户创建，grad_fn为None，但是有
z.grad_fn.next_functions

((<MulBackward0 at 0x1ce24b40ca0>, 0), (<AccumulateGrad at 0x1ce24b401c0>, 0))

# variable的grad_fn对应着和图中的function相对应
print(z.grad_fn.next_functions[0])
z.grad_fn.next_functions[0][0] == y.grad_fn

(<MulBackward0 object at 0x000001CE24B40CA0>, 0)





True

# 第一个是w，叶子节点，需要求导，梯度是累加的
# 第二个是x，叶子节点，不需要求导，所以为None
y.grad_fn.next_functions

((<AccumulateGrad at 0x1ce24b40190>, 0), (None, 0))

# 叶子节点的grad_fn是None
w.grad_fn,x.grad_fn

(None, None)

计算w的梯度的时候，需要用到x的数值(dy / dw = x)，这些数值在前向过程中会保存成buffer，在计算完梯度之后会自动清空。
为了能够多次反向传播需要指定retain_graph来保留这些buffer。

# 使用retain_graph来保存buffer
z.backward(retain_graph=True)
w.grad

tensor([1.])

# 多次反向传播，梯度累加，这也就是w中AccumulateGrad标识的含义
z.backward()
w.grad

tensor([2.])

PyTorch使用的是动态图，它的计算图在每次前向传播时都是从头开始构建，所以它能够使用Python控制语句（如for、if等）根据需求创建计算图。这点在自然语言处理领域中很有用，它意味着你不需要事先构建所有可能用到的图的路径，图在运行时才构建。

def abs(x):
    if x.data[0] > 0: return x
    else: return -x
x = t.ones(1, requires_grad=True)
y = abs(x)
y.backward()
x.grad

tensor([1.])

x = -1*t.ones(1)
x = x.requires_grad_()
y = abs(x)
y.backward()
print(x.grad)

tensor([-1.])

tensor([1.], grad_fn=<NegBackward0>)

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

x.requires_grad

True

x.requires_grad
cc=x*3
cc.requires_grad

True

def f(x):
    result = 1
    for ii in x:
        if ii.item()>0: 
            result=ii*result
    return result
x = t.arange(-2,4, dtype=t.float32).requires_grad_()
x

tensor([-2., -1.,  0.,  1.,  2.,  3.], requires_grad=True)

y = f(x) # y = x[3]*x[4]*x[5]
y.backward()
x.grad

tensor([0., 0., 0., 6., 3., 2.])

变量的requires_grad属性默认为False，如果某一个节点requires_grad被设置为True，那么所有依赖它的节点requires_grad都是True。

有些时候我们可能不希望autograd对tensor求导。认为求导需要缓存许多中间结构，增加额外的内存/显存开销，那么我们可以关闭自动求导。对于不需要反向传播的情景（如inference，即测试推理时），关闭自动求导可实现一定程度的速度提升，并节省约一半显存，因其不需要分配空间计算梯度

x = t.ones(1, requires_grad=True)
w = t.rand(1, requires_grad=True)
y = x * w
# y依赖于w，而w.requires_grad = True
x.requires_grad, w.requires_grad, y.requires_grad

(True, True, True)

with t.no_grad():
    x = t.ones(1)
    w = t.rand(1, requires_grad=True)
    y = x*w
# y依赖于w，而w.requires_grad = True
x.requires_grad, w.requires_grad, y.requires_grad

(False, True, False)

t.set_grad_enabled(False)
x = t.ones(1)
w = t.rand(1, requires_grad = True)
y = x * w
# y依赖于w和x，虽然w.requires_grad = True，但是y的requires_grad依旧为False
x.requires_grad, w.requires_grad, y.requires_grad

(False, True, False)

# 恢复默认配置
t.set_grad_enabled(True)

<torch.autograd.grad_mode.set_grad_enabled at 0x1ce24b40550>

如果我们想要修改tensor的数值，但是又不希望被autograd记录，那么我么可以对tensor.data进行操作

a = t.ones(3,4,requires_grad=True)
b = t.ones(3,4,requires_grad=True)
c = a * b

a.data # 还是一个tensor

tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]])

a.data.requires_grad # 但是已经是独立于计算图之外

False

d = a.data.sigmoid_() # sigmoid_ 是个inplace操作，会修改a自身的值
d.requires_grad

False

tensor([[0.7311, 0.7311, 0.7311, 0.7311],
        [0.7311, 0.7311, 0.7311, 0.7311],
        [0.7311, 0.7311, 0.7311, 0.7311]], requires_grad=True)

如果我们希望对tensor，但是又不希望被记录, 可以使用tensor.data 或者tensor.detach()

a.requires_grad

True

# 近似于 tensor=a.data, 但是如果tensor被修改，backward可能会报错
# tensor = a.detach()
tensor.requires_grad

False

# 统计tensor的一些指标，不希望被记录
mean = tensor.mean()
std = tensor.std()
maximum = tensor.max()

tensor[0]=1
# 下面会报错：　RuntimeError: one of the variables needed for gradient
#             computation has been modified by an inplace operation
#　因为 c=a*b, b的梯度取决于a，现在修改了tensor，其实也就是修改了a，梯度不再准确
# c.sum().backward()

autograd.grad函数 && hook

在反向传播过程中非叶子节点的导数计算完之后即被清空。若想查看这些变量的梯度，有两种方法：

使用autograd.grad函数
使用hook

autograd.grad和hook方法都是很强大的工具，更详细的用法参考官方api文档，这里举例说明基础的使用。推荐使用hook方法，但是在实际使用中应尽量避免修改grad的值。

x = t.ones(3, requires_grad=True)
w = t.rand(3, requires_grad=True)
y = x * w
# y依赖于w，而w.requires_grad = True
z = y.sum()
x.requires_grad, w.requires_grad, y.requires_grad

(True, True, True)

# 非叶子节点grad计算完之后会自动清空，y.grad是None
z.backward()
(x.grad, w.grad, y.grad)

(tensor([0.9707, 0.5827, 0.1209]), tensor([1., 1., 1.]), None)

# 第一种方法：使用grad获取中间变量的梯度
x = t.ones(3, requires_grad=True)
w = t.rand(3, requires_grad=True)
y = x * w
z = y.sum()
# z对y的梯度，隐式调用backward()
t.autograd.grad(z, y)

(tensor([1., 1., 1.]),)

# 第二种方法：使用hook
# hook是一个函数，输入是梯度，不应该有返回值
def variable_hook(grad):
    print('y的梯度：',grad)
    
x = t.ones(3, requires_grad=True)
w = t.rand(3, requires_grad=True)
y = x * w
# 注册hook
hook_handle = y.register_hook(variable_hook)
z = y.sum()
z.backward()

# 除非你每次都要用hook，否则用完之后记得移除hook
hook_handle.remove()

y的梯度： tensor([1., 1., 1.])

variable中grad属性和backward函数grad_variables参数

在这里插入图片描述

只有对variable的操作才能使用autograd，如果对variable的data直接进行操作，将无法使用反向传播。除了对参数初始化，一般我们不会修改variable.data的值。

PyTorch中计算图的特点可总结如下：

autograd根据用户对variable的操作构建其计算图。对变量的操作抽象为Function。
对于那些不是任何函数(Function)的输出，由用户创建的节点称为叶子节点，叶子节点的grad_fn为None。叶子节点中需要求导的variable，具有AccumulateGrad标识，因其梯度是累加的。
variable默认是不需要求导的，即requires_grad属性默认为False，如果某一个节点requires_grad被设置为True，那么所有依赖它的节点requires_grad都为True。
variable的volatile属性默认为False，如果某一个variable的volatile属性被设为True，那么所有依赖它的节点volatile属性都为True。volatile属性为True的节点不会求导，volatile的优先级比requires_grad高。
多次反向传播时，梯度是累加的。反向传播的中间缓存会被清空，为进行多次反向传播需指定retain_graph=True来保存这些缓存。
非叶子节点的梯度计算完之后即被清空，可以使用autograd.grad或hook技术获取非叶子节点的值。
variable的grad与data形状一致，应避免直接修改variable.data，因为对data的直接操作无法利用autograd进行反向传播
反向传播函数backward的参数grad_variables可以看成链式求导的中间结果，如果是标量，可以省略，默认为1
PyTorch采用动态图设计，可以很方便地查看中间层的输出，动态的设计计算图结构。