NestedIOFunction

class torch.autograd.function.NestedIOFunction(*args, **kwargs)

這個類別僅為了向後相容性而存在。對於任何新的使用案例，請使用 Function 來代替它。

backward(*gradients)

共享的反向傳播工具。

回傳類型

Any

backward_extended(*grad_output)

使用者定義的反向傳播。

forward(*args)

共享的前向傳播工具。

回傳類型

Any

forward_extended(*input)

使用者定義的前向傳播。

static jvp(ctx, *grad_inputs)

定義一個公式，用於使用前向模式自動微分來區分運算。

這個函式要被所有子類別覆寫。它必須接受一個 context ctx 作為第一個參數，後面跟著和 forward() 取得一樣多的輸入（對於 forward 函式的非 tensor 輸入，將傳入 None），而且它應該回傳和 forward() 的輸出一樣多的 tensors。每個參數是相對於給定輸入的梯度，而且每個回傳值應該是相對於對應輸出的梯度。如果一個輸出不是 Tensor，或者該函式相對於該輸出不可微分，你可以只將 None 作為該輸入的梯度傳入。

你可以使用 ctx 物件來將任何值從 forward 傳遞到這個函式。

回傳類型

Any

mark_dirty(*args, **kwargs)

參見 Function.mark_dirty()。

mark_non_differentiable(*args, **kwargs)

參見 Function.mark_non_differentiable()。

save_for_backward(*args)

參見 Function.save_for_backward()。

save_for_forward(*tensors)

儲存給定的 tensors，以便將來呼叫 jvp()。

save_for_forward 應該最多被呼叫一次，在 setup_context() 或 forward() 方法中，而且所有參數都應該是 tensors。

在 jvp() 中，可以透過 saved_tensors 屬性存取儲存的物件。

參數也可以是 None。這是一個無操作。

請參閱 擴展 torch.autograd 以了解如何使用此方法的更多詳細資訊。

範例：

>>> class Func(torch.autograd.Function):
>>>     @staticmethod
>>>     def forward(ctx, x: torch.Tensor, y: torch.Tensor, z: int):
>>>         ctx.save_for_backward(x, y)
>>>         ctx.save_for_forward(x, y)
>>>         ctx.z = z
>>>         return x * y * z
>>>
>>>     @staticmethod
>>>     def jvp(ctx, x_t, y_t, _):
>>>         x, y = ctx.saved_tensors
>>>         z = ctx.z
>>>         return z * (y * x_t + x * y_t)
>>>
>>>     @staticmethod
>>>     def vjp(ctx, grad_out):
>>>         x, y = ctx.saved_tensors
>>>         z = ctx.z
>>>         return z * grad_out * y, z * grad_out * x, None
>>>
>>>     a = torch.tensor(1., requires_grad=True, dtype=torch.double)
>>>     t = torch.tensor(1., dtype=torch.double)
>>>     b = torch.tensor(2., requires_grad=True, dtype=torch.double)
>>>     c = 4
>>>
>>>     with fwAD.dual_level():
>>>         a_dual = fwAD.make_dual(a, t)
>>>         d = Func.apply(a_dual, b, c)

property saved_tensors

請參閱 Function.saved_tensors()。

set_materialize_grads(value)

設定是否實例化梯度 tensors。預設值為 True。

這應該只從 setup_context() 或 forward() 方法中呼叫。

如果 True，未定義的梯度 tensors 將在呼叫 backward() 和 jvp() 方法之前，擴展為充滿零的 tensors。

範例：

>>> class SimpleFunc(Function):
>>>     @staticmethod
>>>     def forward(ctx, x):
>>>         return x.clone(), x.clone()
>>>
>>>     @staticmethod
>>>     @once_differentiable
>>>     def backward(ctx, g1, g2):
>>>         return g1 + g2  # No check for None necessary
>>>
>>> # We modify SimpleFunc to handle non-materialized grad outputs
>>> class Func(Function):
>>>     @staticmethod
>>>     def forward(ctx, x):
>>>         ctx.set_materialize_grads(False)
>>>         ctx.save_for_backward(x)
>>>         return x.clone(), x.clone()
>>>
>>>     @staticmethod
>>>     @once_differentiable
>>>     def backward(ctx, g1, g2):
>>>         x, = ctx.saved_tensors
>>>         grad_input = torch.zeros_like(x)
>>>         if g1 is not None:  # We must check for None now
>>>             grad_input += g1
>>>         if g2 is not None:
>>>             grad_input += g2
>>>         return grad_input
>>>
>>> a = torch.tensor(1., requires_grad=True)
>>> b, _ = Func.apply(a)  # induces g2 to be undefined

static setup_context(ctx, inputs, output)

有兩種方法可以定義 autograd.Function 的 forward pass。

或者

1. 覆寫具有簽名 forward(ctx, *args, **kwargs) 的 forward。 setup_context 不會被覆寫。 設定 ctx 以進行 backward 的動作發生在 forward 內部。

2. 覆寫具有簽名 forward(*args, **kwargs) 的 forward 並覆寫 setup_context。設定 ctx 以進行 backward 的動作發生在 setup_context 內部（而不是在 forward 內部）

請參閱 torch.autograd.Function.forward() 和 擴展 torch.autograd 以了解更多詳細資訊。

回傳類型

Any

static vjp(ctx, *grad_outputs)

定義使用 backward 模式自動微分來區分運算的公式。

此函式將被所有子類別覆寫。（定義此函式等同於定義 vjp 函式。）

它必須接受上下文 ctx 作為第一個參數，後跟與 forward() 返回的輸出一樣多的輸出 (對於 forward 函式的非 tensor 輸出，將傳入 None)，並且它應該返回與 forward() 的輸入一樣多的 tensors。每個參數都是相對於給定輸出的梯度，並且每個返回值應該是相對於相應輸入的梯度。如果輸入不是 Tensor 或者是不需要梯度的 Tensor，您可以只傳遞 None 作為該輸入的梯度。

上下文可用於檢索在 forward pass 期間儲存的 tensors。 它還有一個屬性 ctx.needs_input_grad 作為布林值的元組，表示每個輸入是否需要梯度。 例如，如果 forward() 的第一個輸入需要計算相對於輸出的梯度，則 backward() 將具有 ctx.needs_input_grad[0] = True。

回傳類型

Any

static vmap(info, in_dims, *args)

定義在 torch.vmap() 下方此 autograd.Function 的行為。

為了使 torch.autograd.Function() 支援 torch.vmap()，您必須覆寫此靜態方法，或將 generate_vmap_rule 設為 True (兩者不可同時進行)。

如果您選擇覆寫此 staticmethod：它必須接受

• 一個 info 物件作為第一個引數。info.batch_size 指定正在 vmap 的維度大小，而 info.randomness 是傳遞給 torch.vmap() 的 randomness 選項。

• 一個 in_dims tuple 作為第二個引數。對於 args 中的每個 arg，in_dims 都有一個對應的 Optional[int]。如果 arg 不是 Tensor，或如果 arg 沒有被 vmap，則為 None，否則它是一個整數，指定 Tensor 的哪個維度正在被 vmap。

• *args，與 forward() 的引數相同。

vmap staticmethod 的傳回值是一個 (output, out_dims) tuple。與 in_dims 類似，out_dims 應該與 output 具有相同的結構，並且每個輸出都包含一個 out_dim，用於指定輸出是否具有 vmap 維度以及它位於哪個索引中。

有關更多詳細資訊，請參閱 使用 autograd.Function 擴充 torch.func。