/usr/local/lib64/python3.6/site-packages/torch/nn/modules/__pycache__
Edit: /usr/local/lib64/python3.6/site-packages/torch/nn/modules/__pycache__/pooling.cpython-36.pyc (53203B)
3
EgZ @ s d dl mZmZ d dlmZ ddlmZ ddlmZm Z m
Z
ddl m Z
ddlmZmZmZmZmZmZmZmZmZ G d d
d
eZG d d d eZG d
d deZG dd deZG dd deZ G dd de Z G dd de Z G dd de Z G dd deZ G dd d e Z!G d d d e Z"G d d d e Z#G d!d" d"eZ$G d#d$ d$eZ%G d%d& d&eZ&G d'd( d(e&Z'G d)d* d*e&Z(G d+d, d,eZ)G d-d. d.e)Z*G d/d0 d0e)Z+G d1d2 d2e)Z,G d3d4 d4eZ-G d5d6 d6e-Z.G d7d8 d8e-Z/G d9d: d:e-Z0d;S )< )ListOptional)Tensor )Module)_single_pair_triple )
functional) _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_tc s\ e Zd ZU ddddddgZeedeee eeeedd fd d
Z e
dddZ Z S )
_MaxPoolNd kernel_sizestridepaddingdilationreturn_indices ceil_modeNr r F)r r r r r r returnc sB t t| j || _|d k r |n|| _|| _|| _|| _|| _d S )N) superr __init__r r r r r r )selfr r r r r r ) __class__ D/usr/local/lib64/python3.6/site-packages/torch/nn/modules/pooling.pyr s z_MaxPoolNd.__init__)r c C s dj f | jS )Nzikernel_size={kernel_size}, stride={stride}, padding={padding}, dilation={dilation}, ceil_mode={ceil_mode})format__dict__)r r! r! r"
extra_repr s z_MaxPoolNd.extra_repr)Nr r FF)
__name__
__module__ __qualname__
__constants__boolr r r r r strr%
__classcell__r! r! )r r" r s
$ r c @ s2 e Zd ZU dZeeeee e dddZ
dS ) MaxPool1da 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 padded with negative infinity on both sides
for :attr:`padding` number of points. :attr:`dilation` is the stride between the elements within the
sliding window. This `link`_ has a nice visualization of the pooling parameters.
Note:
When ceil_mode=True, sliding windows are allowed to go off-bounds if they start within the left padding
or the input. Sliding windows that would start in the right padded region are ignored.
Args:
kernel_size: The size of the sliding window, must be > 0.
stride: The stride of the sliding window, must be > 0. Default value is :attr:`kernel_size`.
padding: Implicit negative infinity padding to be added on both sides, must be >= 0 and <= kernel_size / 2.
dilation: The stride between elements within a sliding window, must be > 0.
return_indices: If ``True``, will return the argmax along with the max values.
Useful for :class:`torch.nn.MaxUnpool1d` later
ceil_mode: If ``True``, will use `ceil` instead of `floor` to compute the output shape. This
ensures that every element in the input tensor is covered by a sliding window.
Shape:
- Input: :math:`(N, C, L_{in})` or :math:`(C, L_{in})`.
- Output: :math:`(N, C, L_{out})` or :math:`(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)
.. _link:
https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md
)inputr c C s" t j|| j| j| j| j| j| jS )N)FZ
max_pool1dr r r r r r )r r. r! r! r" forwardW s zMaxPool1d.forwardN) r& r' r( __doc__r
r r r r r r0 r! r! r! r" r- " s
.r- c @ s2 e Zd ZU dZeeeee e dddZ
dS ) MaxPool2da 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 padded with negative infinity 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.
Note:
When ceil_mode=True, sliding windows are allowed to go off-bounds if they start within the left padding
or the input. Sliding windows that would start in the right padded region are ignored.
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`
padding: implicit zero padding to be added on both sides
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})` or :math:`(C, H_{in}, W_{in})`
- Output: :math:`(N, C, H_{out}, W_{out})` or :math:`(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)
.. _link:
https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md
)r. r c C s" t j|| j| j| j| j| j| jS )N)r/ Z
max_pool2dr r r r r r )r r. r! r! r" r0 s zMaxPool2d.forwardN) r& r' r( r1 r r r r r r r0 r! r! r! r" r2 ] s
=r2 c @ s2 e Zd ZU dZeeeee e dddZ
dS ) MaxPool3da
Applies a 3D 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, 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 d + k,
\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 padded with negative infinity 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.
Note:
When ceil_mode=True, sliding windows are allowed to go off-bounds if they start within the left padding
or the input. Sliding windows that would start in the right padded region are ignored.
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`
padding: implicit zero padding to be added on all three sides
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})` or :math:`(C, D_{in}, H_{in}, W_{in})`.
- Output: :math:`(N, C, D_{out}, H_{out}, W_{out})` or :math:`(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)
.. _link:
https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md
)r. r c C s" t j|| j| j| j| j| j| jS )N)r/ Z
max_pool3dr r r r r r )r r. r! r! r" r0 s zMaxPool3d.forwardN) r& r' r( r1 r r r r r r r0 r! r! r! r" r3 s
Ar3 c @ s e Zd ZedddZdS ) _MaxUnpoolNd)r c C s dj | j| j| jS )Nz%kernel_size={}, stride={}, padding={})r# r r r )r r! r! r" r% s z_MaxUnpoolNd.extra_reprN)r& r' r( r+ r% r! r! r! r" r4 s r4 c s^ e Zd ZU dZeeed
eee edd fdd
Z d e
e
ee e e
ddd Z
ZS ) MaxUnpool1da 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.
padding (int or tuple): Padding that was added to the input
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})` or :math:`(C, H_{in})`.
- Output: :math:`(N, C, H_{out})` or :math:`(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.]]])
Nr )r r r r c s< t t| j t|| _t|d k r&|n|| _t|| _d S )N)r r5 r r r r r )r r r r )r r! r" r 7 s
zMaxUnpool1d.__init__)r. indices output_sizer c C s t j||| j| j| j|S )N)r/ Z max_unpool1dr r r )r r. r6 r7 r! r! r" r0 = s zMaxUnpool1d.forward)Nr )N)r& r' r( r1 r
r r r r r r r intr0 r, r! r! )r r" r5 s
4 r5 c s^ e Zd ZU dZeeed
eee edd fdd
Z d e
e
ee e e
ddd Z
ZS ) MaxUnpool2da|
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.
padding (int or tuple): Padding that was added to the input
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})` or :math:`(C, H_{in}, W_{in})`.
- Output: :math:`(N, C, H_{out}, W_{out})` or :math:`(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.]]]])
Nr )r r r r c s< t t| j t|| _t|d k r&|n|| _t|| _d S )N)r r9 r r r r r )r r r r )r r! r" r s
zMaxUnpool2d.__init__)r. r6 r7 r c C s t j||| j| j| j|S )N)r/ Z max_unpool2dr r r )r r. r6 r7 r! r! r" r0 s zMaxUnpool2d.forward)Nr )N)r& r' r( r1 r r r r r r r r r8 r0 r, r! r! )r r" r9 B s
< r9 c s^ e Zd ZU dZeeed
eee edd fdd
Z d e
e
ee e e
ddd Z
ZS ) MaxUnpool3da 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.
padding (int or tuple): Padding that was added to the input
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})` or :math:`(C, D_{in}, H_{in}, W_{in})`.
- Output: :math:`(N, C, D_{out}, H_{out}, W_{out})` or :math:`(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])
Nr )r r r r c s< t t| j t|| _t|d k r&|n|| _t|| _d S )N)r r: r r r r r )r r r r )r r! r" r s
zMaxUnpool3d.__init__)r. r6 r7 r c C s t j||| j| j| j|S )N)r/ Z max_unpool3dr r r )r r. r6 r7 r! r! r" r0 s zMaxUnpool3d.forward)Nr )N)r& r' r( r1 r r r r r r r r r8 r0 r, r! r! )r r" r: s
1 r: c @ s( e Zd ZdddddgZedddZd S )
_AvgPoolNdr r r r count_include_pad)r c C s dj | j| j| jS )Nz%kernel_size={}, stride={}, padding={})r# r r r )r r! r! r" r% s z_AvgPoolNd.extra_reprN)r& r' r( r) r+ r% r! r! r! r" r; s r; c sX e Zd ZU dZeeee e
d eeeeedd fdd
Z e e d d
d Z
ZS )
AvgPool1da 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-1}
\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.
Note:
When ceil_mode=True, sliding windows are allowed to go off-bounds if they start within the left padding
or the input. Sliding windows that would start in the right padded region are ignored.
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`
padding: implicit zero padding to be added on both sides
ceil_mode: when True, will use `ceil` instead of `floor` to compute the output shape
count_include_pad: when True, will include the zero-padding in the averaging calculation
Shape:
- Input: :math:`(N, C, L_{in})` or :math:`(C, L_{in}`.
- Output: :math:`(N, C, L_{out})` or :math:`(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.]]])
Nr FT)r r r r r< r c sH t t| j t|| _t|d k r&|n|| _t|| _|| _|| _d S )N) r r= r r r r r r r< )r r r r r r< )r r! r" r s
zAvgPool1d.__init__)r. r c C s t j|| j| j| j| j| jS )N)r/ Z
avg_pool1dr r r r r< )r r. r! r! r" r0 s zAvgPool1d.forward)Nr FT)r& r' r( r1 r
r r r r* r r< r r r0 r, r! r! )r r" r= s
, r= c sr e Zd ZU dZddddddgZeeee
e dee e ee e e e
dd fd
d
ZeedddZ ZS ) AvgPool2da 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.
Note:
When ceil_mode=True, sliding windows are allowed to go off-bounds if they start within the left padding
or the input. Sliding windows that would start in the right padded region are ignored.
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`
padding: implicit zero padding to be added on both sides
ceil_mode: when True, will use `ceil` instead of `floor` to compute the output shape
count_include_pad: when True, will include the zero-padding in the averaging calculation
divisor_override: if specified, it will be used as divisor, otherwise size of the pooling region will be used.
Shape:
- Input: :math:`(N, C, H_{in}, W_{in})` or :math:`(C, H_{in}, W_{in})`.
- Output: :math:`(N, C, H_{out}, W_{out})` or :math:`(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)
r r r r r< divisor_overrideNr FT)r r r r r< r? r c sB t t| j || _|d k r |n|| _|| _|| _|| _|| _d S )N) r r> r r r r r r< r? )r r r r r r< r? )r r! r" r ] s zAvgPool2d.__init__)r. r c C s" t j|| j| j| j| j| j| jS )N)r/ Z
avg_pool2dr r r r r< r? )r r. r! r! r" r0 g s zAvgPool2d.forward)Nr FTN)r& r' r( r1 r) r r r r r* r r< r r8 r r r0 r, r! r! )r r" r> s
7 ( r> c s~ e Zd ZU dZddddddgZeeee
e dee e ee e e e
dd fd
d
ZeedddZ fddZ ZS ) AvgPool3da 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.
Note:
When ceil_mode=True, sliding windows are allowed to go off-bounds if they start within the left padding
or the input. Sliding windows that would start in the right padded region are ignored.
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`
padding: implicit zero padding to be added on all three sides
ceil_mode: when True, will use `ceil` instead of `floor` to compute the output shape
count_include_pad: when True, will include the zero-padding in the averaging calculation
divisor_override: if specified, it will be used as divisor, otherwise :attr:`kernel_size` will be used
Shape:
- Input: :math:`(N, C, D_{in}, H_{in}, W_{in})` or :math:`(C, D_{in}, H_{in}, W_{in})`.
- Output: :math:`(N, C, D_{out}, H_{out}, W_{out})` or
:math:`(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)
r r r r r< r? Nr FT)r r r r r< r? r c sB t t| j || _|d k r |n|| _|| _|| _|| _|| _d S )N) r r@ r r r r r r< r? )r r r r r r< r? )r r! r" r s zAvgPool3d.__init__)r. r c C s" t j|| j| j| j| j| j| jS )N)r/ Z
avg_pool3dr r r r r< r? )r r. r! r! r" r0 s zAvgPool3d.forwardc s> t t| j| | jjdd | jjdd | jjdd d S )Nr r r Fr< T)r r@ __setstate__r$
setdefault)r d)r r! r" rA s zAvgPool3d.__setstate__)Nr FTN)r& r' r( r1 r) r r r r r* r r< r r8 r r r0 rA r, r! r! )r r" r@ l s
> ( r@ c sf e Zd ZU dZddddgZeee e
dee e e e
edd fd d
Z
eed d d
Z ZS )FractionalMaxPool2dax 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:`kH \times kW` 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, 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``
Shape:
- Input: :math:`(N, C, H_{in}, W_{in})` or :math:`(C, H_{in}, W_{in})`.
- Output: :math:`(N, C, H_{out}, W_{out})` or :math:`(C, H_{out}, W_{out})`, where
:math:`(H_{out}, W_{out})=\text{output\_size}` or
:math:`(H_{out}, W_{out})=\text{output\_ratio} \times (H_{in}, W_{in})`.
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:
https://arxiv.org/abs/1412.6071
r r r7 output_ratioNF)r r7 rE r r c s t t| j t|| _|| _| jd| |d k r:t|nd | _|d k rPt|nd | _|d krn|d krnt d|d k r|d k rt d| jd k rd| jd k odk n od| jd k odk n st dj
|d S )N_random_sampleszQFractionalMaxPool2d requires specifying either an output size, or a pooling ratioz9only one of output_size and output_ratio may be specifiedr r z-output_ratio must be between 0 and 1 (got {})) r rD r r r r register_bufferr7 rE
ValueErrorr# )r r r7 rE r rF )r r! r" r s
<z FractionalMaxPool2d.__init__)r. r c C s t j|| j| j| j| j| jdS )N)rF )r/ Zfractional_max_pool2dr r7 rE r rF )r r. r! r! r" r0 s zFractionalMaxPool2d.forward)NNFN)r& r' r( r1 r) r r r* r r7 r rE r r r r0 r, r! r! )r r" rD s
# $rD c sf e Zd ZU dZddddgZeee e
dee e e e
edd fd d
Z
eed d d
Z ZS )FractionalMaxPool3daN Applies a 3D 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:`kTxkHxkW` 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 x k) or a tuple `(kt x kh x kw)`
output_size: the target output size of the image of the form `oT x oH x oW`.
Can be a tuple `(oT, oH, oW)` or a single number oH for a square image `oH x 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.MaxUnpool3d`. Default: ``False``
Examples:
>>> # pool of cubic window of size=3, and target output size 13x12x11
>>> m = nn.FractionalMaxPool3d(3, output_size=(13, 12, 11))
>>> # pool of cubic window and target output size being half of input size
>>> m = nn.FractionalMaxPool3d(3, output_ratio=(0.5, 0.5, 0.5))
>>> input = torch.randn(20, 16, 50, 32, 16)
>>> output = m(input)
.. _Fractional MaxPooling:
https://arxiv.org/abs/1412.6071
r r r7 rE NF)r r7 rE r r c s t t| j t|| _|| _| jd| |d k r:t|nd | _|d k rPt|nd | _|d krn|d krnt d|d k r|d k rt d| jd k rd| jd k odk n od| jd k odk n od| jd k odk n st dj
|d S )NrF zQFractionalMaxPool3d requires specifying either an output size, or a pooling ratioz9only one of output_size and output_ratio may be specifiedr r r
z-output_ratio must be between 0 and 1 (got {})) r rI r r r r rG r7 rE rH r# )r r r7 rE r rF )r r! r" r 3 s
Zz FractionalMaxPool3d.__init__)r. r c C s t j|| j| j| j| j| jdS )N)rF )r/ Zfractional_max_pool3dr r7 rE r rF )r r. r! r! r" r0 F s zFractionalMaxPool3d.forward)NNFN)r& r' r( r1 r) r r r* r r7 r rE r r r r0 r, r! r! )r r" rI s
$rI c sT e Zd ZU ddddgZeed
eee e edd fdd
Z
e d
d d Z Z
S ) _LPPoolNd norm_typer r r NF)rK r r r r c s* t t| j || _|| _|| _|| _d S )N)r rJ r rK r r r )r rK r r r )r r! r" r S s
z_LPPoolNd.__init__)r c C s dj f | jS )NzXnorm_type={norm_type}, kernel_size={kernel_size}, stride={stride}, ceil_mode={ceil_mode})r# r$ )r r! r! r" r% [ s z_LPPoolNd.extra_repr)NF)r& r' r( r) floatrK r* r r r r r+ r% r, r! r! )r r" rJ M s
rJ c @ s* e Zd ZU dZeeeedddZdS )LPPool1da 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 = :math:`\infty`, 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})` or :math:`(C, L_{in})`.
- Output: :math:`(N, C, L_{out})` or :math:`(C, L_{out})`, where
.. math::
L_{out} = \left\lfloor\frac{L_{in} - \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)
)r. r c C s t j|t| j| j| j| jS )N)r/ Z lp_pool1drL rK r r r )r r. r! r! r" r0 s zLPPool1d.forwardN) r& r' r( r1 r
r r r r0 r! r! r! r" rM ` s
rM c @ s* e Zd ZU dZeeeedddZdS )LPPool2da 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} - \text{kernel\_size}[0]}{\text{stride}[0]} + 1\right\rfloor
.. math::
W_{out} = \left\lfloor\frac{W_{in} - \text{kernel\_size}[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)
)r. r c C s t j|t| j| j| j| jS )N)r/ Z lp_pool2drL rK r r r )r r. r! r! r" r0 s zLPPool2d.forwardN) r& r' r( r1 r r r r r0 r! r! r! r" rN s
-rN c sD e Zd ZU ddgZed eedd fdd
Zedd d
Z Z
S ) _AdaptiveMaxPoolNdr7 r FN)r7 r r c s t t| j || _|| _d S )N)r rO r r7 r )r r7 r )r r! r" r s z_AdaptiveMaxPoolNd.__init__)r c C s dj | jS )Nzoutput_size={})r# r7 )r r! r! r" r% s z _AdaptiveMaxPoolNd.extra_repr)F) r& r' r( r) r* r r r r+ r% r, r! r! )r r" rO s
rO c @ s& e Zd ZU dZeeedddZdS )AdaptiveMaxPool1da8 Applies a 1D adaptive max pooling over an input signal composed of several input planes.
The output size is :math:`L_{out}`, for any input size.
The number of output features is equal to the number of input planes.
Args:
output_size: the target output size :math:`L_{out}`.
return_indices: if ``True``, will return the indices along with the outputs.
Useful to pass to nn.MaxUnpool1d. Default: ``False``
Shape:
- Input: :math:`(N, C, L_{in})` or :math:`(C, L_{in})`.
- Output: :math:`(N, C, L_{out})` or :math:`(C, L_{out})`, where
:math:`L_{out}=\text{output\_size}`.
Examples:
>>> # target output size of 5
>>> m = nn.AdaptiveMaxPool1d(5)
>>> input = torch.randn(1, 64, 8)
>>> output = m(input)
)r. r c C s t j|| j| jS )N)r/ Zadaptive_max_pool1dr7 r )r r. r! r! r" r0 s zAdaptiveMaxPool1d.forwardN)r& r' r( r1 r
r7 r r0 r! r! r! r" rP s
rP c @ s& e Zd ZU dZeeedddZdS )AdaptiveMaxPool2daD Applies a 2D adaptive max pooling over an input signal composed of several input planes.
The output is of size :math:`H_{out} \times W_{out}`, 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 :math:`H_{out} \times W_{out}`.
Can be a tuple :math:`(H_{out}, W_{out})` or a single :math:`H_{out}` for a
square image :math:`H_{out} \times H_{out}`. :math:`H_{out}` and :math:`W_{out}`
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``
Shape:
- Input: :math:`(N, C, H_{in}, W_{in})` or :math:`(C, H_{in}, W_{in})`.
- Output: :math:`(N, C, H_{out}, W_{out})` or :math:`(C, H_{out}, W_{out})`, where
:math:`(H_{out}, W_{out})=\text{output\_size}`.
Examples:
>>> # target output size of 5x7
>>> m = nn.AdaptiveMaxPool2d((5,7))
>>> input = torch.randn(1, 64, 8, 9)
>>> output = m(input)
>>> # target output size of 7x7 (square)
>>> m = nn.AdaptiveMaxPool2d(7)
>>> input = torch.randn(1, 64, 10, 9)
>>> output = m(input)
>>> # target output size of 10x7
>>> m = nn.AdaptiveMaxPool2d((None, 7))
>>> input = torch.randn(1, 64, 10, 9)
>>> output = m(input)
)r. r c C s t j|| j| jS )N)r/ Zadaptive_max_pool2dr7 r )r r. r! r! r" r0 s zAdaptiveMaxPool2d.forwardN)r& r' r( r1 r r7 r r0 r! r! r! r" rQ s
"rQ c @ s& e Zd ZU dZeeedddZdS )AdaptiveMaxPool3da Applies a 3D adaptive max pooling over an input signal composed of several input planes.
The output is of size :math:`D_{out} \times H_{out} \times W_{out}`, 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 :math:`D_{out} \times H_{out} \times W_{out}`.
Can be a tuple :math:`(D_{out}, H_{out}, W_{out})` or a single
:math:`D_{out}` for a cube :math:`D_{out} \times D_{out} \times D_{out}`.
:math:`D_{out}`, :math:`H_{out}` and :math:`W_{out}` 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``
Shape:
- Input: :math:`(N, C, D_{in}, H_{in}, W_{in})` or :math:`(C, D_{in}, H_{in}, W_{in})`.
- Output: :math:`(N, C, D_{out}, H_{out}, W_{out})` or :math:`(C, D_{out}, H_{out}, W_{out})`,
where :math:`(D_{out}, H_{out}, W_{out})=\text{output\_size}`.
Examples:
>>> # target output size of 5x7x9
>>> m = nn.AdaptiveMaxPool3d((5,7,9))
>>> input = torch.randn(1, 64, 8, 9, 10)
>>> output = m(input)
>>> # target output size of 7x7x7 (cube)
>>> m = nn.AdaptiveMaxPool3d(7)
>>> 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)
)r. r c C s t j|| j| jS )N)r/ Zadaptive_max_pool3dr7 r )r r. r! r! r" r0 @ s zAdaptiveMaxPool3d.forwardN)r& r' r( r1 r r7 r r0 r! r! r! r" rR s
#rR c s8 e Zd ZdgZedd fdd ZedddZ ZS ) _AdaptiveAvgPoolNdr7 N)r7 r c s t t| j || _d S )N)r rS r r7 )r r7 )r r! r" r G s z_AdaptiveAvgPoolNd.__init__)r c C s dj | jS )Nzoutput_size={})r# r7 )r r! r! r" r% K s z _AdaptiveAvgPoolNd.extra_repr) r& r' r( r) r r r+ r% r, r! r! )r r" rS D s rS c @ s& e Zd ZU dZeeedddZdS )AdaptiveAvgPool1da Applies a 1D adaptive average pooling over an input signal composed of several input planes.
The output size is :math:`L_{out}`, for any input size.
The number of output features is equal to the number of input planes.
Args:
output_size: the target output size :math:`L_{out}`.
Shape:
- Input: :math:`(N, C, L_{in})` or :math:`(C, L_{in})`.
- Output: :math:`(N, C, L_{out})` or :math:`(C, L_{out})`, where
:math:`L_{out}=\text{output\_size}`.
Examples:
>>> # target output size of 5
>>> m = nn.AdaptiveAvgPool1d(5)
>>> input = torch.randn(1, 64, 8)
>>> output = m(input)
)r. r c C s t j|| jS )N)r/ Zadaptive_avg_pool1dr7 )r r. r! r! r" r0 g s zAdaptiveAvgPool1d.forwardN)r& r' r( r1 r
r7 r r0 r! r! r! r" rT O s
rT c @ s& e Zd ZU dZeeedddZdS )AdaptiveAvgPool2da 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.
Shape:
- Input: :math:`(N, C, H_{in}, W_{in})` or :math:`(C, H_{in}, W_{in})`.
- Output: :math:`(N, C, S_{0}, S_{1})` or :math:`(C, S_{0}, S_{1})`, where
:math:`S=\text{output\_size}`.
Examples:
>>> # target output size of 5x7
>>> m = nn.AdaptiveAvgPool2d((5,7))
>>> input = torch.randn(1, 64, 8, 9)
>>> output = m(input)
>>> # target output size of 7x7 (square)
>>> m = nn.AdaptiveAvgPool2d(7)
>>> input = torch.randn(1, 64, 10, 9)
>>> output = m(input)
>>> # target output size of 10x7
>>> m = nn.AdaptiveAvgPool2d((None, 7))
>>> input = torch.randn(1, 64, 10, 9)
>>> output = m(input)
)r. r c C s t j|| jS )N)r/ Zadaptive_avg_pool2dr7 )r r. r! r! r" r0 s zAdaptiveAvgPool2d.forwardN)r& r' r( r1 r r7 r r0 r! r! r! r" rU k s
rU c @ s& e Zd ZU dZeeedddZdS )AdaptiveAvgPool3da 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.
Shape:
- Input: :math:`(N, C, H_{in}, W_{in})` or :math:`(C, H_{in}, W_{in})`.
- Output: :math:`(N, C, S_{0}, S_{1}, S_{2})` or :math:`(C, S_{0}, S_{1}, S_{2})`,
where :math:`S=\text{output\_size}`.
Examples:
>>> # target output size of 5x7x9
>>> m = nn.AdaptiveAvgPool3d((5,7,9))
>>> input = torch.randn(1, 64, 8, 9, 10)
>>> output = m(input)
>>> # target output size of 7x7x7 (cube)
>>> m = nn.AdaptiveAvgPool3d(7)
>>> input = torch.randn(1, 64, 10, 9, 8)
>>> output = m(input)
>>> # target output size of 7x9x8
>>> m = nn.AdaptiveAvgPool3d((7, None, None))
>>> input = torch.randn(1, 64, 10, 9, 8)
>>> output = m(input)
)r. r c C s t j|| jS )N)r/ Zadaptive_avg_pool3dr7 )r r. r! r! r" r0 s zAdaptiveAvgPool3d.forwardN)r& r' r( r1 r r7 r r0 r! r! r! r" rV s
rV N)1typingr r Ztorchr moduler utilsr r r r r/ common_typesr r
r r r r r r r r r- r2 r3 r4 r5 r9 r: r; r= r> r@ rD rI rJ rM rN rO rP rQ rR rS rT rU rV r! r! r! r"
s< ,;JNEMB CO\F?*7 *+ '