# Source code for torch.nn.modules.pooling

import torch

from .module import Module
from .utils import _single, _pair, _triple
from .. import functional as F
from ..._jit_internal import weak_module, weak_script_method

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

def __init__(self, kernel_size, stride=None, padding=0, dilation=1,
return_indices=False, ceil_mode=False):
super(_MaxPoolNd, self).__init__()
self.kernel_size = kernel_size
self.stride = stride or kernel_size
self.dilation = dilation
self.return_indices = return_indices
self.ceil_mode = ceil_mode

def extra_repr(self):
', dilation={dilation}, ceil_mode={ceil_mode}'.format(**self.__dict__)

[docs]@weak_module
class MaxPool1d(_MaxPoolNd):
r"""Applies a 1D max pooling over an input signal composed of several input
planes.

In the simplest case, the output value of the layer with input size :math:(N, C, L)
and output :math:(N, C, L_{out}) can be precisely described as:

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

If :attr:padding is non-zero, then the input is implicitly zero-padded on both sides
for :attr:padding number of points. :attr:dilation controls the spacing between the kernel points.
It is harder to describe, but this link_ has a nice visualization of what :attr:dilation does.

Args:
kernel_size: the size of the window to take a max over
stride: the stride of the window. Default value is :attr:kernel_size
dilation: a parameter that controls the stride of elements in the window
return_indices: if True, will return the max indices along with the outputs.
Useful for :class:torch.nn.MaxUnpool1d later
ceil_mode: when True, will use ceil instead of floor to compute the output shape

Shape:
- Input: :math:(N, C, L_{in})
- Output: :math:(N, C, L_{out}), where

.. 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

Examples::

>>> # pool of size=3, stride=2
>>> m = nn.MaxPool1d(3, stride=2)
>>> input = torch.randn(20, 16, 50)
>>> output = m(input)

"""

@weak_script_method
def forward(self, input):
return F.max_pool1d(input, self.kernel_size, self.stride,
self.return_indices)

def extra_repr(self):
', dilation={dilation}, ceil_mode={ceil_mode}'.format(**self.__dict__)

[docs]@weak_module
class MaxPool2d(_MaxPoolNd):
r"""Applies a 2D max pooling over an input signal composed of several input
planes.

In the simplest case, the output value of the layer with input size :math:(N, C, H, W),
output :math:(N, C, H_{out}, W_{out}) and :attr:kernel_size :math:(kH, kW)
can be precisely described as:

.. math::
\begin{aligned}
out(N_i, C_j, h, w) ={} & \max_{m=0, \ldots, kH-1} \max_{n=0, \ldots, kW-1} \\
& \text{input}(N_i, C_j, \text{stride[0]} \times h + m,
\text{stride[1]} \times w + n)
\end{aligned}

If :attr:padding is non-zero, then the input is implicitly zero-padded on both sides
for :attr:padding number of points. :attr:dilation controls the spacing between the kernel points.
It is harder to describe, but this link_ has a nice visualization of what :attr:dilation does.

The parameters :attr:kernel_size, :attr:stride, :attr:padding, :attr:dilation can either be:

- a single int -- in which case the same value is used for the height and width dimension
- 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

Args:
kernel_size: the size of the window to take a max over
stride: the stride of the window. Default value is :attr:kernel_size
dilation: a parameter that controls the stride of elements in the window
return_indices: if True, will return the max indices along with the outputs.
Useful for :class:torch.nn.MaxUnpool2d later
ceil_mode: when True, will use ceil instead of floor to compute the output shape

Shape:
- Input: :math:(N, C, H_{in}, W_{in})
- Output: :math:(N, C, H_{out}, W_{out}), where

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

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

Examples::

>>> # pool of square window of size=3, stride=2
>>> m = nn.MaxPool2d(3, stride=2)
>>> # pool of non-square window
>>> m = nn.MaxPool2d((3, 2), stride=(2, 1))
>>> input = torch.randn(20, 16, 50, 32)
>>> output = m(input)

"""

