pytorch--Pooling layers

---

1.torch.nn.MaxPool1d()

  torch.nn.MaxPool1d() 是 PyTorch 库中的一个类，用于在神经网络中执行一维最大池化操作。最大池化是卷积神经网络（CNN）中常用的一种降采样操作，它可以减小输入的空间维度，并保留最显著的特征。一维最大池化操作主要应用于处理具有时间序列或一维信号的数据。例如，对于音频信号的处理或文本数据的卷积操作，可以使用一维最大池化来减小输入的长度。

"""
参数:

kernel_size：一个整数或元组，用于指定最大池化窗口的大小。如果是一个整数，表示池化窗口的宽度为 kernel_size，高度为 1。如果是一个元组，可以分别指定窗口的宽度和高度。默认值为 1。
stride：一个整数或元组，用于指定池化操作的步幅（stride）。它控制在应用池化窗口时的滑动步长。如果未提供，将默认使用 kernel_size 的值，即非重叠池化。默认值为 kernel_size。
padding：一个整数或元组，用于指定在输入的两侧添加的零填充的数量。填充有助于在应用池化操作时保持输入的空间维度。默认值为 0，表示不进行填充。
dilation：一个整数或元组，用于指定核元素之间的间距（dilation）。它控制池化窗口元素的步幅，有效地增加感受野。默认值为 1，表示没有间距。
return_indices：一个布尔值，指示是否返回最大值的索引。如果设置为 True，则除了池化的输出之外，还会返回最大值的索引。默认值为 False。
输入:

输入的形状应为 (batch_size, channels, sequence_length)，其中 batch_size 是输入数据的批量大小，channels 是输入数据的通道数，sequence_length 是输入数据的序列长度。
输出:

输出的形状为 (batch_size, channels, sequence_length_out)，其中 sequence_length_out 是经过池化操作后的序列长度。输出的通道数与输入的通道数相同。
"""

import torch
import torch.nn as nn

# 创建一个输入大小为 (batch_size=1, channels=1, sequence_length=10) 的张量
input_tensor = torch.tensor([[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]], dtype=torch.float32)

# 创建一个一维最大池化层，池化窗口大小为 2，步幅为 2
maxpool = nn.MaxPool1d(kernel_size=2, stride=2)

# 应用最大池化操作
output = maxpool(input_tensor)

print(output)

tensor([[[ 2.,  4.,  6.,  8., 10.]]])

2.torch.nn.MaxPool2d

torch.nn.MaxPool2d() 是 PyTorch 库中的一个类，用于在神经网络中执行二维最大池化操作。最大池化是卷积神经网络（CNN）中常用的一种降采样操作，它可以减小输入的空间维度，并保留最显著的特征。二维最大池化操作主要应用于处理图像数据。它在每个池化窗口内找到最大值，并将其作为输出，以减小图像的尺寸。这有助于提取图像中的重要特征并减少计算量。

import torch
import torch.nn as nn

# 创建一个输入大小为 (batch_size=1, channels=1, height=4, width=4) 的张量
input_tensor = torch.tensor([[[[1, 2, 3, 4],
                               [5, 6, 7, 8],
                               [9, 10, 11, 12],
                               [13, 14, 15, 16]]]], dtype=torch.float32)

# 创建一个二维最大池化层，池化窗口大小为 2x2，步幅为 2
maxpool = nn.MaxPool2d(kernel_size=2, stride=2)

# 应用最大池化操作
output = maxpool(input_tensor)

print(output)

tensor([[[[ 6.,  8.],
          [14., 16.]]]])

3.torch.nn.AvgPool2d()

torch.nn.AvgPool2d() 是 PyTorch 库中的一个类，用于在神经网络中执行二维平均池化操作。平均池化操作将输入的特征图分割成固定大小的窗口，并计算每个窗口内元素的平均值。

"""
参数:

kernel_size：整数或元组，用于指定平均池化窗口的大小。如果是一个整数，表示窗口的宽度和高度都为 kernel_size。如果是一个元组，可以分别指定窗口的宽度和高度。默认值为 2。
stride：整数或元组，用于指定平均池化操作的步幅（stride）。它控制在应用平均池化窗口时的滑动步长。默认值为 kernel_size。
padding：整数或元组，用于指定在输入的四周添加的零填充的数量。填充有助于在应用平均池化操作时保持输入的空间维度。默认值为 0，表示不进行填充。
ceil_mode：布尔值，表示在计算输出形状时是否使用 ceil 函数代替 floor 函数。当设置为 True 时，使用 ceil 函数；当设置为 False 时，使用 floor 函数。该参数主要影响在进行池化操作时是否向上取整来计算输出的尺寸。
输入:

输入的形状应为 (batch_size, channels, height, width)，其中 batch_size 是输入数据的批量大小，channels 是输入数据的通道数，height 是输入数据的高度，width 是输入数据的宽度。
输出:

输出的形状为 (batch_size, channels, height_out, width_out)，其中 height_out 和 width_out 是经过平均池化操作后的高度和宽度。输出的通道数与输入的通道数相同。
"""
import torch
import torch.nn as nn

