|
@@ -0,0 +1,140 @@
|
|
|
|
+--- /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<tf32_on_ampere>`.
|
|
|
|
+
|
|
|
|
+ * :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)
|
|
|
|
+-
|