@weak_script_method
def forward(self, input):
return F.max_pool2d(input, self.kernel_size, self.stride,
self.return_indices)

[docs]@weak_module
class MaxPool3d(_MaxPoolNd):
r"""Applies a 3D max pooling over an input signal composed of several input
planes. This is not a test

In the simplest case, the output value of the layer with input size :math:(N, C, D, H, W),
output :math:(N, C, D_{out}, H_{out}, W_{out}) and :attr:kernel_size :math:(kD, kH, kW)
can be precisely described as:

.. math::
\begin{aligned}
\text{out}(N_i, C_j, d, h, w) ={} & \max_{k=0, \ldots, kD-1} \max_{m=0, \ldots, kH-1} \max_{n=0, \ldots, kW-1} \\
& \text{input}(N_i, C_j, \text{stride[0]} \times k + d,
\text{stride[1]} \times h + m, \text{stride[2]} \times w + n)
\end{aligned}

If :attr:padding is non-zero, then the input is implicitly zero-padded on both sides
for :attr:padding number of points. :attr:dilation controls the spacing between the kernel points.
It is harder to describe, but this link_ has a nice visualization of what :attr:dilation does.

The parameters :attr:kernel_size, :attr:stride, :attr:padding, :attr:dilation can either be:

- a single int -- in which case the same value is used for the depth, height and width dimension
- a tuple of three ints -- in which case, the first int is used for the depth dimension,
the second int for the height dimension and the third int for the width dimension

Args:
kernel_size: the size of the window to take a max over
stride: the stride of the window. Default value is :attr:kernel_size
dilation: a parameter that controls the stride of elements in the window
return_indices: if True, will return the max indices along with the outputs.
Useful for :class:torch.nn.MaxUnpool3d later
ceil_mode: when True, will use ceil instead of floor to compute the output shape

Shape:
- Input: :math:(N, C, D_{in}, H_{in}, W_{in})
- Output: :math:(N, C, D_{out}, H_{out}, W_{out}), where

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

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

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

Examples::

>>> # pool of square window of size=3, stride=2
>>> m = nn.MaxPool3d(3, stride=2)
>>> # pool of non-square window
>>> m = nn.MaxPool3d((3, 2, 2), stride=(2, 1, 2))
>>> input = torch.randn(20, 16, 50,44, 31)
>>> output = m(input)

"""  # noqa: E501

@weak_script_method
def forward(self, input):
return F.max_pool3d(input, self.kernel_size, self.stride,
self.return_indices)

@weak_module
class _MaxUnpoolNd(Module):

def extra_repr(self):
)

[docs]@weak_module
class MaxUnpool1d(_MaxUnpoolNd):
r"""Computes a partial inverse of :class:MaxPool1d.

:class:MaxPool1d is not fully invertible, since the non-maximal values are lost.

:class:MaxUnpool1d takes in as input the output of :class:MaxPool1d
including the indices of the maximal values and computes a partial inverse
in which all non-maximal values are set to zero.

.. note:: :class:MaxPool1d can map several input sizes to the same output
sizes. Hence, the inversion process can get ambiguous.
To accommodate this, you can provide the needed output size
as an additional argument :attr:output_size in the forward call.
See the Inputs and Example below.

Args:
kernel_size (int or tuple): Size of the max pooling window.
stride (int or tuple): Stride of the max pooling window.
It is set to :attr:kernel_size by default.

Inputs:
- input: the input Tensor to invert
- indices: the indices given out by :class:~torch.nn.MaxPool1d
- output_size (optional): the targeted output size

Shape:
- Input: :math:(N, C, H_{in})
- Output: :math:(N, C, H_{out}), where

.. math::
H_{out} = (H_{in} - 1) \times \text{stride}[0] - 2 \times \text{padding}[0] + \text{kernel\_size}[0]

or as given by :attr:output_size in the call operator

Example::

>>> pool = nn.MaxPool1d(2, stride=2, return_indices=True)
>>> unpool = nn.MaxUnpool1d(2, stride=2)
>>> input = torch.tensor([[[1., 2, 3, 4, 5, 6, 7, 8]]])
>>> output, indices = pool(input)
>>> unpool(output, indices)
tensor([[[ 0.,  2.,  0.,  4.,  0.,  6.,  0., 8.]]])

>>> # Example showcasing the use of output_size
>>> input = torch.tensor([[[1., 2, 3, 4, 5, 6, 7, 8, 9]]])
>>> output, indices = pool(input)
>>> unpool(output, indices, output_size=input.size())
tensor([[[ 0.,  2.,  0.,  4.,  0.,  6.,  0., 8.,  0.]]])

>>> unpool(output, indices)
tensor([[[ 0.,  2.,  0.,  4.,  0.,  6.,  0., 8.]]])
"""

