torch.nn.modules.pooling 的源代码

from typing import List, Optional

from torch import Tensor
from .module import Module
from .utils import _single, _pair, _triple
from .. import functional as F

from ..common_types import (_size_any_t, _size_1_t, _size_2_t, _size_3_t,
                            _ratio_3_t, _ratio_2_t, _size_any_opt_t, _size_2_opt_t, _size_3_opt_t)

__all__ = ['MaxPool1d', 'MaxPool2d', 'MaxPool3d', 'MaxUnpool1d', 'MaxUnpool2d', 'MaxUnpool3d',
           'AvgPool1d', 'AvgPool2d', 'AvgPool3d', 'FractionalMaxPool2d', 'FractionalMaxPool3d', 'LPPool1d',
           'LPPool2d', 'LPPool3d', 'AdaptiveMaxPool1d', 'AdaptiveMaxPool2d', 'AdaptiveMaxPool3d',
           'AdaptiveAvgPool1d', 'AdaptiveAvgPool2d', 'AdaptiveAvgPool3d']

class _MaxPoolNd(Module):
    __constants__ = ['kernel_size', 'stride', 'padding', 'dilation',
                     'return_indices', 'ceil_mode']
    return_indices: bool
    ceil_mode: bool

    def __init__(self, kernel_size: _size_any_t, stride: Optional[_size_any_t] = None,
                 padding: _size_any_t = 0, dilation: _size_any_t = 1,
                 return_indices: bool = False, ceil_mode: bool = False) -> None:
        super().__init__()
        self.kernel_size = kernel_size
        self.stride = stride if (stride is not None) else kernel_size
        self.padding = padding
        self.dilation = dilation
        self.return_indices = return_indices
        self.ceil_mode = ceil_mode

    def extra_repr(self) -> str:
        return 'kernel_size={kernel_size}, stride={stride}, padding={padding}' \
            ', dilation={dilation}, ceil_mode={ceil_mode}'.format(**self.__dict__)


class MaxPool1d(_MaxPoolNd):
    r"""对由多个输入平面组成的输入信号应用1D最大池化。

    在最简单的情况下，具有输入大小 :math:`(N, C, L)`
    和输出 :math:`(N, C, L_{out})` 的层的输出值可以精确描述为：

    .. math::
        out(N_i, C_j, k) = \max_{m=0, \ldots, \text{kernel\_size} - 1}
                input(N_i, C_j, stride \times k + m)

    如果 :attr:`padding` 非零，则输入在两侧隐式填充负无穷
    对于 :attr:`padding` 个点。:attr:`dilation` 是滑动窗口内元素之间的步幅。
    这个 `link`_ 有池化参数的很好的可视化。

    注意：
        当 ceil_mode=True 时，滑动窗口允许超出边界，如果它们在左侧填充
        或输入内开始。在右侧填充区域开始的滑动窗口将被忽略。

    参数：
        kernel_size: 滑动窗口的大小，必须 > 0。
        stride: 滑动窗口的步幅，必须 > 0。默认值为 :attr:`kernel_size`。
        padding: 两侧隐式添加的负无穷填充，必须 >= 0 且 <= kernel_size / 2。
        dilation: 滑动窗口内元素之间的步幅，必须 > 0。
        return_indices: 如果 ``True``，将返回最大值的索引以及最大值。
                        对于之后的 :class:`torch.nn.MaxUnpool1d` 很有用
        ceil_mode: 如果 ``True``，将使用 `ceil` 而不是 `floor` 来计算输出形状。
                   这确保输入张量的每个元素都被滑动窗口覆盖。

    形状：
        - 输入: :math:`(N, C, L_{in})` 或 :math:`(C, L_{in})`。
        - 输出: :math:`(N, C, L_{out})` 或 :math:`(C, L_{out})`，其中

          .. math::
              L_{out} = \left\lfloor \frac{L_{in} + 2 \times \text{padding} - \text{dilation}
                    \times (\text{kernel\_size} - 1) - 1}{\text{stride}} + 1\right\rfloor

    示例::

        >>> # 池化窗口大小=3，步幅=2
        >>> m = nn.MaxPool1d(3, stride=2)
        >>> input = torch.randn(20, 16, 50)
        >>> output = m(input)

    .. _link:
        https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md
    """

    kernel_size: _size_1_t
    stride: _size_1_t
    padding: _size_1_t
    dilation: _size_1_t

    def forward(self, input: Tensor):
        return F.max_pool1d(input, self.kernel_size, self.stride,
                            self.padding, self.dilation, ceil_mode=self.ceil_mode,
                            return_indices=self.return_indices)


<a class="viewcode-back" href