文章目录
- 1.torch.nn.MaxPool1d()
- 2.torch.nn.MaxPool2d
- 3.torch.nn.AvgPool2d()
- 4.torch.nn.FractionalMaxPool2d()
- 5.torch.nn.AdaptiveMaxPool2d()
- 6.torch.nn.AdaptiveAvgPool2d()
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]]]])
