# mypy: 允许未类型化定义
导入
数学
来自
打字
导入
可选,
联合
来自 typing_extensions
导入
已弃用
导入
火炬
来自
火炬
导入
张量
来自 torch._torch_docs
导入
可复现性说明
来自 torch.nn
导入
功能性
作为 F,
初始化
来自 torch.nn.common_types
导入 _size_1_t, _size_2_t, _size_3_t
来自
torch.nn 参数
导入
参数,
未初始化的参数
来自
.懒
导入 LazyModuleMixin
来自
.模块
导入
模块
来自
.工具
导入 _pair, _reverse_repeat_tuple, _single, _triple
__all__ = [
Conv1d,
Conv2d,
Conv3d,
ConvTranspose1d,
"卷积转置 2D",
"卷积转置 3D",
"懒卷积 1D",
"懒卷积 2D",
"LazyConv3d",
"LazyConvTranspose1d",
"LazyConvTranspose2d",
"LazyConvTranspose3d",
]
卷积笔记 = {
"分组说明": r
"* :attr:`groups` 控制输入和输出之间的连接。
attr:`in_channels` 和 :attr:`out_channels` 必须都能被
attr:`分组`. 例如，
* 在 groups=1 时，所有输入都与所有输出进行卷积。
* 在 groups=2 时，操作相当于有两个卷积层并排，每个层看到一半的输入通道
* 在 groups=2 时，操作相当于有两个卷积层并排，每个层看到一半的输入通道
并且产生一半的输出通道，并且随后连接。
连接。
* 在 groups= :attr:`in_channels` 时，每个输入通道与其自己的过滤器（大小为）进行卷积。
`out_channels / in_channels`).""",
深度可分离注意: r
当 `groups == in_channels` 且 `out_channels == K * in_channels`，
其中 `K` 是一个正整数，这种操作也称为“深度卷积”。
换句话说，对于大小为 :math:`(N, C_`{in}
， L_{in})`,
使用深度乘数 `K` 可以执行深度可分离卷积，其参数为
math:`(C_\text{in}`{in}
=C_\text{in}
{入}
, C_文本
{出}
=C_文本
{入}
× 文{K}
， ..., 文
{分组}
=C_文本
{内}
)`。”,
} # 无需注意：B950
类
_卷积 Nd(
模块):
常量 = [
步长,
填充,
扩展,
组,
"填充模式",
"输出填充",
"输入通道数",
"输出通道数",
核心大小,
]
__annotations__ = {偏置:
可选[
火炬.
张量]}
def _卷积前向(
我,
输入:
张量,
重量:
张量,
偏差:
可选[
张量]) ->
张量:
# 类型：忽略[空体]
...
输入通道:
整型
反转填充重复两次:
列表[int]
输出通道:
整型
核心大小:
元组[int, ...]
步长:
元组[int, ...]
填充:
联盟[
字符串,
元组[int, ...]]
扩展率:
元组[int, ...]
交换:
布尔类型
输出填充:
元组[int, ...]
群组:
整型
填充模式:
字符串
重量:
张量
偏差:
可选[
张量]
def 初始化(
我,
输入通道: int,
输出通道: int,
核心大小:
元组[int, ...
]
步长:
元组[int, ...
]
填充:
联盟[
字符串,
元组[int, ...]],
扩展率:
元组[int, ...
]
交换:
布尔,
输出填充:
元组[int, ...
]
群组: int,
偏差:
布尔,
填充模式:
字符串,
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
超级().
初始化()
如果
组们
≤ 0:
提升 ValueError(
"组必须是正整数")
如果
输入通道 %
组们 != 0:
提升 ValueError(
"输入通道必须能被组整除")
如果
输出通道 %
组们 != 0:
提升 ValueError(
"通道数必须能被组数整除")
有效的填充字符串 = {"same",
"有效"}
如果 isinstance(
填充,
字符串):
如果
填充 not
在
有效的填充字符串:
提升 ValueError(
f"无效的填充字符串{
填充!r}
，应该是以下有效填充字符串之一{
有效的填充字符串}"
)
如果
填充 ==
相同
和
任何(s != 1
为 s
在
步长):
提升 ValueError(
"padding='same' 不支持用于步进卷积"
)
有效的填充模式 = {
零,
反射,
复制,
循环}
如果
填充模式 not
在
有效的填充模式:
提升 ValueError(
f"填充模式必须是以下之一{
有效的填充模式}
，但是得到填充模式='{
填充模式}
)
我.
输入通道 =
输入通道
我.
输出通道 =
输出通道
我.
核心大小 =
核心大小
我.
步长 =
步长
我.
填充 =
填充
我.
扩展率 =
扩展率
我.
交换 =
交换
我.
输出填充 =
输出填充
我.
组们 =
组们
我.
填充模式 =
填充模式
`_reversed_padding_repeated_twice` 是需要传递的填充（例如，对于作为两个操作实现的非零填充类型：填充 + 卷积）。`F.pad` 接受以下填充：
`F.pad` 如果需要（例如，对于作为两个操作实现的非零填充类型：填充 + 卷积）。`F.pad` 接受以下填充：
`F.pad` 接受以下填充：
顺序与维度相反。
如果 isinstance(
我.
填充,
字符串):
我.
反复填充反转两次 = [0, 0] *
长度(
核心大小)
如果
填充 ==
相同:
为 d, k, i
在
压缩(
扩展率,
核心大小,
范围(
长度(
核心大小) - 1, -1, -1)
):
总填充 = d * (k - 1)
左填充 =
总填充 // 2
我.
反转填充重复两次[2 * i] =
左填充
我.
两次重复的逆序填充[2 * i + 1] = (
总填充 -
左填充
)
否则:
我.
两次重复的逆序填充 =
反转重复元组(
我.
填充, 2
)
如果
交换:
我.
权重 =
参数(
火炬.
空的(
(输入通道,
输出通道 //
群组, *
核心大小),
**工厂参数,
)
)
否则:
我.
权重 =
参数(
火炬.
空的(
(输出通道,
输入通道 //
群组, *
核心大小),
**工厂参数,
)
)
如果
偏差:
我.bias =
参数(
火炬.
空的(
输出通道, **
工厂参数))
否则:
我.
注册参数(
偏差,
无)
我.
重置参数()
def 重置参数(
我) ->
无:
在 kaiming_uniform 中将 a=sqrt(5)设置与用
初始化为 uniform(-1/sqrt(k), 1/sqrt(k))相同，其中 k = weight.size(1) * prod(*kernel_size)
更多详情请见：https://github.com/pytorch/pytorch/issues/15314#issuecomment-477448573
初始化.kaiming_uniform_(
我.
重量, a=
数学.
平方根(5))
如果
我.bias
是 not
无:
风扇进, _ =
初始化.
_计算扇入和扇出(
我.
重量)
如果
扩展输入 != 0:
限制 = 1 /
数学.
平方根(
风扇进)
初始化.
均匀的(
我.
偏差, -
绑定,
绑定)
def 额外表示(
我):
s = (
"{输入通道},
{输出通道}
, 核大小=
{核大小}"
", 步长="
{步长}"
)
如果
我.
填充 != (0,) *
长度(
我.
填充):
s += ", 填充="
{填充}"
如果
我.
膨胀 != (1,) *
长度(
我.
扩展率):
s += ", 膨胀="
扩张"
如果
我.
输出填充 != (0,) *
长度(
我.
输出填充):
s += ", 输出填充="
{输出填充}"
如果
我.
组们 != 1:
s += ", 组数="
{分组}"
如果
我.bias
是
无:
s += ", 偏置=False"
如果
我.
填充模式 !=
零:
s += ", 填充模式="
{填充模式}"
返回 s.
格式(**
我.
字典)
def __setstate__(我,
状态):
超级().__setstate__(
状态)
如果 not
有属性(
我,
填充模式):
我.
填充模式 =
"零"
[文档]
类
卷积 1D(
_卷积 Nd):
__doc__ = (
r应用于由多个输入信号组成的输入信号上的 1D 卷积
飞机。
在最简单的情况下，具有输入大小
的层的输出值 :math:`(N, C_{\text{in}}, L)` 和输出 :math:`(N, C_{\text{out}}, L_{\text{out}})` 可以被
准确描述为：
.. math::
\text{out}(N_i, C_{\text{out}_j}) = \text{bias}(C_{\text{out}_j}) +
\sum_{k = 0}^{C_{in} - 1} \text{权重}(C_{\text{out}_j}, k)
\star \text{输入}(N_i, k)
其中 :math:`\star` 是有效的 `互相关`_ 运算符，
math:`N` 是批量大小，:math:`C` 表示通道数，
`L` 是信号序列的长度。
"源代码"
+ r""
此模块支持 :ref:`TensorFloat32`。
在某些 ROCm 设备上，当使用 float16 输入时，此模块将使用 :ref:`不同的精度` 进行反向计算。
* :attr:`stride` 控制卷积的步长，一个单独的
数字或一个元素的元组。
* :attr:`padding` 控制应用于输入的填充量。
可以是字符串 {{'valid', 'same'}} 或一个整数元组，表示在两侧应用隐式填充的量。
表示在两侧应用隐式填充的量。
""
""
* :attr:`dilation` 控制内核点之间的间距；也
称为à trous 算法。描述起来更难，但这个`链接`_
具有对`:attr:`dilation`作用效果的直观可视化。
""
r""
{分组说明}
注意：
{depthwise_separable_note}
注意：
{cudnn_可复现性说明}
注意：
``padding='valid'`` 与无填充相同。``padding='same'`` 进行填充
输入，以便输出形状与输入相同。然而，此模式
不支持除 1 以外的任何步长值。
注意：
此模块支持复杂数据类型，即 ``complex32, complex64, complex128``。
参数：
in_channels（整数）：输入图像中的通道数
输出通道（整数）：卷积产生的通道数
核大小（整数或元组）：卷积核的大小
步长（整数或元组，可选）：卷积的步长。默认：1
填充（整数、元组或字符串，可选）：添加到两侧的填充
输入。默认：0
扩展（整数或元组，可选）：核之间的间隔
元素。默认：1
组（整数，可选）：从输入到输出的阻塞连接数
输出通道到输出通道。默认：1
偏置（布尔值，可选）：如果为 ``True``，则向输出添加可学习的偏置。默认：``True``
填充模式（字符串，可选）：``'zeros'``、``'reflect'``、
填充模式（字符串，可选）：``'zeros'``、``'reflect'``、
``'复制'`` 或 ``'循环'``。默认：``'零'``
""".格式(
**可复现性说明, **
卷积笔记
)
+ r""
形状：
输入：\(N, C\){in}
，L\_{in}
）或：数学公式（C_
{内}
，L_
{内})`
- 输出: \(N, C\){out}
，L_{out}
)` 或 :math:`(C_{out}, L_{out}
)`, 其中
.. math::
L_{out} = \left\lfloor\frac{L_{入}
+ 2 × {文本}
{填充}
文本
{膨胀}
\times (内核大小 - 1) - 1}{\text
步长} + 1\right\rfloor
属性：
weight (张量)：该模块的可学习权重，形状为
(输出通道，
输入文本翻译为简体中文为：
\frac{in\_channels}{{分组}
}, 核心大小`)`.
这些权重的值是从中抽取的
数学符号
矢量
负根号
集合
，根号{k}
）` 其中
math:`k = \frac
{分组}
{C_文本
{在} * \text{kernel\_size}}`
偏置 (Tensor)： 该模块的可学习偏置，形状为
(out_channels)。如果 :attr:`bias` 为 ``True``，则这些权重的值是从 :math:`\mathcal{U}` 中采样的
{U}{U}
(-√{k}
，√{k}
）`其中
\( k = \frac \)
{分组}
\{C_\text\}
\{in\}
* \text{kernel\_size\}\)
示例：
>>> m = nn.Conv1d(16, 33, 3, stride=2)
>>> input = torch.randn(20, 16, 50)
>>> output = m(input)
.. _cross-correlation:
https://en.wikipedia.org/wiki/Cross-correlation
.. _链接:
https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md
"源代码"
)
def 初始化(
我,
输入通道: int,
输出通道: int,
核心大小: _size_1_t,
步长:
_尺寸_1_t = 1,
填充:
联盟[
字符串,
_尺寸_1_t] = 0,
扩展率:
_尺寸_1_t = 1,
群组:
整型 = 1,
偏差:
布尔类型 = True,
填充模式:
字符串 =
零,
# TODO: 精炼此类型
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
以下创建新变量以使 mypy 高兴，因为 kernel_size 具有
类型 Union[int, Tuple[int]]，而 kernel_size_具有类型 Tuple[int]
kernel_size_ = _single(核心大小)
步长_ = _single(
步长)
填充_ =
填充
如果 isinstance(
填充,
字符串)
否则 _single(
填充)
膨胀_ = _single(
扩展率)
超级().
初始化(
输入通道,
输出通道,
核大小_,
步长_,
填充_,
扩展_,
错误,
_single(0),
群组,
偏差,
填充模式,
**工厂参数,
)
def _卷积前向(
我,
输入:
张量,
重量:
张量,
偏差:
可选[
张量
)]
如果
我.
填充模式 !=
零:
返回 F.
卷积 1D(
F.填充(
输入,
我._reversed_padding_repeated_twice,
模式=
我.
填充模式
),
重量,
偏差,
我.
步长,
_single(0),
我.
扩展率,
我.
群组,
)
返回 F.
卷积 1D(
输入,
重量,
偏差,
我.
步长,
我.
填充,
我.
扩展率,
我.
组们
)
def 前向(
我,
输入:
张量) ->
张量:
返回
我._conv_forward(
输入,
我.
重量,
我.
偏差)
[文档]
类
卷积 2D(_ConvNd):
__doc__ = (
r应用在由多个输入信号组成的输入信号上的 2D 卷积
飞机。
在最简单的情况下，该层的输出值与输入大小
`(N, C_{\text{in}}, H, W)` 和输出 :math:`(N, C_{\text{out}}, H_{\text{out}}, W_{\text{out}})`
可以精确描述为：
.. math::
\text{out}(N_i, C_{\text{out}_j}) = \text{bias}(C_{\text{out}_j}) +
\sum_{k = 0}^{C_{\text{in}} - 1} \text{weight}(C_{\text{out}_j}, k) \star \text{input}(N_i, k)
其中 :math:`\star` 是有效的二维 `互相关`_ 运算符，
math:`N` 表示批量大小，:math:`C` 表示通道数，
math:`H` 表示输入平面的高度（像素），而 :math:`W` 表示
宽度（像素）。
"源代码"
+ r""
本模块支持：ref:`TensorFloat32`.
在某些 ROCm 设备上，当使用 float16 输入时，此模块将使用：ref:`不同精度`进行反向操作。
* :attr:`stride` 控制卷积的步长，可以是单个数字或一个元组。
数字或一个元组。
* :attr:`padding` 控制应用于输入的填充量。它
可以是字符串 {{'valid', 'same'}} 或一个整数 / 整数元组，表示
在两侧应用隐式填充的量。
""
""
* :attr:`dilation` 控制内核点之间的间距；也
被称为à trouss 算法。描述起来比较困难，但这个`链接`_
有一个很好的可视化，展示了:attr:`膨胀`的作用。
""
r""
{groups_note}
参数:attr:`kernel_size`、:attr:`stride`、:attr:`padding`、:attr:`dilation`可以是：
- 一个单个的 `int` -- 在这种情况下，相同的价值用于高度和宽度维度
- 两个 `int` 的 `tuple` -- 在这种情况下，第一个 `int` 用于高度维度，
并且第二个 `int` 用于宽度维度
注意：
{深度可分离注释}
注意：
{cudnn_可复现性说明}
注意：
``padding='valid'`` 与无填充相同。``padding='same'`` 进行填充
输入以使输出形状与输入相同。然而，此模式
不支持除 1 以外的任何步长值。
注意：
此模块支持复杂数据类型，例如 ``complex32, complex64, complex128``。
参数：
in_channels（整数）：输入图像中的通道数
out_channels（整数）：卷积产生的通道数
内核大小（int 或 tuple）：卷积核大小
步长（int 或 tuple，可选）：卷积的步长。默认：1
填充（int，tuple 或 str，可选）：添加到所有四边的填充
输入。默认：0
稀疏度（int 或 tuple，可选）：核元素之间的间距。默认：1
groups（int，可选）：从输入通道到输出通道的阻塞连接数。默认：1
channels（int，可选）：从输入通道到输出通道的阻塞连接数。默认：1
bias（bool，可选）：如果为 True，则添加一个可学习的偏置
输出。默认：``True``
填充模式（str，可选）：``'zeros'``、``'reflect'``、
``'replicate'`` 或 ``'circular'``。默认：``'zeros'``
""".格式(
**可复现性说明, **
卷积说明
)
+ r""
形状：
输入：\(N, C\){in}
，H\_{in}
，W_
{内}
)` 或 :math:`(C_
{内}
，H_{in}
，W_{in})`
- 输出: \(N, C\){out}
， H\_{out}
，W_
{输出}
)` 或者 :math:`(C_
{输出}
，H_
{出}
，W_
{出}
)`，其中
.. math::
H_{出} = \left\lfloor\frac{H_
{入} + 2 \times \text
填充[0] - \text
膨胀[0]
\times (内核大小[0] - 1) - 1}{\text
步长[0]} + 1\right\rfloor
.. math::
W_{出} = \left\lfloor\frac{W_
{入} + 2 \times \text
填充[1] - \text
膨胀[1]
$\times (\text{kernel\_size}[1] - 1) - 1}{\text$
步长
[1]} + 1[右花括号]
属性：
权重（张量）：该模块的可学习权重，形状为
输出通道数，输入通道数的比值
{分组}},`
kernel_size[0], kernel_size[1])
这些权重的值是从中抽取的
\(\mathcal\){U}
\(-\sqrt\){k}
，根号{k}
）` 其中
math:`k = \frac
{分组}
{C_文本}
{内} * \prod_{i=0}^{1}\text{kernel\_size}[i]}`
偏置 (Tensor)：该模块的可学习偏置，形状为
(out_channels)。如果 :attr:`bias` 为 ``True``，
则这些权重的值是从 :math:`\mathcal
{U} 中抽取的{U}
-√{k}
，√{k}
)` 在哪里
数学公式:`k = \frac
{分组}
{C_文本
{在} * \prod_{i=0}^{1}\text{kernel\_size}[i]}`
示例：
>>> # 使用方形核和相等步长
>>> m = nn.Conv2d(16, 33, 3, stride=2)
>>> # 非方形核、不等步长和填充
>>> m = nn.Conv2d(16, 33, (3, 5), stride=(2, 1), padding=(4, 2))
>>> # 非正方形核、不等步长、带填充和膨胀
>>> m = nn.Conv2d(16, 33, (3, 5), stride=(2, 1), padding=(4, 2), dilation=(3, 1))
>>> input = torch.randn(20, 16, 50, 100)
>>> 输出 = m(输入)
.. _互相关:
https://en.wikipedia.org/wiki/Cross-correlation
.. _链接:
https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md
"源代码"
)
def 初始化(
我,
输入通道: int,
输出通道: int,
核心大小: _size_2_t,
步长: _size_2_t = 1,
填充:
联盟[
字符串, _size_2_t] = 0,
扩展率:
_大小_2_t = 1,
群组:
整型 = 1,
偏差:
布尔类型 = True,
填充模式:
字符串 =
零,
# TODO: 精炼此类型
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
内核大小_ = _pair(
核心大小)
步长_ = _pair(
步长)
填充_ =
填充
如果 isinstance(
填充,
字符串)
否则 _pair(
填充)
扩展_ = _pair(
扩展率)
超级().
初始化(
输入通道,
输出通道,
核心大小_,
步长_,
填充_,
扩展率_,
错误,
_pair(0),
群组,
偏差,
填充模式,
**工厂参数,
)
def _conv_forward(我,
输入:
张量,
重量:
张量,
偏差:
可选[
张量
)]
如果
我.
填充模式 !=
零:
返回 F.
卷积 2D(
F.填充(
输入,
我._reversed_padding_repeated_twice,
模式=
我.
填充模式
),
重量,
偏差,
我.
步长,
_pair(0),
我.
扩展率,
我.
群组,
)
返回 F.
卷积 2D(
输入,
重量,
偏差,
我.
步长,
我.
填充,
我.
扩展率,
我.
组们
)
def 前向(
我,
输入:
张量) ->
张量:
返回
自己._conv_forward(
输入,
我.
重量,
我.
偏差)
[文档]
类
卷积 3D(_ConvNd):
__doc__ = (
r对由多个输入信号组成的输入信号应用 3D 卷积
飞机。
在最简单的情况下，输入大小为 :math:`(N, C_{in}, D, H, W)` 的层输出值
和输出 :math:`(N, C_{out}, D_{out}, H_{out}, W_{out})` 可以精确描述为：
.. math::
out(N_i, C_{out_j}) = bias(C_{out_j}) +
\sum_{k = 0}^{C_{in} - 1} weight(C_{out_j}, k) \star input(N_i, k)
其中 :math:`\star` 是有效的 3D `交叉相关`_ 操作符
"源代码"
+ r""
此模块支持 :ref:`TensorFloat32`.
在某些 ROCm 设备上，当使用 float16 输入时，此模块将使用：ref:`不同精度`进行反向操作。
* :attr:`步长` 控制卷积的步长。
* :attr:`填充` 控制应用于输入的填充量。
它可以是字符串 {{'valid', 'same'}} 或一个表示填充量的整数元组。
两侧应用的隐式填充量。
""
""
* :attr:`dilation` 控制内核点之间的间距；也称为 \u00e0 trouss 算法。
描述起来比较困难，但这个 `链接`_ 有一个关于 :attr:`dilation` 做什么的良好可视化。
""
r""
{分组说明}
参数 :attr:`kernel_size`、:attr:`stride`、:attr:`padding`、:attr:`dilation` 可以是以下之一：
- 一个单独的 ``int`` -- 在这种情况下，相同的值用于深度、高度和宽度维度
- 一个包含三个整数的 ``tuple`` -- 在这种情况下，第一个 `int` 用于深度维度，
第二个 `int` 用于高度维度，第三个 `int` 用于宽度维度
注意：
{depthwise_separable_note}
注意：
{cudnn_可复现性说明}
注意：
``padding='valid'`` 与无填充相同。``padding='same'`` 进行填充
输入，因此输出形状与输入相同。然而，此模式
不支持除 1 以外的任何步长值。
注意：
此模块支持复杂数据类型，即 ``complex32, complex64, complex128``。
参数：
in_channels（整数）：输入图像中的通道数
输出通道（整数）：卷积产生的通道数
核大小（整数或元组）：卷积核的大小
步长（整数或元组，可选）：卷积的步长。默认：1
填充（整数、元组或字符串，可选）：添加到所有六边的填充
输入。默认值：0
扩展（整数或元组，可选）：核元素之间的间距。默认值：1
groups（int，可选）：从输入通道到输出通道的阻塞连接数。默认：1
bias（bool，可选）：如果为 True，则向输出添加可学习的偏置。默认：True
padding_mode（str，可选）：'zeros'、'reflect'、'replicate'或'circular'。默认：'zeros'
""".格式(
**可复现性说明, **
卷积说明
)
+ r""
形状：
输入：\(N, C\){in}
，D\_{in}
，H_{in}
，W_{in}
)` 或 :math:`(C_{in}, D_{in}
，H_{in}
，W_{in})`
- 输出: \(N, C\){out}
，D\_{out}
，H_
{出}
，W_
{出}
)` 或 :math:`(C_{out}, D_{out}
，H_
{出}
，W_
{出})`,
哪里
.. math::
D_{出} = \left\lfloor\frac{D_
{入}
+ 2 × {文本}
{填充}
[0] - {文本}
扩张[0]
\times (核大小[0] - 1) - 1}{文本
步长
\[\] + 1\right\rfloor
.. math::
H_{输出} = \left\lfloor\frac{H_
{入}
+ 2 × {文本}
{填充}
[1] - {文本}
扩张[1]
\times (核大小[1] - 1) - 1}{文本
步长
[1]} + 1[右花括号]
.. math::
W_{出} = \left\lfloor\frac{W_
{入} + 2 \times \text
填充[2] - \text
膨胀[2]
\times (内核大小[2] - 1) - 1}{\text
步长[2]} + 1\right\rfloor
属性：
重量（张量）：该模块的可学习权重，形状为
输出通道数，输入通道数的比值
{分组}},`
kernel_size[0], kernel_size[1], kernel_size[2]
这些权重的值是从中抽取的
数学公式{U}
(-√){k}
，√{k}
)` 其中
math:`k = \frac
{分组}
{C_文本
{内} * \prod_{i=0}^{2}\text{kernel\_size}[i]}`
偏置（Tensor）：模块的可学习偏置，形状为（输出通道数）。如果 :attr:`bias` 为 ``True``，
则这些权重的值是从
math:`\mathcal{U}
-√{k}
，√{k}
)` 在哪里
数学公式:`k = \frac
{分组}
{C_文本
{在} * \prod_{i=0}^{2}\text{kernel\_size}[i]}`
示例：
>>> # 使用方形核和相等步长
>>> m = nn.Conv3d(16, 33, 3, stride=2)
>>> # 非正方形核和不等距步长以及填充
>>> m = nn.Conv3d(16, 33, (3, 5, 2), stride=(2, 1, 1), padding=(4, 2, 0))
>>> input = torch.randn(20, 16, 10, 50, 100)
>>> 输出 = m(输入)
.. _互相关:
https://en.wikipedia.org/wiki/Cross-correlation
.. _链接:
https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md
"源代码"
)
def 初始化(
我,
in_channels: int,
输出通道: int,
核心大小:
_尺寸_3_t,
步长:
_尺寸_3_t = 1,
填充:
联盟[
字符串,
_尺寸_3_t] = 0,
扩展率:
_尺寸_3_t = 1,
群组:
整型 = 1,
偏差:
布尔类型 = True,
填充模式:
字符串 =
零,
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
核心大小_ =
_三倍_(
核心大小)
步长_ =
_三倍_(
步长)
填充_ =
填充
如果 isinstance(
填充,
字符串)
否则
_三倍_(
填充)
扩展率_ =
_三倍_(
扩展率)
超级().
初始化(
输入通道,
输出通道,
内核大小_,
步长_,
填充_,
膨胀_,
错误,
_三倍_(0),
群组,
偏差,
填充模式,
**工厂参数,
)
def _conv_forward(我,
输入:
张量,
重量:
张量,
偏差:
可选[
张量
])：
如果
我.
填充模式 !=
零:
返回 F.
卷积 3D(
F.填充(
输入,
我._reversed_padding_repeated_twice,
模式=
我.
填充模式
),
重量,
偏差,
我.
步长,
_三倍_(0),
我.
扩展率,
我.
群组,
)
返回 F.
卷积 3D(
输入,
重量,
偏差,
我.
步长,
我.
填充,
我.
扩展率,
我.
组们
)
def 前向(
我,
输入:
张量) ->
张量:
返回
我._conv_forward(
输入,
我.
重量,
我.
偏差)
类 _ConvTransposeNd(_ConvNd):
def 初始化(
我,
in_channels,
输出通道,
核心大小,
步长,
填充,
扩展率,
交换,
输出填充,
群组,
偏差,
填充模式,
设备=
无,
数据类型=
无,
) -> 无:
如果
填充模式 !=
零:
提升 ValueError(
f仅支持 "zeros" 填充模式{
我.
类.__name__}'
)
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
超级().
初始化(
输入通道,
输出通道,
核心大小,
步长,
填充,
扩展率,
交换,
输出填充,
群组,
偏差,
填充模式,
**工厂参数,
)
# 扩张参数为可选参数，用于向后兼容
# 兼容性
def _输出填充(
我,
输入:
张量,
output_size: 可选[
列表[int]],
步长:
列表[int
]
填充:
列表[int
]
核心大小:
列表[int
]
空间维度数: int,
扩展率:
可选[
列表[int]] =
无,
) -> 列表[int
]
如果
输出大小
是
无:
返回 = _single(
我.
输出填充)
# 转换为列表（如果尚未是列表）
否则:
has_batch_dim = 输入.
暗淡() == num_spatial_dims + 2
num_non_spatial_dims = 2 如果 has_batch_dim
否则 1
如果
长度(output_size) == num_non_spatial_dims + num_spatial_dims:
输出大小 = output_size[
空间维度数量
]
如果
长度(output_size) !=
空间维度数:
提升 ValueError(
f"卷积转置"{
空间维度数}
D: 用于{
输入.
暗淡()}
D 输入，output_size 必须有{
空间维度数} "
f或者{
非空间维度数 +
空间维度数}
元素（获取{
长度(output_size)})"
)
最小尺寸 =
火炬.
算子.
标注(
列表[int
]
[]
最大尺寸 =
火炬.
算子.
标注(
列表[int
]
[]
为 d
在
范围(
空间维度数):
维度大小 = (
(输入.
尺寸(d +
非空间维度数) - 1) *
步长[d]
- 2 * 填充[d]
+ (扩展率[d]
如果
扩展率
是 not
无
否则 1)
* (核心大小[d] - 1)
+ 1
)
最小尺寸.
追加(
尺寸)
最大尺寸.
追加(
最小尺寸[d] +
步长[d] - 1)
为 i
在
范围(
长度(output_size)):
大小 = output_size[i]
最小尺寸 = min_sizes[i]
max_size = max_sizes[i]
如果
大小 <
最小尺寸
或
大小 >
最大大小:
提升 ValueError(
f"请求输出大小为"{output_size}
，但有效的大小范围是
f"从"{min_sizes}
到{max_sizes}
（用于输入的）{
输入.
尺寸()[2
]})"
)
res = 火炬.
算子.
标注(
列表[int
]
[]
为 d
在
范围(
空间维度数):
资源.
追加(output_size[d] -
最小尺寸[d])
返回 = res
返回
返回
[文档]
类 ConvTranspose1d(_ConvTransposeNd):
__doc__ = (
r对输入图像应用 1D 转置卷积算子
由多个输入平面组成。
此模块可以看作是 Conv1d 相对于其输入的梯度。
它也被称为分数步长卷积或
反卷积（尽管它并不是真正的反卷积操作，因为它不）
不计算卷积的真实逆矩阵）。更多信息，请参阅可视化
这里和《去卷积网络》_ 论文。
本模块支持：:ref:`TensorFloat32`.
在某些 ROCm 设备上，当使用 float16 输入时，此模块将使用：ref:`不同精度`进行反向操作。
* :attr:`stride` 控制卷积的步长。
* :attr:`padding` 控制两侧隐式零填充的数量，
两侧对于 ``dilation * (kernel_size - 1) - padding`` 个点的数量。参见备注
以下内容请见详情。
* :attr:`output_padding` 控制输出形状额外添加到一侧的大小。
请参阅以下说明以获取详细信息。
""
""
* :attr:`dilation` 控制内核点之间的间距；也称为 \u00e0 trous 算法。
描述起来更难，但链接 `这里`_ 有一个很好的可视化，展示了 :attr:`膨胀` 是如何工作的。
""
r""
{groups_note}
注意：
attr:`padding` 参数实际上添加了 ``dilation * (kernel_size - 1) - padding`` 的零填充量
这是为了使输入的两种尺寸都添加零填充量
当使用 :class:`~torch.nn.Conv1d` 和 :class:`~torch.nn.ConvTranspose1d`
如果它们使用相同的参数初始化，它们在输入和输出形状方面互为逆运算。
然而，当 ``stride > 1`` 时，:class:`~torch.nn.Conv1d` 将多个输入形状映射到相同的输出形状。:attr:`output_padding` 提供了解决这种歧义的方法。
class:`~torch.nn.Conv1d` 将多个输入形状映射到相同的输出形状。:attr:`output_padding` 提供了解决这种歧义的方法。
attr:`output_padding` 提供了解决这种歧义的方法。
有效增加一侧的计算输出形状。注意
该 `output_padding` 属性仅用于查找输出形状，但并不
实际上不会向输出添加零填充。
注意：
在某些情况下，使用 CUDA 后端和 CuDNN 时，此运算符
可以选择一个非确定性算法来提高性能。如果这
不可取，您可以尝试将操作设置为确定性（可能
会有性能成本）通过设置 `torch.backends.cudnn.deterministic =
True`。
请参阅：doc:`/notes/randomness` 中的笔记以获取背景信息。
参数：
输入通道（int）：输入图像中的通道数
输出通道（int）：卷积产生的通道数
核大小（int 或元组）：卷积核的大小
步长（int 或元组，可选）：卷积的步长。默认：1
填充（int 或 tuple，可选）：``膨胀 * (内核大小 - 1) - 填充``零填充
将被添加到输入的两边。默认：0
输出填充（int 或 tuple，可选）：添加到输出形状一边的额外大小
。默认：0
groups（整数，可选）：从输入通道到输出通道的阻塞连接数。默认：1
bias（布尔值，可选）：如果为 True，则向输出添加可学习的偏置。默认：True
dilation（整数或元组，可选）：内核元素之间的间距。默认：1
""".格式(
**可复现性说明, **
卷积说明
)
+ r""
形状：
输入：\(N, C\){in}
，L\_{in}
）或：数学公式（C_
{内}
，L_
{内})`
- 输出: \(N, C\){out}
，L_{out}
)` 或 :math:`(C_{out}, L_{out}
)
.. math::
L_{out} = (L_{入}
- 1) 乘 \text
{步长}
- 2 乘 \text
{填充} + \text
{膨胀}
\times (\text{核大小} - 1) + \text{输出填充} + 1
属性：
权重（张量）：该模块的可学习权重，形状为
输入文本翻译为简体中文为：
:math:`(in\_channels, \frac{out\_channels}{\text{{分组}},`
核\_大小(\text{kernel\_size})。
这些权重的值是从中抽取的
\(\mathcal\){U}
\(-\sqrt\){k}
，根号{k}
）` 其中
math:`k = \frac
{分组}
{C_文本
{输出} * \text{kernel\_size}}`
偏置 (Tensor)：模块的可学习偏置，形状为 (输出通道数)。
如果 :attr:`bias` 为 ``True``，则这些权重的值是从 :math:`\mathcal{U}` 中抽取的
样本{U}
(-√{k}
，√{k}
）`其中
\( k = \frac \)
{分组}
\{C_\text\}
\{out\}
\* \text{kernel\_size\}}\)
.. _`这里`:
https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md
.. _`去卷积网络`:
https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf
"源代码"
)
def 初始化(
我,
in_channels: int,
out_channels: int,
核心大小:
_尺寸_1_t,
步长:
_尺寸_1_t = 1,
填充:
_尺寸_1_t = 0,
输出填充:
_尺寸_1_t = 0,
群组:
整型 = 1,
偏差:
布尔类型 = True,
扩展率:
_大小_1_t = 1,
填充模式:
字符串 =
零,
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
内核大小 = _single(
核心大小)
步长 = _single(
步长)
填充 = _single(
填充)
扩张 = _single(
扩展率)
输出填充 = _single(
输出填充)
超级().
初始化(
输入通道数,
输出通道数,
核心大小,
步长,
填充,
扩展率,
True,
输出填充,
群组,
偏差,
填充模式,
**工厂参数,
)
def 前向(
我,
输入:
张量, output_size:
可选[
列表[int]] =
无) ->
张量:
如果
我.
填充模式 !=
零:
提升 ValueError(
仅支持 `zeros` 填充模式用于 ConvTranspose1d
)
断言 isinstance(
我.
填充,
元组)
在 "_output_padding" 中不能将 List 替换为 Tuple 或 Sequence
TorchScript 不支持 `Sequence[T]` 或 `Tuple[T, ...]`
空间维度数 = 1
输出填充 =
我.
_输出填充(
输入,
output_size,
我.
步长, # type: ignore[arg-type]
我.
填充, # type: ignore[arg-type]
我.
核心大小, # type: ignore[arg-type]
空间维度数,
我.
扩展率, # type: ignore[arg-type]
)
返回 F.
卷积转置 1D(
输入,
我.
重量,
我.
偏差,
我.
步长,
我.
填充,
输出填充,
我.
群组,
我.
扩展率,
)
[文档]
类 ConvTranspose2d(
_卷积转置算子):
__doc__ = (
r应用 2D 转置卷积算子到输入图像上
由几个输入平面组成。
这个模块可以看作是 Conv2d 相对于其输入的梯度。
它也被称为分数步长卷积或
反卷积（尽管它并不是真正的反卷积操作，因为它并不计算卷积的真正逆）。更多信息，请参阅此处_和《反卷积网络》_论文。
对于更多信息，请参阅此处_和《反卷积网络》_论文。
`此处`_和《反卷积网络》_论文。
本模块支持：:ref:`TensorFloat32`.
在某些 ROCm 设备上，当使用 float16 输入时，本模块将使用：ref:`不同精度`进行反向操作。
* :attr:`stride` 控制卷积的步长。
* :attr:`padding` 控制两侧隐式零填充的数量
边距为 `dilation * (kernel_size - 1) - padding` 个点。参见注释
以下为详情。
* :attr:`output_padding` 控制添加到一侧的额外大小
输出形状的细节。见下文注释。
""
""
* :attr:`膨胀` 控制核点之间的间距；也称为 \u00e0 trouss 算法。
描述起来比较困难，但链接 `这里`_ 有一个很好的可视化，展示了 :attr:`膨胀` 的作用。
""
r""
{groups_note}
参数 :attr:`kernel_size`、:attr:`stride`、:attr:`padding`、:attr:`output_padding`
可以是：
- 一个 ``int`` -- 在这种情况下，相同的值用于高度和宽度维度
- 一个包含两个 ``int`` 的 ``tuple`` -- 在这种情况下，第一个 `int` 用于高度维度，
第二个 `int` 用于宽度维度
注意：
`:attr:`padding` 参数实际上添加了 `dilation * (kernel_size - 1) - padding`
输入文本的简体中文翻译为：
输入两种大小的输入的零填充量。这是设置为
当使用 :class:`~torch.nn.Conv2d` 和 :class:`~torch.nn.ConvTranspose2d` 时
它们使用相同的参数初始化，它们是彼此的倒数
关于输入和输出形状。然而，当 ``stride > 1`` 时，
class:`~torch.nn.Conv2d` 将多个输入形状映射到相同的输出
形状。:attr:`output_padding` 提供了解决这种歧义的方法，通过
有效地增加计算输出形状的一侧。注意
`output_padding` 仅用于查找输出形状，但实际上并不会添加零填充到输出。
不会实际添加零填充到输出。
注意：
{cudnn_可复现性说明}
参数：
输入通道（int）：输入图像中的通道数
输出通道（int）：卷积产生的通道数
核大小（int 或元组）：卷积核的大小
步长（int 或元组，可选）：卷积的步长。默认：1
填充（int 或 tuple，可选）：``dilation * (kernel_size - 1) - padding`` 零填充
将被添加到输入的每个维度的两侧。默认值：0
输出填充（int 或 tuple，可选）：添加到一侧的额外大小
输出形状中每个维度的偏移。默认：0
groups（整数，可选）：从输入通道到输出通道的阻塞连接数。默认：1
bias（布尔值，可选）：如果为 True，则向输出添加可学习的偏置。默认：True
dilation（整数或元组，可选）：内核元素之间的间距。默认：1
""".格式(
**可复现性说明, **
卷积说明
)
+ r""
形状：
输入：\(N, C\){in}
，H\_{in}
，W_
{内}
)` 或 :math:`(C_
{内}
，H_{in}
，W_{in})`
- 输出: \(N, C\){out}
， H\_{out}
，W_
{输出}
)` 或者 :math:`(C_
{输出}
，H_
{出}
，W_
{出}
)`, 其中
.. math::
H_{out} = (H_{入}
- 1) 乘 \text
{步长}
[0] - 2 乘 \text
填充
[0] + 文本
膨胀[0]
\times (kernel\_size[0] - 1) + output\_padding[0] + 1
.. math::
W_{out} = (W_{入}
- 1) 乘 \text
{步长}
[1] - 2 乘 \text
填充
[1] + 文本
膨胀[1]
\times (\text{kernel\_size}[1] - 1) + \text{output\_padding}[1] + 1
属性：
weight (Tensor)：该模块的可学习权重，形状为
math:`(\text{in\_channels}, \frac{\text{out\_channels}}{\text
{分组}},`
math:`\text{kernel\_size[0]}, \text{kernel\_size[1]})`。
这些权重的值是从中采样的
\mathcal{U}(-\sqrt{k}
，√{k}
）`其中
\( k = \frac \)
{分组}
\{C_\text\}
\{out\} * \prod_{i=0}^{1}
`kernel_size[i]`
偏置（Tensor）：模块的可学习偏置，形状为（输出通道数）
如果 :attr:`bias` 为 ``True``，则这些权重的值
从 :math:`\mathcal{U}` 中采样{U}
-√{k}
，√{k}
)` 在哪里
数学公式 `k = \frac
{分组}
{C_文本
{输出} * \prod_{i=0}^{1}\text{kernel\_size}[i]}`
示例：
>>> # 使用方形核和相等步长
>>> m = nn.ConvTranspose2d(16, 33, 3, stride=2)
>>> # 非方形核、不等步长和填充
>>> m = nn.ConvTranspose2d(16, 33, (3, 5), stride=(2, 1), padding=(4, 2))
>>> input = torch.randn(20, 16, 50, 100)
>>> output = m(input)
>>> # 精确输出大小也可以作为参数指定
>>> input = torch.randn(1, 16, 12, 12)
>>> downsample = nn.Conv2d(16, 16, 3, stride=2, padding=1)
>>> upsample = nn.ConvTranspose2d(16, 16, 3, stride=2, padding=1)
>>> h = downsample(input)
>>> h.size()
torch.Size([1, 16, 6, 6])
>>> output = upsample(h, output_size=input.size())
>>> output.size()
torch.Size([1, 16, 12, 12])
.. _`这里`:
https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md
.. _`去卷积网络`:
https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf
"源代码"
)
def 初始化(
我,
输入通道: int,
输出通道: int,
核心大小: _size_2_t,
步长: _size_2_t = 1,
填充:
_尺寸_2_t = 0,
输出填充:
_尺寸_2_t = 0,
群组:
整型 = 1,
偏差:
布尔类型 = True,
扩展率:
_尺寸_2_t = 1,
填充模式:
字符串 =
零,
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
核大小 = _pair(
核心大小)
步长 = _pair(
步长)
填充 = _pair(
填充)
扩展率 = _pair(
扩展率)
输出填充 = _pair(
输出填充)
超级().
初始化(
输入通道数,
输出通道,
核心大小,
步长,
填充,
扩展率,
True,
输出填充,
群组,
偏差,
填充模式,
**工厂参数,
)
def 前向(
我,
输入:
张量, output_size:
可选[
列表[int]] =
无) ->
张量:
如果
我.
填充模式 !=
零:
提升 ValueError(
仅支持 `zeros` 填充模式用于 ConvTranspose2d
)
断言 isinstance(
我.
填充,
元组)
在 "_output_padding" 中不能将 List 替换为 Tuple 或 Sequence，因为
TorchScript 不支持 `Sequence[T]` 或 `Tuple[T, ...]`。
空间维度数 = 2
输出填充 =
我.
_输出填充(
输入,
output_size,
我.
步长, # type: ignore[arg-type]
我.
填充, # type: ignore[arg-type]
我.
核心大小, # type: ignore[arg-type]
空间维度数,
我.
扩展率, # type: ignore[arg-type]
)
返回 F.
转置卷积 2D(
输入,
我.
重量,
我.
偏差,
我.
步长,
我.
填充,
输出填充,
我.
群组,
我.
扩展率,
)
[文档]
类 ConvTranspose3d(_ConvTransposeNd):
__doc__ = (
r应用在由多个输入图像组成的输入图像上的 3D 转置卷积算子
飞机。
转置卷积算子将每个输入值元素乘以一个可学习的核，
并对所有输入特征平面上的输出求和。
这个模块可以看作是 Conv3d 相对于其输入的梯度。
它也被称为分数步长卷积或
反卷积（尽管它并不是真正的反卷积操作，因为它不）
不计算卷积的真实逆矩阵）。更多信息，请参阅可视化
这里和《去卷积网络》_ 论文。
本模块支持：:ref:`TensorFloat32`.
在某些 ROCm 设备上，当使用 float16 输入时，此模块将使用：ref:`不同精度`进行反向操作。
* :attr:`stride` 控制卷积的步长。
* :attr:`padding` 控制两侧隐式零填充的数量，
两侧对于 ``dilation * (kernel_size - 1) - padding`` 个点的数量。参见备注
以下内容请见详情。
* :attr:`output_padding` 控制输出形状额外添加到一侧的大小。
请参阅以下说明以获取详细信息。
""
""
* :attr:`dilation` 控制内核点之间的间距；也称为 \u00e0 trous 算法。
描述起来比较困难，但链接 `这里`_ 有一个很好的可视化，展示了 :attr:`dilation` 的作用。
""
r""
{groups_note}
参数 :attr:`kernel_size`、:attr:`stride`、:attr:`padding`、:attr:`output_padding`
可以是：
- 一个单个的 ``int`` -- 在这种情况下，相同的值用于深度、高度和宽度维度
- 一个包含三个整数的 ``tuple`` -- 在这种情况下，第一个 `int` 用于深度维度，
第二个 `int` 用于高度维度，第三个 `int` 用于宽度维度
注意：
attr:`padding` 参数实际上添加了 ``dilation * (kernel_size - 1) - padding``
输入文本的简体中文翻译为：
输入两种大小的输入的零填充量。这是设置为
当使用 :class:`~torch.nn.Conv3d` 和 :class:`~torch.nn.ConvTranspose3d` 时
它们使用相同的参数初始化，它们是彼此的倒数
关于输入和输出形状。然而，当“步长 > 1”时
`:class:`~torch.nn.Conv3d` 将多个输入形状映射到相同的输出
shape. :attr:`输出填充` 提供以解决此歧义
有效增加一侧的计算输出形状。注意
该 `output_padding` 属性仅用于查找输出形状，但并不
实际上不向输出添加零填充。
注意：
{cudnn_可复现性说明}
参数：
in_channels（整数）：输入图像中的通道数
out_channels（整数）：卷积产生的通道数
kernel_size（整数或元组）：卷积核的大小
stride（int 或 tuple，可选）：卷积的步长。默认：1
padding（int 或 tuple，可选）：``dilation * (kernel_size - 1) - padding`` 零填充
将被添加到输入的每个维度的两侧。默认：0
output_padding（int 或 tuple，可选）：添加到一侧的额外大小
输出形状的每个维度的数量。默认值：0
组（int，可选）：从输入通道到输出通道的阻塞连接数。默认值：1
偏置（bool，可选）：如果为 ``True``，则向输出添加可学习的偏置。默认值：``True``
扩展（int 或 tuple，可选）：内核元素之间的间距。默认值：1
""".格式(
**可复现性说明, **
卷积笔记
)
+ r""
形状：
- 输入：:math:`(N, C_`{in}, D_
{入}
，H_
{入}
，W_
{入}
)` 或者 :math:`(C_
{入}, D_
{入}
，H_
{入}
，W_
{入})`
- 输出：:math:`(N, C_`
{出}
，D_{out}
，H_{out}
，W_
{输出}
)` 或者
math:`(C_
{出}
，D_
{出}
，H_
{出}
，W_
{出}
)`, 其中
.. math::
D_{出} = (D_
{入}
- 1) 乘以 \text
{步长}
[0] - 2 乘以 \text
{填充}
[0] + 文本
{膨胀}[0]
\times (核大小[0] - 1) + 输出填充[0] + 1
.. math::
H_{out} = (H_{in}- 1) 乘以 \text
{步长}
[1] - 2 乘以 \text
{填充}
[1] + 文本
{膨胀}[1]
\times (卷积核大小[1] - 1) + 输出填充[1] + 1
.. math::
W_{出} = (W_
{入}
- 1) 乘以 \text
{步长}
[2] - 2 乘以 \text
{填充}
[2] + 文本
{膨胀}[2]
\times (kernel_size[2] - 1) + output_padding[2] + 1
属性：
权重（张量）：该模块的可学习权重，形状为
输入文本翻译为简体中文为：
:math:`(in\_channels, \frac{out\_channels}{\text{{分组}},`
kernel_size[0], kernel_size[1], kernel_size[2]
这些权重的值是从中抽取的
\(\mathcal\){U}
\(-\sqrt\){k}
，根号{k}
）` 其中
math:`k = \frac
{分组}
{C_文本
{输出} * \prod_{i=0}^{2}\text{kernel\_size}[i]}`
偏置（Tensor）：模块的可学习偏置，形状为（输出通道数）
如果 :attr:`bias` 为 ``True``，则这些权重的值
从 :math:`\mathcal{U}` 中采样{U}
-√{k}
，√{k}
)` 在哪里
math:`k = \frac{...}{...}`
{分组}
{C_文本}
{输出} * \prod_{i=0}^{2}\text{kernel\_size}[i]}`
示例：
>>> # 使用方形核和相等步长
>>> m = nn.ConvTranspose3d(16, 33, 3, stride=2)
>>> # 非正方形核和不等步长以及填充
>>> m = nn.ConvTranspose3d(16, 33, (3, 5, 2), stride=(2, 1, 1), padding=(0, 4, 2))
>>> input = torch.randn(20, 16, 10, 50, 100)
>>> output = m(input)
.. _`here`:
https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md
.. _`Deconvolutional Networks`:
https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf
"源代码"
)
def 初始化(
我,
输入通道: int,
输出通道: int,
核心大小: _size_3_t,
步长: _size_3_t = 1,
填充:
_尺寸_3_t = 0,
输出填充:
_尺寸_3_t = 0,
群组:
整型 = 1,
偏差:
布尔类型 = True,
扩展率: _size_3_t = 1,
填充模式:
字符串 =
零,
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
内核大小 =
_三倍_(
核心大小)
步长 =
_三倍_(
步长)
填充 =
_三倍_(
填充)
扩张 =
_三倍_(
扩展率)
输出填充 =
_三倍_(
输出填充)
超级().
初始化(
输入通道,
输出通道,
核心大小,
步长,
填充,
扩展率,
True,
输出填充,
群组,
偏差,
填充模式,
**工厂参数,
)
def 前向(
我,
输入:
张量, output_size:
可选[
列表[int]] =
无) ->
张量:
如果
我.
填充模式 !=
零:
提升 ValueError(
"仅支持 `zeros` 填充模式用于 ConvTranspose3d"
)
断言 isinstance(
我.
填充,
元组)
# 在 "_output_padding" 中不能将 List 替换为 Tuple 或 Sequence
# TorchScript 不支持 `Sequence[T]` 或 `Tuple[T, ...]`
空间维度数 = 3
输出填充 =
我.
_输出填充(
输入,
output_size,
我.
步长, # type: ignore[arg-type]
我.
填充, # type: ignore[arg-type]
我.
核心大小, # type: ignore[arg-type]
空间维度数,
我.
扩展率, # type: ignore[arg-type]
)
返回 F.
3D 转置卷积(
输入,
我.
重量,
我.
偏差,
我.
步长,
我.
填充,
输出填充,
我.
群组,
我.
扩展率,
)
# TODO: 废弃并移除以下别名 `_ConvTransposeMixin`。
#
# `_ConvTransposeMixin` 是一个已移除的混入类。它原本是用来
# 与 `_ConvNd` 结合，以构建实现转置卷积操作的模块类：
# 转置操作：
#
# class MyConvTranspose(_ConvNd, _ConvTransposeMixin):
# ...
#
# 在 PyTorch 中，它已被替换为`_ConvTransposeNd`，这是一个正确
# 的`_ConvNd`子类。然而，一些野外的用户代码仍然（错误地）使用
# 内部类`_ConvTransposeMixin`。因此，我们提供了这个别名
由于这样做成本低且方便，尽管如此，# for BC
`_ConvTransposeNd` 现在已不再是混合类（但多重继承仍然可以工作）。
上面的方法仍然有效）。
类 _ConvTransposeMixin(
_卷积转置算子):
@deprecated(
`_ConvTransposeMixin` 是一个已弃用的内部类。
请考虑使用公共 API。,
分类=
未来警告,
)
def 初始化(
我, *
参数, **kwargs):
超级().
初始化(*
参数, **kwargs)
# TODO: Conv2dLocal
# TODO: Conv2dMap
# TODO: 卷积转置 2d 映射
类
_LazyConvXd 混入(
LazyModule 混入):
群组:
整型
交换:
布尔类型
输入通道:
整型
输出通道:
整型
核心大小:
元组[int, ...]
重量:
未初始化的参数
偏差:
未初始化的参数
def 重置参数(
我) ->
无:
# 在父类中定义了 has_uninitialized_params，它正在使用 self 上的协议
如果 not
我.has_uninitialized_params()
和
我.in_channels != 0:
# 类型：忽略[杂项]
# "type:ignore[..]" 是必需的，因为 mypy 认为 reset_parameters 未定义
# 在超类中。结果证明，它是在_ConvND 中定义的，任何类都继承自_ConvND
# 该类还继承了_LazyConvXdMixin
超级().
重置参数()
# 类型：忽略[杂项]
与父类中定义的 'initialize_parameters' 签名不兼容
def initialize_parameters(我,
输入:
张量, *
参数, **kwargs) ->
无:
# 类型：忽略[覆盖]
由父类定义但使用协议
如果
我.has_uninitialized_params():
# 类型：忽略[杂项]
我.
输入通道 =
我.
_获取输入通道(
输入)
如果
我.
输入通道 %
我.
组们 != 0:
提升 ValueError(
"输入通道必须能被组数整除")
断言 isinstance(
我.
重量,
未初始化参数)
如果
我.
交换:
我.
重量.
实现化(
(
我.
输入通道,
我.
输出通道 //
我.
群组,
*我.
核心大小,
)
)
否则:
我.
重量.
实现化(
(
我.
输出通道,
我.
输入通道 //
我.
群组,
*我.
核心大小,
)
)
如果
我.bias
是 not
无:
断言 isinstance(
我.
偏差,
未初始化参数)
我.
偏差.
实现化((
我.
输出通道,))
我.
重置参数()
# 从第一个输入中提取 in_channels 的函数。
def _get_in_channels(我,
输入:
张量) -> int:
空间维度数 =
我.
_获取空间维度数()
不含批次的维度数 =
空间维度数 + 1
频道维度+1
批量维度数 =
无批量的维度数 + 1
如果
输入.
暗淡() not
在 (
无批量的维度数,
批量维度数):
提升
运行时错误(
f预期{
无批量的维度数}
D（未批量化）或{
批量维度数}
批量输入 "D"
f"到"{
我.
类.__name__}
，但 "
f"获取输入大小："{
输入.shape}"
)
返回
输入.shape[1]
如果
输入.
暗淡() == num_dims_batch
否则
输入.shape[0]
函数用于返回模块输入所期望的空间维度数。
这是预期由子类实现。
def 获取空间维度数(
我) -> int:
提升
未实现异常
LazyConv1d 定义权重为 Tensor，但派生类将其定义为 UnitializeParameter
[文档]
类 LazyConv1d(_LazyConvXdMixin,
卷积 1D):
# 类型：忽略[杂项]
r"""一个具有延迟初始化``in_channels``参数的：class:`torch.nn.Conv1d`模块。
`in_channels` 参数的值是从 `input.size(1)` 推断出来的。
将被惰性初始化的属性是 `weight` 和 `bias`。
有关惰性模块及其限制的更多文档，请查看 :class:`torch.nn.modules.lazy.LazyModuleMixin`。
惰性模块及其限制的更多文档，请查看 :class:`torch.nn.modules.lazy.LazyModuleMixin`。
参数：
输出通道（整数）：卷积产生的通道数
核大小（整数或元组）：卷积核的大小
步长（整数或元组，可选）：卷积的步长。默认：1
填充（整数或元组，可选）：在卷积的两侧添加的零填充
输入。默认：0
扩展（整数或元组，可选）：核之间的间隔
元素。默认：1
组（整数，可选）：从输入到输出的阻塞连接数
输出通道到输出通道。默认：1
偏置（布尔值，可选）：如果为 ``True``，则向输出添加可学习的偏置。默认：``True``
填充模式（字符串，可选）：``'zeros'``、``'reflect'``、
填充模式（字符串，可选）：``'zeros'``、``'reflect'``、
``'复制'`` 或 ``'循环'``。默认：``'零'``
.. 参见：:class:`torch.nn.Conv1d` 和 :class:`torch.nn.modules.lazy.LazyModuleMixin`
"源代码"
# 父类将此变量定义为 None。需要 "type: ignore[..]"
# 因为我们正在重新定义此变量。
cls_to_become = Conv1d # 类型：忽略[赋值]
def 初始化(
我,
输出通道: int,
核心大小: _size_1_t,
步长:
_大小_1_t = 1,
填充:
_大小_1_t = 0,
扩展率:
_大小_1_t = 1,
群组:
整型 = 1,
偏差:
布尔类型 = True,
填充模式:
字符串 =
零,
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
超级().
初始化(
0,
0,
核心大小,
步长,
填充,
扩展率,
群组,
# 偏差被硬编码为 False 以避免创建张量
# 将很快被覆盖。
错误,
填充模式,
**工厂参数,
)
我.
权重 =
未初始化参数(**
工厂参数)
我.
输出通道 =
输出通道
如果
偏差:
我.bias =
未初始化参数(**
工厂参数)
def 获取空间维度数(
我) -> int:
返回 1
# LazyConv2d 将权重定义为 Tensor，但派生类将其定义为 UnitializeParameter
[文档]
类 LazyConv2d(_LazyConvXdMixin,
卷积 2D):
# 类型：忽略[杂项]
r具有延迟初始化 ``in_channels`` 参数的 :class:`torch.nn.Conv2d` 模块。
从 ``input.size(1)`` 推断出的 :class:`Conv2d` 的 ``in_channels`` 参数。
将延迟初始化的属性是 `weight` 和 `bias`。
查阅 :class:`torch.nn.modules.lazy.LazyModuleMixin` 获取更多文档信息。
关于懒加载模块及其限制。
参数：
out_channels（整数）：卷积产生的通道数。
kernel_size（整数或元组）：卷积核的大小。
stride（整数或元组，可选）：卷积的步长。默认：1
填充（整数或元组，可选）：添加到输入两边的零填充
默认：0
扩展（整数或元组，可选）：内核元素之间的间距
默认：1
groups（int，可选）：从输入到输出通道的阻塞连接数
channels（通道）到输出通道的数量。默认：1
bias（bool，可选）：如果为 True，则向输出添加可学习的偏置
。默认：True
padding_mode (str, 可选): ``'zeros'``、``'reflect'``、
``'replicate'`` 或 ``'circular'``。默认值：``'zeros'``
.. 参见：:class:`torch.nn.Conv2d` 和 :class:`torch.nn.modules.lazy.LazyModuleMixin`
"源代码"
# 父类将此变量定义为 None。需要 "type: ignore[..]"
由于我们正在重新定义变量。
cls_to_become = Conv2d # 类型：忽略[赋值]
def 初始化(
我,
输出通道: int,
核心大小: _size_2_t,
步长: _size_2_t = 1,
填充: _size_2_t = 0,
扩展率: _size_2_t = 1,
群组:
整型 = 1,
偏差:
布尔类型 = True,
填充模式:
字符串 =
零,
# TODO: 精炼此类型
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
超级().
初始化(
0,
0,
核心大小,
步长,
填充,
扩展率,
群组,
# 偏置被硬编码为 False 以避免创建张量
# 将很快被覆盖。
错误,
填充模式,
**工厂参数,
)
我.
权重 =
未初始化参数(**
工厂参数)
我.
输出通道 =
输出通道
如果
偏差:
我.bias =
未初始化参数(**
工厂参数)
def _get_num_spatial_dims(我) -> int:
返回 2
# LazyConv3d 将权重定义为 Tensor，但派生类将其定义为 UnitializeParameter
[文档]
类 LazyConv3d(_LazyConvXdMixin,
卷积 3D):
# 类型：忽略[杂项]
r具有延迟初始化 ``in_channels`` 参数的 :class:`torch.nn.Conv3d` 模块。
从 ``input.size(1)`` 推断出的 :class:`Conv3d` 的 ``in_channels`` 参数。
将延迟初始化的属性是 `weight` 和 `bias`。
将延迟初始化的属性是 `weight` 和 `bias`。
查看文档 :class:`torch.nn.modules.lazy.LazyModuleMixin` 获取更多说明
关于懒加载模块及其限制。
参数：
out_channels (int): 卷积产生的通道数
kernel_size (int 或 tuple): 卷积核的大小
stride（int 或 tuple，可选）：卷积的步长。默认：1
padding（int 或 tuple，可选）：添加到输入两侧的零填充。默认：0
the input. Default: 0
dilation（int 或 tuple，可选）：内核之间的间距
元素。默认：1
组（int，可选）：输入端阻塞连接的数量
通道到输出通道。默认：1
偏差（布尔值，可选）：如果为 ``True``，则添加一个可学习的偏差
输出。默认：``True``
填充模式（str，可选）：``'zeros'``、``'reflect'``、
``'replicate'`` 或 ``'circular'``。默认：``'zeros'``
.. 参见：:class:`torch.nn.Conv3d` 和 :class:`torch.nn.modules.lazy.LazyModuleMixin`
"源代码"
# 超类定义此变量为 None。"type: ignore[..]是必需的"
# 由于我们正在重新定义该变量。
cls_to_become = Conv3d # 类型：忽略[赋值]
def 初始化(
我,
out_channels: int,
核心大小: _size_3_t,
步长:
_尺寸_3_t = 1,
填充:
_尺寸_3_t = 0,
扩展率:
_尺寸_3_t = 1,
群组:
整型 = 1,
偏差:
布尔类型 = True,
填充模式:
字符串 =
零,
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
超级().
初始化(
0,
0,
核心大小,
步长,
填充,
扩展率,
群组,
# 偏置被硬编码为 False 以避免创建张量
# 将很快被覆盖。
错误,
填充模式,
**工厂参数,
)
我.
权重 =
未初始化参数(**
工厂参数)
我.
输出通道 =
输出通道
如果
偏差:
我.bias =
未初始化参数(**
工厂参数)
def _获取空间维度数(
我) -> int:
返回 3
LazyConvTranspose1d 定义权重为 Tensor，但派生类将其定义为 UnitializeParameter
[文档]
类 LazyConvTranspose1d(_LazyConvXdMixin, ConvTranspose1d):
# 类型：忽略[杂项]
r"""一个具有延迟初始化``in_channels``参数的：class:`torch.nn.ConvTranspose1d`模块。
`in_channels` 参数由推断的 :class:`ConvTranspose1d` 提供。
`input.size(1)`。
将被惰性初始化的属性是 `weight` 和 `bias`。
进一步的文档请查看 :class:`torch.nn.modules.lazy.LazyModuleMixin`。
关于懒加载模块及其限制。
参数：
out_channels（整数）：卷积产生的通道数。
kernel_size（整数或元组）：卷积核的大小。
stride（整数或元组，可选）：卷积的步长。默认：1
填充（int 或 tuple，可选）：``膨胀 * (内核大小 - 1) - 填充``零填充
将被添加到输入的两边。默认：0
输出填充（int 或 tuple，可选）：添加到输出形状一边的额外大小
。默认：0
groups（int，可选）：从输入通道到输出通道的阻塞连接数。默认：1
bias（bool，可选）：如果为 True，则向输出添加可学习的偏置。默认：True
dilation（int 或 tuple，可选）：内核元素之间的间距。默认：1
.. seealso:: :class:`torch.nn.ConvTranspose1d` 和 :class:`torch.nn.modules.lazy.LazyModuleMixin`
"源代码"
# 超类定义此变量为 None。"type: ignore[..]是必需的"
# 由于我们正在重新定义该变量。
cls_to_become = ConvTranspose1d # 类型：忽略[赋值]
def 初始化(
我,
输出通道: int,
核心大小:
_大小_1_t,
步长:
_尺寸_1_t = 1,
填充:
_尺寸_1_t = 0,
输出填充:
_尺寸_1_t = 0,
群组:
整型 = 1,
偏差:
布尔类型 = True,
扩展率: _size_1_t = 1,
填充模式:
字符串 =
零,
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
超级().
初始化(
0,
0,
核心大小,
步长,
填充,
输出填充,
群组,
# 偏置被硬编码为 False 以避免创建张量
# 将很快被覆盖。
错误,
扩展率,
填充模式,
**工厂参数,
)
我.
权重 =
未初始化参数(**
工厂参数)
我.
输出通道 =
输出通道
如果
偏差:
我.bias =
未初始化参数(**
工厂参数)
def 获取空间维度数(
我) -> int:
返回 1
# LazyConvTranspose2d 将权重定义为 Tensor，但派生类将其定义为 UnitializeParameter
[文档]
类 LazyConvTranspose2d(_LazyConvXdMixin, ConvTranspose2d):
# 类型：忽略[杂项]
r具有延迟初始化 ``in_channels`` 参数的 :class:`torch.nn.ConvTranspose2d` 模块。
class:`ConvTranspose2d` 的 ``in_channels`` 参数从 ``input.size(1)`` 中推断。
将延迟初始化的属性是 `weight` 和 `bias`。
将延迟初始化的属性是 `weight` 和 `bias`。
查看文档 :class:`torch.nn.modules.lazy.LazyModuleMixin` 以获取更多说明
关于懒加载模块及其限制。
参数：
输出通道（整数）：卷积产生的通道数
核大小（整数或元组）：卷积核的大小
步长（整数或元组，可选）：卷积的步长。默认：1
填充（整数或元组，可选）：``填充 = 核大小 - 1 - 扩展 * 核大小`` 零填充
将被添加到输入的每个维度的两侧。默认值：0
输出填充（int 或 tuple，可选）：添加到一侧的额外大小
输出形状中每个维度的偏移。默认：0
组（int，可选）：从输入通道到输出通道的阻塞连接数。默认：1
bias (bool, 可选): 如果为 ``True``，则向输出添加可学习的偏置。默认：``True``
dilation (int 或 tuple，可选): 卷积核元素之间的间距。默认：1
.. seealso:: :class:`torch.nn.ConvTranspose2d` 和 :class:`torch.nn.modules.lazy.LazyModuleMixin`
"源代码"
# 父类将此变量定义为 None。 "type: ignore[..] 是必需的
变量重新定义
cls_to_become = ConvTranspose2d # 类型：忽略[赋值]
def 初始化(
我,
输出通道: int,
核心大小: _size_2_t,
步长:
_尺寸_2_t = 1,
填充:
_尺寸_2_t = 0,
输出填充:
_尺寸_2_t = 0,
群组:
整型 = 1,
偏差:
布尔类型 = True,
扩展率:
整型 = 1,
填充模式:
字符串 =
零,
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
超级().
初始化(
0,
0,
核心大小,
步长,
填充,
输出填充,
群组,
# 偏置被硬编码为 False 以避免创建张量
# 将很快被覆盖。
错误,
扩展率,
填充模式,
**工厂参数,
)
我.
权重 =
未初始化参数(**
工厂参数)
我.
输出通道 =
输出通道
如果
偏差:
我.bias =
未初始化参数(**
工厂参数)
def 获取空间维度数(
我) -> int:
返回 2
# LazyConvTranspose3d 将权重定义为 Tensor，但派生类将其定义为 UnitializeParameter
[文档]
类 LazyConvTranspose3d(_LazyConvXdMixin, ConvTranspose3d):
# 类型：忽略[杂项]
r具有延迟初始化 ``in_channels`` 参数的 :class:`torch.nn.ConvTranspose3d` 模块。
class:`ConvTranspose3d` 的 ``in_channels`` 参数从 ``input.size(1)`` 中推断。
将延迟初始化的属性是 `weight` 和 `bias`。
将延迟初始化的属性是 `weight` 和 `bias`。
查看文档 :class:`torch.nn.modules.lazy.LazyModuleMixin` 获取更多说明
关于懒加载模块及其限制。
参数：
out_channels (int): 卷积产生的通道数
kernel_size (int 或 tuple): 卷积核的大小
stride（int 或 tuple，可选）：卷积的步长。默认：1
padding（int 或 tuple，可选）：``dilation * (kernel_size - 1) - padding`` 零填充
将被添加到输入的每个维度的两侧。默认：0
output_padding（int 或 tuple，可选）：添加到一侧的额外大小
输出形状的每个维度的数量。默认值：0
组（int，可选）：从输入通道到输出通道的阻塞连接数。默认值：1
偏置（bool，可选）：如果为 ``True``，则向输出添加可学习的偏置。默认值：``True``
扩展（int 或 tuple，可选）：内核元素之间的间距。默认值：1
.. 参见 :: :class:`torch.nn.ConvTranspose3d` 和 :class:`torch.nn.modules.lazy.LazyModuleMixin`
"源代码"
# 父类将此变量定义为 None。 "type: ignore[..] 是必需的"
# 由于我们正在重新定义此变量。
cls_to_become = ConvTranspose3d # 类型：忽略[赋值]
def 初始化(
我,
输出通道: int,
核心大小: _size_3_t,
步长: _size_3_t = 1,
填充: _size_3_t = 0,
输出填充:
_尺寸_3_t = 0,
群组:
整型 = 1,
偏差:
布尔类型 = True,
扩展率:
_尺寸_3_t = 1,
填充模式:
字符串 =
零,
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
超级().
初始化(
0,
0,
核心大小,
步长,
填充,
输出填充,
群组,
# 偏置被硬编码为 False 以避免创建张量
# 将很快被覆盖。
错误,
扩展率,
填充模式,
**工厂参数,
)
我.
权重 =
未初始化参数(**
工厂参数)
我.
输出通道 =
输出通道
如果
偏差:
我.bias =
未初始化的参数(**
工厂参数)
def 获取空间维度数(
我) -> int:
返回 3
