池化层解析：简单易懂理解 PyTorch 中的核心组件

E寻数据

已于 2024-01-08 10:48:35 修改

阅读量982

点赞数 23

分类专栏： pytorch python 深度学习文章标签： pytorch 深度学习人工智能

于 2024-01-03 10:18:08 首次发布

本文链接：https://blog.csdn.net/qq_42452134/article/details/135340488

版权

深度学习同时被 3 个专栏收录

77 篇文章 38 订阅

订阅专栏

pytorch

53 篇文章 1 订阅

订阅专栏

python

53 篇文章 0 订阅

订阅专栏

nn.FractionalMaxPool2d

nn.FractionalMaxPool3d

torch.nn详解

nn.MaxPool1d

在 PyTorch 中，nn.MaxPool1d 是一种一维最大池化层，常用于卷积神经网络中对输入张量的空间维度（宽度）进行下采样。该层通过在输入张量上应用一个滑动窗口（也称为池化窗口），并在每个窗口中选择最大值。让我们详细解释一下其参数：

kernel_size（Union[int, Tuple[int]]）：滑动窗口的大小，必须大于 0。
stride（Union[int, Tuple[int]]）：滑动窗口的步长，必须大于 0。默认值是 kernel_size。
padding（Union[int, Tuple[int]]）：在两侧添加的隐式负无穷填充，必须大于等于 0 且小于等于 kernel_size / 2。
dilation（Union[int, Tuple[int]]）：滑动窗口内部元素之间的步距，必须大于 0。
return_indices（bool）：如果为 True，则返回最大值以及其索引。在之后使用 torch.nn.MaxUnpool1d 时很有用。
ceil_mode（bool）：如果为 True，则使用 ceil 而不是 floor 来计算输出形状。这确保输入张量中的每个元素都被滑动窗口覆盖。

示例：

# 池化大小=3，步长=2
m = nn.MaxPool1d(3, stride=2)
input = torch.randn(20, 16, 50)
output = m(input)

在这个示例中，我们创建了一个池化层 m，其池化大小为 3，步长为 2。然后我们对一个随机生成的输入张量 input 应用这个池化层，并得到了输出张量 output。

nn.MaxPool2d

nn.MaxPool2d 是二维最大池化层，广泛用于卷积神经网络来进行空间下采样。它通过在输入张量上应用一个二维滑动窗口，并选择每个窗口中的最大值来工作。以下是它的参数及其解释：

kernel_size（Union[int, Tuple[int, int]]）：执行最大池化的窗口大小。可以是单个整数（在高度和宽度维度上使用相同的值），或一个包含两个整数的元组（第一个整数用于高度维度，第二个用于宽度维度）。
stride（Union[int, Tuple[int, int]]）：滑动窗口的步长。默认值是 kernel_size。同样可以是单个整数或两个整数的元组。
padding（Union[int, Tuple[int, int]]）：在输入的两侧隐式添加的负无穷填充。如果为非零，则输入会在两侧各添加指定数量的填充。
dilation（Union[int, Tuple[int, int]]）：控制窗口中元素的间距。可以视为窗口中每个点之间的距离。
return_indices（bool）：如果为 True，则除了输出最大值外，还会返回它们的索引。这在稍后使用 torch.nn.MaxUnpool2d 时非常有用。
ceil_mode（bool）：如果为 True，则在计算输出形状时使用 ceil 而非 floor。这意味着当滑动窗口开始于左侧填充或输入中时，它们可以超出边界。在右侧填充区域开始的滑动窗口将被忽略。

例子：

# 创建一个池化层，窗口大小=3，步长=2
m = nn.MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1)
input = torch.randn(20, 16, 50, 32)
output = m(input)

在此示例中，我们定义了一个二维最大池化层 m，其窗口大小为 3x3，步长为 2，填充为 1，且不扩展窗口（dilation=1）。然后我们对一个随机生成的输入张量 input 应用这个池化层，并得到了输出张量 output。

nn.MaxPool3d

nn.MaxPool3d 是三维最大池化层，用于在三维数据（如3D图像或视频帧）上进行空间下采样。以下是它的参数及其解释：

kernel_size (Union[int, Tuple[int, int, int]])：执行最大池化的立方体（或“窗口”）的大小。可以是单个整数（在深度、高度和宽度维度上使用相同的值），或一个包含三个整数的元组（第一个整数用于深度维度，第二个用于高度维度，第三个用于宽度维度）。
stride (Union[int, Tuple[int, int, int]])：滑动窗口的步长。默认值是 kernel_size。同样可以是单个整数或三个整数的元组。
padding (Union[int, Tuple[int, int, int]])：在输入的所有三侧隐式添加的负无穷填充。填充数量指定了在每个维度上要添加的填充点数。
dilation (Union[int, Tuple[int, int, int]])：控制窗口中元素的间距。这个参数决定了窗口内各点之间的距离。
return_indices (bool)：如果为 True，则除了输出最大值外，还会返回它们的索引。这在稍后使用 torch.nn.MaxUnpool3d 时非常有用。
ceil_mode (bool)：如果为 True，则在计算输出形状时使用 ceil 而非 floor。这意味着允许滑动窗口超出输入边界，只要它们开始于左侧填充或输入内部。在右侧填充区域开始的滑动窗口将被忽略。

