跳转至

Automatic differentiation package - torch.autograd

torch.autograd提供了类和函数用来对任意标量函数进行求导。要想使用自动求导,只需要对已有的代码进行微小的改变。只需要将所有的tensor包含进Variable对象中即可。

torch.autograd.backward(variables, grad_variables, retain_variables=False)

Computes the sum of gradients of given variables w.r.t. graph leaves. 给定图的叶子节点variables, 计算图中变量的梯度和。 计算图可以通过链式法则求导。如果variables中的任何一个variable是 非标量(non-scalar)的,且requires_grad=True。那么此函数需要指定grad_variables,它的长度应该和variables的长度匹配,里面保存了相关variable的梯度(对于不需要gradient tensorvariableNone是可取的)。

此函数累积leaf variables计算的梯度。你可能需要在调用此函数之前将leaf variable的梯度置零。

参数说明:

  • variables (variable 列表) – 被求微分的叶子节点,即 ys

  • grad_variables (Tensor 列表) – 对应variable的梯度。仅当variable不是标量且需要求梯度的时候使用。

  • retain_variables (bool) – True,计算梯度时所需要的buffer在计算完梯度后不会被释放。如果想对一个子图多次求微分的话,需要设置为True

Variable

API 兼容性

Variable API 几乎和 Tensor API一致 (除了一些in-place方法,这些in-place方法会修改 required_grad=Trueinput 的值)。多数情况下,将Tensor替换为Variable,代码一样会正常的工作。由于这个原因,我们不会列出Variable的所有方法,你可以通过torch.Tensor的文档来获取相关知识。

In-place operations on Variables

autograd中支持in-place operations是非常困难的。同时在很多情况下,我们阻止使用in-place operationsAutograd的贪婪的 释放buffer和 复用使得它效率非常高。只有在非常少的情况下,使用in-place operations可以降低内存的使用。除非你面临很大的内存压力,否则不要使用in-place operations

In-place 正确性检查

所有的Variable都会记录用在他们身上的 in-place operations。如果pytorch检测到variable在一个Function中已经被保存用来backward,但是之后它又被in-place operations修改。当这种情况发生时,在backward的时候,pytorch就会报错。这种机制保证了,如果你用了in-place operations,但是在backward过程中没有报错,那么梯度的计算就是正确的。

class torch.autograd.Variable [source]

包装一个Tensor,并记录用在它身上的operations

VariableTensor对象的一个thin wrapper,它同时保存着Variable的梯度和创建这个VariableFunction的引用。这个引用可以用来追溯创建这个Variable的整条链。如果Variable是被用户所创建的,那么它的creatorNone,我们称这种对象为 leaf Variables

由于autograd只支持标量值的反向求导(即:y是标量),梯度的大小总是和数据的大小匹配。同时,仅仅给leaf variables分配梯度,其他Variable的梯度总是为0.

变量:

  • data – 包含的Tensor

  • grad – 保存着Variable的梯度。这个属性是懒分配的,且不能被重新分配。

  • requires_grad – 布尔值,指示这个Variable是否是被一个包含Variable的子图创建的。更多细节请看Excluding subgraphs from backward。只能改变leaf variable的这个标签。

  • volatile – 布尔值,指示这个Variable是否被用于推断模式(即,不保存历史信息)。更多细节请看Excluding subgraphs from backward。只能改变leaf variable的这个标签。

  • creator – 创建这个VariableFunction,对于leaf variable,这个属性为None。只读属性。

属性:

  • data (any tensor class) – 被包含的Tensor

  • requires_grad (bool) – requires_grad标记. 只能通过keyword传入.

  • volatile (bool) – volatile标记. 只能通过keyword传入.

backward(gradient=None, retain_variables=False)[source]

当前Variableleaf variable求偏导。

计算图可以通过链式法则求导。如果Variable是 非标量(non-scalar)的,且requires_grad=True。那么此函数需要指定gradient,它的形状应该和Variable的长度匹配,里面保存了Variable的梯度。

此函数累积leaf variable的梯度。你可能需要在调用此函数之前将Variable的梯度置零。

参数:

  • gradient (Tensor) – 其他函数对于此Variable的导数。仅当Variable不是标量的时候使用,类型和位形状应该和self.data一致。
  • retain_variables (bool) – True, 计算梯度所必要的buffer在经历过一次backward过程后不会被释放。如果你想多次计算某个子图的梯度的时候,设置为True。在某些情况下,使用autograd.backward()效率更高。

detach()[source]

Returns a new Variable, detached from the current graph. 返回一个新的Variable,从当前图中分离下来的。

返回的Variable requires_grad=False,如果输入 volatile=True,那么返回的Variable volatile=True

注意:

返回的Variable和原始的Variable公用同一个data tensorin-place修改会在两个Variable上同时体现(因为它们共享data tensor),可能会导致错误。

detach_()[source]

将一个Variable从创建它的图中分离,并把它设置成leaf variable

register_hook(hook)[source]

注册一个backward钩子。

每次gradients被计算的时候,这个hook都被调用。hook应该拥有以下签名:

hook(grad) -> Variable or None