super(MaxUnpool1d, self).__init__()
self.kernel_size = _single(kernel_size)
self.stride = _single(stride or kernel_size)

def forward(self, input, indices, output_size=None):
return F.max_unpool1d(input, indices, self.kernel_size, self.stride,

[docs]@weak_module
class MaxUnpool2d(_MaxUnpoolNd):
r"""Computes a partial inverse of :class:MaxPool2d.

:class:MaxPool2d is not fully invertible, since the non-maximal values are lost.

:class:MaxUnpool2d takes in as input the output of :class:MaxPool2d
including the indices of the maximal values and computes a partial inverse
in which all non-maximal values are set to zero.

.. note:: :class:MaxPool2d can map several input sizes to the same output
sizes. Hence, the inversion process can get ambiguous.
To accommodate this, you can provide the needed output size
as an additional argument :attr:output_size in the forward call.
See the Inputs and Example below.

Args:
kernel_size (int or tuple): Size of the max pooling window.
stride (int or tuple): Stride of the max pooling window.
It is set to :attr:kernel_size by default.

Inputs:
- input: the input Tensor to invert
- indices: the indices given out by :class:~torch.nn.MaxPool2d
- output_size (optional): the targeted output size

Shape:
- Input: :math:(N, C, H_{in}, W_{in})
- Output: :math:(N, C, H_{out}, W_{out}), where

.. math::
H_{out} = (H_{in} - 1) \times \text{stride[0]} - 2 \times \text{padding[0]} + \text{kernel\_size[0]}

.. math::
W_{out} = (W_{in} - 1) \times \text{stride[1]} - 2 \times \text{padding[1]} + \text{kernel\_size[1]}

or as given by :attr:output_size in the call operator

Example::

>>> pool = nn.MaxPool2d(2, stride=2, return_indices=True)
>>> unpool = nn.MaxUnpool2d(2, stride=2)
>>> input = torch.tensor([[[[ 1.,  2,  3,  4],
[ 5,  6,  7,  8],
[ 9, 10, 11, 12],
[13, 14, 15, 16]]]])
>>> output, indices = pool(input)
>>> unpool(output, indices)
tensor([[[[  0.,   0.,   0.,   0.],
[  0.,   6.,   0.,   8.],
[  0.,   0.,   0.,   0.],
[  0.,  14.,   0.,  16.]]]])

>>> # specify a different output size than input size
>>> unpool(output, indices, output_size=torch.Size([1, 1, 5, 5]))
tensor([[[[  0.,   0.,   0.,   0.,   0.],
[  6.,   0.,   8.,   0.,   0.],
[  0.,   0.,   0.,  14.,   0.],
[ 16.,   0.,   0.,   0.,   0.],
[  0.,   0.,   0.,   0.,   0.]]]])
"""

super(MaxUnpool2d, self).__init__()
self.kernel_size = _pair(kernel_size)
self.stride = _pair(stride or kernel_size)

def forward(self, input, indices, output_size=None):
return F.max_unpool2d(input, indices, self.kernel_size, self.stride,

[docs]@weak_module
class MaxUnpool3d(_MaxUnpoolNd):
r"""Computes a partial inverse of :class:MaxPool3d.

:class:MaxPool3d is not fully invertible, since the non-maximal values are lost.
:class:MaxUnpool3d takes in as input the output of :class:MaxPool3d
including the indices of the maximal values and computes a partial inverse
in which all non-maximal values are set to zero.

.. note:: :class:MaxPool3d can map several input sizes to the same output
sizes. Hence, the inversion process can get ambiguous.
To accommodate this, you can provide the needed output size
as an additional argument :attr:output_size in the forward call.
See the Inputs section below.

Args:
kernel_size (int or tuple): Size of the max pooling window.
stride (int or tuple): Stride of the max pooling window.
It is set to :attr:kernel_size by default.

Inputs:
- input: the input Tensor to invert
- indices: the indices given out by :class:~torch.nn.MaxPool3d
- output_size (optional): the targeted output size

Shape:
- Input: :math:(N, C, D_{in}, H_{in}, W_{in})
- Output: :math:(N, C, D_{out}, H_{out}, W_{out}), where

.. math::
D_{out} = (D_{in} - 1) \times \text{stride[0]} - 2 \times \text{padding[0]} + \text{kernel\_size[0]}

.. math::
H_{out} = (H_{in} - 1) \times \text{stride[1]} - 2 \times \text{padding[1]} + \text{kernel\_size[1]}

.. math::
W_{out} = (W_{in} - 1) \times \text{stride[2]} - 2 \times \text{padding[2]} + \text{kernel\_size[2]}

or as given by :attr:output_size in the call operator

Example::

>>> # pool of square window of size=3, stride=2
>>> pool = nn.MaxPool3d(3, stride=2, return_indices=True)
>>> unpool = nn.MaxUnpool3d(3, stride=2)
>>> output, indices = pool(torch.randn(20, 16, 51, 33, 15))
>>> unpooled_output = unpool(output, indices)
>>> unpooled_output.size()
torch.Size([20, 16, 51, 33, 15])
"""

super(MaxUnpool3d, self).__init__()
self.kernel_size = _triple(kernel_size)
self.stride = _triple(stride or kernel_size)

def forward(self, input, indices, output_size=None):
return F.max_unpool3d(input, indices, self.kernel_size, self.stride,

@weak_module
class _AvgPoolNd(Module):

def extra_repr(self):
)

[docs]@weak_module
class AvgPool1d(_AvgPoolNd):
r"""Applies a 1D average pooling over an input signal composed of several
input planes.

In the simplest case, the output value of the layer with input size :math:(N, C, L),
output :math:(N, C, L_{out}) and :attr:kernel_size :math:k
can be precisely described as:

.. math::

\text{out}(N_i, C_j, l) = \frac{1}{k} \sum_{m=0}^{k}
\text{input}(N_i, C_j, \text{stride} \times l + m)

If :attr:padding is non-zero, then the input is implicitly zero-padded on both sides
for :attr:padding number of points.

The parameters :attr:kernel_size, :attr:stride, :attr:padding can each be
an int or a one-element tuple.

Args:
kernel_size: the size of the window
stride: the stride of the window. Default value is :attr:kernel_size
ceil_mode: when True, will use ceil instead of floor to compute the output shape

Shape:
- Input: :math:(N, C, L_{in})
- Output: :math:(N, C, L_{out}), where

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

Examples::

>>> # pool with window of size=3, stride=2
>>> m = nn.AvgPool1d(3, stride=2)
>>> m(torch.tensor([[[1.,2,3,4,5,6,7]]]))
tensor([[[ 2.,  4.,  6.]]])
"""
def __init__(self, kernel_size, stride=None, padding=0, ceil_mode=False,
super(AvgPool1d, self).__init__()
self.kernel_size = _single(kernel_size)
self.stride = _single(stride if stride is not None else kernel_size)
self.ceil_mode = ceil_mode

@weak_script_method
def forward(self, input):
return F.avg_pool1d(

[docs]@weak_module
class AvgPool2d(_AvgPoolNd):
r"""Applies a 2D average pooling over an input signal composed of several input
planes.

In the simplest case, the output value of the layer with input size :math:(N, C, H, W),
output :math:(N, C, H_{out}, W_{out}) and :attr:kernel_size :math:(kH, kW)
can be precisely described as:

.. math::

out(N_i, C_j, h, w)  = \frac{1}{kH * kW} \sum_{m=0}^{kH-1} \sum_{n=0}^{kW-1}
input(N_i, C_j, stride[0] \times h + m, stride[1] \times w + n)

If :attr:padding is non-zero, then the input is implicitly zero-padded on both sides
for :attr:padding number of points.

The parameters :attr:kernel_size, :attr:stride, :attr:padding can either be:

- a single int -- in which case the same value is used for the height and width dimension
- 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

Args:
kernel_size: the size of the window
stride: the stride of the window. Default value is :attr:kernel_size
ceil_mode: when True, will use ceil instead of floor to compute the output shape

Shape:
- Input: :math:(N, C, H_{in}, W_{in})
- Output: :math:(N, C, H_{out}, W_{out}), where

.. math::
H_{out} = \left\lfloor\frac{H_{in}  + 2 \times \text{padding}[0] -
\text{kernel\_size}[0]}{\text{stride}[0]} + 1\right\rfloor

.. math::
W_{out} = \left\lfloor\frac{W_{in}  + 2 \times \text{padding}[1] -
\text{kernel\_size}[1]}{\text{stride}[1]} + 1\right\rfloor

Examples::

>>> # pool of square window of size=3, stride=2
>>> m = nn.AvgPool2d(3, stride=2)
>>> # pool of non-square window
>>> m = nn.AvgPool2d((3, 2), stride=(2, 1))
>>> input = torch.randn(20, 16, 50, 32)
>>> output = m(input)
"""
def __init__(self, kernel_size, stride=None, padding=0, ceil_mode=False,
super(AvgPool2d, self).__init__()
self.kernel_size = kernel_size
self.stride = stride or kernel_size
self.ceil_mode = ceil_mode

@weak_script_method
def forward(self, input):
return F.avg_pool2d(input, self.kernel_size, self.stride,

[docs]@weak_module
class AvgPool3d(_AvgPoolNd):
r"""Applies a 3D average pooling over an input signal composed of several input
planes.

In the simplest case, the output value of the layer with input size :math:(N, C, D, H, W),
output :math:(N, C, D_{out}, H_{out}, W_{out}) and :attr:kernel_size :math:(kD, kH, kW)
can be precisely described as:

.. math::
\begin{aligned}
\text{out}(N_i, C_j, d, h, w) ={} & \sum_{k=0}^{kD-1} \sum_{m=0}^{kH-1} \sum_{n=0}^{kW-1} \\
& \frac{\text{input}(N_i, C_j, \text{stride}[0] \times d + k,
\text{stride}[1] \times h + m, \text{stride}[2] \times w + n)}
{kD \times kH \times kW}
\end{aligned}

If :attr:padding is non-zero, then the input is implicitly zero-padded on all three sides
for :attr:padding number of points.

The parameters :attr:kernel_size, :attr:stride can either be:

- a single int -- in which case the same value is used for the depth, height and width dimension
- a tuple of three ints -- in which case, the first int is used for the depth dimension,
the second int for the height dimension and the third int for the width dimension

Args:
kernel_size: the size of the window
stride: the stride of the window. Default value is :attr:kernel_size
ceil_mode: when True, will use ceil instead of floor to compute the output shape

Shape:
- Input: :math:(N, C, D_{in}, H_{in}, W_{in})
- Output: :math:(N, C, D_{out}, H_{out}, W_{out}), where

.. math::
D_{out} = \left\lfloor\frac{D_{in} + 2 \times \text{padding}[0] -
\text{kernel\_size}[0]}{\text{stride}[0]} + 1\right\rfloor

.. math::
H_{out} = \left\lfloor\frac{H_{in} + 2 \times \text{padding}[1] -
\text{kernel\_size}[1]}{\text{stride}[1]} + 1\right\rfloor

.. math::
W_{out} = \left\lfloor\frac{W_{in} + 2 \times \text{padding}[2] -
\text{kernel\_size}[2]}{\text{stride}[2]} + 1\right\rfloor

Examples::

>>> # pool of square window of size=3, stride=2
>>> m = nn.AvgPool3d(3, stride=2)
>>> # pool of non-square window
>>> m = nn.AvgPool3d((3, 2, 2), stride=(2, 1, 2))
>>> input = torch.randn(20, 16, 50,44, 31)
>>> output = m(input)
"""
def __init__(self, kernel_size, stride=None, padding=0, ceil_mode=False,
super(AvgPool3d, self).__init__()
self.kernel_size = kernel_size
self.stride = stride or kernel_size
self.ceil_mode = ceil_mode

@weak_script_method
def forward(self, input):
return F.avg_pool3d(input, self.kernel_size, self.stride,

def __setstate__(self, d):
super(AvgPool3d, self).__setstate__(d)
self.__dict__.setdefault('ceil_mode', False)

[docs]@weak_module
class FractionalMaxPool2d(Module):
r"""Applies a 2D fractional max pooling over an input signal composed of several input planes.

Fractional MaxPooling is described in detail in the paper Fractional MaxPooling_ by Ben Graham

The max-pooling operation is applied in :math:kHxkW regions by a stochastic
step size determined by the target output size.
The number of output features is equal to the number of input planes.

Args:
kernel_size: the size of the window to take a max over.
Can be a single number k (for a square kernel of k x k) or a tuple (kh x kw)
output_size: the target output size of the image of the form oH x oW.
Can be a tuple (oH, oW) or a single number oH for a square image oH x oH
output_ratio: If one wants to have an output size as a ratio of the input size, this option can be given.
This has to be a number or tuple in the range (0, 1)
return_indices: if True, will return the indices along with the outputs.
Useful to pass to :meth:nn.MaxUnpool2d. Default: False

Examples:
>>> # pool of square window of size=3, and target output size 13x12
>>> m = nn.FractionalMaxPool2d(3, output_size=(13, 12))
>>> # pool of square window and target output size being half of input image size
>>> m = nn.FractionalMaxPool2d(3, output_ratio=(0.5, 0.5))
>>> input = torch.randn(20, 16, 50, 32)
>>> output = m(input)

.. _Fractional MaxPooling:
http://arxiv.org/abs/1412.6071
"""
__constants__ = ['kernel_size', 'return_indices', 'output_size',
'output_ratio']

def __init__(self, kernel_size, output_size=None, output_ratio=None,
return_indices=False, _random_samples=None):
super(FractionalMaxPool2d, self).__init__()
self.kernel_size = _pair(kernel_size)
self.return_indices = return_indices
self.register_buffer('_random_samples', _random_samples)
self.output_size = _pair(output_size) if output_size is not None else None
self.output_ratio = _pair(output_ratio) if output_ratio is not None else None
if output_size is None and output_ratio is None:
raise ValueError("FractionalMaxPool2d requires specifying either "
"an output size, or a pooling ratio")
if output_size is not None and output_ratio is not None:
raise ValueError("only one of output_size and output_ratio may be specified")
if self.output_ratio is not None:
if not (0 < self.output_ratio[0] < 1 and 0 < self.output_ratio[1] < 1):
raise ValueError("output_ratio must be between 0 and 1 (got {})"
.format(output_ratio))

@weak_script_method
def forward(self, input):
return F.fractional_max_pool2d(
input, self.kernel_size, self.output_size, self.output_ratio,
self.return_indices,
_random_samples=self._random_samples)

@weak_module
class _LPPoolNd(Module):
__constants__ = ['norm_type', 'kernel_size', 'stride', 'ceil_mode']

def __init__(self, norm_type, kernel_size, stride=None, ceil_mode=False):
super(_LPPoolNd, self).__init__()
self.norm_type = norm_type
self.kernel_size = kernel_size
self.stride = stride
self.ceil_mode = ceil_mode

def extra_repr(self):
return 'norm_type={norm_type}, kernel_size={kernel_size}, stride={stride}, ' \
'ceil_mode={ceil_mode}'.format(**self.__dict__)

[docs]@weak_module
class LPPool1d(_LPPoolNd):
r"""Applies a 1D power-average pooling over an input signal composed of several input
planes.

On each window, the function computed is:

.. math::
f(X) = \sqrt[p]{\sum_{x \in X} x^{p}}

- At p = infinity, one gets Max Pooling
- At p = 1, one gets Sum Pooling (which is proportional to Average Pooling)

.. note:: If the sum to the power of p is zero, the gradient of this function is
not defined. This implementation will set the gradient to zero in this case.

Args:
kernel_size: a single int, the size of the window
stride: a single int, the stride of the window. Default value is :attr:kernel_size
ceil_mode: when True, will use ceil instead of floor to compute the output shape

Shape:
- Input: :math:(N, C, L_{in})
- Output: :math:(N, C, L_{out}), where

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

Examples::
>>> # power-2 pool of window of length 3, with stride 2.
>>> m = nn.LPPool1d(2, 3, stride=2)
>>> input = torch.randn(20, 16, 50)
>>> output = m(input)
"""

@weak_script_method
@weak_script_method
def forward(self, input):
return F.lp_pool1d(input, float(self.norm_type), self.kernel_size,
self.stride, self.ceil_mode)

[docs]@weak_module
class LPPool2d(_LPPoolNd):
r"""Applies a 2D power-average pooling over an input signal composed of several input
planes.

On each window, the function computed is:

.. math::
f(X) = \sqrt[p]{\sum_{x \in X} x^{p}}

- At p = :math:\infty, one gets Max Pooling
- At p = 1, one gets Sum Pooling (which is proportional to average pooling)

The parameters :attr:kernel_size, :attr:stride can either be:

- a single int -- in which case the same value is used for the height and width dimension
- 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:: If the sum to the power of p is zero, the gradient of this function is
not defined. This implementation will set the gradient to zero in this case.

Args:
kernel_size: the size of the window
stride: the stride of the window. Default value is :attr:kernel_size
ceil_mode: when True, will use ceil instead of floor to compute the output shape

Shape:
- Input: :math:(N, C, H_{in}, W_{in})
- Output: :math:(N, C, H_{out}, W_{out}), where

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

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

Examples::

>>> # power-2 pool of square window of size=3, stride=2
>>> m = nn.LPPool2d(2, 3, stride=2)
>>> # pool of non-square window of power 1.2
>>> m = nn.LPPool2d(1.2, (3, 2), stride=(2, 1))
>>> input = torch.randn(20, 16, 50, 32)
>>> output = m(input)

"""

@weak_script_method
def forward(self, input):
return F.lp_pool2d(input, float(self.norm_type), self.kernel_size,
self.stride, self.ceil_mode)

@weak_module
__constants__ = ['output_size', 'return_indices']

def __init__(self, output_size, return_indices=False):
self.output_size = output_size
self.return_indices = return_indices

def extra_repr(self):
return 'output_size={}'.format(self.output_size)

# FIXME (by @ssnl): Improve adaptive pooling docs: specify what the input and
#   output shapes are, and how the operation computes output.

[docs]@weak_module
r"""Applies a 1D adaptive max pooling over an input signal composed of several input planes.

The output size is H, for any input size.
The number of output features is equal to the number of input planes.

Args:
output_size: the target output size H
return_indices: if True, will return the indices along with the outputs.
Useful to pass to nn.MaxUnpool1d. Default: False

Examples:
>>> # target output size of 5
>>> input = torch.randn(1, 64, 8)
>>> output = m(input)

"""

@weak_script_method
def forward(self, input):

[docs]@weak_module
r"""Applies a 2D adaptive max pooling over an input signal composed of several input planes.

The output is of size H x W, for any input size.
The number of output features is equal to the number of input planes.

Args:
output_size: the target output size of the image of the form H x W.
Can be a tuple (H, W) or a single H for a square image H x H.
H and W can be either a int, or None which means the size will
be the same as that of the input.
return_indices: if True, will return the indices along with the outputs.
Useful to pass to nn.MaxUnpool2d. Default: False

Examples:
>>> # target output size of 5x7
>>> input = torch.randn(1, 64, 8, 9)
>>> output = m(input)
>>> # target output size of 7x7 (square)
>>> input = torch.randn(1, 64, 10, 9)
>>> output = m(input)
>>> # target output size of 10x7
>>> input = torch.randn(1, 64, 10, 9)
>>> output = m(input)

"""

@weak_script_method
def forward(self, input):

[docs]@weak_module
r"""Applies a 3D adaptive max pooling over an input signal composed of several input planes.

The output is of size D x H x W, for any input size.
The number of output features is equal to the number of input planes.

Args:
output_size: the target output size of the image of the form D x H x W.
Can be a tuple (D, H, W) or a single D for a cube D x D x D.
D, H and W can be either a int, or None which means the size will
be the same as that of the input.

return_indices: if True, will return the indices along with the outputs.
Useful to pass to nn.MaxUnpool3d. Default: False

Examples:
>>> # target output size of 5x7x9
>>> input = torch.randn(1, 64, 8, 9, 10)
>>> output = m(input)
>>> # target output size of 7x7x7 (cube)
>>> input = torch.randn(1, 64, 10, 9, 8)
>>> output = m(input)
>>> # target output size of 7x9x8
>>> m = nn.AdaptiveMaxPool3d((7, None, None))
>>> input = torch.randn(1, 64, 10, 9, 8)
>>> output = m(input)

"""

@weak_script_method
def forward(self, input):

@weak_module
__constants__ = ['output_size']

def __init__(self, output_size):
self.output_size = output_size

def extra_repr(self):
return 'output_size={}'.format(self.output_size)

[docs]@weak_module
r"""Applies a 1D adaptive average pooling over an input signal composed of several input planes.

The output size is H, for any input size.
The number of output features is equal to the number of input planes.

Args:
output_size: the target output size H

Examples:
>>> # target output size of 5
>>> input = torch.randn(1, 64, 8)
>>> output = m(input)

"""

@weak_script_method
def forward(self, input):

[docs]@weak_module
r"""Applies a 2D adaptive average pooling over an input signal composed of several input planes.

The output is of size H x W, for any input size.
The number of output features is equal to the number of input planes.

Args:
output_size: the target output size of the image of the form H x W.
Can be a tuple (H, W) or a single H for a square image H x H
H and W can be either a int, or None which means the size will
be the same as that of the input.

Examples:
>>> # target output size of 5x7
>>> input = torch.randn(1, 64, 8, 9)
>>> output = m(input)
>>> # target output size of 7x7 (square)
>>> input = torch.randn(1, 64, 10, 9)
>>> output = m(input)
>>> # target output size of 10x7
>>> input = torch.randn(1, 64, 10, 9)
>>> output = m(input)

"""

@weak_script_method
def forward(self, input):

[docs]@weak_module
r"""Applies a 3D adaptive average pooling over an input signal composed of several input planes.

The output is of size D x H x W, for any input size.
The number of output features is equal to the number of input planes.

Args:
output_size: the target output size of the form D x H x W.
Can be a tuple (D, H, W) or a single number D for a cube D x D x D
D, H and W can be either a int, or None which means the size will
be the same as that of the input.

Examples:
>>> # target output size of 5x7x9
>>> input = torch.randn(1, 64, 8, 9, 10)
>>> output = m(input)
>>> # target output size of 7x7x7 (cube)