使用 nn.MaxPool3d 的例子：

# 创建一个池化层，窗口大小=3x3x3，步长=2
m = nn.MaxPool3d(kernel_size=3, stride=2, padding=1, dilation=1)
input = torch.randn(20, 16, 50, 44, 32)  # 示例输入
output = m(input)

在这个例子中，定义了一个三维最大池化层 m，其窗口大小为 3x3x3，步长为 2，填充为 1，且不扩展窗口（dilation=1）。然后对一个随机生成的三维输入张量 input 应用这个池化层，得到输出张量 output。

nn.MaxUnpool1d

torch.nn.MaxUnpool1d 是 PyTorch 中的一个类，它实现了 MaxPool1d 的部分逆运算。MaxPool1d 是不完全可逆的，因为在池化过程中非最大值丢失了。MaxUnpool1d 通过接受 MaxPool1d 的输出及最大值的索引，并将所有非最大值设为零，来完成这一部分逆运算。

注意点：

非确定性操作：当输入索引存在重复值时，该操作可能表现出非确定性。这可能会影响模型的重现性。
模糊的反向映射：由于 MaxPool1d 可以将多个不同大小的输入映射到相同大小的输出，因此反向映射过程可能会有歧义。为了解决这个问题，可以在前向传播调用时提供所需的输出大小作为额外的参数 output_size。

参数：

kernel_size (int 或 tuple)：最大池化窗口的大小。
stride (int 或 tuple)：最大池化窗口的步长。默认值为 kernel_size。
padding (int 或 tuple)：输入中添加的填充量。

输入：

input：要反转的输入张量。
indices：由 MaxPool1d 提供的最大值索引。
output_size (可选)：目标输出大小。

示例：

# 创建最大池化和对应的反池化层
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)
unpooled_output = unpool(output, indices)
# 输出: tensor([[[ 0.,  2.,  0.,  4.,  0.,  6.,  0., 8.]]])

# 使用 output_size 的示例
input = torch.tensor([[[1., 2, 3, 4, 5, 6, 7, 8, 9]]])
output, indices = pool(input)
unpooled_output = unpool(output, indices, output_size=input.size())
# 输出: tensor([[[ 0.,  2.,  0.,  4.,  0.,  6.,  0., 8.,  0.]]])

在这些示例中，首先进行最大池化操作，然后使用 MaxUnpool1d 进行部分逆操作。在第二个示例中，通过指定 output_size 参数，确保反池化输出的尺寸与原始输入一致。

nn.MaxUnpool2d

torch.nn.MaxUnpool2d 是 PyTorch 中的一个类，用于实现 MaxPool2d 的部分逆操作。由于 MaxPool2d 在池化过程中丢失了非最大值，因此它不是完全可逆的。MaxUnpool2d 的作用是接受 MaxPool2d 的输出（包括最大值的索引）并计算一个部分逆操作，在这个操作中，所有非最大值被设置为零。

注意事项：

非确定性操作：当输入索引有重复值时，此操作可能表现出非确定性。更多信息见 PyTorch 文档和可重现性指南。
模糊的反向映射：MaxPool2d 可以将多个不同大小的输入映射到相同大小的输出，因此反向映射过程可能会有歧义。为了解决这个问题，可以在前向传播调用时提供所需的输出大小作为额外的参数 output_size。

参数：

kernel_size (int 或 tuple)：最大池化窗口的大小。
stride (int 或 tuple)：最大池化窗口的步长。默认值为 kernel_size。
padding (int 或 tuple)：输入中添加的填充量。

输入：

input：要反转的输入张量。
indices：由 MaxPool2d 提供的最大值索引。
output_size (可选)：目标输出大小。

示例：

# 创建最大池化和对应的反池化层
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)
unpooled_output = unpool(output, indices)
# 输出: tensor([[[[  0.,   0.,   0.,   0.],
#                [  0.,   6.,   0.,   8.],
#                [  0.,   0.,   0.,   0.],
#                [  0.,  14.,   0.,  16.]]]])

# 使用 output_size 的示例
input = torch.tensor([[[[ 1.,  2.,  3., 4., 5.],
                        [ 6.,  7.,  8., 9., 10.],
                        [11., 12., 13., 14., 15.],
                        [16., 17., 18., 19., 20.]]]])
