池化层

class torch.nn.MaxPool1d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)

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

如果输入的大小是(N,C,L)，那么输出的大小是(N,C,L_out)的计算方式是：

$$out(Ni, Cj,k)=max^{kernel_size-1}{m=0}input(N{i},C_j,stride*k+m)$$

如果padding不是0，会在输入的每一边添加相应数目0dilation用于控制内核点之间的距离，详细描述在这里

参数：

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)

$$L{out}=floor((L{in} + 2padding - dilation(kernel_size - 1) - 1)/stride + 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)

class torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)

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

如果输入的大小是(N,C,H,W)，那么输出的大小是(N,C,H_out,W_out)和池化窗口大小(kH,kW)的关系是：

$$out(Ni, C_j,k)=max^{kH-1}{m=0}max^{kW-1}{m=0}input(N{i},C_j,stride[0]h+m,stride[1]w+n)$$

如果padding不是0，会在输入的每一边添加相应数目0dilation用于控制内核点之间的距离，详细描述在这里

参数kernel_size，stride, padding，dilation数据类型：可以是一个int类型的数据，此时卷积height和width值相同; 也可以是一个tuple数组（包含来两个int类型的数据），第一个int数据表示height的数值，tuple的第二个int类型的数据表示width的数值

参数：

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,H_{in},W_in)输出: (N,C,H_out,W_out)

$$H{out}=floor((H{in} + 2padding[0] - dilation0 - 1)/stride[0] + 1$$

$$W{out}=floor((W{in} + 2padding[1] - dilation1 - 1)/stride[1] + 1$$

example:

>>> # 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)

class torch.nn.MaxPool3d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)

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

如果输入的大小是(N,C,D,H,W)，那么输出的大小是(N,C,D,H_out,W_out)和池化窗口大小(kD,kH,kW)的关系是：

$$out(Ni,C_j,d,h,w)=max^{kD-1}{m=0}max^{kH-1}{m=0}max^{kW-1}{m=0}$$

$$input(N_{i},C_j,stride[0]k+d,stride[1]h+m,stride[2]*w+n)$$

如果padding不是0，会在输入的每一边添加相应数目0dilation用于控制内核点之间的距离，详细描述在这里

参数kernel_size，stride, padding，dilation数据类型：可以是int类型的数据，此时卷积height和width值相同; 也可以是一个tuple数组（包含来两个int类型的数据），第一个int数据表示height的数值，tuple的第二个int类型的数据表示width的数值

参数：

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,H_in,W_in)输出: (N,C,H_out,W_out)

$$D{out}=floor((D{in} + 2padding[0] - dilation0 - 1)/stride[0] + 1)$$

$$H{out}=floor((H{in} + 2padding[1] - dilation1 - 1)/stride[1] + 1)$$

$$W{out}=floor((W{in} + 2padding[2] - dilation2 - 1)/stride[2] + 1)$$

example:

>>> # 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.MaxUnpool1d(kernel_size, stride=None, padding=0)

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

注意：MaxPool1d可以将多个输入大小映射到相同的输出大小。因此，反演过程可能会变得模棱两可。为了适应这一点，可以在调用中将输出大小（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)

$$H{out}=(H{in}-1)stride[0]-2padding[0]+kernel_size[0]$$也可以使用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]

class torch.nn.MaxUnpool2d(kernel_size, stride=None, padding=0)

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

注意：MaxPool2d可以将多个输入大小映射到相同的输出大小。因此，反演过程可能会变得模棱两可。为了适应这一点，可以在调用中将输出大小（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:需要转换的tensorindices：Maxpool1d的索引号output_size:一个指定输出大小的torch.Size

大小：input: (N,C,H_in,W_in)output:(N,C,H_out,W_out)

$$H{out}=(H{in}-1)stride[0]-2padding[0]+kernel_size[0]$$

$$W{out}=(W{in}-1)stride[1]-2padding[1]+kernel_size[1]$$

也可以使用output_size指定输出的大小

Example：

>>> 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 0 0 6 0 8 0 0 0 0 0 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 0 6 0 8 0 0 0 0 0 14 0 16 0 0 0 0 0 0 0 0 0 [torch.FloatTensor of size 1x1x5x5]

