def conv3d(input,
weight,
bias=None,
stride=1,
padding=0,
dilation=1,
groups=1):
"""Applies a 3D convolution over an input image composed of several input
planes.
See :class:`~torch.nn.Conv3d` for details and output shape.
Args:
input: input tensor of shape (minibatch x in_channels x iT x iH x iW)
weight: filters tensor of shape (out_channels, in_channels, kT, kH, kW)
bias: optional bias tensor of shape (out_channels)
stride: the stride of the convolving kernel. Can be a single number or
a tuple (st x sh x sw). Default: 1
padding: implicit zero padding on the input. Can be a single number or
a tuple. Default: 0
Examples:
>>> filters = autograd.Variable(torch.randn(33, 16, 3, 3, 3))
>>> inputs = autograd.Variable(torch.randn(20, 16, 50, 10, 20))
>>> F.conv3d(inputs)
"""
f = ConvNd(_triple(stride), _triple(padding), _triple(dilation), False,
_triple(0), groups)
return f(input, weight, bias) if bias is not None else f(input, weight)
def conv1d(input,
weight,
bias=None,
stride=1,
padding=0,
dilation=1,
groups=1):
"""Applies a 1D convolution over an input signal composed of several input
planes.
See :class:`~torch.nn.Conv1d` for details and output shape.
Args:
input: input tensor of shape (minibatch x in_channels x iW)
weight: filters of shape (out_channels, in_channels, kW)
bias: optional bias of shape (out_channels)
stride: the stride of the convolving kernel, default 1
Examples:
>>> filters = autograd.Variable(torch.randn(33, 16, 3))
>>> inputs = autograd.Variable(torch.randn(20, 16, 50))
>>> F.conv1d(inputs)
"""
f = ConvNd(_single(stride), _single(padding), _single(dilation), False,
_single(0), groups)
return f(input, weight, bias) if bias is not None else f(input, weight)
def conv_transpose2d(input,
weight,
bias=None,
stride=1,
padding=0,
output_padding=0,
groups=1):
"""Applies a 2D transposed convolution operator over an input image
composed of several input planes, sometimes also called "deconvolution".
See :class:`~torch.nn.ConvTranspose2d` for details and output shape.
Args:
input: input tensor of shape (minibatch x in_channels x iH x iW)
weight: filters of shape (in_channels x out_channels x kH x kW)
bias: optional bias of shape (out_channels)
stride: the stride of the convolving kernel, a single number or a
tuple (sh x sw). Default: 1
padding: implicit zero padding on the input, a single number or a
tuple (padh x padw). Default: 0
groups: split input into groups, in_channels should be divisible by
the number of groups
output_padding: A zero-padding of 0 <= padding < stride that should be
added to the output. Can be a single number or a tuple. Default: 0
"""
f = ConvNd(_pair(stride), _pair(padding), _pair(1), True,
_pair(output_padding), groups)
return f(input, weight, bias) if bias is not None else f(input, weight)
def conv2d(input,
weight,
bias=None,
stride=1,
padding=0,
dilation=1,
groups=1):
"""Applies a 2D convolution over an input image composed of several input
planes.
See :class:`~torch.nn.Conv2d` for details and output shape.
Args:
input: input tensor (minibatch x in_channels x iH x iW)
weight: filters tensor (out_channels, in_channels/groups, kH, kW)
bias: optional bias tensor (out_channels)
stride: the stride of the convolving kernel. Can be a single number or
a tuple (sh x sw). Default: 1
padding: implicit zero padding on the input. Can be a single number or
a tuple. Default: 0
groups: split input into groups, in_channels should be divisible by
the number of groups
Examples:
>>> # With square kernels and equal stride
>>> filters = autograd.Variable(torch.randn(8,4,3,3))
>>> inputs = autograd.Variable(torch.randn(1,4,5,5))
>>> F.conv2d(inputs, filters, padding=1)
"""
f = ConvNd(_pair(stride), _pair(padding), _pair(dilation), False, _pair(0),
groups)
return f(input, weight, bias) if bias is not None else f(input, weight)
def conv_transpose1d(input,
weight,
bias=None,
stride=1,
padding=0,
output_padding=0,
groups=1):
f = ConvNd(_single(stride), _single(padding), _single(1), True,
_single(output_padding), groups)
return f(input, weight, bias) if bias is not None else f(input, weight)
def conv_transpose3d(input, weight, bias=None, stride=1, padding=0,
output_padding=0, groups=1):
"""Applies a 3D transposed convolution operator over an input image
composed of several input planes, sometimes also called "deconvolution"
See :class:`~torch.nn.ConvTranspose3d` for details and output shape.
Args:
input: input tensor of shape (minibatch x in_channels x iT x iH x iW)
weight: filters of shape (in_channels x out_channels x kH x kW)
bias: optional bias of shape (out_channels)
stride: the stride of the convolving kernel, a single number or a
tuple (sh x sw). Default: 1
padding: implicit zero padding on the input, a single number or a
tuple (padh x padw). Default: 0
"""
f = ConvNd(_triple(stride), _triple(padding), _triple(1), True,
_triple(output_padding), groups)
return f(input, weight, bias) if bias is not None else f(input, weight)