output, indices = pool(input)
unpooled_output = unpool(output, indices, output_size=input.size())
# 输出: tensor([[[[ 0.,  0.,  0.,  0.,  0.],
#                [ 0.,  7.,  0.,  9.,  0.],
#                [ 0.,  0.,  0.,  0.,  0.],
#                [ 0., 17.,  0., 19.,  0.]]]])

在这些示例中，MaxUnpool2d 用于对 MaxPool2d 的结果进行部分逆操作。第二个示例中，通过指定 output_size 参数，确保反池化输出的尺寸与原始输入一致。

nn.MaxUnpool3d

torch.nn.MaxUnpool3d 是 PyTorch 中的一个类，用于实现 MaxPool3d 的部分逆操作。由于 MaxPool3d 在池化过程中丢失了非最大值，因此它不是完全可逆的。MaxUnpool3d 的作用是接受 MaxPool3d 的输出（包括最大值的索引）并计算一个部分逆操作，在这个操作中，所有非最大值被设置为零。

注意事项：

非确定性操作：当输入索引有重复值时，此操作可能表现出非确定性。更多信息见 PyTorch 文档和可重现性指南。
模糊的反向映射：MaxPool3d 可以将多个不同大小的输入映射到相同大小的输出，因此反向映射过程可能会有歧义。为了解决这个问题，可以在前向传播调用时提供所需的输出大小作为额外的参数 output_size。

参数：

kernel_size (int 或 tuple)：最大池化窗口的大小。
stride (int 或 tuple)：最大池化窗口的步长。默认值为 kernel_size。
padding (int 或 tuple)：输入中添加的填充量。

输入：

input：要反转的输入张量。
indices：由 MaxPool3d 提供的最大值索引。
output_size (可选)：目标输出大小。

示例：

# 创建最大池化和对应的反池化层
pool = nn.MaxPool3d(3, stride=2, return_indices=True)
unpool = nn.MaxUnpool3d(3, stride=2)

# 输入张量
input = torch.randn(20, 16, 51, 33, 15)
output, indices = pool(input)
unpooled_output = unpool(output, indices)
# 检查反池化后的尺寸
print(unpooled_output.size())  # 输出: torch.Size([20, 16, 51, 33, 15])

在这个示例中，MaxUnpool3d 用于对 MaxPool3d 的结果进行部分逆操作。通过指定 output_size 参数，可以确保反池化输出的尺寸与原始输入一致。

nn.AvgPool1d

torch.nn.AvgPool1d 是 PyTorch 中的一个类，用于在一维数据上执行平均池化操作。它通过将输入数据划分为大小固定的窗口，并在每个窗口内计算平均值来降低数据的维度，从而实现池化。

重要特性：

隐式零填充：如果 padding 参数非零，则在输入的两侧隐式地添加零填充。填充的数量由 padding 参数的值决定。
输出形状的计算：
- 当 ceil_mode=True 时，使用向上取整而不是向下取整来计算输出的形状。这确保了所有输入元素都被窗口覆盖。
- 若窗口开始于左侧填充区域或输入区域内，允许窗口超出边界。从右侧填充区域开始的窗口将被忽略。

参数：

kernel_size (int 或 tuple)：池化窗口的大小。
stride (int 或 tuple)：池化窗口的步长。默认值为 kernel_size。
padding (int 或 tuple)：在两侧添加的隐式零填充量。
ceil_mode (bool)：如果为 True，使用向上取整计算输出形状。
count_include_pad (bool)：如果为 True，在计算平均值时包括零填充。

示例：

# 创建一维平均池化层，窗口大小为3，步长为2
m = nn.AvgPool1d(3, stride=2)
# 输入张量
input = torch.tensor([[[1., 2, 3, 4, 5, 6, 7]]])
# 应用平均池化
output = m(input)
print(output)  # 输出: tensor([[[2., 4., 6.]]])

在这个示例中，AvgPool1d 对输入数据进行了平均池化。每个窗口覆盖3个元素，步长为2，因此第一个窗口计算了 [1., 2, 3] 的平均值，第二个窗口计算了 [3, 4, 5] 的平均值，以此类推。由于采用的是平均池化，每个窗口的输出是窗口内元素的平均值。

nn.AvgPool2d

torch.nn.AvgPool2d 是 PyTorch 中用于二维数据的平均池化层。这个类通过对输入数据应用大小固定的滑动窗口，并计算每个窗口内元素的平均值来降低数据的维度，这种操作通常用于卷积神经网络中降低特征图的空间维度。

主要特性：