# 创建一个输入大小为 (batch_size=1, channels=1, height=4, width=4) 的张量
input_tensor = torch.tensor([[[[1, 2, 3, 4],
                               [5, 6, 7, 8],
                               [9, 10, 11, 12],
                               [13, 14, 15, 16]]]], dtype=torch.float32)

# 创建一个二维平均池化层，池化窗口大小为 2x2，步幅为 2
avgpool = nn.AvgPool2d(kernel_size=2, stride=2)
# 应用平均池化操作
output = avgpool(input_tensor)

print(output)

tensor([[[[ 3.5000,  5.5000],
          [11.5000, 13.5000]]]])

4.torch.nn.FractionalMaxPool2d()

nn.FractionalMaxPool2d() 是 PyTorch 中的一个类，用于执行分数最大池化操作。分数最大池化是一种池化方法，它可以在非整数位置上对输入进行池化操作，从而提供更大的灵活性。

"""
参数:

kernel_size：整数或元组，用于指定池化窗口的大小。如果是一个整数，表示窗口的宽度和高度都为 kernel_size。如果是一个元组，可以分别指定窗口的宽度和高度。
output_size：整数或元组，用于指定输出的大小。如果是一个整数，表示输出的宽度和高度都为 output_size。如果是一个元组，可以分别指定输出的宽度和高度。如果提供了 output_size，则会忽略 kernel_size。
output_ratio：浮点数或元组，用于指定输出的比例。如果是一个浮点数，表示输出相对于输入的比例。如果是一个元组，可以分别指定宽度和高度的比例。如果提供了 output_ratio，则会忽略 kernel_size 和 output_size。
return_indices：布尔值，表示是否返回池化操作的索引。如果为 True，则除了池化结果之外，还会返回每个池化区域的索引。默认值为 False。
输入:

输入的形状应为 (batch_size, channels, height, width)，其中 batch_size 是输入数据的批量大小，channels 是输入数据的通道数，height 是输入数据的高度，width 是输入数据的宽度。
输出:

输出的形状取决于输入的形状和参数设置。如果 return_indices 设置为 False，则输出的形状为 (batch_size, channels, height_out, width_out)，其中 height_out 和 width_out 是经过分数最大池化操作后的高度和宽度。如果 return_indices 设置为 True，则输出的形状为 (batch_size, channels, height_out, width_out, 3)，其中最后一个维度包含了分数最大池化操作的结果和索引。
"""
import torch
import torch.nn as nn

# 创建一个输入大小为 (batch_size=1, channels=1, height=6, width=6) 的张量
input_tensor = torch.tensor([[[[1, 2, 3, 4, 5, 6],
                               [7, 8, 9, 10, 11, 12],
                               [13, 14, 15, 16, 17, 18],
                               [19, 20, 21, 22, 23, 24],
                               [25, 26, 27, 28, 29, 30],
                               [31, 32, 33, 34, 35, 36]]]], dtype=torch.float32)

# 创建一个分数最大池化层，指定输出大小为 (height_out=3, width_out=3)
fractional_maxpool = nn.FractionalMaxPool2d(kernel_size=2, output_size=(3, 3))

# 应用分数最大池化操作
output = fractional_maxpool(input_tensor)

print("Input shape:", input_tensor.shape)
print("Output shape:", output.shape)
print("Output tensor:")
print(output)

Input shape: torch.Size([1, 1, 6, 6])
Output shape: torch.Size([1, 1, 3, 3])
Output tensor:
tensor([[[[ 8., 10., 12.],
          [20., 22., 24.],
          [32., 34., 36.]]]])

5.torch.nn.AdaptiveMaxPool2d()

torch.nn.AdaptiveMaxPool2d() 是 PyTorch 中用于执行自适应最大池化操作的模块。与传统的最大池化操作不同，自适应最大池化允许指定输出的大小而不是固定的池化窗口大小。这样可以适应不同输入尺寸的情况。