class torch.nn.MaxUnpool3d(kernel_size, stride=None, padding=0)

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

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

参数：

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

输入：input:需要转换的tensorindices：Maxpool1d的索引序数output_size:一个指定输出大小的torch.Size

大小:input: (N,C,D_in,H_in,W_in)output:(N,C,D_out,H_out,W_out)

$$ \begin{aligned} D{out}=(D{in}-1)stride[0]-2padding[0]+kernel_size[0]\H{out}=(H{in}-1)stride[1]-2padding[0]+kernel_size[1]\ W{out}=(W{in}-1)stride[2]-2padding[2]+kernel_size[2]\end{aligned}

也可以使用output_size指定输出的大小

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

class torch.nn.AvgPool1d(kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True)

对信号的输入通道，提供1维平均池化（average pooling ）输入信号的大小(N,C,L)，输出大小(N,C,L_out)和池化窗口大小k的关系是：

$$out(Ni,C_j,l)=1/k\sum^{k}{m=0}input(N{i},C{j},stridel+m)$$如果padding不是0，会在输入的每一边添加相应数目0

参数：

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) – 一个控制窗口中元素步幅的参数
return_indices - 如果等于True，会返回输出最大值的序号，对于上采样操作会有帮助
ceil_mode - 如果等于True，计算输出信号大小的时候，会使用向上取整，代替默认的向下取整的操作

大小：input:(N,C,L_in)output:(N,C,L_out)

$$L{out}=floor((L{in}+2*padding-kernel_size)/stride+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]

class torch.nn.AvgPool2d(kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True)

对信号的输入通道，提供2维的平均池化（average pooling ）输入信号的大小(N,C,H,W)，输出大小(N,C,H_out,W_out)和池化窗口大小(kH,kW)的关系是：

$$ out(Ni,Cj,h,w)=1/(kHkW)\sum^{kH-1}{m=0}\sum^{kW-1}{n=0}input(N{i},C{j},stride[0]h+m,stride[1]w+n)$$

如果padding不是0，会在输入的每一边添加相应数目0

参数：

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) – 一个控制窗口中元素步幅的参数
ceil_mode - 如果等于True，计算输出信号大小的时候，会使用向上取整，代替默认的向下取整的操作
count_include_pad - 如果等于True，计算平均池化时，将包括padding填充的0

shape：input: (N,C,H_in,W_in)output: (N,C,H_out,W_out)

$$\begin{aligned} H{out}=floor((H{in}+2padding[0]-kernel_size[0])/stride[0]+1)\W{out}=floor((W{in}+2padding[1]-kernel_size[1])/stride[1]+1) \end{aligned}

Example:

>>> # 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)

class torch.nn.AvgPool3d(kernel_size, stride=None)

对信号的输入通道，提供3维的平均池化（average pooling）输入信号的大小(N,C,D,H,W)，输出大小(N,C,D_out,H_out,W_out)和池化窗口大小(kD,kH,kW)的关系是：

$$ \begin{aligned} out(Ni,C_j,d,h,w)=1/(kDkHkW)\sum^{kD-1}{k=0}\sum^{kH-1}{m=0}\sum^{kW-1}{n=0}input(N{i},C{j},stride[0]d+k,stride[1]h+m,stride[2]w+n) \end{aligned}

$$ 如果padding不是0，会在输入的每一边添加相应数目0

参数：

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

shape：输入大小:(N,C,D_in,H_in,W_in)输出大小:(N,C,D_out,H_out,W_out)

$$\begin{aligned} D{out}=floor((D{in}+2padding[0]-kernel_size[0])/stride[0]+1)\H{out}=floor((H{in}+2padding[1]-kernel_size[1])/stride[1]+1)\W{out}=floor((W{in}+2*padding[2]-kernel_size[2])/stride[2]+1)\end{aligned}

Example:

>>> # 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.FractionalMaxPool2d(kernel_size, output_size=None, output_ratio=None, return_indices=False, _random_samples=None)

对输入的信号，提供2维的分数最大化池化操作分数最大化池化的细节请阅读论文由目标输出大小确定的随机步长,在$kH*kW$区域进行最大池化操作。输出特征和输入特征的数量相同。