隐式零填充：如果 padding 参数非零，则在输入的两侧隐式地添加零填充。填充的数量由 padding 参数的值决定。
输出形状的计算：
- 当 ceil_mode=True 时，使用向上取整而不是向下取整来计算输出的形状。这确保了所有输入元素都被窗口覆盖。
- 若窗口开始于左侧填充区域或输入区域内，允许窗口超出边界。从右侧填充区域开始的窗口将被忽略。

参数：

kernel_size (int 或 tuple)：池化窗口的大小。
stride (int 或 tuple)：池化窗口的步长。默认值为 kernel_size。
padding (int 或 tuple)：在两侧添加的隐式零填充量。
ceil_mode (bool)：如果为 True，使用向上取整计算输出形状。
count_include_pad (bool)：如果为 True，在计算平均值时包括零填充。
divisor_override (Optional[int])：如果指定，将用作除数，否则使用池化区域的大小。

示例：

# 创建二维平均池化层，窗口大小为3x3，步长为2
m = nn.AvgPool2d(3, stride=2)
# 创建二维平均池化层，非方形窗口
m = nn.AvgPool2d((3, 2), stride=(2, 1))
# 输入张量
input = torch.randn(20, 16, 50, 32)
# 应用平均池化
output = m(input)

在这个示例中，AvgPool2d 对输入数据进行了平均池化。第一个例子中的池化层使用3x3的方形窗口和步长为2，第二个例子使用3x2的非方形窗口和不同的步长。每个窗口覆盖相应大小的元素，并计算这些元素的平均值。这种类型的池化操作常用于减少特征图的空间维度，同时保留重要的特征信息。

nn.AvgPool3d

torch.nn.AvgPool3d 是 PyTorch 中用于三维数据的平均池化层，主要应用于三维卷积神经网络。这个类通过在输入数据上应用一个固定大小的三维滑动窗口，并计算每个窗口内元素的平均值，以此来降低数据的维度。

主要特性：

隐式零填充：如果 padding 参数非零，输入数据将在所有三个维度上隐式地添加零填充。
输出形状的计算：
- 当 ceil_mode=True 时，使用向上取整而不是向下取整来计算输出的形状，确保每个输入元素都被覆盖。
- 若窗口开始于左侧填充区或输入区内，允许窗口超出边界。从右侧填充区开始的窗口将被忽略。

参数：

kernel_size (int 或 tuple)：池化窗口的大小。
stride (int 或 tuple)：池化窗口的步长。默认值为 kernel_size。
padding (int 或 tuple)：在所有三个维度上添加的隐式零填充。
ceil_mode (bool)：如果为 True，计算输出形状时使用向上取整。
count_include_pad (bool)：如果为 True，计算平均值时包括零填充。
divisor_override (Optional[int])：如果指定，它将用作除数，否则将使用 kernel_size。

示例：

# 创建三维平均池化层，窗口大小为3x3x3，步长为2
m = nn.AvgPool3d(3, stride=2)
# 输入张量
input = torch.randn(20, 16, 51, 33, 15)
# 应用平均池化
output = m(input)

在这个示例中，AvgPool3d 对输入数据进行了三维平均池化。池化层使用3x3x3的立方体窗口和步长为2。每个窗口覆盖相应大小的元素，并计算这些元素的平均值。这种类型的池化操作用于减少三维特征图的空间维度，同时保留关键的特征信息，常见于三维图像处理或视频处理的深度学习应用中。

nn.FractionalMaxPool2d

torch.nn.FractionalMaxPool2d 是 PyTorch 中用于实现二维分数最大池化的类。分数最大池化（Fractional MaxPooling）是一种池化操作，它与传统的最大池化略有不同。在传统的最大池化中，池化窗口的大小和步长是固定的。相比之下，分数最大池化允许使用随机或非整数的步长，从而可以获得不同大小的输出特征图。

主要特性：

随机步长：通过目标输出大小确定的随机步长对输入数据进行池化。
灵活的输出尺寸：可以通过指定输出尺寸或输出比例来控制输出特征图的大小。

参数：

kernel_size (int 或 tuple)：池化窗口的大小。可以是单个数字 k（表示 k x k 的方形窗口）或一个元组 (kh, kw)。
output_size (int 或 tuple)：目标输出尺寸，形式为 oH x oW。可以是元组 (oH, oW) 或单个数字 oH（表示方形图像 oH x oH）。
output_ratio (float 或 tuple)：如果希望输出尺寸是输入尺寸的比例，则可以使用此选项。必须是 (0, 1) 范围内的数字或元组。
return_indices (bool)：如果为 True，则返回最大值的索引和输出。这对于后续使用 nn.MaxUnpool2d() 很有用。默认为 False。

示例：

# 方形窗口大小为3，目标输出尺寸为 13x12
m = nn.FractionalMaxPool2d(3, output_size=(13, 12))
# 输入张量
input = torch.randn(20, 16, 50, 32)
# 应用分数最大池化
output = m(input)

