torch.nn.modules.fold 的源代码


导入 torch.nn.functional 
作为 F
来自 
火炬 
导入 
张量
来自 torch.nn.common_types 
导入 _size_any_t

来自 
.模块 
导入 
模块


__all__ = [折叠, 
展开]


[文档]
类 
折叠(
模块):
    r将一系列滑动局部块组合成一个大的包含张量。

考虑一个包含滑动局部块的批处理：attr：`input`张量，
例如，图像块，形状为 :math:`(N, C \times  \prod(\text{kernel\_size}), L)`，
其中 :math:`N` 是批量维度，:math:`C \times \prod(\text{kernel\_size})`
是一个块中的值数量（一个块包含 :math:`\prod(\text{kernel\_size})`
个空间位置，每个位置包含一个 :math:`C` 通道的向量），和
`L` 是总块数。 (这正是)
与 :class:`~torch.nn.Unfold` 的输出形状相同的规范。) 这
操作将这些局部块组合成大的：attr:`output` 张量
形状为：(N, C, output_size[0], output_size[1], ...)
通过求重叠值的和。类似于 :class:`~torch.nn.Unfold`，参数必须满足
条件

    .. math::
        L = \prod_d \left\lfloor\frac{\text{output\_size}[d] + 2 \times \text{padding}[d] %
            - \text{dilation}[d] \times (\text{kernel\_size}[d] - 1) - 1}{\text{stride}[d]} + 1\right\rfloor,

其中 :math:`d` 是所有空间维度。

* :attr:`output_size` 描述了包含大张量的空间形状。
滑动局部块的张量。当多个输入形状映射到相同数量的滑动块时很有用，例如。
当多个输入形状映射到相同数量的滑动块时，例如。
with ``步长 > 0``。

attr:`padding`、:attr:`步长` 和 :attr:`膨胀` 参数指定了
如何检索滑动块。

* :attr:`步长` 控制滑动块的步长。

* :attr:`padding` 控制了隐式零填充的数量
边距为：attr:`padding` 每个维度的点数
重塑。
"" 
""
* :attr:`dilation` 控制核点之间的间距；也称为
à
Trous 算法。
描述起来比较困难，但这个 `链接`_ 有一个关于 :attr:`dilation` 做什么的良好可视化。
"" r
""
    Args:
output_size（int 或 tuple）：空间维度形状（int 或 tuple）。
输出（即`output.sizes()[2:]`）。
核心大小（整数或元组）：滑动块的尺寸
扩展率（整数或元组，可选）：控制元素在
邻域内的
步长。默认：1
填充（int 或 tuple，可选）：输入两侧的隐式零填充。默认：0
两侧。默认：0
步长（int 或 tuple）：输入滑动块的步长
空间维度。默认：1

* 如果 :attr:`output_size`、:attr:`kernel_size`、:attr:`dilation`
attr:`padding` 或 :attr:`stride` 是一个整数或长度为 1 的元组，则
它们的值将在所有空间维度上重复。

* 对于两个输出空间维度的情况，此操作有时
称为 `col2im`。

.. 注意::
`:class:`~torch.nn.Fold` 计算结果中每个组合值的
通过将所有包含块中的所有值相加得到大张量。
`:class:`~torch.nn.Unfold` 通过提取局部块中的值
从大张量中复制。因此，如果块重叠，它们不是彼此的逆。
通常，折叠和展开操作是相关的。考虑：class:`~torch.nn.Fold` 和

一般而言，折叠和展开操作如下。考虑：class:`~torch.nn.Fold` 和
考虑：class:`~torch.nn.Fold` 和
使用相同参数创建的 :class:`~torch.nn.Unfold` 实例
参数：

        >>> fold_params = dict(kernel_size=..., dilation=..., padding=..., stride=...)
        >>> fold = nn.Fold(output_size=..., **fold_params)
>>> 展开为 nn.Unfold(**fold_params)

对于任何（支持的）``input``张量，以下
等式成立：

        ::

            fold(unfold(input)) == divisor * input

其中 ``divisor`` 是一个只依赖于 ``input`` 形状和类型的张量
以及 ``input`` 的数据类型：

        >>> # xdoctest: +SKIP
        >>> input_ones = torch.ones(input.shape, dtype=input.dtype)
        >>> divisor = fold(unfold(input_ones))