参数：

kernel_size(int or tuple) - 最大池化操作时的窗口大小。可以是一个数字（表示KK的窗口），也可以是一个元组（khkw）
output_size - 输出图像的尺寸。可以使用一个tuple指定(oH,oW)，也可以使用一个数字oH指定一个oH*oH的输出。
output_ratio – 将输入图像的大小的百分比指定为输出图片的大小，使用一个范围在(0,1)之间的数字指定
return_indices - 默认值False，如果设置为True，会返回输出的索引，索引对 nn.MaxUnpool2d有用。

Example：

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

class torch.nn.LPPool2d(norm_type, kernel_size, stride=None, ceil_mode=False)

对输入信号提供2维的幂平均池化操作。输出的计算方式：

$$f(x)=pow(sum(X,p),1/p)$$

当p为无穷大的时候时，等价于最大池化操作
当p=1时，等价于平均池化操作

参数kernel_size, stride的数据类型：

int，池化窗口的宽和高相等
tuple数组（两个数字的），一个元素是池化窗口的高，另一个是宽

参数

kernel_size: 池化窗口的大小
stride：池化窗口移动的步长。kernel_size是默认值
ceil_mode: ceil_mode=True时，将使用向下取整代替向上取整

shape

输入：(N,C,H_in,W_in)
输出：(N,C,Hout,Wout)$$\begin{aligned} H{out} = floor((H{in}+2padding[0]-dilation0-1)/stride[0]+1)\ W{out} = floor((W{in}+2padding[1]-dilation1-1)/stride[1]+1) \end{aligned} $$

Example:

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

class torch.nn.AdaptiveMaxPool1d(output_size, return_indices=False)

对输入信号，提供1维的自适应最大池化操作对于任何输入大小的输入，可以将输出尺寸指定为H，但是输入和输出特征的数目不会变化。

参数：

output_size: 输出信号的尺寸
return_indices: 如果设置为True，会返回输出的索引。对 nn.MaxUnpool1d有用，默认值是False

Example：

>>> # target output size of 5>>> m = nn.AdaptiveMaxPool1d(5)>>> input = autograd.Variable(torch.randn(1, 64, 8))>>> output = m(input)

class torch.nn.AdaptiveMaxPool2d(output_size, return_indices=False)

对输入信号，提供2维的自适应最大池化操作对于任何输入大小的输入，可以将输出尺寸指定为H*W，但是输入和输出特征的数目不会变化。

参数：

output_size: 输出信号的尺寸,可以用（H,W）表示HW的输出，也可以使用数字H表示HH大小的输出
return_indices: 如果设置为True，会返回输出的索引。对 nn.MaxUnpool2d有用，默认值是False

Example：

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

class torch.nn.AdaptiveAvgPool1d(output_size)

对输入信号，提供1维的自适应平均池化操作对于任何输入大小的输入，可以将输出尺寸指定为H*W，但是输入和输出特征的数目不会变化。

参数：

output_size: 输出信号的尺寸

Example：

>>> # target output size of 5>>> m = nn.AdaptiveAvgPool1d(5)>>> input = autograd.Variable(torch.randn(1, 64, 8))>>> output = m(input)

class torch.nn.AdaptiveAvgPool2d(output_size)

对输入信号，提供2维的自适应平均池化操作对于任何输入大小的输入，可以将输出尺寸指定为H*W，但是输入和输出特征的数目不会变化。

参数：

output_size: 输出信号的尺寸,可以用(H,W)表示HW的输出，也可以使用耽搁数字H表示HH大小的输出

Example：

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

池化层

池化层

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)

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)

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)

class torch.nn.FractionalMaxPool2d(kernel_size, output_size=None, output_ratio=None, return_indices=False, _random_samples=None)

class torch.nn.LPPool2d(norm_type, kernel_size, stride=None, ceil_mode=False)

class torch.nn.AdaptiveMaxPool1d(output_size, return_indices=False)

class torch.nn.AdaptiveMaxPool2d(output_size, return_indices=False)

class torch.nn.AdaptiveAvgPool1d(output_size)

class torch.nn.AdaptiveAvgPool2d(output_size)

results matching ""

No results matching ""