# 方形窗口大小为3，目标输出尺寸为输入尺寸的一半
m = nn.FractionalMaxPool2d(3, output_ratio=(0.5, 0.5))
# 输入张量
input = torch.randn(20, 16, 50, 32)
# 应用分数最大池化
output = m(input)

在这些示例中，FractionalMaxPool2d 根据指定的输出尺寸或输出比例，使用随机步长对输入张量进行二维最大池化。这种类型的池化操作用于在保留重要特征的同时减少特征图的尺寸，特别适用于需要更细粒度控制输出尺寸的情况。

nn.FractionalMaxPool3d

torch.nn.FractionalMaxPool3d 是 PyTorch 中用于实现三维分数最大池化（Fractional MaxPooling）的类。与二维版本类似，它允许使用随机或非整数的步长来进行池化，从而可以获得不同大小的输出特征图。这种池化操作对于提取三维数据（如体积图像或视频序列）中的特征特别有用。

主要特性：

随机步长：通过目标输出大小确定的随机步长对输入数据进行池化。
灵活的输出尺寸：可以通过指定输出尺寸或输出比例来控制输出特征图的大小。

参数：

kernel_size (int 或 tuple)：池化窗口的大小。可以是单个数字 k（表示 k x k x k 的立方窗口）或一个元组 (kt, kh, kw)。
output_size (int 或 tuple)：目标输出尺寸，形式为 oT x oH x oW。可以是元组 (oT, oH, oW) 或单个数字 oH（表示立方图像 oH x oH x oH）。
output_ratio (float 或 tuple)：如果希望输出尺寸是输入尺寸的比例，则可以使用此选项。必须是 (0, 1) 范围内的数字或元组。
return_indices (bool)：如果为 True，则返回最大值的索引和输出。这对于后续使用 nn.MaxUnpool3d() 很有用。默认为 False。

示例：

# 立方窗口大小为3，目标输出尺寸为 13x12x11
m = nn.FractionalMaxPool3d(3, output_size=(13, 12, 11))
# 输入张量
input = torch.randn(20, 16, 50, 32, 16)
# 应用分数最大池化
output = m(input)

# 立方窗口大小为3，目标输出尺寸为输入尺寸的一半
m = nn.FractionalMaxPool3d(3, output_ratio=(0.5, 0.5, 0.5))
# 输入张量
input = torch.randn(20, 16, 50, 32, 16)
# 应用分数最大池化
output = m(input)

在这些示例中，FractionalMaxPool3d 根据指定的输出尺寸或输出比例，使用随机步长对输入张量进行三维最大池化。这种类型的池化操作用于在保留重要特征的同时减少特征图的尺寸，特别适用于处理三维数据或视频内容。

nn.LPPool1d

torch.nn.LPPool1d 是 PyTorch 中用于实现一维 Lp 池化（Lp pooling）的类。这种池化操作是最大池化（Max Pooling）和平均池化（Average Pooling）的泛化形式，它使用 Lp 范数来池化输入数据。

主要特性：

Lp 范数：通过 Lp 范数计算池化区域内的平均值，其中 p 由 norm_type 参数指定。
灵活的窗口和步长：可以指定池化窗口的大小（kernel_size）和步长（stride）。

参数：

norm_type (float)：指定 Lp 范数的 p 值。例如，p=2 时为 L2 范数（平方和的平方根）。
kernel_size (int 或 tuple)：单个整数，指定池化窗口的大小。
stride (int 或 tuple)：单个整数，指定池化窗口的步长。默认值为 kernel_size。
ceil_mode (bool)：如果为 True，则使用 ceil 而不是 floor 来计算输出形状。

注意：

如果 p 次幂之和为零，则此函数的梯度未定义。在这种情况下，实现将梯度设置为零。

示例：

# 二次方平均池化，窗口长度为 3，步长为 2
m = nn.LPPool1d(2, 3, stride=2)
# 输入张量
input = torch.randn(20, 16, 50)
# 应用 Lp 池化
output = m(input)

在此示例中，LPPool1d 使用 L2 范数（即平方和的平方根）对输入张量的每个一维子区域进行池化。它可以捕获区域内的整体能量或强度，而不是像最大池化那样只关注最大值。这种类型的池化操作用于在保留关键信息的同时减少特征的尺寸，特别适用于处理一维信号数据（如音频波形）。

nn.LPPool2d

torch.nn.LPPool2d 是 PyTorch 中用于实现二维 Lp 池化（Lp pooling）的类。这种池化操作是最大池化（Max Pooling）和平均池化（Average Pooling）的泛化形式，它使用 Lp 范数来池化输入数据。

主要特性：

