190 lines
9.5 KiB
Python
190 lines
9.5 KiB
Python
"""Gradient interface."""
|
|
|
|
import torch
|
|
from .modules.utils import _single, _pair, _triple
|
|
|
|
|
|
def conv1d_input(input_size, weight, grad_output, stride=1, padding=0, dilation=1, groups=1):
|
|
r"""Compute the gradient of conv1d with respect to the input of the convolution.
|
|
|
|
This is same as the 1D transposed convolution operator under the hood but requires
|
|
the shape of the gradient w.r.t. input to be specified explicitly.
|
|
|
|
Args:
|
|
input_size : Shape of the input gradient tensor
|
|
weight: weight tensor (out_channels x in_channels/groups x kW)
|
|
grad_output : output gradient tensor (minibatch x out_channels x oW)
|
|
stride (int or tuple, optional): Stride of the convolution. Default: 1
|
|
padding (int or tuple, optional): Zero-padding added to both sides of the input. Default: 0
|
|
dilation (int or tuple, optional): Spacing between kernel elements. Default: 1
|
|
groups (int, optional): Number of blocked connections from input channels to output channels. Default: 1
|
|
|
|
Examples::
|
|
|
|
>>> input = torch.randn(1, 1, 3, requires_grad=True)
|
|
>>> weight = torch.randn(1, 1, 1, requires_grad=True)
|
|
>>> output = F.conv1d(input, weight)
|
|
>>> grad_output = torch.randn(output.shape)
|
|
>>> grad_input = torch.autograd.grad(output, input, grad_output)
|
|
>>> F.grad.conv1d_input(input.shape, weight, grad_output)
|
|
|
|
"""
|
|
input = grad_output.new_empty(1).expand(input_size)
|
|
|
|
return torch.ops.aten.convolution_backward(grad_output, input, weight, None,
|
|
_single(stride), _single(padding), _single(dilation),
|
|
False, [0], groups, (True, False, False))[0]
|
|
|
|
|
|
def conv1d_weight(input, weight_size, grad_output, stride=1, padding=0, dilation=1, groups=1):
|
|
r"""Compute the gradient of conv1d with respect to the weight of the convolution.
|
|
|
|
Args:
|
|
input: input tensor of shape (minibatch x in_channels x iW)
|
|
weight_size : Shape of the weight gradient tensor
|
|
grad_output : output gradient tensor (minibatch x out_channels x oW)
|
|
stride (int or tuple, optional): Stride of the convolution. Default: 1
|
|
padding (int or tuple, optional): Zero-padding added to both sides of the input. Default: 0
|
|
dilation (int or tuple, optional): Spacing between kernel elements. Default: 1
|
|
groups (int, optional): Number of blocked connections from input channels to output channels. Default: 1
|
|
|
|
Examples::
|
|
|
|
>>> input = torch.randn(1, 1, 3, requires_grad=True)
|
|
>>> weight = torch.randn(1, 1, 1, requires_grad=True)
|
|
>>> output = F.conv1d(input, weight)
|
|
>>> grad_output = torch.randn(output.shape)
|
|
>>> # xdoctest: +SKIP
|
|
>>> grad_weight = torch.autograd.grad(output, filter, grad_output)
|
|
>>> F.grad.conv1d_weight(input, weight.shape, grad_output)
|
|
|
|
"""
|
|
weight = grad_output.new_empty(1).expand(weight_size)
|
|
|
|
return torch.ops.aten.convolution_backward(grad_output, input, weight, None,
|
|
_single(stride), _single(padding), _single(dilation),
|
|
False, [0], groups, (False, True, False))[1]
|
|
|
|
|
|
def conv2d_input(input_size, weight, grad_output, stride=1, padding=0, dilation=1, groups=1):
|
|
r"""Compute the gradient of conv2d with respect to the input of the convolution.
|
|
|
|
This is same as the 2D transposed convolution operator under the hood but requires
|
|
the shape of the gradient w.r.t. input to be specified explicitly.
|
|
|
|
Args:
|
|
input_size : Shape of the input gradient tensor
|
|
weight: weight tensor (out_channels x in_channels/groups x kH x kW)
|
|
grad_output : output gradient tensor (minibatch x out_channels x oH x oW)
|
|
stride (int or tuple, optional): Stride of the convolution. Default: 1
|
|
padding (int or tuple, optional): Zero-padding added to both sides of the input. Default: 0
|
|
dilation (int or tuple, optional): Spacing between kernel elements. Default: 1
|
|
groups (int, optional): Number of blocked connections from input channels to output channels. Default: 1
|
|
|
|
Examples::
|
|
|
|
>>> input = torch.randn(1, 1, 3, 3, requires_grad=True)
|
|
>>> weight = torch.randn(1, 1, 1, 2, requires_grad=True)
|
|
>>> output = F.conv2d(input, weight)
|
|
>>> grad_output = torch.randn(output.shape)
|
|
>>> grad_input = torch.autograd.grad(output, input, grad_output)
|
|
>>> F.grad.conv2d_input(input.shape, weight, grad_output)
|
|
|
|
"""
|
|
input = grad_output.new_empty(1).expand(input_size)
|
|
|
|
return torch.ops.aten.convolution_backward(grad_output, input, weight, None,
|
|
_pair(stride), _pair(padding), _pair(dilation),
|
|
False, [0], groups, (True, False, False))[0]
|
|
|
|
|
|
def conv2d_weight(input, weight_size, grad_output, stride=1, padding=0, dilation=1, groups=1):
|
|
r"""Compute the gradient of conv2d with respect to the weight of the convolution.
|
|
|
|
Args:
|
|
input: input tensor of shape (minibatch x in_channels x iH x iW)
|
|
weight_size : Shape of the weight gradient tensor
|
|
grad_output : output gradient tensor (minibatch x out_channels x oH x oW)
|
|
stride (int or tuple, optional): Stride of the convolution. Default: 1
|
|
padding (int or tuple, optional): Zero-padding added to both sides of the input. Default: 0
|
|
dilation (int or tuple, optional): Spacing between kernel elements. Default: 1
|
|
groups (int, optional): Number of blocked connections from input channels to output channels. Default: 1
|
|
|
|
Examples::
|
|
|
|
>>> input = torch.randn(1, 1, 3, 3, requires_grad=True)
|
|
>>> weight = torch.randn(1, 1, 1, 2, requires_grad=True)
|
|
>>> output = F.conv2d(input, weight)
|
|
>>> grad_output = torch.randn(output.shape)
|
|
>>> # xdoctest: +SKIP
|
|
>>> grad_weight = torch.autograd.grad(output, filter, grad_output)
|
|
>>> F.grad.conv2d_weight(input, weight.shape, grad_output)
|
|
|
|
"""
|
|
weight = grad_output.new_empty(1).expand(weight_size)
|
|
|
|
return torch.ops.aten.convolution_backward(grad_output, input, weight, None,
|
|
_pair(stride), _pair(padding), _pair(dilation),
|
|
False, [0], groups, (False, True, False))[1]
|
|
|
|
|
|
def conv3d_input(input_size, weight, grad_output, stride=1, padding=0, dilation=1, groups=1):
|
|
r"""Compute the gradient of conv3d with respect to the input of the convolution.
|
|
|
|
This is same as the 3D transposed convolution operator under the hood but requires
|
|
the shape of the gradient w.r.t. input to be specified explicitly.
|
|
|
|
Args:
|
|
input_size : Shape of the input gradient tensor
|
|
weight: weights tensor (out_channels x in_channels/groups x kT x kH x kW)
|
|
grad_output : output gradient tensor (minibatch x out_channels x oT x oH x oW)
|
|
stride (int or tuple, optional): Stride of the convolution. Default: 1
|
|
padding (int or tuple, optional): Zero-padding added to both sides of the input. Default: 0
|
|
dilation (int or tuple, optional): Spacing between kernel elements. Default: 1
|
|
groups (int, optional): Number of blocked connections from input channels to output channels. Default: 1
|
|
|
|
Examples::
|
|
|
|
>>> input = torch.randn(2, 8, 10, 10, 20, requires_grad=True)
|
|
>>> weight = torch.randn(4, 8, 2, 3, 3, requires_grad=True)
|
|
>>> output = F.conv3d(input, weight)
|
|
>>> grad_output = torch.randn(output.shape)
|
|
>>> grad_input = torch.autograd.grad(output, input, grad_output)
|
|
>>> F.grad.conv3d_input(input.shape, weight, grad_output)
|
|
|
|
"""
|
|
input = grad_output.new_empty(1).expand(input_size)
|
|
|
|
return torch.ops.aten.convolution_backward(grad_output, input, weight, None,
|
|
_triple(stride), _triple(padding), _triple(dilation),
|
|
False, [0], groups, (True, False, False))[0]
|
|
|
|
|
|
def conv3d_weight(input, weight_size, grad_output, stride=1, padding=0, dilation=1, groups=1):
|
|
r"""Compute the gradient of conv3d with respect to the weight of the convolution.
|
|
|
|
Args:
|
|
input: input tensor of shape (minibatch x in_channels x iT x iH x iW)
|
|
weight_size : Shape of the weight gradient tensor
|
|
grad_output : output gradient tensor (minibatch x out_channels x oT x oH x oW)
|
|
stride (int or tuple, optional): Stride of the convolution. Default: 1
|
|
padding (int or tuple, optional): Zero-padding added to both sides of the input. Default: 0
|
|
dilation (int or tuple, optional): Spacing between kernel elements. Default: 1
|
|
groups (int, optional): Number of blocked connections from input channels to output channels. Default: 1
|
|
|
|
Examples::
|
|
|
|
>>> input = torch.randn(2, 8, 10, 10, 20, requires_grad=True)
|
|
>>> weight = torch.randn(4, 8, 2, 3, 3, requires_grad=True)
|
|
>>> output = F.conv3d(input, weight)
|
|
>>> grad_output = torch.randn(output.shape)
|
|
>>> grad_weight = torch.autograd.grad(output, weight, grad_output)
|
|
>>> F.grad.conv3d_weight(input, weight.shape, grad_output)
|
|
|
|
"""
|
|
weight = grad_output.new_empty(1).expand(weight_size)
|
|
|
|
return torch.ops.aten.convolution_backward(grad_output, input, weight, None,
|
|
_triple(stride), _triple(padding), _triple(dilation),
|
|
False, [0], groups, (False, True, False))[1]
|