torch.nn.AdaptiveMaxPool2d(output_size, return_indices=False)
"""
参数：

output_size：指定输出的大小，可以是一个整数 output_size，表示输出的高度和宽度相同，或者是一个元组 (output_height, output_width)，表示输出的高度和宽度分别指定。
return_indices：一个布尔值，表示是否返回最大值的索引，默认为 False。如果设置为 True，则除了输出张量之外，还会返回一个包含最大值索引的张量。
返回值：返回经过自适应最大池化操作后的输出张量。
"""

import torch
import torch.nn as nn

# 创建一个输入大小为 (batch_size=1, channels=3, height=8, width=8) 的张量
input_tensor = torch.randn(1, 3, 8, 8)

# 创建一个自适应最大池化层，指定输出大小为 (output_height=4, output_width=4)
adaptive_max_pool = nn.AdaptiveMaxPool2d((4, 4))

# 应用自适应最大池化操作
output = adaptive_max_pool(input_tensor)

print("Input shape:", input_tensor.shape)
print("Output shape:", output.shape)
print("Output tensor:")
print(output)

Input shape: torch.Size([1, 3, 8, 8])
Output shape: torch.Size([1, 3, 4, 4])
Output tensor:
tensor([[[[ 1.2610,  1.7199,  0.5566, -0.6244],
          [ 1.2304,  1.0557,  1.0771,  1.9450],
          [ 1.2392,  2.3084,  1.0637,  1.1622],
          [ 1.3770,  0.6236,  1.3798,  0.7460]],

         [[ 0.8982,  1.4581,  0.3343,  0.9386],
          [ 1.6850,  0.6486,  1.8757,  0.2791],
          [ 1.7288, -0.0283,  0.3951,  1.4132],
          [ 0.8079, -0.1223,  1.0691,  1.6758]],

         [[ 0.7427,  1.1573,  1.2954, -0.4555],
          [ 2.0537,  1.0242,  1.2825,  0.0518],
          [ 0.1625,  1.7359,  1.3700,  0.8211],
          [ 2.9089,  1.0194,  0.5195,  0.3354]]]])

Process finished with exit code 0

6.torch.nn.AdaptiveAvgPool2d()

torch.nn.AdaptiveAvgPool2d() 是 PyTorch 中用于执行自适应平均池化操作的模块。与传统的平均池化操作不同，自适应平均池化允许您指定输出的大小而不是固定的池化窗口大小。这样可以适应不同输入尺寸的情况。

torch.nn.AdaptiveAvgPool2d(output_size)
"""
参数：

output_size：指定输出的大小，可以是一个整数 output_size，表示输出的高度和宽度相同，或者是一个元组 (output_height, output_width)，表示输出的高度和宽度分别指定。
返回值：

返回经过自适应平均池化操作后的输出张量。
"""

import torch
import torch.nn as nn

# 创建一个输入大小为 (batch_size=1, channels=3, height=8, width=8) 的张量
input_tensor = torch.randn(1, 3, 8, 8)

# 创建一个自适应平均池化层，指定输出大小为 (output_height=4, output_width=4)
adaptive_avg_pool = nn.AdaptiveAvgPool2d((4, 4))

# 应用自适应平均池化操作
output = adaptive_avg_pool(input_tensor)

print("Input shape:", input_tensor.shape)
print("Output shape:", output.shape)
print("Output tensor:")
print(output)

Input shape: torch.Size([1, 3, 8, 8])
Output shape: torch.Size([1, 3, 4, 4])
Output tensor:
tensor([[[[ 0.2527, -0.1540,  0.5581,  0.3150],
          [ 0.1681,  0.1476,  0.6236, -0.3700],
          [ 0.4671,  0.2676,  0.2503,  0.9639],
          [ 1.3397, -0.6461,  0.1389,  1.3841]],

         [[ 0.0513, -0.3766, -0.0537, -0.4022],
          [ 0.2456,  0.1087,  0.1884, -0.3771],
          [-0.1746, -0.4370,  0.7384,  0.5044],
          [ 0.2178,  0.3246, -0.5665, -0.6366]],

         [[-0.3851, -0.0275, -0.3056,  0.0675],
          [-0.6003, -0.4432,  0.9833, -0.4356],
          [-0.0093, -0.2932,  0.7755, -0.1698],
          [ 0.3236,  0.8242, -0.1989,  0.2372]]]])