池化函数

最大池化函数

一维
class torch.nn.MaxPool1d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
二维
class torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
三维
class torch.nn.MaxPool3d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)

对于输入信号的输入通道，提供一维、二维、三维最大池化（max pooling）操作

参数：

kernel_size(int or tuple) - max pooling的窗口大小
stride(int or tuple, optional) - max pooling的窗口移动的步长。默认值是kernel_size
padding(int or tuple, optional) - 输入的每一条边补充0的层数
dilation(int or tuple, optional) – 一个控制窗口中元素步幅的参数
return_indices - 如果等于True，会返回输出最大值的序号，对于上采样操作会有帮助
ceil_mode - 如果等于True，计算输出信号大小的时候，会使用向上取整，代替默认的向下取整的操作。

shape:

一维最大池化层
输入: (N,C_in,L_in)
输出: (N,C_out,L_out)
Lout=floor((Lin+2padding−dilation(kernelsize−1)−1)/stride+1L_{out}=floor((L_{in} + 2padding - dilation(kernel_size - 1) - 1)/stride + 1Lout=floor((Lin+2padding−dilation(kernelsize−1)−1)/stride+1
二维最大池化层
输入: (N,C,H_{in},W_in)
输出: (N,C,H_out,W_out)
Hout=floor((Hin+2padding[0]−dilation[0](kernelsize[0]−1)−1)/stride[0]+1H_{out}=floor((H_{in} + 2padding[0] - dilation[0](kernel_size[0] - 1) - 1)/stride[0] + 1Hout=floor((Hin+2padding[0]−dilation[0](kernelsize[0]−1)−1)/stride[0]+1 Wout=floor((Win+2padding[1]−dilation[1](kernelsize[1]−1)−1)/stride[1]+1W_{out}=floor((W_{in} + 2padding[1] - dilation[1](kernel_size[1] - 1) - 1)/stride[1] + 1Wout=floor((Win+2padding[1]−dilation[1](kernelsize[1]−1)−1)/stride[1]+1
三维最大池化层
输入: (N,C,H_in,W_in)
输出: (N,C,H_out,W_out)
Dout=floor((Din+2padding[0]−dilation[0](kernelsize[0]−1)−1)/stride[0]+1)D_{out}=floor((D_{in} + 2padding[0] - dilation[0](kernel_size[0] - 1) - 1)/stride[0] + 1)Dout=floor((Din+2padding[0]−dilation[0](kernelsize[0]−1)−1)/stride[0]+1) Hout=floor((Hin+2padding[1]−dilation[1](kernelsize[0]−1)−1)/stride[1]+1)H_{out}=floor((H_{in} + 2padding[1] - dilation[1](kernel_size[0] - 1) - 1)/stride[1] + 1)Hout=floor((Hin+2padding[1]−dilation[1](kernelsize[0]−1)−1)/stride[1]+1) Wout=floor((Win+2padding[2]−dilation[2](kernelsize[2]−1)−1)/stride[2]+1)W_{out}=floor((W_{in} + 2padding[2] - dilation[2](kernel_size[2] - 1) - 1)/stride[2] + 1)Wout=floor((Win+2padding[2]−dilation[2](kernelsize[2]−1)−1)/stride[2]+1)

Example：

一维最大池化层

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

二维最大池化层

# 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 = autograd.Variable(torch.randn(20, 16, 50, 32))
output = m(input)

三维最大池化层

# 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 = autograd.Variable(torch.randn(20, 16, 50,44, 31))
output = m(input)

平均池化函数

一维
class torch.nn.AvgPool1d(kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True) 和
二维
class torch.nn.AvgPool2d(kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True)
三维
class torch.nn.AvgPool3d(kernel_size, stride=None)

对信号的输入通道，提供一维、二维、三维的平均池化（average pooling ）

参数：
一维、二维平均池化

kernel_size(int or tuple) - 池化窗口大小
stride(int or tuple, optional) - max pooling的窗口移动的步长。默认值是kernel_size
padding(int or tuple, optional) - 输入的每一条边补充0的层数
dilation(int or tuple, optional) – 一个控制窗口中元素步幅的参数
count_include_pad - 如果等于True，计算平均池化时，将包括padding填充的0
ceil_mode - 如果等于True，计算输出信号大小的时候，会使用向上取整，代替默认的向下取整的操作

三维平均池化
kernel_size(int or tuple) - 池化窗口大小
stride(int or tuple, optional) - avg pooling的窗口移动的步长。默认值是kernel_size

shape：

一维平均池化
input:(N,C,L_in)
output:(N,C,L_out)
Lout=floor((Lin+2∗padding−kernel_size)/stride+1)L_{out}=floor((L_{in}+2 ∗ padding−kernel\_size)/stride+1)Lout=floor((Lin+2∗padding−kernel_size)/stride+1)
二维平均池化
input: (N,C,H_in,W_in)
output: (N,C,H_out,W_out)
Hout=floor((Hin+2padding[0]−kernelsize[0])/stride[0]+1)H_{out}=floor((H_{in}+2padding[0]-kernel_size[0])/stride[0]+1)\ Hout=floor((Hin+2padding[0]−kernelsize[0])/stride[0]+1) Wout=floor((Win+2padding[1]−kernelsize[1])/stride[1]+1)W_{out}=floor((W_{in}+2padding[1]-kernel_size[1])/stride[1]+1) Wout=floor((Win+2padding[1]−kernelsize[1])/stride[1]+1)
三维平均池化
输入大小:(N,C,D_in,H_in,W_in)
输出大小:(N,C,D_out,H_out,W_out)
Dout=floor((Din+2padding[0]−kernelsize[0])/stride[0]+1)D_{out}=floor((D_{in}+2padding[0]-kernel_size[0])/stride[0]+1)\ Dout=floor((Din+2padding[0]−kernelsize[0])/stride[0]+1) Hout=floor((Hin+2padding[1]−kernelsize[1])/stride[1]+1)H_{out}=floor((H_{in}+2padding[1]-kernel_size[1])/stride[1]+1)\ Hout=floor((Hin+2padding[1]−kernelsize[1])/stride[1]+1) Wout=floor((Win+2∗padding[2]−kernelsize[2])/stride[2]+1)W_{out}=floor((W_{in}+2*padding[2]-kernel_size[2])/stride[2]+1) Wout=floor((Win+2∗padding[2]−kernelsize[2])/stride[2]+1)

Example:
一维平均池化

>>> # pool with window of size=3, stride=2
>>> m = nn.AvgPool1d(3, stride=2)
>>> m(Variable(torch.Tensor([[[1,2,3,4,5,6,7]]])))
Variable containing:(0 ,.,.) =2  4  6[torch.FloatTensor of size 1x1x3]

二维平均池化

>>> # 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 = autograd.Variable(torch.randn(20, 16, 50, 32))
>>> output = m(input)

三维平均池化

>>> # 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 = autograd.Variable(torch.randn(20, 16, 50,44, 31))
>>> output = m(input)

池化逆函数

最大池化的近似逆函数

一维
class torch.nn.MaxUnpool1d(kernel_size, stride=None, padding=0)
二维
class torch.nn.MaxUnpool2d(kernel_size, stride=None, padding=0)
三维
class torch.nn.MaxUnpool3d(kernel_size, stride=None, padding=0)

Maxpool1d、Maxpool2d、Maxpool3d的逆过程，不过并不是完全的逆过程，因为在maxpool1d、maxpool2d、maxpool3d的过程中，一些最大值的已经丢失。 MaxUnpool1d、MaxUnpool2d、 MaxUnpool3d输入MaxPool1d、MaxPool2d、MaxPool3d的输出，包括最大值的索引，并计算所有maxpool1d、maxpool2d、maxpool3d过程中非最大值被设置为零的部分的反向。

注意：
MaxPool1d、MaxPool2d、MaxPool3d可以将多个输入大小映射到相同的输出大小。因此，反演过程可能会变得模棱两可。为了适应这一点，可以在调用中将输出大小（output_size）作为额外的参数传入。具体用法，请参阅下面的输入和示例

参数：

kernel_size(int or tuple) - max pooling的窗口大小
stride(int or tuple, optional) - max pooling的窗口移动的步长。默认值是kernel_size
padding(int or tuple, optional) - 输入的每一条边补充0的层数

输入：

input:需要转换的tensor
indices：Maxpool1d的索引号
output_size:一个指定输出大小的torch.Size

shape:

一维逆池化
input: (N,C,H_in)
output:(N,C,H_out)
Hout=(Hin−1)stride[0]−2padding[0]+kernel_size[0]H_{out}=(H_{in}-1)stride[0]-2padding[0]+kernel\_size[0]Hout=(Hin−1)stride[0]−2padding[0]+kernel_size[0] 也可以使用output_size指定输出的大小
二维逆池化
input: (N,C,H_in,W_in)
output:(N,C,H_out,W_out)
Hout=(Hin−1)stride[0]−2padding[0]+kernel_size[0]H_{out}=(H_{in}-1)stride[0]-2padding[0]+kernel\_size[0]Hout=(Hin−1)stride[0]−2padding[0]+kernel_size[0] Wout=(Win−1)stride[1]−2padding[1]+kernel_size[1]W_{out}=(W_{in}-1)stride[1]-2padding[1]+kernel\_size[1]Wout=(Win−1)stride[1]−2padding[1]+kernel_size[1]
也可以使用output_size指定输出的大小
三维逆池化
input: (N,C,D_in,H_in,W_in)
output:(N,C,D_out,H_out,W_out)
Dout=(Din−1)stride[0]−2padding[0]+kernel_size[0]D_{out}=(D_{in}-1)stride[0]-2padding[0]+kernel\_size[0]\ Dout=(Din−1)stride[0]−2padding[0]+kernel_size[0] Hout=(Hin−1)stride[1]−2padding[0]+kernel_size[1]H_{out}=(H_{in}-1)stride[1]-2padding[0]+kernel\_size[1]\ Hout=(Hin−1)stride[1]−2padding[0]+kernel_size[1] Wout=(Win−1)stride[2]−2padding[2]+kernel_size[2]W_{out}=(W_{in}-1)stride[2]-2padding[2]+kernel\_size[2] Wout=(Win−1)stride[2]−2padding[2]+kernel_size[2] 也可以使用output_size指定输出的大小

Example：

一维逆池化

>>> pool = nn.MaxPool1d(2, stride=2, return_indices=True)
>>> unpool = nn.MaxUnpool1d(2, stride=2)
>>> input = Variable(torch.Tensor([[[1, 2, 3, 4, 5, 6, 7, 8]]]))
>>> output, indices = pool(input)
>>> unpool(output, indices)Variable containing:(0 ,.,.) =0   2   0   4   0   6   0   8[torch.FloatTensor of size 1x1x8]>>> # Example showcasing the use of output_size
>>> input = Variable(torch.Tensor([[[1, 2, 3, 4, 5, 6, 7, 8, 9]]]))
>>> output, indices = pool(input)
>>> unpool(output, indices, output_size=input.size())Variable containing:(0 ,.,.) =0   2   0   4   0   6   0   8   0[torch.FloatTensor of size 1x1x9]
>>> unpool(output, indices)Variable containing:(0 ,.,.) =0   2   0   4   0   6   0   8[torch.FloatTensor of size 1x1x8]

二维逆池化

>>> pool = nn.MaxPool2d(2, stride=2, return_indices=True)
>>> unpool = nn.MaxUnpool2d(2, stride=2)
>>> input = Variable(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)Variable containing:(0 ,0 ,.,.) =0   0   0   00   6   0   80   0   0   00  14   0  16[torch.FloatTensor of size 1x1x4x4]>>> # specify a different output size than input size
>>> unpool(output, indices, output_size=torch.Size([1, 1, 5, 5]))Variable containing:(0 ,0 ,.,.) =0   0   0   0   06   0   8   0   00   0   0  14   016   0   0   0   00   0   0   0   0[torch.FloatTensor of size 1x1x5x5]

三维逆池化

>>> # 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(Variable(torch.randn(20, 16, 51, 33, 15)))
>>> unpooled_output = unpool(output, indices)
>>> unpooled_output.size()
torch.Size([20, 16, 51, 33, 15])

[深度学习] 池化层函数及其逆过程函数相关推荐

深度学习——池化层理论学习（Pooling Layer）
这里写目录标题 1. 什么是池化层 2. 池化层作用 3. 常见的池化层 3.1 最大池化层(max pooling layer) 3.2 平均池化层(average pooling layer) 3 ...
[十七]深度学习Pytorch-优化器Optimizer
0. 往期内容 [一]深度学习Pytorch-张量定义与张量创建 [二]深度学习Pytorch-张量的操作:拼接.切分.索引和变换 [三]深度学习Pytorch-张量数学运算 [四]深度学习Pytor ...
花书+吴恩达深度学习（十一）卷积神经网络 CNN 之池化层
目录 0. 前言 1. 最大池化(max pooling) 2. 平移不变形 3. 其他池化函数 4. 卷积和池化作为一种无限强的先验如果这篇文章对你有一点小小的帮助,请给个关注,点个赞喔~我会非常 ...
深度学习入门 (九)：卷积层和池化层的实现
目录卷积神经网络 CNN 整体结构卷积层全连接层存在的问题卷积运算乘积累加运算偏置填充 (padding) 步幅 (stride) 小结:卷积层的输出特征图的大小 3 维数据的卷积运算 ...
1.9 池化层-深度学习第四课《卷积神经网络》-Stanford吴恩达教授
←上一篇 ↓↑ 下一篇→ 1.8 简单卷积网络示例回到目录 1.10 卷积神经网络示例池化层 (Pooling Layers) 除了卷积层,卷积网络也经常使用池化层来缩减模型的大小,提高计算速度, ...
深度学习之卷积神经网络（7）池化层
深度学习之卷积神经网络(7)池化层在卷积层中,可以通过调节步长参数s实现特征图的高宽成倍缩小,从而降低了网络的参数量.实际上,处理通过设置步长,还有一种专门的网络层可以实现尺寸缩减功能,它就是这里要 ...
深度学习笔记（25）池化层
深度学习笔记(25) 池化层 1. max pooling 2. mean pooling 3. pooling 超参 1. max pooling 除了卷积层,卷积网络也经常使用池化层来缩减模型的大 ...
深度学习基础之池化层
谷歌浏览器搜索.看Youtube视频必备VPN:SockBoom 或者网址:https://sockboom.bar/auth/register?affid=212828 一.深度学习中池化层的作用 ...
【动手学深度学习PyTorch版】15 池化层
上一篇请移步[动手学深度学习PyTorch版]14 卷积层里的多输入多输出通道_水w的博客-CSDN博客目录一.池化层 1.1 池化层 ◼池化层原因 ◼ 二维最大池化 1.2 填充.步幅与多个通道 ...

[深度学习] 池化层函数及其逆过程函数