Lp 范数：通过 Lp 范数计算池化区域内的平均值，其中 p 由 norm_type 参数指定。
灵活的窗口和步长：可以指定池化窗口的大小（kernel_size）和步长（stride）。

参数：

norm_type (float)：指定 Lp 范数的 p 值。
kernel_size (int 或 tuple)：指定池化窗口的大小。
stride (int 或 tuple)：指定池化窗口的步长。默认值为 kernel_size。
ceil_mode (bool)：如果为 True，则使用 ceil 而不是 floor 来计算输出形状。

注意：

如果 p 次幂之和为零，则此函数的梯度未定义。在这种情况下，实现将梯度设置为零。

示例：

# 二次方平均池化，正方形窗口大小为 3，步长为 2
m = nn.LPPool2d(2, 3, stride=2)
# 非正方形窗口的 1.2 次方平均池化
m = nn.LPPool2d(1.2, (3, 2), stride=(2, 1))
# 输入张量
input = torch.randn(20, 16, 50, 32)
# 应用 Lp 池化
output = m(input)

在此示例中，LPPool2d 使用 L2 范数（平方和的平方根）对输入张量的每个二维子区域进行池化。这可以捕获区域内的整体能量或强度，而不是像最大池化那样只关注最大值。这种类型的池化操作用于在保留关键信息的同时减少特征的尺寸，特别适用于处理图像和二维信号数据。

nn.AdaptiveMaxPool1d

torch.nn.AdaptiveMaxPool1d 是 PyTorch 中用于实现一维自适应最大池化（Adaptive Max Pooling）的类。这种池化操作允许模型自动适应不同大小的输入数据，确保输出张量具有特定的大小。

主要特性：

自适应输出大小：无论输入数据的尺寸如何，都能得到固定大小的输出。
灵活适应输入：对于不同长度的输入序列，可以灵活调整池化窗口的大小。

参数：

output_size (int 或 tuple)：目标输出大小 $L_{out}$ 。这是池化后的长度。
return_indices (bool)：如果为 True，则返回最大值的索引以及输出。这对于稍后使用 nn.MaxUnpool1d 进行反池化非常有用。默认为 False。

示例：

# 目标输出大小为 5 的自适应最大池化
m = nn.AdaptiveMaxPool1d(5)
# 输入张量，尺寸为 (批次大小, 通道数, 长度)
input = torch.randn(1, 64, 8)
# 应用自适应最大池化
output = m(input)

在此示例中，无论输入张量的长度是多少（在这个例子中是 8），AdaptiveMaxPool1d 都会调整其内部池化窗口的大小，以确保输出张量的长度始终为 5。这种自适应池化方法在处理具有不同长度的时间序列或信号时非常有用，例如在处理不同长度的音频记录或其他一维信号时。通过自适应池化，可以确保网络的后续层总是接收到固定大小的输入，从而简化了模型的设计和优化。

nn.AdaptiveMaxPool2d

torch.nn.AdaptiveMaxPool2d 是 PyTorch 中用于实现二维自适应最大池化（Adaptive Max Pooling）的类。这种池化操作允许模型自动适应不同尺寸的输入数据，确保输出张量具有特定的尺寸。

主要特性：

自适应输出尺寸：不论输入数据的尺寸如何，输出都具有固定的尺寸 $H_{out}\ast W_{out}$ 。
灵活性：适用于多种场景，特别是当输入图片尺寸不固定时

参数：