当“除数”张量不包含零元素时，则
折叠和展开操作是彼此的逆操作
其他（至常数除数）。

.. 警告::
当前，仅支持非批处理（3D）或批处理（4D）图像类输出张量。

形状：
- 输入：:math:`(N, C \times \prod(\text{kernel\_size}), L)` 或 :math:`(C \times \prod(\text{kernel\_size}), L)`
- 输出：:math:`(N, C, \text{output\_size}[0], \text{output\_size}[1], \dots)`
或 :math:`(C, \text{output\_size}[0], \text{output\_size}[1], \dots)` 如上所述

示例：

        >>> fold = nn.Fold(output_size=(4, 5), kernel_size=(2, 2))
        >>> input = torch.randn(1, 3 * 2 * 2, 12)
        >>> output = fold(input)
        >>> output.size()
        torch.Size([1, 3, 4, 5])

.. _链接:
        https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md

"源代码"

    常量 = [
输出大小, 
"内核大小", 
"膨胀", 
"填充", 
步长]
    output_size: _size_any_t
    核心大小: _size_any_t
    扩展率: _size_any_t
    填充: _size_any_t
    步长: _size_any_t

    def 初始化(
        self,
        output_size: _size_any_t,
        核心大小: _size_any_t,
        扩展率: _size_any_t = 1,
        填充: _size_any_t = 0,
        步长: _size_any_t = 1,
    ) -> 无:
        超级().
初始化()
        self.输出大小 = 
输出大小
        self.核心大小 = 
核心大小
        self.扩展率 = 
扩展率
        self.填充 = 
填充
        self.步长 = 
步长

    def 前向(self, 
输入: 
张量) -> 
张量:
        返回 F.
折叠(
            输入,
            self.output_size,
            self.核心大小,
            self.扩展率,
            self.填充,
            self.步长,
        )

    def 额外表示(self) -> 
字符串:
        返回 (
            输出大小=
{输出大小}
, 核大小=
{核大小}
，"
            扩展率=
膨胀
, 填充=
填充
, 步长=
步长".
格式(
                **self.字典
            )
        )



[文档]
类 
展开(
模块):
    r从批处理的输入张量中提取滑动局部块。

考虑一个形状为 :math:`(N, C, *)` 的批处理 :attr:`input` 张量
其中 :math:`N` 是批维度，:math:`C` 是通道维度
和 :math:`*` 代表任意空间维度。此操作将...展平
每个空间维度内的每个：attr:`kernel_size`大小的滑动块
将输入：attr:`input` 转换为 3-D 输出：attr:`output` 的列（即最后一个维度）
张量的形状为 :math:`(N, C \times \prod(\text{kernel\_size}), L)`，其中
math:`C \times \prod(\text{kernel\_size})` 是每个块中的值总数（一个块有 :math:`\prod(\text{kernel\_size})` 个空间）
每个块（一个块有 :math:`\prod(\text{kernel\_size})` 个空间）内的值
包含一个 :math:`C`-通道向量的位置，其中 :math:`L` 是
这样的块的总数：

    .. math::
        L = \prod_d \left\lfloor\frac{\text{spatial\_size}[d] + 2 \times \text{padding}[d] %
            - \text{dilation}[d] \times (\text{kernel\_size}[d] - 1) - 1}{\text{stride}[d]} + 1\right\rfloor,

空间大小 :math:`\text{spatial\_size}` 由空间维度组成
的 :attr:`input` (:math:`*` 之上)，而 :math:`d` 是在整个空间上
尺寸。

因此，在最后一个维度（列维度）对 :attr:`output` 进行索引
可以得到一定块内的所有值。

attr:`padding`、:attr:`步长` 和 :attr:`膨胀` 参数指定了
如何检索滑动块。

* :attr:`步长` 控制滑动块的步长。

* :attr:`padding` 控制了隐式零填充的数量
边距为：attr:`padding` 每个维度的点数
重塑。
"" 
""
* :attr:`dilation` 控制核点之间的间距；也称为
à
Trous 算法。
描述起来比较困难，但这个 `链接`_ 有一个关于 :attr:`dilation` 做什么的良好可视化。
"" r
""
    Args:
核心大小（整数或元组）：滑动块的尺寸
扩展率（整数或元组，可选）：控制元素在
邻域内的
步长。默认：1
填充（int 或 tuple，可选）：输入两侧的隐式零填充。默认：0
两侧。默认：0
步长（整数或元组，可选）：输入中滑动块的步长
空间维度。默认：1

