--- /usr/local/lib/python3.5/dist-packages/torch/nn/modules/conv.py +++ /usr/local/lib/python3.5/dist-packages/torch/nn/modules/conv.py @@ -1,5 +1,5 @@ class Conv2d(_ConvNd): - __doc__ = r"""Applies a 2D convolution over an input signal composed of several input + r"""Applies a 2D convolution over an input signal composed of several input planes. In the simplest case, the output value of the layer with input size @@ -15,21 +15,29 @@ :math:`N` is a batch size, :math:`C` denotes a number of channels, :math:`H` is a height of input planes in pixels, and :math:`W` is width in pixels. - """ + r""" - - This module supports :ref:`TensorFloat32`. * :attr:`stride` controls the stride for the cross-correlation, a single number or a tuple. - * :attr:`padding` controls the amount of implicit padding on both + * :attr:`padding` controls the amount of implicit zero-paddings on both sides for :attr:`padding` number of points for each dimension. * :attr:`dilation` controls the spacing between the kernel points; also known as the ид trous algorithm. It is harder to describe, but this `link`_ has a nice visualization of what :attr:`dilation` does. - {groups_note} + * :attr:`groups` controls the connections between inputs and outputs. + :attr:`in_channels` and :attr:`out_channels` must both be divisible by + :attr:`groups`. For example, + + * At groups=1, all inputs are convolved to all outputs. + * At groups=2, the operation becomes equivalent to having two conv + layers side by side, each seeing half the input channels, + and producing half the output channels, and both subsequently + concatenated. + * At groups= :attr:`in_channels`, each input channel is convolved with + its own set of filters, of size: + :math:`\left\lfloor\frac{C_\text{out}}{C_\text{in}}\right\rfloor`. The parameters :attr:`kernel_size`, :attr:`stride`, :attr:`padding`, :attr:`dilation` can either be: @@ -37,27 +45,34 @@ - a ``tuple`` of two ints -- in which case, the first `int` is used for the height dimension, and the second `int` for the width dimension - Note: - {depthwise_separable_note} + .. note:: - Note: - {cudnn_reproducibility_note} + Depending of the size of your kernel, several (of the last) + columns of the input might be lost, because it is a valid `cross-correlation`_, + and not a full `cross-correlation`_. + It is up to the user to add proper padding. + + .. note:: + + When `groups == in_channels` and `out_channels == K * in_channels`, + where `K` is a positive integer, this operation is also termed in + literature as depthwise convolution. + + In other words, for an input of size :math:`(N, C_{in}, H_{in}, W_{in})`, + a depthwise convolution with a depthwise multiplier `K`, can be constructed by arguments + :math:`(in\_channels=C_{in}, out\_channels=C_{in} \times K, ..., groups=C_{in})`. + + .. include:: cudnn_deterministic.rst Args: in_channels (int): Number of channels in the input image out_channels (int): Number of channels produced by the convolution kernel_size (int or tuple): Size of the convolving kernel 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 - padding_mode (string, optional): ``'zeros'``, ``'reflect'``, - ``'replicate'`` or ``'circular'``. Default: ``'zeros'`` + 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 - bias (bool, optional): If ``True``, adds a learnable bias to the - output. Default: ``True`` - """.format(**reproducibility_notes, **convolution_notes) + r""" + groups (int, optional): Number of blocked connections from input channels to output channels. Default: 1 + bias (bool, optional): If ``True``, adds a learnable bias to the output. Default: ``True`` Shape: - Input: :math:`(N, C_{in}, H_{in}, W_{in})` @@ -73,18 +88,16 @@ Attributes: weight (Tensor): the learnable weights of the module of shape - :math:`(\text{out\_channels}, \frac{\text{in\_channels}}{\text{groups}},` - :math:`\text{kernel\_size[0]}, \text{kernel\_size[1]})`. - The values of these weights are sampled from - :math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})` where - :math:`k = \frac{groups}{C_\text{in} * \prod_{i=0}^{1}\text{kernel\_size}[i]}` - bias (Tensor): the learnable bias of the module of shape - (out_channels). If :attr:`bias` is ``True``, - then the values of these weights are - sampled from :math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})` where - :math:`k = \frac{groups}{C_\text{in} * \prod_{i=0}^{1}\text{kernel\_size}[i]}` + (out_channels, in_channels, kernel_size[0], kernel_size[1]). + The values of these weights are sampled from + :math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})` where + :math:`k = \frac{1}{C_\text{in} * \prod_{i=0}^{1}\text{kernel\_size}[i]}` + bias (Tensor): the learnable bias of the module of shape (out_channels). If :attr:`bias` is ``True``, + then the values of these weights are + sampled from :math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})` where + :math:`k = \frac{1}{C_\text{in} * \prod_{i=0}^{1}\text{kernel\_size}[i]}` - Examples: + Examples:: >>> # With square kernels and equal stride >>> m = nn.Conv2d(16, 33, 3, stride=2) @@ -101,35 +114,18 @@ .. _link: https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md """ + def __init__(self, in_channels, out_channels, kernel_size, stride=1, + padding=0, dilation=1, groups=1, bias=True): + kernel_size = _pair(kernel_size) + stride = _pair(stride) + padding = _pair(padding) + dilation = _pair(dilation) + super(Conv2d, self).__init__( + in_channels, out_channels, kernel_size, stride, padding, dilation, + False, _pair(0), groups, bias) - def __init__( - self, - in_channels: int, - out_channels: int, - kernel_size: _size_2_t, - stride: _size_2_t = 1, - padding: _size_2_t = 0, - dilation: _size_2_t = 1, - groups: int = 1, - bias: bool = True, - padding_mode: str = 'zeros' # TODO: refine this type - ): - kernel_size_ = _pair(kernel_size) - stride_ = _pair(stride) - padding_ = _pair(padding) - dilation_ = _pair(dilation) - super(Conv2d, self).__init__( - in_channels, out_channels, kernel_size_, stride_, padding_, dilation_, - False, _pair(0), groups, bias, padding_mode) - - def _conv_forward(self, input: Tensor, weight: Tensor, bias: Optional[Tensor]): - if self.padding_mode != 'zeros': - return F.conv2d(F.pad(input, self._reversed_padding_repeated_twice, mode=self.padding_mode), - weight, bias, self.stride, - _pair(0), self.dilation, self.groups) - return F.conv2d(input, weight, bias, self.stride, + @weak_script_method + def forward(self, input): + return F.conv2d(input, self.weight, self.bias, self.stride, self.padding, self.dilation, self.groups) - def forward(self, input: Tensor) -> Tensor: - return self._conv_forward(input, self.weight, self.bias) -