output_size (int, tuple, None)：目标输出尺寸 $H_{out}\ast W_{out}$ 。可以是一个元组 $(H_{out},W_{out})$ 或单个整数 $H_{out}$ (对于正方形图像）。 $H_{out}$ 和 $W_{out}$ 可以是整数或 None，None 表示输出尺寸与输入相同。
return_indices (bool)：如果为 True，将返回最大值的索引及输出。这在使用 nn.MaxUnpool2d 进行反池化时非常有用。默认为 False。

示例：

# 目标输出尺寸为 5x7 的自适应最大池化
m = nn.AdaptiveMaxPool2d((5, 7))
input = torch.randn(1, 64, 8, 9)
output = m(input)

# 目标输出尺寸为 7x7（正方形）的自适应最大池化
m = nn.AdaptiveMaxPool2d(7)
input = torch.randn(1, 64, 10, 9)
output = m(input)

# 目标输出尺寸为 10x7 的自适应最大池化
m = nn.AdaptiveMaxPool2d((None, 7))
input = torch.randn(1, 64, 10, 9)
output = m(input)

在这些示例中，无论输入张量的高度和宽度是多少，AdaptiveMaxPool2d 都会调整其内部池化窗口的大小，以确保输出张量具有指定的尺寸。这种自适应池化方法在处理具有不同尺寸的图像时非常有用，例如在处理来自不同来源的图像集时。通过自适应池化，可以确保网络的后续层总是接收到固定尺寸的输入，从而简化了模型的设计和优化。

nn.AdaptiveMaxPool3d

torch.nn.AdaptiveMaxPool3d 是 PyTorch 中的一个类，用于实现三维自适应最大池化（Adaptive Max Pooling）。这种池化操作允许模型自动适应不同尺寸的输入数据，确保输出张量具有特定的尺寸。

主要特性：

自适应输出尺寸：不论输入数据的尺寸如何，输出都具有固定的尺寸 $D_{out}*H_{out}*W_{out}$ 。
适用于3D数据：适用于处理三维数据（如体积图像或视频序列），使输出尺寸保持一致。

参数：

output_size (int, tuple, None)：目标输出尺寸 $D_{out}*H_{out}*W_{out}$ 。可以是一个元组 $(D_{out}*H_{out}*W_{out})$ 或单个整数 $D_{out}$ （对于立方体数据）。 $D_{out}, H_{out}, W_{out}$ 可以是整数或 None，None 表示输出尺寸与输入相同。
return_indices (bool)：如果为 True，将返回最大值的索引及输出。这在使用 nn.MaxUnpool3d 进行反池化时非常有用。默认为 False。

示例：

# 目标输出尺寸为 5x7x9 的自适应最大池化
m = nn.AdaptiveMaxPool3d((5, 7, 9))
input = torch.randn(1, 64, 8, 9, 10)
output = m(input)

# 目标输出尺寸为 7x7x7（立方体）的自适应最大池化
m = nn.AdaptiveMaxPool3d(7)
input = torch.randn(1, 64, 10, 9, 8)
output = m(input)

# 目标输出尺寸为 7x9x8 的自适应最大池化
m = nn.AdaptiveMaxPool3d((7, None, None))
input = torch.randn(1, 64, 10, 9, 8)
output = m(input)

在这些示例中，无论输入张量的深度、高度和宽度是多少，AdaptiveMaxPool3d 都会调整其内部池化窗口的大小，以确保输出张量具有指定的尺寸。这种自适应池化方法在处理具有不同尺寸的三维数据时非常有用，例如在医学成像或视频处理领域。通过自适应池化，可以确保网络的后续层总是接收到固定尺寸的输入，从而简化了模型的设计和优化。

nn.AdaptiveAvgPool1d

torch.nn.AdaptiveAvgPool1d 是 PyTorch 中的一个类，它实现了一维自适应平均池化（Adaptive Average Pooling）。这种池化方式允许模型适应不同长度的输入序列，同时确保输出序列具有固定的长度。

主要特性：

自适应输出长度：无论输入序列的长度如何，输出序列的长度 $L_{out}$ 都是固定的。
适用于1D数据：特别适合处理一维数据，如时间序列或一维信号。

参数：

output_size (int 或 tuple)：目标输出长度 $L_{out}$ 。可以是一个整数，指定输出序列的固定长度。

示例：

# 目标输出长度为 5 的自适应平均池化
m = nn.AdaptiveAvgPool1d(5)
input = torch.randn(1, 64, 8)  # 输入序列长度为 8
output = m(input)  # 输出序列长度为 5

在这个示例中，无论输入序列的长度是多少，AdaptiveAvgPool1d 都会调整其内部池化窗口的大小，以确保输出序列的长度为指定的 5。这种自适应池化方法在处理长度不一的一维数据时非常有用，例如在音频处理或时间序列分析中。通过自适应池化，可以确保网络的后续层总是接收到固定长度的输入，从而简化了模型的设计和优化过程。

nn.AdaptiveAvgPool2d

torch.nn.AdaptiveAvgPool2d 是 PyTorch 中的一个类，用于实现二维自适应平均池化（Adaptive Average Pooling）。这种池化方式使得模型能够自适应不同尺寸的输入图像，同时确保输出图像具有指定的尺寸。

主要特性：

自适应输出尺寸：无论输入图像的尺寸如何，输出图像的尺寸都是固定的，即 $H_{out}*W_{out}$
适用于2D数据：特别适合处理二维数据，如图像。

参数：

output_size (int, None 或 tuple)：目标输出尺寸 $H_{out}*W_{out}$ 。可以是一个元组 (H, W) 或一个整数 H（对于正方形图像）。H 和 W 可以是整数或 None，None 表示尺寸将与输入相同。

输入和输出形状：

输入：形状为 (N, C, H_in, W_in) 或 (C, H_in, W_in)，其中 N 是批次大小，C 是通道数，H_in 和 W_in 是输入图像的高度和宽度。
输出：形状为 (N, C, S_0, S_1) 或 (C, S_0, S_1)，其中 S_0 和 S_1 是输出尺寸，由 output_size 指定。

示例：

# 目标输出尺寸为 5x7 的自适应平均池化
m = nn.AdaptiveAvgPool2d((5, 7))
input = torch.randn(1, 64, 8, 9)
output = m(input)

# 目标输出尺寸为 7x7（正方形）的自适应平均池化
m = nn.AdaptiveAvgPool2d(7)
input = torch.randn(1, 64, 10, 9)
output = m(input)

# 目标输出尺寸为 10x7 的自适应平均池化
m = nn.AdaptiveAvgPool2d((None, 7))
input = torch.randn(1, 64, 10, 9)
output = m(input)

在这些示例中，AdaptiveAvgPool2d 通过调整内部池化窗口的大小，确保无论输入图像的尺寸如何，输出图像始终具有指定的尺寸。这在处理不同尺寸的图像时非常有用，例如在图像分类或对象检测任务中。通过自适应池化，可以确保网络的后续层总是接收到固定尺寸的输入，从而简化了模型的设计和优化过程。

nn.AdaptiveAvgPool3d

torch.nn.AdaptiveAvgPool3d 是 PyTorch 中的一个类，用于实现三维自适应平均池化（Adaptive Average Pooling）。这种池化方式适用于三维数据，例如在医学成像或视频处理中常见的三维体积数据。

主要特性：

自适应输出尺寸：无论输入体积的尺寸如何，输出体积的尺寸都是固定的，即 $D_{out}*H_{out}*W_{out}$
适用于3D数据：特别适合处理三维数据，如体积数据或视频序列。

参数：

output_size (int, None 或 tuple)：目标输出尺寸 $D_{out}*H_{out}*W_{out}$ 。可以是一个元组 (D, H, W) 或一个整数 D（对于立方体体积 D x D x D）。D、H 和 W 可以是整数或 None，None 表示尺寸将与输入相同。

输入和输出形状：

输入：形状为 (N, C, D_in, H_in, W_in) 或 (C, D_in, H_in, W_in)，其中 N 是批次大小，C 是通道数，D_in、H_in 和 W_in 是输入体积的深度、高度和宽度。
输出：形状为 (N, C, S_0, S_1, S_2) 或 (C, S_0, S_1, S_2)，其中 S_0、S_1、S_2 是输出尺寸，由 output_size 指定。

示例：

# 目标输出尺寸为 5x7x9 的自适应平均池化
m = nn.AdaptiveAvgPool3d((5, 7, 9))
input = torch.randn(1, 64, 8, 9, 10)
output = m(input)

# 目标输出尺寸为 7x7x7（立方体）的自适应平均池化
m = nn.AdaptiveAvgPool3d(7)
input = torch.randn(1, 64, 10, 9, 8)
output = m(input)

# 目标输出尺寸为 7x9x8 的自适应平均池化
m = nn.AdaptiveAvgPool3d((7, None, None))
input = torch.randn(1, 64, 10, 9, 8)
output = m(input)

在这些示例中，AdaptiveAvgPool3d 通过调整内部池化窗口的大小，确保无论输入体积的尺寸如何，输出体积始终具有指定的尺寸。这在处理不同尺寸的三维数据时非常有用，例如在体积图像分类或三维对象检测任务中。通过自适应池化，可以确保网络的后续层总是接收到固定尺寸的输入，从而简化了模型的设计和优化过程。

总结

在这篇博客中，我们深入探讨了 PyTorch 中的多种池化层（Pooling layers），它们在深度学习和神经网络中起着至关重要的作用。从基本的最大池化（Max Pooling）到平均池化（Average Pooling），再到更高级的自适应池化（Adaptive Pooling）和分数池化（Fractional Pooling），我们详细解释了每种池化操作的特点、参数和应用场景。这些池化层不仅减少了模型的参数数量，还帮助提高了计算效率，并能够在一定程度上防止过拟合。无论是一维数据（如音频信号），二维数据（如图像），还是三维数据（如体积图像或视频序列），池化层都能够在保持数据的关键特征的同时，有效地降低数据的维度。

E寻数据

关注

23
点赞
踩
23

收藏

觉得还不错? 一键收藏
打赏
0
评论
池化层解析：简单易懂理解 PyTorch 中的核心组件

在这篇博客中，我们深入探讨了 PyTorch 中的多种池化层（Pooling layers），它们在深度学习和神经网络中起着至关重要的作用。从基本的最大池化（Max Pooling）到平均池化（Average Pooling），再到更高级的自适应池化（Adaptive Pooling）和分数池化（Fractional Pooling），我们详细解释了每种池化操作的特点、参数和应用场景。这些池化层不仅减少了模型的参数数量，还帮助提高了计算效率，并能够在一定程度上防止过拟合。
复制链接

扫一扫