来自
打字
导入
可选
导入 torch.nn.functional
作为 F
来自
火炬
导入
张量
来自 torch.nn.common_types
导入 (
_ratio_2_t,
_ratio_3_t,
_size_1_t,
_size_2_opt_t,
_size_2_t,
_size_3_opt_t,
_size_3_t,
_size_any_opt_t,
_size_any_t,
)
来自
.模块
导入
模块
来自
.工具
导入 _pair, _single, _triple
__all__ = [
"MaxPool1d",
"MaxPool2d",
"MaxPool3d",
"MaxUnpool1d",
"MaxUnpool2d",
"MaxUnpool3d",
"AvgPool1d",
"AvgPool2d",
"AvgPool3d",
"FractionalMaxPool2d",
"FractionalMaxPool3d",
"LPPool1d",
"LPPool2d",
"LPPool3d",
"自适应最大池化 1d",
"自适应最大池化 2d",
"自适应最大池化 3d",
自适应平均池化 1d,
自适应平均池化 2d,
自适应平均池化 3d,
]
类
_最大池化 Nd(
模块):
常量 = [
"内核大小",
步长,
"填充",
"膨胀",
"返回索引",
"向上取整模式",
]
返回索引:
布尔类型
向上取整模式:
布尔类型
def 初始化(
self,
核心大小: _size_any_t,
步长:
可选[_size_any_t] =
无,
填充: _size_any_t = 0,
扩展率: _size_any_t = 1,
返回索引:
布尔类型 =
错误,
向上取整模式:
布尔类型 =
错误,
) -> 无:
超级().
初始化()
self.核心大小 =
核心大小
self.步长 =
步长
如果 (
步长
是 not
无)
否则
核心大小
self.填充 =
填充
self.扩展率 =
扩展率
self.返回索引 =
返回索引
self.向上取整模式 =
向上取整模式
def 额外表示(self) ->
字符串:
返回 (
"内核大小="
{核大小}
, 步长=
步长
, 填充=
填充"
", 膨胀="
膨胀
ceil_mode={ceil_mode}".
格式(**self.
字典)
)
[文档]
类 MaxPool1d(_MaxPoolNd):
r对由多个输入平面组成的输入信号应用 1D 最大池化。
在最简单的情况下，输入大小为 :math:`(N, C, L)` 的层输出值可以精确描述为：
输出大小为 :math:`(N, C, L_{out})`，可以精确描述如下：
.. math::
out(N_i, C_j, k) = \max_{m=0, \ldots, \text{kernel\_size} - 1}
输入(N_i, C_j, stride × k + m)
如果:attr:`padding`不为零，则输入将在两侧隐式填充负无穷
对于:attr:`padding`个点。:attr:`dilation`是滑动窗口内元素之间的步长
此`链接`_提供了一个关于池化参数的精彩可视化
注意：
当 ceil_mode=True 时，滑动窗口可以超出边界，前提是它们从左填充开始
或者输入。如果滑动窗口将从右填充区域开始，则忽略。
Args:
kernel_size：滑动窗口的大小，必须大于 0。
stride：滑动窗口的步长，必须大于 0。默认值是：attr:`kernel_size`。
填充：在两侧添加隐式负无穷填充，必须大于等于 0 且小于等于核大小的一半。
扩展率：滑动窗口内元素之间的步长，必须大于 0。
如果为 ``True``，将返回 argmax 沿着最大值。
适用于：class:`torch.nn.MaxUnpool1d`之后
ceil_mode: 如果为 ``True``，将使用 `ceil` 而不是 `floor` 来计算输出形状。
确保输入张量中的每个元素都被滑动窗口覆盖。
形状：
- 输入：:math:`(N, C, L_{in})` 或 :math:`(C, L_{in})`。
- 输出：:math:`(N, C, L_{out})` 或 :math:`(C, L_{out})`，其中
.. math::
L_{out} = \left\lfloor \frac{L_{in} + 2 \times \text{padding} - \text{dilation}
\times (核大小 - 1) - 1}{步长} + 1\right\rfloor
示例：
>>> 池大小=3，步长=2
>>> m = nn.MaxPool1d(3, stride=2)
>>> input = torch.randn(20, 16, 50)
>>> output = m(input)
.. _链接:
https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md
"源代码"
核心大小:
_大小_1_t
步长:
_大小_1_t
填充:
_大小_1_t
扩展率:
_大小_1_t
def 前向(self,
输入:
张量):
返回 F.
最大池化 1D(
输入,
self.核心大小,
self.步长,
self.填充,
self.扩展率,
向上取整模式=self.
向上取整模式,
返回索引=self.
返回索引,
)
[文档]
类 MaxPool2d(_MaxPoolNd):
r应用在由多个输入平面组成的输入信号上的 2D 最大池化。
在最简单的情况下，输入层的大小为 :math:`(N, C, H, W)`，输出大小为 :math:`(N, C, H_{out}, W_{out})`，核大小为 :attr:`kernel_size` :math:`(kH, kW)`。
输出 :math:`(N, C, H_{out}, W_{out})` 和 :attr:`kernel_size` :math:`(kH, kW)`。
可以精确描述为：
.. math::
\begin{aligned}
out(N_i, C_j, h, w) ={} & \max_{m=0, \ldots, kH-1} \max_{n=0, \ldots, kW-1} \\
& \text{input}(N_i, C_j, \text{stride[0]} \times h + m,
\text{stride[1]} \times w + n)
\end{aligned}
如果 :attr:`padding` 不为零，则输入将在两侧隐式填充负无穷大
对于 :attr:`padding` 的点数数量。:attr:`dilation` 控制内核点之间的间距。
描述起来比较困难，但这个 `链接`_ 有一个关于 :attr:`dilation` 做什么的良好可视化。
注意：
当 ceil_mode=True 时，滑动窗口可以在左填充内开始时超出边界。
或者输入。如果滑动窗口将开始于右填充区域，则忽略这些窗口。
参数:attr:`kernel_size`、:attr:`stride`、:attr:`padding`、:attr:`dilation`可以是：
- 一个单个的 `int` -- 在这种情况下，相同的价值用于高度和宽度维度
- 两个 `int` 的 `tuple` -- 在这种情况下，第一个 `int` 用于高度维度，
并且第二个 `int` 用于宽度维度
Args:
kernel_size: 对窗口进行最大值操作的窗口大小。
窗口的步长。默认值为 :attr:`kernel_size`
填充：在两侧添加隐式负无穷填充
扩展率：控制窗口中元素步长的参数
return_indices：如果为 ``True``，将返回最大索引和输出
适用于：class:`torch.nn.MaxUnpool2d`之后
ceil_mode：当为 True 时，将使用`ceil`代替`floor`来计算输出形状
形状：
输入：:math:`(N, C, H_{in}, W_{in})` 或 :math:`(C, H_{in}, W_{in})`
- 输出: :math:`(N, C, H_{out}, W_{out})` 或 :math:`(C, H_{out}, W_{out})`，其中
.. math::
H_{out} = \left\lfloor\frac{H_{in} + 2 * \text{padding[0]} - \text{dilation[0]}
\times (\text{kernel\_size[0]} - 1) - 1}{\text{stride[0]}} + 1\right\rfloor
.. math::
W_{out} = \left\lfloor\frac{W_{in} + 2 * \text{padding[1]} - \text{dilation[1]}
\times (\text{kernel\_size[1]} - 1) - 1}{\text{stride[1]}} + 1\right\rfloor
示例：
>>> # 正方形窗口池化大小=3，步长=2
>>> m = nn.MaxPool2d(3, stride=2)
>>> # 非正方形窗口池
>>> m = nn.MaxPool2d((3, 2), stride=(2, 1))
>>> input = torch.randn(20, 16, 50, 32)
>>> output = m(input)
.. _链接:
https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md
"源代码"
核心大小:
_尺寸_2_t
步长:
_尺寸_2_t
填充:
_尺寸_2_t
扩展率:
_尺寸_2_t
def 前向(self,
输入:
张量):
返回 F.max_pool2d(
输入,
self.核心大小,
self.步长,
self.填充,
self.扩展率,
向上取整模式=self.
向上取整模式,
返回索引=self.
返回索引,
)
[文档]
类 MaxPool3d(_MaxPoolNd):
r对由多个输入平面组成的输入信号应用 3D 最大池化。
在最简单的情况下，该层的输出值具有输入大小 :math:`(N, C, D, H, W)`，
输出 :math:`(N, C, D_{out}, H_{out}, W_{out})` 和 :attr:`kernel_size` :math:`(kD, kH, kW)`
可以精确描述为：
.. math::
\begin{aligned}
\text{out}(N_i, C_j, d, h, w) ={} & \max_{k=0, \ldots, kD-1} \max_{m=0, \ldots, kH-1} \max_{n=0, \ldots, kW-1} \\
输入(N_i, C_j, stride[0] × d + k,
stride[1] 乘以 h 加 m, stride[2] 乘以 w 加 n)
\end{aligned}
如果 :attr:`padding` 非零，则输入将在两侧隐式填充负无穷大
对于 :attr:`padding` 的点数。:attr:`dilation` 控制内核点之间的间距。
描述起来比较困难，但这个 `链接`_ 有一个关于 :attr:`dilation` 做什么的良好可视化。
注意：
当 ceil_mode=True 时，滑动窗口可以超出边界，前提是它们从左填充开始
或者输入。如果滑动窗口将从右填充区域开始，则忽略。
参数:attr:`kernel_size`、:attr:`stride`、:attr:`padding`、:attr:`dilation`可以是：
- 一个单独的 ``int`` -- 在这种情况下，相同的值用于深度、高度和宽度维度
- 一个包含三个整数的 ``tuple`` -- 在这种情况下，第一个 `int` 用于深度维度，
第二个 `int` 用于高度维度，第三个 `int` 用于宽度维度
Args:
kernel_size：取最大值窗口的大小
stride：窗口的步长。默认值是：attr:`kernel_size`
填充：在所有三侧添加隐式负无穷填充
扩展：控制窗口中元素步长的参数
return_indices：如果为 True，将返回最大索引和输出
对后续的 torch.nn.MaxUnpool3d 很有用
ceil_mode: 当为 True 时，将使用`ceil`而不是`floor`来计算输出形状
形状：
- 输入: :math:`(N, C, D_{in}, H_{in}, W_{in})` 或 :math:`(C, D_{in}, H_{in}, W_{in})`。
- 输出: :math:`(N, C, D_{out}, H_{out}, W_{out})` 或 :math:`(C, D_{out}, H_{out}, W_{out})`，其中
.. math::
D_{out} = \left\lfloor\frac{D_{in} + 2 \times \text{padding}[0] - \text{dilation}[0] \times
(\text{kernel\_size}[0] - 1) - 1}{\text{stride}[0]} + 1\right\rfloor
D_{out} = \left\lfloor\frac{D_{in} + 2 \times \text{padding}[0] - \text{dilation}[0] \times
(\text{kernel\_size}[0] - 1) - 1}{\text{stride}[0]} + 1\right\rfloor
.. math::
输出文本:
H_{out} = \left\lfloor\frac{H_{in} + 2 \times \text{填充}[1] - \text{膨胀}[1] \times \right\rfloor
[1] - 1) - 1}{步长[1]} + 1]
.. math::
输出文本:
W_{out} = \left\lfloor\frac{W_{in} + 2 \times \text{填充}[2] - \text{膨胀}[2] \times \right\rfloor
[（kernel_size[2] - 1) - 1] / [stride[2]] + 1
示例：
>>> # 正方形窗口池化大小=3，步长=2
>>> m = nn.MaxPool3d(3, stride=2)
>>> # 非正方形窗口池化
>>> m = nn.MaxPool3d((3, 2, 2), stride=(2, 1, 2))
>>> input = torch.randn(20, 16, 50, 44, 31)
>>> output = m(input)
.. _链接:
https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md
"源代码" # noqa: E501
核心大小:
_尺寸_3_t
步长:
_尺寸_3_t
填充:
_尺寸_3_t
扩展率:
_尺寸_3_t
def 前向(self,
输入:
张量):
返回 F.
最大池化 3D(
输入,
self.核心大小,
self.步长,
self.填充,
self.扩展率,
向上取整模式=self.
向上取整模式,
返回索引=self.
返回索引,
)
类 _MaxUnpoolNd(
模块):
def 额外表示(self) ->
字符串:
返回 f
"内核大小="{self.
核心大小}
, 步长={self.
步长}
, 填充={self.
填充}"
[文档]
类 MaxUnpool1d(_MaxUnpoolNd):
r计算一个 :class:`MaxPool1d` 的部分逆操作。
class:`MaxPool1d` 不是完全可逆的，因为非最大值已经丢失。
class:`MaxUnpool1d` 以 :class:`MaxPool1d` 的输出作为输入。
包括最大值的索引并计算部分逆
其中所有非最大值均设置为 0。
注意：
当输入索引有重复值时，此操作可能表现出非确定性。
更多信息请参阅 https://github.com/pytorch/pytorch/issues/80827 和 :doc:`/notes/randomness`。
.. 注意:: :class:`MaxPool1d` 可以将多个输入大小映射到相同的输出大小。因此，反演过程可能会变得模糊不清。
为了适应这种情况，您可以在前向调用中提供一个额外的参数 :attr:`output_size` 来指定所需的输出大小。
这样做可以确保输出大小符合预期。
在前向调用中提供这个参数可以避免反演过程中的歧义。
请查看下面的输入和示例。
Args:
kernel_size（整数或元组）：最大池化窗口的大小。
stride（整数或元组）：最大池化窗口的步长。
默认设置为 :attr:`kernel_size`。
填充（整数或元组）：添加到输入的填充
输入：
- `input`：要反转的输入张量
- `indices`：由`:class:`~torch.nn.MaxPool1d``给出的索引
- `output_size`（可选）：目标输出大小
形状：
- 输入：:math:`(N, C, H_{in})` 或 :math:`(C, H_{in})`
- 输出：:math:`(N, C, H_{out})` 或 :math:`(C, H_{out})`，其中
.. math::
H_{out} = (H_{in} - 1) × :text{stride}[0] - 2 × :text{padding}[0] + :text{kernel\_size}[0]
或者如调用操作符中的 :attr:`output_size` 所示
示例::
>>> # xdoctest: +IGNORE_WANT("是否其他测试会修改全局状态？")
>>> 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]]])
>>> 输出，索引 = pool(input)
>>> 反池化(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)
>>> unpool(output, indices, output_size=input.size())
tensor([[[ 0., 2., 0., 4., 0., 6., 0.,8., 0.]]])
>>> unpool(output, indices)
tensor([[[ 0., 2., 0., 4., 0., 6., 0.,8.]]])
"源代码"
核心大小:
_大小_1_t
步长:
_大小_1_t
填充:
_大小_1_t
def 初始化(
self,
核心大小: _size_1_t,
步长:
可选[_size_1_t] =
无,
填充:
_大小_1_t = 0,
) -> 无:
超级().
初始化()
self.核心大小 = _single(
核心大小)
self.步长 = _single(
步长
如果 (
步长
是 not
无)
否则
核心大小)
self.填充 = _single(
填充)
def 前向(
self, 输入:
张量,
索引:
张量, output_size:
可选[
列表[int]] =
无
) -> 张量:
返回 F.max_unpool1d(
输入,
索引, self.
核心大小, self.
步长, self.
填充,
输出大小
)
[文档]
类 MaxUnpool2d(_MaxUnpoolNd):
r计算一个 :class:`MaxPool2d` 的部分逆操作。
class:`MaxPool2d` 不是完全可逆的，因为非最大值已经丢失。
`MaxUnpool2d`类接受`MaxPool2d`类的输出作为输入，包括最大值的索引，并计算部分逆运算。
在其中，所有非最大值都被设置为 0。
当输入索引有重复值时，此操作可能表现出非确定性。
注意：
当输入索引有重复值时，此操作可能表现出非确定性。
请参阅 https://github.com/pytorch/pytorch/issues/80827 和 :doc:`/notes/randomness` 获取更多信息。
.. 注意:: :class:`MaxPool2d` 可以将多个输入大小映射到相同的输出大小。
因此，反演过程可能会变得模糊。为了适应这种情况，您可以提供所需的输出大小。
以便适应这种情况，您可以提供所需的输出大小。
在前向调用中添加一个额外的参数：attr:`output_size`。
请参阅下面的输入和示例。
Args:
kernel_size（整数或元组）：最大池化窗口的大小。
stride（整数或元组）：最大池化窗口的步长。
默认设置为 :attr:`kernel_size`。
填充（整数或元组）：添加到输入的填充。
输入：
- `input`：要反转的输入 Tensor。
- `indices`：由 :class:`~torch.nn.MaxPool2d` 给出的索引。
输出大小（可选）：目标输出大小
形状：
- 输入：:math:`(N, C, H_{in}, W_{in})` 或 :math:`(C, H_{in}, W_{in})`。
- 输出: :math:`(N, C, H_{out}, W_{out})` 或 :math:`(C, H_{out}, W_{out})`，其中
.. math::
H_{out} = (H_{in} - 1) \times \text{stride[0]} - 2 \times \text{padding[0]} + \text{kernel\_size[0]}
.. math::
W_{out} = (W_{in} - 1) \times \text{stride[1]} - 2 \times \text{padding[1]} + \text{kernel\_size[1]}
或如调用操作符中的 :attr:`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.]]]])
>>> 输出，索引 = pool(input)
>>> 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.]]]])
>>> 输出，索引 = pool(input)
>>> # 此调用未指定 output_size 将无法工作
>>> 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.]
"源代码"
核心大小:
_尺寸_2_t
步长:
_尺寸_2_t
填充:
_尺寸_2_t
def 初始化(
self,
核心大小: _size_2_t,
步长:
可选[_size_2_t] =
无,
填充:
_尺寸_2_t = 0,
) -> 无:
超级().
初始化()
self.核心大小 = _pair(
核心大小)
self.步长 = _pair(
步长
如果 (
步长
是 not
无)
否则
核心大小)
self.填充 = _pair(
填充)
def 前向(
self, 输入:
张量,
索引:
张量, output_size:
可选[
列表[int]] =
无
) -> 张量:
返回 F.max_unpool2d(
输入,
索引, self.
核心大小, self.
步长, self.
填充,
输出大小
)
[文档]
类 MaxUnpool3d(_MaxUnpoolNd):
r计算一个 :class:`MaxPool3d` 的部分逆操作。
class:`MaxPool3d` 不是完全可逆的，因为非最大值已经丢失。
`MaxUnpool3d`类接受`MaxPool3d`类的输出作为输入，包括最大值的索引并计算部分逆运算
在其中所有非最大值都被设置为 0。
当输入索引有重复值时，此操作可能表现出非确定性。
注意：
当输入索引有重复值时，此操作可能表现出非确定性。
请参阅 https://github.com/pytorch/pytorch/issues/80827 和 :doc:`/notes/randomness` 获取更多信息。
.. 注意:: :class:`MaxPool3d` 可以将多个输入大小映射到相同的输出大小。
因此，反演过程可能会变得模糊。为了适应这种情况，您可以提供所需的输出大小。
以便适应这种情况，您可以提供所需的输出大小。
在前向调用中添加一个额外的参数：attr:`output_size`。
请参阅下面的输入部分。
Args:
kernel_size（整数或元组）：最大池化窗口的大小。
stride（整数或元组）：最大池化窗口的步长。
默认设置为 :attr:`kernel_size`。
填充（整数或元组）：添加到输入的填充。
输入：
- `input`：要反转的输入 Tensor。
- `indices`：由 :class:`~torch.nn.MaxPool3d` 提供的索引。
- `输出大小`（可选）：目标输出大小
形状：
- 输入: :math:`(N, C, D_{in}, H_{in}, W_{in})` 或 :math:`(C, D_{in}, H_{in}, W_{in})`。
- 输出：:math:`(N, C, D_{out}, H_{out}, W_{out})` 或 :math:`(C, D_{out}, H_{out}, W_{out})`，其中
.. math::
D_{out} = (D_{in} - 1) × stride[0] - 2 × padding[0] + kernel_size[0]
.. math::
H_{out} = (H_{in} - 1) × stride[1] - 2 × padding[1] + kernel_size[1]
.. math::
W_{out} = (W_{in} - 1) \times \text{stride[2]} - 2 \times \text{padding[2]} + \text{kernel\_size[2]}
或如调用操作符中的 :attr:`output_size` 所示
示例::
>>> # 正方形窗口池化大小=3，步长=2
>>> pool = nn.MaxPool3d(3, stride=2, return_indices=True)
>>> unpool = nn.MaxUnpool3d(3, stride=2)
>>> output, indices = pool(torch.randn(20, 16, 51, 33, 15))
>>> unpooled_output = unpool(output, indices)
>>> unpooled_output.size()
torch.Size([20, 16, 51, 33, 15])
"源代码"
核心大小:
_尺寸_3_t
步长:
_尺寸_3_t
填充:
_尺寸_3_t
def 初始化(
self,
核心大小: _size_3_t,
步长:
可选[_size_3_t] =
无,
填充:
_尺寸_3_t = 0,
) -> 无:
超级().
初始化()
self.核心大小 =
_三倍_(
核心大小)
self.步长 =
_三倍_(
步长
如果 (
步长
是 not
无)
否则
核心大小)
self.填充 =
_三倍_(
填充)
def 前向(
self, 输入:
张量,
索引:
张量, output_size:
可选[
列表[int]] =
无
) -> 张量:
返回 F.max_unpool3d(
输入,
索引, self.
核心大小, self.
步长, self.
填充,
输出大小
)
类 _AvgPoolNd(
模块):
常量 = [
"内核大小",
步长,
"填充",
"ceil_mode",
"count_include_pad",
]
def 额外表示(self) ->
字符串:
返回 f
"内核大小="{self.
核心大小}, stride={self.
步长}
,填充={self.
填充}"
[文档]
类 AvgPool1d(_AvgPoolNd):
r应用 1D 平均池化到由多个输入平面组成的输入信号。
在最简单的情况下，输入大小为 :math:`(N, C, L)` 的层输出值，
输出 :math:`(N, C, L_{out})` 和 :attr:`kernel_size` :math:`k`
可以精确描述为：
.. math::
\text{out}(N_i, C_j, l) = \frac{1}{k} \sum_{m=0}^{k-1}
\text{input}(N_i, C_j, \text{stride} \times l + m)
如果 :attr:`padding` 不为零，则输入将在两侧隐式地用零填充
对于 :attr:`padding` 个点数。
注意：
当 ceil_mode=True 时，滑动窗口允许在左填充或输入内部超出边界
滑动窗口如果从右侧填充区域开始将被忽略。
参数：:attr:`kernel_size`、:attr:`stride`、:attr:`padding` 可以是整数或一个包含一个元素的元组。
一个 ``int`` 或一个包含一个元素的元组。
Args:
kernel_size：窗口的大小。
stride：窗口的步长。默认值是 :attr:`kernel_size`。
填充：在两侧添加隐式零填充
ceil_mode：当为 True 时，将使用`ceil`而不是`floor`来计算输出形状
count_include_pad：当为 True 时，将包括零填充在平均计算中
形状：
输入：:math:`(N, C, L_{in})` 或 :math:`(C, L_{in})`。
输出：:math:`(N, C, L_{out})` 或 :math:`(C, L_{out})`，其中
.. math::
L_{out} = :leftlfloor :frac{L_{in} +
2 × :text{padding} - :text{kernel_size}}{:text{stride}} + 1 :rightlfloor
根据上面的说明，如果 ``ceil_mode`` 为 True 且 :math:`(L_{out} - 1) × :text{stride} ≥ L_{in}
使用`+ \text{padding}`，我们跳过最后一个窗口，因为它将开始于右填充区域，这将导致
math:`L_{out}`减少一个。
示例：
>>> # 使用大小为 3，步长为 2 的池化
>>> m = nn.AvgPool1d(3, stride=2)
>>> m(torch.tensor([[[1., 2, 3, 4, 5, 6, 7]]]))
tensor([[[2., 4., 6.]]])
"源代码"
核心大小:
_大小_1_t
步长:
_大小_1_t
填充:
_大小_1_t
向上取整模式:
布尔类型
计数包含填充:
布尔类型
def 初始化(
self,
核心大小: _size_1_t,
步长:
_大小_1_t =
无,
填充:
_大小_1_t = 0,
向上取整模式:
布尔类型 =
错误,
计数包含填充:
布尔类型 = True,
) -> 无:
超级().
初始化()
self.核心大小 = _single(
核心大小)
self.步长 = _single(
步长
如果
步长
是 not
无
否则
核心大小)
self.填充 = _single(
填充)
self.向上取整模式 =
向上取整模式
self.包含填充的计数 =
包含填充的计数
def 前向(self,
输入:
张量) ->
张量:
返回 F.avg_pool1d(
输入,
self.核心大小,
self.步长,
self.填充,
self.向上取整模式,
self.计数包含填充,
)
[文档]
类
2D 平均池化(
_N 维平均池化):
r应用在由多个输入平面组成的输入信号上的 2D 平均池化。
在最简单的情况下，输入尺寸为 :math:`(N, C, H, W)` 的层的输出值，
输出尺寸为 :math:`(N, C, H_{out}, W_{out})` 和 :attr:`kernel_size` :math:`(kH, kW)`
可以精确描述为：
.. math::
输出 (N_i, C_j, h, w) = \frac{1}{kH * kW} \sum_{m=0}^{kH-1} \sum_{n=0}^{kW-1}
输入 (N_i, C_j, stride[0] \times h + m, stride[1] \times w + n)
如果 :attr:`padding` 不为零，则输入将在两侧隐式地用零填充
对于 :attr:`padding` 个点数。
注意：
当 ceil_mode=True 时，滑动窗口可以超出边界，前提是它们从左填充开始
或者输入。如果滑动窗口将从右填充区域开始，则忽略。
参数:attr:`kernel_size`、:attr:`stride`、:attr:`padding`可以是：
- 一个单个的 `int` -- 在这种情况下，相同的价值用于高度和宽度维度
- 两个 `int` 的 `tuple` -- 在这种情况下，第一个 `int` 用于高度维度，
并且第二个 `int` 用于宽度维度
Args:
kernel_size: 窗口大小
窗口步长。默认值为：attr:`kernel_size`
填充：在两侧添加隐式零填充
ceil_mode：当为 True 时，将使用`ceil`代替`floor`来计算输出形状
count_include_pad：当为 True 时，将包括零填充在平均计算中
divisor_override：如果指定，则用作除数，否则使用池化区域的大小。
形状：
- 输入：:math:`(N, C, H_{in}, W_{in})` 或 :math:`(C, H_{in}, W_{in})`。
- 输出: :math:`(N, C, H_{out}, W_{out})` 或 :math:`(C, H_{out}, W_{out})`，其中
.. math::
输出文本:
H_{out} = \left\lfloor\frac{H_{in} + 2 \times \text{填充}[0] -
\[ \text{kernel\_size}[0] \div \text{stride}[0] + 1 \]
.. math::
输出文本:
W_{out} = \left\lfloor\frac{W_{in} + 2 \times \text{填充}[1] -
\text{kernel\_size}[1]}{\text{stride}[1]} + 1\right\rfloor
根据上面的说明，如果 ``ceil_mode`` 为 True 并且 :math:`(H_{out} - 1)\times \text{stride}[0]\geq H_{in}
+ \text{padding}[0]`，我们将跳过最后一个窗口，因为它将开始于底部填充区域，
从而导致 :math:`H_{out}` 减少一个。
同样适用于：math:`W_{out}`。
示例：
>>> # 正方形窗口池化大小=3，步长=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)
"源代码"
常量 = [
"内核大小",
步长,
"填充",
"ceil_mode",
"count_include_pad",
"divisor_override",
]
核心大小:
_尺寸_2_t
步长:
_尺寸_2_t
填充:
_尺寸_2_t
向上取整模式:
布尔类型
计数包含填充:
布尔类型
def 初始化(
self,
核心大小: _size_2_t,
步长:
可选[_size_2_t] =
无,
填充:
_尺寸_2_t = 0,
向上取整模式:
布尔类型 =
错误,
计数包含填充:
布尔类型 = True,
除数覆盖:
可选[int] =
无,
) -> 无:
超级().
初始化()
self.核心大小 =
核心大小
self.步长 =
步长
如果 (
步长
是 not
无)
否则
核心大小
self.填充 =
填充
self.向上取整模式 =
向上取整模式
self.包含填充计数 =
包含填充计数
self.覆盖除数 =
覆盖除数
def 前向(self,
输入:
张量) ->
张量:
返回 F.avg_pool2d(
输入,
self.核心大小,
self.步长,
self.填充,
self.向上取整模式,
self.计数包含填充,
self.除数覆盖,
)
[文档]
类 AvgPool3d(_AvgPoolNd):
r"""应用 3D 平均池化到由多个输入平面组成的输入信号上。
在最简单的情况下，该层的输出值与输入大小 :math:`(N, C, D, H, W)` 相关，
输出 :math:`(N, C, D_{out}, H_{out}, W_{out})` 和 :attr:`kernel_size` :math:`(kD, kH, kW)`
可以精确描述为：
.. math::
\begin{aligned}
\text{out}(N_i, C_j, d, h, w) ={} & \sum_{k=0}^{kD-1} \sum_{m=0}^{kH-1} \sum_{n=0}^{kW-1} \\
& \frac{\text{input}(N_i, C_j, \text{stride}[0] \times d + k,
\text{stride}[1] \times h + m, \text{stride}[2] \times w + n)}
{kD × kH × kW}
\end{aligned}
如果 :attr:`padding` 不为零，则输入将在所有三侧隐式零填充
对于 :attr:`padding` 个点。
注意：
当 ceil_mode=True 时，滑动窗口可以在左填充内开始时超出边界
或输入。起始于右填充区域的滑动窗口将被忽略。
参数：attr:`kernel_size`、:attr:`stride`可以是：
- 一个单独的 ``int`` -- 在这种情况下，相同的值用于深度、高度和宽度维度
- 一个包含三个整数的 ``tuple`` -- 在这种情况下，第一个 `int` 用于深度维度，
第二个 `int` 用于高度维度，第三个 `int` 用于宽度维度
Args:
kernel_size：窗口的大小
stride：窗口的步长。默认值是：attr:`kernel_size`
填充：在所有三边添加隐式零填充
ceil_mode：当为 True 时，将使用`ceil`而不是`floor`来计算输出形状
count_include_pad：当为 True 时，将包括零填充在平均计算中
divisor_override：如果指定，则用作除数，否则使用`:attr:`kernel_size`
形状：
- 输入: :math:`(N, C, D_{in}, H_{in}, W_{in})` 或 :math:`(C, D_{in}, H_{in}, W_{in})`。
输出：:math:`(N, C, D_{out}, H_{out}, W_{out})` 或
math:`(C, D_{out}, H_{out}, W_{out})`，其中
.. math::
D_{out} = \left\lfloor\frac{D_{in} + 2 \times \text{padding}[0] -
\text{kernel\_size}[0]}{\text{stride}[0]} + 1\right\rfloor
.. math::
输出文本:
H_{out} = \left\lfloor\frac{H_{in} + 2 \times \text{填充}[1] -
\[ \text{kernel\_size}[1]}{\text{stride}[1]} + 1 \]
.. math::
输出文本:
W_{out} = \left\lfloor\frac{W_{in} + 2 \times \text{填充}[2] - \right\rfloor
\[ \text{kernel\_size}[2]{\text{stride}[2]} + 1 \]
根据上述说明，如果 `ceil_mode` 为 True 且 `(D_{out} - 1)× stride[0]≥ D_{in}`
+ \text{padding}[0]，我们跳过最后一个窗口，因为它将从填充区域开始
导致输出维度：math:`D_{out}`减少一个。
同样适用于 :math:`W_{out}` 和 :math:`H_{out}`。
示例：
>>> # 正方形窗口池化大小=3，步长=2
>>> m = nn.AvgPool3d(3, stride=2)
>>> # 非正方形窗口池化
>>> m = nn.AvgPool3d((3, 2, 2), stride=(2, 1, 2))
>>> input = torch.randn(20, 16, 50, 44, 31)
>>> output = m(input)
"源代码"
常量 = [
"内核大小",
步长,
"填充",
"ceil_mode",
"count_include_pad",
"divisor_override",
]
核心大小:
_尺寸_3_t
步长:
_尺寸_3_t
填充:
_尺寸_3_t
向上取整模式:
布尔类型
计数包含填充:
布尔类型
def 初始化(
self,
核心大小: _size_3_t,
步长:
可选[_size_3_t] =
无,
填充:
_尺寸_3_t = 0,
向上取整模式:
布尔类型 =
错误,
计数包含填充:
布尔类型 = True,
除数覆盖:
可选[int] =
无,
) -> 无:
超级().
初始化()
self.核心大小 =
核心大小
self.步长 =
步长
如果 (
步长
是 not
无)
否则
核心大小
self.填充 =
填充
self.向上取整模式 =
向上取整模式
self.包含填充计数 =
包含填充计数
self.覆盖除数 =
覆盖除数
def 前向(self,
输入:
张量) ->
张量:
返回 F.avg_pool3d(
输入,
self.核心大小,
self.步长,
self.填充,
self.向上取整模式,
self.计数包含填充,
self.除数覆盖,
)
def __setstate__(self, d):
超级().__setstate__(d)
self.字典.setdefault(
"填充", 0)
self.字典.setdefault("ceil_mode",
错误)
self.字典.setdefault("count_include_pad", True)
[文档]
类 FractionalMaxPool2d(
模块):
r"应用在由多个输入平面组成的输入信号上的 2D 分数最大池化。"
分数最大池化在 Ben Graham 的论文《Fractional MaxPooling》中详细描述
最大池化操作在`:math:`kH \times kW`区域通过随机方式应用
步长由目标输出大小确定。
输出特征的数量等于输入平面的数量。
.. 注意:: 必须定义 ``output_size`` 或 ``output_ratio`` 中的一个。
Args:
kernel_size：取最大值操作的窗口大小。
可以是一个数字 k（表示 k x k 的正方形核）或者一个元组 `(kh, kw)`。
output_size: 图像的目标输出大小，形式为 `oH x oW`。
可以是一个元组 `(oH, oW)` 或者一个单独的数字 oH，用于正方形图像 `oH x oH`。
注意必须满足 :math:`kH + oH - 1 <= H_{in}` 和 :math:`kW + oW - 1 <= W_{in}`
输出比例：如果想要将输出大小设置为输入大小的比例，则可以提供此选项。
这必须是一个在范围 (0, 1) 内的数字或元组。
注意必须满足 :math:`kH + (output_ratio_H * H_{in}) - 1 <= H_{in}`
以及 :math:`kW + (output_ratio_W * W_{in}) - 1 <= W_{in}`
return_indices：如果为 True，则将返回索引和输出。
适用于传递给 :meth:`nn.MaxUnpool2d`。默认：``False``
形状：
- 输入：:math:`(N, C, H_{in}, W_{in})` 或 :math:`(C, H_{in}, W_{in})`。
- 输出: :math:`(N, C, H_{out}, W_{out})` 或 :math:`(C, H_{out}, W_{out})`，其中
math:`(H_{out}, W_{out})=\text{output\_size}` 或
math:`(H_{out}, W_{out})=\text{output\_ratio} \times (H_{in}, W_{in})`。
示例：
>>> # 使用大小为 3 的正方形窗口池化，目标输出大小为 13x12
>>> m = nn.FractionalMaxPool2d(3, output_size=(13, 12))
>>> # 正方形窗口池和目标输出大小为输入图像大小的一半
>>> m = nn.FractionalMaxPool2d(3, 输出比例=(0.5, 0.5))
>>> input = torch.randn(20, 16, 50, 32)
>>> output = m(input)
.. _Fractional MaxPooling:
https://arxiv.org/abs/1412.6071
"源代码"
常量 = [
"内核大小",
"返回索引",
输出大小,
输出比例]
核心大小:
_尺寸_2_t
返回索引:
布尔类型
output_size: _尺寸_2_t
输出比例:
比率_2_t
def 初始化(
self,
核心大小: _size_2_t,
output_size: 可选[_size_2_t] =
无,
输出比例:
可选[
比率_2_t] =
无,
返回索引:
布尔类型 =
错误,
_随机样本=
无,
) -> 无:
超级().
初始化()
self.核心大小 = _pair(
核心大小)
self.返回索引 =
返回索引
self.注册缓冲区(
_随机样本,
_随机样本)
self.输出大小 = _pair(output_size)
如果
输出大小
是 not
无
否则
无
self.输出比率 = _pair(
输出比例)
如果
输出比率
是 not
无
否则
无
如果
输出大小
是
无
和
输出比率
是
无:
提升 ValueError(
FractionalMaxPool2d 需要指定 "
输出大小，或池化比率
)
如果
输出大小
是 not
无
和
输出比率
是 not
无:
提升 ValueError(
只能指定 output_size 和 output_ratio 中的一个
)
如果 self.
输出比率
是 not
无:
如果 not (0 < self.
输出比例[0] < 1
和 0 < self.
输出比例[1] < 1):
提升 ValueError(
f输出比例必须在 0 和 1 之间（得到{
输出比例})"
)
def 前向(self,
输入:
张量):
返回 F.
分数最大池化 2d(
输入,
self.核心大小,
self.output_size,
self.输出比例,
self.返回索引,
_随机样本=self.
_随机样本,
)
[文档]
类 FractionalMaxPool3d(
模块):
r应用在由多个输入平面组成的输入信号上的 3D 分数最大池化。
分数最大池化在 Ben Graham 的论文《Fractional MaxPooling》中详细描述
最大池化操作通过随机方式应用于 :math:`kT \times kH \times kW` 区域
步长由目标输出大小确定。
输出特征的数量等于输入平面的数量。
注意：必须定义 `output_size` 或 `output_ratio` 中的一个。
Args:
kernel_size：取最大值操作的窗口大小。
可以是一个数字 k（表示 k x k x k 的正方形核）或一个元组 `(kt x kh x kw)`。
输出大小：图像的目标输出大小，形式为 `oT x oH x oW`。
可以是元组 `(oT, oH, oW)` 或单个数字 oH，用于正方形图像 `oH x oH x oH`。
输出比例：如果想要将输出大小设置为输入大小的比例，则可以提供此选项。
这必须是一个在范围（0，1）内的数字或元组。
return_indices：如果为 True，则将返回索引和输出。
可用于传递给 :meth:`nn.MaxUnpool3d`。默认：``False``。
形状：
- 输入：:math:`(N, C, T_{in}, H_{in}, W_{in})` 或 :math:`(C, T_{in}, H_{in}, W_{in})`。
输出：:math:`(N, C, T_{out}, H_{out}, W_{out})` 或 :math:`(C, T_{out}, H_{out}, W_{out})`，其中
math:`(T_{out}, H_{out}, W_{out})=\text{output\_size}` 或
math:`(T_{out}, H_{out}, W_{out})=\text{output\_ratio} \times (T_{in}, H_{in}, W_{in})`
示例：
>>> # 立方体窗口大小为 3 的池化，目标输出大小为 13x12x11
>>> m = nn.FractionalMaxPool3d(3, output_size=(13, 12, 11))
>>> # 立方体窗口池化，目标输出大小为输入大小的一半
>>> m = nn.FractionalMaxPool3d(3, 输出比例=(0.5, 0.5, 0.5))
>>> input = torch.randn(20, 16, 50, 32, 16)
>>> output = m(input)
.. _Fractional MaxPooling:
https://arxiv.org/abs/1412.6071
"源代码"
常量 = [
"内核大小",
"返回索引",
输出大小,
输出比例]
核心大小:
_尺寸_3_t
返回索引:
布尔类型
output_size: _尺寸_3_t
输出比例: _ratio_3_t
def 初始化(
self,
核心大小: _size_3_t,
output_size: 可选[_size_3_t] =
无,
输出比例:
可选[_ratio_3_t] =
无,
返回索引:
布尔类型 =
错误,
_随机样本=
无,
) -> 无:
超级().
初始化()
self.核心大小 =
_三倍_(
核心大小)
self.返回索引 =
返回索引
self.注册缓冲区(
_random_samples,
_随机样本)
self.输出大小 =
_三倍_(output_size)
如果
输出大小
是 not
无
否则
无
self.输出比率 =
_三倍_(
输出比例)
如果
输出比率
是 not
无
否则
无
如果
输出大小
是
无
和
输出比率
是
无:
提升 ValueError(
分数最大池化 3d 需要指定“
输出大小，或池化比率
)
如果
输出大小
是 not
无
和
输出比率
是 not
无:
提升 ValueError(
只能指定 output_size 和 output_ratio 中的一个
)
如果 self.
输出比率
是 not
无:
如果 not (
0 < self.输出比例[0] < 1
和 0 < self.
输出比例[1] < 1
和 0 < self.
输出比例[2] < 1
):
提升 ValueError(
f输出比例必须在 0 和 1 之间（得到{
输出比例})"
)
def 前向(self,
输入:
张量):
返回 F.
分数最大池化 3d(
输入,
self.核心大小,
self.output_size,
self.输出比例,
self.返回索引,
_随机样本=self.
_随机样本,
)
类
LPPoolNd(
模块):
常量 = ["norm_type",
"内核大小",
步长, "ceil_mode"]
归一化类型:
浮点数
向上取整模式:
布尔类型
def 初始化(
self,
归一化类型: float,
核心大小: _size_any_t,
步长:
可选[_size_any_t] =
无,
向上取整模式:
布尔类型 =
错误,
) -> 无:
超级().
初始化()
self.规范类型 =
规范类型
self.核心大小 =
核心大小
self.步长 =
步长
self.向上取整模式 =
向上取整模式
def 额外表示(self) ->
字符串:
返回 (
"norm_type="{norm_type}
, 核大小=
{核大小}, stride=
步长
，"
"ceil_mode="{ceil_mode}".
格式(**self.
字典)
)
[文档]类 LPPool1d(_LPPoolNd):
r"""对由多个输入平面组成的输入信号应用 1D 功率平均池化。
每个窗口上计算的功能是：
.. math::
f(X) = ∑_{x ∈ X} x^{p} 的 p 次方根
- 当 p = ∞ 时，得到最大池化
- 当 p = 1 时，得到求和池化（与平均池化成比例）
.. 注意:: 如果幂和为 `p` 的零，则此函数的梯度未定义。在此实现中，将梯度设置为零。
此实现将在此情况下将梯度设置为零。
Args:
核大小：一个整数，表示窗口大小
stride：单个整数，窗口的步长。默认值是：attr:`kernel_size`
ceil_mode：当为 True 时，将使用`ceil`而不是`floor`来计算输出形状
形状：
- 输入：:math:`(N, C, L_{in})` 或 :math:`(C, L_{in})`。
输出：:math:`(N, C, L_{out})` 或 :math:`(C, L_{out})`，其中
.. math::
L_{out} = \left\lfloor\frac{L_{in} - \text{kernel\_size}}{\text{stride}} + 1\right\rfloor
示例::
>>> # 2 的幂次方池，长度为 3 的窗口，步长为 2。
>>> m = nn.LPPool1d(2, 3, stride=2)
>>> input = torch.randn(20, 16, 50)
>>> output = m(input)
"""
核心大小: _size_1_t
步长: _size_1_t
def forward(self, 输入: Tensor) -> Tensor:
return F.lp_pool1d(
input, float(self.norm_type), self.kernel_size, self.stride, self.ceil_mode
)
[文档]
类 LPPool2d(_LPPoolNd):
r对由多个输入平面组成的输入信号应用 2D 功率平均池化。
在每个窗口上，计算函数为：
.. math::
f(X) = \sqrt[p]{\sum_{x \in X} x^{p}}
在 p = ∞ 时，得到最大池化
在 p = 1 时，得到求和池化（与平均池化成比例）
参数 :attr:`kernel_size` 和 :attr:`stride` 可以是：
- 一个单个的 `int` -- 在这种情况下，相同的价值用于高度和宽度维度
- 两个 `int` 的 `tuple` -- 在这种情况下，第一个 `int` 用于高度维度，
并且第二个 `int` 用于宽度维度
.. note:: 如果求和的 p 次幂为零，则该函数的梯度为
未定义。在这种情况下，此实现将梯度设置为零。
Args:
核大小：窗口的大小
窗口的步长。默认值为 :attr:`kernel_size`
当为 True 时，将使用 `ceil` 而不是 `floor` 来计算输出形状
形状：
- 输入：:math:`(N, C, H_{in}, W_{in})` 或 :math:`(C, H_{in}, W_{in})`。
- 输出: :math:`(N, C, H_{out}, W_{out})` 或 :math:`(C, H_{out}, W_{out})`，其中
.. math::
H_{out} = \left\lfloor\frac{H_{in} - \text{kernel\_size}[0]}{\text{stride}[0]} + 1\right\rfloor
.. math::
W_{out} = \left\lfloor\frac{W_{in} - \text{kernel\_size}[1]}{\text{stride}[1]} + 1\right\rfloor
示例：
>>> # 2 次方池，正方形窗口大小为 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)
>>> output = m(input)
"源代码"
核心大小:
_尺寸_2_t
步长:
_尺寸_2_t
def 前向(self,
输入:
张量) ->
张量:
返回 F.
二维低通池化(
输入, float(self.
归一化类型), self.
核心大小, self.
步长, self.
向上取整模式
)
[文档]
类 LPPool3d(_LPPoolNd):
r对由多个输入平面组成的输入信号应用 3D 功率平均池化。
在每个窗口上，计算的功能是：
.. math::
f(X) = X 中所有 x 的 p 次幂之和的 p 次方根
- 当 p = ∞时，得到最大池化
- 当 p = 1 时，得到求和池化（与平均池化成比例）
参数 :attr:`kernel_size` 和 :attr:`stride` 可以是：
- 一个单独的 ``int`` -- 在这种情况下，相同的价值用于高度、宽度和深度维度
- 一个包含三个整数的 ``tuple`` -- 在这种情况下，第一个 `int` 用于深度维度，
第二个 `int` 用于高度维度，第三个 `int` 用于宽度维度
.. 注意:: 如果 `p` 次幂的和为零，则该函数的梯度未定义。在这种情况下，此实现将梯度设置为零。
未定义。此实现将在此情况下将梯度设置为零。
Args:
kernel_size: 窗口大小
窗口步长。默认值为 :attr:`kernel_size`
ceil_mode: 当为 True 时，将使用 `ceil` 而不是 `floor` 来计算输出形状
形状：
- 输入: :math:`(N, C, D_{in}, H_{in}, W_{in})` 或 :math:`(C, D_{in}, H_{in}, W_{in})`。
- 输出: :math:`(N, C, D_{out}, H_{out}, W_{out})` 或
math:`(C, D_{out}, H_{out}, W_{out})`，其中
.. math::
D_out = ⌊(D_in - kernel_size[0]) / stride[0] + 1⌋
.. math::
H_out = ⌊(H_in - kernel_size[1]) / stride[1] + 1⌋
.. math::
W_out = ⌊(W_in - kernel_size[2]) / stride[2] + 1⌋
示例：
>>> # 2 次方池，正方形窗口大小为 3，步长为 2
>>> m = nn.LPPool3d(2, 3, stride=2)
>>> # 非正方形窗口的 1.2 次方池
>>> m = nn.LPPool3d(1.2, (3, 2, 2), stride=(2, 1, 2))
>>> input = torch.randn(20, 16, 50, 44, 31)
>>> output = m(input)
"源代码"
核心大小:
_尺寸_3_t
步长:
_尺寸_3_t
def 前向(self,
输入:
张量) ->
张量:
返回 F.lp_pool3d(
输入, float(self.
归一化类型), self.
核心大小, self.
步长, self.
向上取整模式
)
类 _AdaptiveMaxPoolNd(
模块):
常量 = [
输出大小,
"返回索引"]
返回索引:
布尔类型
def 初始化(
self, output_size: _size_any_opt_t, 返回索引:
布尔类型 =
假
) -> 无:
超级().
初始化()
self.输出大小 =
输出大小
self.返回索引 =
返回索引
def 额外表示(self) ->
字符串:
返回 f
输出大小={self.output_size}"
# FIXME (by @ssnl): 改进自适应池化文档：指定输入和输出形状，以及该操作如何计算输出。
# 输入和输出形状是什么，以及该操作如何计算输出。
[docs]class AdaptiveMaxPool1d(_AdaptiveMaxPoolNd):
r"""应用在由多个输入平面组成的输入信号上的 1D 自适应最大池化。
输出大小为 :math:`L_{out}`，对于任何输入大小。
输出特征的数量等于输入平面的数量。
Args:
output_size: 目标输出大小 :math:`L_{out}`。
return_indices: 如果为 ``True``，将返回索引和输出。
有用，可传递给 nn.MaxUnpool1d。默认：``False``
形状：
- 输入：:math:`(N, C, L_{in})` 或 :math:`(C, L_{in})`。
- 输出：:math:`(N, C, L_{out})` 或 :math:`(C, L_{out})`，其中
math:`L_{out}=\text{output\_size}`。
示例：
>>> 目标输出大小为 5
>>> m = nn.AdaptiveMaxPool1d(5)
>>> input = torch.randn(1, 64, 8)
>>> output = m(input)
"""
output_size: _size_1_t
def forward(self, input: Tensor):
return F.adaptive_max_pool1d(input, self.output_size, self.return_indices)
[文档]class AdaptiveMaxPool2d(_AdaptiveMaxPoolNd):
r"""在由多个输入平面组成的输入信号上应用 2D 自适应最大池化。
输出大小为 :math:`H_{out} \times W_{out}`，对于任何输入大小。
输出特征的数量等于输入平面的数量。
Args:
output_size: 图像的目标输出大小，形式为 :math:`H_{out} \times W_{out}`。
可以是一个元组 :math:`(H_{out}, W_{out})` 或者一个单独的 :math:`H_{out}` 用于
正方形图像：:math:`H_{out} \times H_{out}`。:math:`H_{out}` 和 :math:`W_{out}`
可以是 ``int`` 或 ``None``，表示大小将与输入相同
的输入。
return_indices: 如果为 ``True``，将返回索引和输出。
默认：``False``，用于传递给 nn.MaxUnpool2d。
形状：
- 输入：:math:`(N, C, H_{in}, W_{in})` 或 :math:`(C, H_{in}, W_{in})`。
- 输出：:math:`(N, C, H_{out}, W_{out})` 或 :math:`(C, H_{out}, W_{out})`，其中
`(H_{out}, W_{out})=\text{输出大小}`.
示例：
>>> # 目标输出大小为 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)
"""
output_size: _size_2_opt_t
def forward(self, input: Tensor):
return F.adaptive_max_pool2d(input, self.output_size, self.return_indices)
[docs]class AdaptiveMaxPool3d(_AdaptiveMaxPoolNd):
r"""应用在由多个输入平面组成的输入信号上的 3D 自适应最大池化。
输出大小为 :math:`D_{out} \times H_{out} \times W_{out}`，对于任何输入大小。
输出特征的数量等于输入平面的数量。
Args:
output_size: 图像的目标输出大小，形式为 :math:`D_{out} \times H_{out} \times W_{out}`。
可以是一个元组 :math:`(D_{out}, H_{out}, W_{out})` 或单个
math:`D_{out}` 用于立方体 :math:`D_{out} \times D_{out} \times D_{out}`。
输出维度 :math:`D_{out}`, :math:`H_{out}` 和 :math:`W_{out}` 可以是整数或 ``None``，表示大小将与输入相同。
``int``，或者 ``None``，表示大小将与输入相同。
return_indices: 如果为 ``True``，将返回索引和输出。
适用于传递给 nn.MaxUnpool3d。默认：``False``。
形状：
- 输入：:math:`(N, C, D_{in}, H_{in}, W_{in})` 或 :math:`(C, D_{in}, H_{in}, W_{in})`。
- 输出：:math:`(N, C, D_{out}, H_{out}, W_{out})` 或 :math:`(C, D_{out}, H_{out}, W_{out})`，
其中 :math:`(D_{out}, H_{out}, W_{out})=\text{output\_size}`。
示例：
>>> 目标输出大小为 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)
"""
output_size: _size_3_opt_t
def forward(self, input: Tensor):
返回 F.adaptive_max_pool3d(input, self.output_size, self.return_indices)
类
_自适应平均池化 N 维(
模块):
常量 = [
输出大小]
def 初始化(self, output_size: _size_any_opt_t) ->
无:
超级().
初始化()
self.输出大小 =
输出大小
def 额外表示(self) ->
字符串:
返回 f
输出大小={self.output_size}"
[docs]class AdaptiveAvgPool1d(_AdaptiveAvgPoolNd):
r"""应用在由多个输入平面组成的输入信号上的 1D 自适应平均池化。
输出大小为 :math:`L_{out}`，对于任何输入大小。
输出特征的数量等于输入平面的数量。
Args:
output_size: 目标输出大小 :math:`L_{out}`。
Shape:
- 输入: :math:`(N, C, L_{in})` 或 :math:`(C, L_{in})`。
输出：:math:`(N, C, L_{out})` 或 :math:`(C, L_{out})`，其中
math:`L_{out}=\text{output\_size}`。
示例：
>>> # 目标输出大小为 5
>>> m = nn.AdaptiveAvgPool1d(5)
>>> input = torch.randn(1, 64, 8)
>>> output = m(input)
"""
output_size: _size_1_t
def forward(self, input: Tensor) -> Tensor:
return F.adaptive_avg_pool1d(input, self.output_size)
[文档]class AdaptiveAvgPool2d(_AdaptiveAvgPoolNd):
对由多个输入平面组成的输入信号应用 2D 自适应平均池化。
输出大小为 H x W，对于任何输入大小。
输出特征的数量等于输入平面的数量。
参数：
输出大小：图像的目标输出大小，形式为 H x W。
可以是一个元组 (H, W) 或单个 H，表示正方形图像 H x H。
H 和 W 可以是整数（int）或 None，表示大小将与输入相同。
H 和 W 可以是整数（int）或 None，表示大小将与输入相同。
形状：
- 输入：:math:`(N, C, H_{in}, W_{in})` 或 :math:`(C, H_{in}, W_{in})`。
- 输出：:math:`(N, C, S_{0}, S_{1})` 或 :math:`(C, S_{0}, S_{1})`，其中
math:`S=\text{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)
"""
output_size: _size_2_opt_t
def forward(self, input: Tensor) -> Tensor:
返回 F.adaptive_avg_pool2d(input, self.output_size)
[docs]类 AdaptiveAvgPool3d(_AdaptiveAvgPoolNd):
r"""在由多个输入平面组成的输入信号上应用 3D 自适应平均池化。
输出大小为 D x H x W，对于任何输入大小。
输出特征的数量等于输入平面的数量。
Args:
输出大小：目标输出大小，形式为 D x H x W。
可以是一个元组 (D, H, W) 或单个数字 D，表示 D x D x D 的立方体。
D、H 和 W 可以是整数或 None，None 表示大小将
与输入相同。
形状：
输入：:math:`(N, C, D_{in}, H_{in}, W_{in})` 或 :math:`(C, D_{in}, H_{in}, W_{in})`.
翻译：输入：:math:`(N, C, D_{in}, H_{in}, W_{in})` 或 :math:`(C, D_{in}, H_{in}, W_{in})`.
输出：:math:`(N, C, S_{0}, S_{1}, S_{2})` 或 :math:`(C, S_{0}, S_{1}, S_{2})`
其中 :math:`S=\text{输出大小}`。
示例：
>>> # 目标输出大小为 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)
"""
output_size: _size_3_opt_t
def forward(self, input: Tensor) -> Tensor:
return F.adaptive_avg_pool3d(input, self.output_size)
