--- /usr/local/lib/python3.5/dist-packages/torch/nn/modules/conv.py +++ /usr/local/lib/python3.5/dist-packages/torch/nn/modules/conv.py @@ -15,8 +15,6 @@ :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. - - This module supports :ref:`TensorFloat32`. * :attr:`stride` controls the stride for the cross-correlation, a single number or a tuple. @@ -39,7 +37,7 @@ concatenated. * At groups= :attr:`in_channels`, each input channel is convolved with its own set of filters, of size: - :math:`\left\lfloor\frac{out\_channels}{in\_channels}\right\rfloor`. + :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: @@ -47,14 +45,14 @@ - 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: + .. 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: + .. note:: When `groups == in_channels` and `out_channels == K * in_channels`, where `K` is a positive integer, this operation is also termed in @@ -64,29 +62,17 @@ 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})`. - Note: - In some circumstances when using the CUDA backend with CuDNN, this operator - may select a nondeterministic algorithm to increase performance. If this is - undesirable, you can try to make the operation deterministic (potentially at - a performance cost) by setting ``torch.backends.cudnn.deterministic = - True``. - Please see the notes on :doc:`/notes/randomness` for background. - + .. 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`` + 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})` @@ -102,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) @@ -130,34 +114,18 @@ .. _link: https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md """ - 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 - ): + 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, padding_mode) + False, _pair(0), groups, bias) - def _conv_forward(self, input, weight): - if self.padding_mode != 'zeros': - return F.conv2d(F.pad(input, self._reversed_padding_repeated_twice, mode=self.padding_mode), - weight, self.bias, self.stride, - _pair(0), self.dilation, self.groups) - return F.conv2d(input, weight, self.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) -