hook不应该修改它的输入,但是它可以选择性的返回一个替代当前梯度的新梯度。

这个函数返回一个 句柄(handle)。它有一个方法 handle.remove(),可以用这个方法将hookmodule移除。

Example

v = Variable(torch.Tensor([0, 0, 0]), requires_grad=True)
h = v.register_hook(lambda grad: grad * 2)  # double the gradient
v.backward(torch.Tensor([1, 1, 1]))
#先计算原始梯度,再进hook,获得一个新梯度。
print(v.grad.data)

 2
 2
 2
[torch.FloatTensor of size 3]
>>> h.remove()  # removes the hook
def w_hook(grad):
    print("hello")
    return None
w1 = Variable(torch.FloatTensor([1, 1, 1]),requires_grad=True)

w1.register_hook(w_hook) # 如果hook返回的是None的话,那么梯度还是原来计算的梯度。

w1.backward(gradient=torch.FloatTensor([1, 1, 1]))
print(w1.grad)
hello
Variable containing:
 1
 1
 1
[torch.FloatTensor of size 3]

reinforce(reward)[source]

注册一个奖励,这个奖励是由一个随机过程得到的。

微分一个随机节点需要提供一个奖励值。如果你的计算图中包含随机 operations,你需要在他们的输出上调用这个函数。否则的话,会报错。

参数:

  • reward (Tensor) – 每个元素的reward。必须和Varaible形状相同,并在同一个设备上。

class torch.autograd.Function[source]

Records operation history and defines formulas for differentiating ops. 记录operation的历史,定义微分公式。 每个执行在Varaibles上的operation都会创建一个Function对象,这个Function对象执行计算工作,同时记录下来。这个历史以有向无环图的形式保存下来,有向图的节点为functions,有向图的边代表数据依赖关系(input<-output)。之后,当backward被调用的时候,计算图以拓扑顺序处理,通过调用每个Function对象的backward(),同时将返回的梯度传递给下一个Function

通常情况下,用户能和Functions交互的唯一方法就是创建Function的子类,定义新的operation。这是扩展torch.autograd的推荐方法。

由于Function逻辑在很多脚本上都是热点,所有我们把几乎所有的Function都使用C实现,通过这种策略保证框架的开销是最小的。

每个Function只被使用一次(在forward过程中)。

变量:

  • saved_tensors – 调用forward()时需要被保存的 Tensorstuple

  • needs_input_grad – 长度为 输入数量的 布尔值组成的 tuple。指示给定的input是否需要梯度。这个被用来优化用于backward过程中的buffer,忽略backward中的梯度计算。

  • num_inputs – forward 的输入参数数量。

  • num_outputs – forward返回的Tensor数量。

  • requires_grad – 布尔值。指示backward以后会不会被调用。

  • previous_functions – 长度为 num_inputs的 Tuple of (int, Function) pairs。Tuple中的每单元保存着创建 inputFunction的引用,和索引。

backward(* grad_output)[source]

定义了operation的微分公式。

所有的Function子类都应该重写这个方法。

所有的参数都是Tensor。他必须接收和forward的输出 相同个数的参数。而且它需要返回和forward的输入参数相同个数的Tensor。 即:backward的输入参数是 此operation的输出的值的梯度。backward的返回值是此operation输入值的梯度。

forward(* input)[source]

执行operation

所有的Function子类都需要重写这个方法。

可以接收和返回任意个数 tensors

mark_dirty(* args)[source]

将输入的 tensors 标记为被in-place operation修改过。

这个方法应当至多调用一次,仅仅用在 forward方法里,而且mark_dirty的实参只能是forward的实参。

每个在forward方法中被in-place operations修改的tensor都应该传递给这个方法。这样,可以保证检查的正确性。这个方法在tensor修改前后调用都可以。

mark_non_differentiable(* args)[source]

将输出标记为不可微。

这个方法至多只能被调用一次,只能在forward中调用,而且实参只能是forward的返回值。

这个方法会将输出标记成不可微,会增加backward过程中的效率。在backward中,你依旧需要接收forward输出值的梯度,但是这些梯度一直是None

This is used e.g. for indices returned from a max Function.

mark_shared_storage(* pairs)[source]

将给定的tensors pairs标记为共享存储空间。

这个方法至多只能被调用一次,只能在forward中调用,而且所有的实参必须是(input, output)对。

如果一些 inputsoutputs 是共享存储空间的,所有的这样的 (input, output)对都应该传给这个函数,保证 in-place operations 检查的正确性。唯一的特例就是,当 outputinput是同一个tensor(in-place operations的输入和输出)。这种情况下,就没必要指定它们之间的依赖关系,因为这个很容易就能推断出来。

这个函数在很多时候都用不到。主要是用在 索引 和 转置 这类的 op 中。

save_for_backward(* tensors)[source]

将传入的 tensor 保存起来,留着backward的时候用。

这个方法至多只能被调用一次,只能在forward中调用。

之后,被保存的tensors可以通过 saved_tensors属性获取。在返回这些tensors之前,pytorch做了一些检查,保证这些tensor没有被in-place operations修改过。

实参可以是None