123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168 |
- --- /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<tf32_on_ampere>`.
-
- * :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)
- -
|