* 如果 :attr:`kernel_size`、:attr:`dilation`、:attr:`padding` 或 :attr:`stride` 是一个整数或长度为 1 的元组，
则它们的值将在所有空间维度上复制。
在所有空间维度上复制。

对于两个输入空间维度的情况，这个操作有时被称为
``im2col``。

.. 注意::
`:class:`~torch.nn.Fold` 计算结果中每个组合值的
通过将所有包含块中的所有值相加得到大张量。
`:class:`~torch.nn.Unfold` 通过提取局部块中的值
从大张量中复制。因此，如果块重叠，它们不是彼此的逆。
通常，折叠和展开操作是相关的。考虑：class:`~torch.nn.Fold` 和

一般而言，折叠和展开操作如下。考虑：class:`~torch.nn.Fold` 和
考虑：class:`~torch.nn.Fold` 和
使用相同参数创建的 :class:`~torch.nn.Unfold` 实例
参数：

        >>> fold_params = dict(kernel_size=..., dilation=..., padding=..., stride=...)
        >>> fold = nn.Fold(output_size=..., **fold_params)
>>> 展开为 nn.Unfold(**fold_params)

对于任何（支持的）``input``张量，以下
等式成立：

        ::

            fold(unfold(input)) == divisor * input

其中 ``divisor`` 是一个只依赖于 ``input`` 形状和类型的张量
以及 ``input`` 的数据类型：

        >>> # xdoctest: +SKIP
        >>> input_ones = torch.ones(input.shape, dtype=input.dtype)
        >>> divisor = fold(unfold(input_ones))

当“除数”张量不包含零元素时，则
折叠和展开操作是彼此的逆操作
其他（至常数除数）。

.. 警告::
目前，仅支持 4-D 输入张量（批量的图像类张量）
不支持。

形状：
- 输入: :math:`(N, C, *)`
- 输出：:math:`(N, C \times \prod(\text{kernel\_size}), L)` 如上所述

示例：

        >>> unfold = nn.Unfold(kernel_size=(2, 3))
        >>> input = torch.randn(2, 5, 3, 4)
        >>> output = unfold(input)
>>> # 每个块包含 30 个值（2x3=6 个向量，每个 5 个通道）
>>> # 总共 4 块（2x3 核）在 3x4 输入中
        >>> output.size()
        torch.Size([2, 30, 4])

        >>> # xdoctest: +IGNORE_WANT
>>> 线性卷积相当于展开 + 矩阵乘法 + 折叠（或视图到输出形状）
        >>> inp = torch.randn(1, 3, 10, 12)
        >>> w = torch.randn(2, 3, 4, 5)
        >>> inp_unf = torch.nn.functional.unfold(inp, (4, 5))
        >>> out_unf = inp_unf.transpose(1, 2).matmul(w.view(w.size(0), -1).t()).transpose(1, 2)
        >>> out = torch.nn.functional.fold(out_unf, (7, 8), (1, 1))
>>> # 或者等价地（避免复制），
        >>> # out = out_unf.view(1, 2, 7, 8)
        >>> (torch.nn.functional.conv2d(inp, w) - out).abs().max()
        tensor(1.9073e-06)

.. _链接:
        https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md

"源代码"

    常量 = [
"内核大小", 
"膨胀", 
"填充", 
步长]
    核心大小: _size_any_t
    扩展率: _size_any_t
    填充: _size_any_t
    步长: _size_any_t

    def 初始化(
        self,
        核心大小: _size_any_t,
        扩展率: _size_any_t = 1,
        填充: _size_any_t = 0,
        步长: _size_any_t = 1,
    ) -> 无:
        超级().
初始化()
        self.核心大小 = 
核心大小
        self.扩展率 = 
扩展率
        self.填充 = 
填充
        self.步长 = 
步长

    def 前向(self, 
输入: 
张量) -> 
张量:
        返回 F.
展开(
            输入, self.
核心大小, self.
扩展率, self.
填充, self.
步长
        )

    def 额外表示(self) -> 
字符串:
        返回 (
            "内核大小="
{核大小}
, 扩展率=
膨胀
, 填充=
填充
，
            " 步长=
步长".
格式(**self.
字典)
        )
torch.nn.modules.fold 的源代码

文档

教程

资源
