# mypy: 允许未类型化定义
r“量化卷积模块。”
来自
打字
导入
类变量,
可选
导入
火炬
导入 torch.ao.nn.intrinsic
作为 nni
导入 torch.ao.nn.intrinsic.qat
作为 nniqat
导入 torch.nn
作为
然后
导入 torch.nn.functional
作为 F
来自 torch._ops
导入 ops
来自 torch.nn.common_types
导入
_大小_1_t
来自
torch.nn 模块.utils
导入 _pair, _single, _triple
来自 torch.nn.utils
导入
熔合卷积批量归一化权重
来自
.工具
导入
_量化权重,
加权量化模块
__all__ = [
Conv1d,
Conv2d,
Conv3d,
ConvTranspose1d,
"卷积转置 2D",
"卷积转置 3D",
]
支持的填充 = {
零,
反射}
定义
反向重复填充(
填充:
列表[int]) ->
列表[int
]：
反转填充重复两次:
列表[int] = []
N = 长度(
填充)
为
索引
在
范围(N):
反转填充重复两次.
扩展(
填充[N -
索引 - 1]
为 _
在
范围(2))
返回
反复填充反转两次
类
_卷积 Nd(
加权量化模块):
定义
初始化(
自身,
输入通道,
输出通道,
核心大小,
步长=1,
填充=0,
扩展率=1,
群组=1,
偏置=True,
填充模式=
零,
设备=
无,
数据类型=
无,
):
所有子类都有此签名 - 请参阅 PR #49702s
抛出异常
未实现异常
定义
_初始化(
自身,
输入通道,
输出通道,
核心大小,
步长,
填充,
扩展率,
交换,
输出填充,
群组,
偏置,
填充模式=
零,
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
超级().
初始化()
如果
输入通道 %
组们 != 0:
抛出异常 ValueError(
"输入通道必须能被组数整除")
如果
输出通道 %
组们 != 0:
抛出异常 ValueError(
"通道数必须能被组数整除")
自身.
输入通道 =
输入通道
自身.
输出通道 =
输出通道
自身.
核心大小 =
核心大小
自身.
步长 =
步长
自身.
填充 =
填充
自身.
扩展率 =
扩展率
自身.
交换 =
交换
自身.
输出填充 =
输出填充
自身.
组们 =
组们
如果
填充模式 not
在
支持填充:
抛出异常 ValueError(
f'填充模式'{
填充模式}
不支持量化卷积
)
自身.
填充模式 =
填充模式
初始化为 NCHW。set_weight 将内部转换为 NHWC。
如果
自身.
交换:
权重形状 = [
输入通道,
输出通道 //
自身.
群组]
否则:
权重形状 = [
输出通道,
输入通道 //
自身.
群组]
权重 =
火炬.
_空线性量化(
权重形状 +
列表(
核心大小),
比例=1,
零点=0,
数据类型=
火炬.qint8,
**{k: v 为 k, v
在 factory_kwargs.
项目()
如果 k != "dtype"},
)
偏差浮点数 = (
火炬.
零(
输出通道,
数据类型=
火炬.float,
**{k: v 为 k, v
在 factory_kwargs.
项目()
如果 k != "dtype"},
)
如果
偏差
否则 None
)
自身.
设置权重偏差(
权重,
偏差浮点数)
自身.
缩放 = 1.0
自身.
零点 = 0
定义
设置权重偏差(
自身,
权重,
偏差浮点数):
抛出异常
未实现异常
定义
偏置(
自身):
抛出异常
未实现异常
定义 _weight_bias(
自身):
抛出异常
未实现异常
定义
额外表示(
自身):
s = (
"{输入通道},
{输出通道}
, 核大小=
{核大小}"
", 步长="
步长
，缩放=
{缩放}
, 零点=
{零点}"
)
如果
自身.
填充 != (0,) *
长度(
自身.
填充):
s += ", 填充="
填充"
如果
自身.
扩展率 != (1,) *
长度(
自身.
扩展率):
s += ", 膨胀="
膨胀"
如果
自身.
输出填充 != (0,) *
长度(
自身.
输出填充):
s += ", 输出填充="
{输出填充}"
如果
自身.
组们 != 1:
s += ", 组数="
{分组}"
如果
自身.
偏置()
是
无:
s += ", 偏置=False"
返回 s.
格式(**
自身.
字典)
# ===== 序列化方法 =====
在这里需要特别注意，我们必须将权重拆解成
他们的常规 QTensor 形式以进行序列化。打包的权重不应
该在创建它们的进程之外存在，相反，它们应该从
QTensor 权重派生而来。
# self
# |--- 重量：张量
# |--- 偏置：张量
#
# TODO：当 https://github.com/pytorch/pytorch/pull/32958 被合并时，可能需要更改为这个
# self
# |--- _packed_params：Conv2dPackedParamsBase 或 Conv3dPackedParamsBase
定义
保存到状态字典(
自身,
目的地,
前缀,
保留变量):
超级().
保存到状态字典(
目的地,
前缀,
保留变量)
(w, b) = 自身._weight_bias()
目的地[
前缀 +
权重] = w
目的地[
前缀 +
偏置] = b
目的地[
前缀 +
"缩放"] =
火炬.
张量(
自身.
比例)
目的地[
前缀 +
零点] =
火炬.
张量(
自身.
零点)
@torch.算子.
导出
def __getstate__(自身):
(w, b) = 自身.
_权重偏差()
返回 (
自身.
输入通道,
自身.
输出通道,
自身.
核心大小,
自身.
步长,
自身.
填充,
自身.
扩展率,
自身.
交换,
自身.
输出填充,
自身.
群组,
自身.
填充模式,
w,
b,
自身.
比例,
自身.
零点,
自身.
训练,
)
# ===== 反序列化方法 =====
# 与序列化方法相对应，我们必须将序列化的
# QTensor 权重打包成其压缩格式，以便由 FBGEMM 操作使用。
定义
从状态字典加载(
自身,
state_dict,
前缀,
本地元数据,
严格的,
缺少键,
预期之外的键,
错误信息,
):
自身.
设置权重偏差(state_dict[
前缀 +
权重
] state_dict[
前缀 +
偏置])
state_dict.弹出(
前缀 +
权重)
state_dict.弹出(
前缀 +
偏置)
自身.
缩放 = float(state_dict[
前缀 +
"缩放"])
state_dict.弹出(
前缀 +
"缩放")
自身.
零点 = int(state_dict[
前缀 +
零点])
state_dict.弹出(
前缀 +
零点)
超级().
从状态字典加载(
state_dict,
前缀,
本地元数据,
错误,
缺少键,
预期之外的键,
错误信息,
)
@torch.算子.
导出
定义 __setstate__(
自身,
状态):
自身.
输入通道 =
状态[0]
自身.
输出通道 =
状态[1]
自身.
核心大小 =
状态[2]
自身.
步长 =
状态[3]
自身.
填充 =
状态[4]
自身.
扩展率 =
状态[5]
自身.
交换 =
状态[6]
自身.
输出填充 =
状态[7]
自身.
组们 =
状态[8]
自身.
填充模式 =
状态[9]
自身.
设置权重偏差(
状态[10
]
状态[11])
自身.
缩放 =
状态[12]
自身.
零点 =
状态[13]
自身.
训练 =
状态[14]
定义
深拷贝(
自身,
描述):
创建新实例 =
类型(
自身).__new__(
类型(
自身))
火炬.nn.
模块.
初始化(
创建新实例)
状态 =
自身.__getstate__()
新实例.__setstate__(
状态)
返回
新实例
定义
复制(
自身):
返回
自身.
深拷贝({})
@classmethod
定义
获取 qconv(
类,
模块,
激活后处理,
权重后处理=
无):
r创建一个 qconv 对象并返回它。
如果
权重后处理
是
无:
权重后处理 =
模块.qconfig.
重量()
权重后处理(
模块.
重量)
断言 (
权重后处理.dtype ==
火炬.qint8
), 重量观察器必须具有 qint8 数据类型
权重 = _quantize_weight(
模块.
重量.float(),
权重后处理)
# 使用的是从派生类中调用的 __init__ 调用，而不是从 _ConvNd 中调用的 __init__ 调用
qconv = 类(
模块.
输入通道,
模块.
输出通道,
模块.
核心大小,
模块.
步长,
模块.
填充,
模块.
扩展率,
模块.
群组,
模块.
偏差
是 not
无,
模块.
填充模式,
)
qconv.设置权重偏差(qweight,
模块.
偏置)
如果 (
activation_post_process 是 None
或
激活后处理.dtype ==
火炬.
浮点数
):
返回 qconv
动态量化不需要 scale/zero_point
否则:
act_scale, act_zp = 激活后处理.
计算 q 参数()
qconv.缩放 = float(
活动规模)
量子卷积.
零点 = int(
活动零偏置)
返回
量子卷积
@staticmethod
定义
从浮点数(
类,
模块,
使用预计算的假量化=
错误):
如果
有属性(
模块,
"权重伪量化"):
# assert type(mod) == cls.__QAT_MODULE, " nnq." + cls.__name__ + \
# ".from_float only works for " + cls.__QAT_MODULE.__name__
如果
类型(
模块) ==
类._NNIQAT_CONV_BN_MODULE:
模块.
重量,
模块.
偏差 =
熔合卷积归一化权重(
模块.
重量,
模块.
偏置,
模块.
归一化.
运行平均值,
模块.
归一化.
运行变量,
模块.
孟加拉语.eps,
模块.
孟加拉语.
重量,
模块.
孟加拉语.
偏置,
)
断言
有属性(
模块,
"激活后处理"
), 输入 QAT 模块必须附加观察者
权重后处理 =
模块.weight_fake_quant
activation_post_process = 模块.activation_post_process
否则:
断言
类型(
模块) ==
类._FLOAT_MODULE, (
nnq.
+ 类.__name__
+ ".from_float 仅适用于 "
+ 类._FLOAT_MODULE.__name__
+ 但是得到了：
+ 字符串(
类型(
模块))
)
断言
有属性(
模块, "qconfig"
), "输入浮点模块必须定义 qconfig。"
activation_post_process = (
None
如果 not
有属性(
模块,
激活后处理)
否则
模块.activation_post_process
)
如果
类型(
模块)
在 [
类._NNI_CONV_RELU_MODULE,
类._NNI_CONV_ADD_MODULE,
类.
_NNI 卷积加 ReLU 模块,
]：
修饰 =
模块[0]
权重后处理 =
模块.qconfig.
重量()
返回
类.
获取 q 卷积(
模块,
激活后处理,
权重后处理)
@classmethod
定义
从参考(
类,
ref_q 卷积,
输出尺度,
输出零点):
r创建一个从参考量化模块的量化模块（fbgemm/qnnpack）
参数：
ref_qconv（模块）：一个引用量化模块，由 torch.ao.quantization 产生
工具或由用户提供的
输出尺度（浮点数）：输出张量的尺度
输出零点（int）：输出张量的零点
```python
# 假设输入文本为：
input_text = '"""'
# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
# 这里应该调用真实的翻译 API 进行翻译
# 由于示例中不使用真实的 API，以下为模拟翻译结果
return text
# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
qconv = 类(
ref_qconv.输入通道,
ref_qconv.输出通道,
引用_qconv.
核心大小, # type: ignore[arg-type]
引用_qconv.
步长, # type: ignore[arg-type]
引用_qconv.
填充, # type: ignore[arg-type]
引用_qconv.
扩展率, # type: ignore[arg-type]
参考 qconv.
群组,
引用_qconv.
偏差
是 not
无, # type: ignore[arg-type]
引用_qconv.
填充模式,
设备=
引用_qconv.
重量.
设备,
数据类型=
引用_qconv.
重量.
数据类型,
)
权重 =
参考 q 卷积.
获取量化权重()
q 卷积.
设置权重偏差(
q 权重,
ref_q 卷积.
偏置)
q 卷积.
缩放 = float(
输出尺度)
qconv.零点 = int(
输出零点)
返回 qconv
[文档]
类
卷积 1D(
_卷积 Nd):
r对由多个量化输入平面组成的量化输入信号应用 1D 卷积。
。
关于输入参数、参数和实现的详细信息，请参阅
`torch.nn.Conv1d` 类。
.. 注意::
仅支持 `zeros` 作为 `padding_mode` 参数。
.. 注意::
输入数据类型仅支持 `torch.quint8`。
属性：
weight（张量）：从可学习的权重派生出的打包张量
参数。
scale（张量）：输出缩放比例的标量
zero_point（张量）：输出零点的标量
请参阅：class:`~torch.nn.Conv1d` 了解其他属性。
示例：
>>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_QENGINE)
>>> m = nn.quantized.Conv1d(16, 33, 3, stride=2)
>>> input = torch.randn(20, 16, 100)
>>> # 将输入量化为 quint8
>>> # xdoctest: +SKIP
>>> q_input = torch.quantize_per_tensor(input, scale=1.0, zero_point=0,
... dtype=torch.quint8)
>>> output = m(q_input)
```python
# 假设输入文本为：
input_text = '"""'
# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
# 这里应该调用真实的翻译 API 进行翻译
# 由于示例中不使用真实的 API，以下为模拟翻译结果
return text
# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
_FLOAT_MODULE: 类变量[
类型[nn.
卷积 1D]] = nn.Conv1d
_NNIQAT_CONV_BN_MODULE: 类变量[
可选[
类型[nn.
模块]]] = nniqat.ConvBn1d
_NNI 卷积 ReLU 模块:
类变量[
可选[
类型[nn.
模块]]] = nni.ConvReLU1d
_NNI 卷积加模块:
类变量[
可选[
类型[nn.
模块]]] = None
_NNI_CONV_ADD_RELU 模块:
类变量[
可选[
类型[nn.
模块]]] = None
定义
初始化(
自身,
输入通道: int,
输出通道: int,
核心大小: _size_1_t,
步长:
_大小_1_t = 1,
填充:
_大小_1_t = 0,
扩展率:
_大小_1_t = 1,
群组:
整型 = 1,
偏置:
布尔类型 = True,
填充模式:
字符串 =
零,
设备=
无,
数据类型=
无,
):
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
核心大小 = _single(
核心大小)
步长 = _single(
步长)
填充 =
填充
如果 isinstance(
填充,
字符串)
否则 _single(
填充)
扩展率 = _single(
扩展率)
# _ConvNd 的子类需要调用_init 而不是__init__。参见
# PR #49702 的讨论
超级().
_初始化(
输入通道,
输出通道,
核心大小,
步长,
填充,
扩展率,
错误,
_single(0),
群组,
偏置,
填充模式,
**factory_kwargs,
)
定义
_获取名称(
自身):
返回
"量化卷积 1D"
定义
设置权重偏差(
自身, w:
火炬.
张量, b:
可选[
火炬.
张量]) ->
无:
如果
自身.
填充模式 ==
零:
自身._packed_params =
火炬.
操作.
量化.
conv1d 预打包(
w, b, 自身.
步长,
自身.
填充,
自身.
扩展率,
自身.
组们
)
否则:
自身._packed_params =
火炬.
操作.
量化.
conv1d 预打包(
w, b, 自身.
步长, _pair(0),
自身.
扩展率,
自身.
组们
)
定义
_权重偏置(
自身):
w, b = 火炬.
操作.
量化.conv1d_unpack(
自身._packed_params)
返回 w, b
定义
重量(
自身):
返回
自身.
_权重偏置()[0]
定义
偏置(
自身):
返回
自身.
_权重偏置()[1]
定义
前向(
自身,
输入):
由于 JIT 问题，暂时使用 len(shape)代替 ndim
https://github.com/pytorch/pytorch/issues/23890
如果
长度(
输入.shape) != 3:
抛出异常 ValueError(
"输入形状必须是 `(N, C, L)`！")
如果
自身.
填充模式 !=
零:
Conv1d 中的填充以(p, p)的形式存储，需要获取(p,)
反复填充反转两次 = _reverse_repeat_padding(
自身.
填充
[1])
输入 = F.
填充(
输入,
反转填充重复两次,
模式=
自身.
填充模式
)
返回
操作.
量化.
卷积 1D(
输入,
自身._packed_params,
自身.
比例,
自身.
零点
)
[文档] @类方法
def from_float(cls, mod, use_precomputed_fake_quant=False):
r"""从浮点模块或 qparams_dict 创建量化模块。"""
Args:
mod (模块): 一个浮点模块，可以是 torch.ao.quantization
utilities 生成的，或者由用户提供的
"""
return _ConvNd.from_float(
cls, mod, use_precomputed_fake_quant=use_precomputed_fake_quant
)
[文档]
类
卷积 2D(
_卷积 Nd):
r应用 2D 卷积于由量化输入信号组成的
几个量化输入平面。
有关输入参数、参数和实现的详细信息，请参阅
`torch.nn.Conv2d` 类。
.. 注意::
仅支持 `zeros` 作为 `padding_mode` 参数。
.. 注意::
仅支持输入数据类型为 `torch.quint8`。
属性：
weight (张量)：从可学习权重派生出的打包张量
参数。
scale (张量)：输出缩放比例的标量
zero_point (Tensor)：输出零点的标量
请参阅 :class:`~torch.nn.Conv2d` 了解其他属性。
示例：
>>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_QENGINE)
>>> # 使用方形核和相等步长
>>> m = nn.quantized.Conv2d(16, 33, 3, stride=2)
>>> # 非方形核、不等步长和填充
>>> m = nn.quantized.Conv2d(16, 33, (3, 5), stride=(2, 1), padding=(4, 2))
>>> # 非正方形核、不等步长、带填充和膨胀
>>> m = nn.quantized.Conv2d(16, 33, (3, 5), stride=(2, 1), padding=(4, 2), dilation=(3, 1))
>>> input = torch.randn(20, 16, 50, 100)
>>> # 将输入量化为 quint8
>>> # xdoctest: +SKIP
>>> q_input = torch.quantize_per_tensor(input, scale=1.0, zero_point=0, dtype=torch.quint8)
>>> output = m(q_input)
```python
# 假设输入文本为：
input_text = '"""'
# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
# 这里应该调用真实的翻译 API 进行翻译
# 由于示例中不使用真实的 API，以下为模拟翻译结果
return text
# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
_FLOAT_MODULE: 类变量[
类型[nn.
卷积 2D]] = nn.Conv2d
_NNIQAT_CONV_BN_MODULE: 类变量[
可选[
类型[nn.
模块]]] = nniqat.ConvBn2d
_NNI_CONV_RELU_MODULE: 类变量[
可选[
类型[nn.
模块]]] = nni.ConvReLU2d
_NNI 卷积加模块:
类变量[
类型[nni.ConvAdd2d]] = nni.ConvAdd2d
_NNI 卷积加 ReLU 模块:
类变量[
类型[nni.ConvAddReLU2d]] = nni.ConvAddReLU2d
定义
初始化(
自身,
输入通道,
输出通道,
核心大小,
步长=1,
填充=0,
扩展率=1,
群组=1,
偏置=True,
填充模式=
零,
设备=
无,
数据类型=
无,
):
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
核心大小 = _pair(
核心大小)
步长 = _pair(
步长)
填充 = _pair(
填充)
扩展率 = _pair(
扩展率)
# _ConvNd 的子类需要调用_init 而不是__init__。参见
# PR #49702 的讨论
超级().
_初始化(
输入通道,
输出通道,
核心大小,
步长,
填充,
扩展率,
错误,
_pair(0),
群组,
偏置,
填充模式,
**factory_kwargs,
)
定义
_获取名称(
自身):
返回
"量化卷积 2D"
定义
设置权重偏差(
自身, w:
火炬.
张量, b:
可选[
火炬.
张量]) ->
无:
如果
自身.
填充模式 ==
零:
自身.
_打包参数 =
火炬.
操作.
量化.conv2d_prepack(
w, b, 自身.
步长,
自身.
填充,
自身.
扩展率,
自身.
组们
)
否则:
自身.
_打包参数 =
火炬.
操作.
量化.conv2d_prepack(
w, b, 自身.
步长, _pair(0),
自身.
扩展率,
自身.
组们
)
定义
_权重偏置(
自身):
返回
自身._packed_params.
解包()
定义
重量(
自身):
返回
自身.
_权重偏置()[0]
定义
偏置(
自身):
返回
自身.
_权重偏置()[1]
定义
前向(
自身,
输入):
由于 JIT 问题，暂时使用 len(shape)代替 ndim
# https://github.com/pytorch/pytorch/issues/23890
如果
长度(
输入.shape) != 4:
抛出异常 ValueError(
"输入形状必须是 `(N, C, H, W)`！")
如果
自身.
填充模式 !=
零:
反复填充反转两次 = _reverse_repeat_padding(
自身.
填充)
输入 = F.
填充(
输入,
反转填充重复两次,
模式=
自身.
填充模式
)
返回
操作.
量化.
卷积 2D(
输入,
自身._packed_params,
自身.
比例,
自身.
零点
)
[文档] @类方法
def from_float(cls, mod, use_precomputed_fake_quant=False):
r"""从浮点模块或 qparams_dict 创建量化模块。"""
Args:
mod (模块): 一个浮点模块，可以是 torch.ao.quantization
utilities 生成的，或者由用户提供的
"""
return _ConvNd.from_float(
cls, mod, use_precomputed_fake_quant=use_precomputed_fake_quant
)
[文档]
类
卷积 3D(
_卷积 Nd):
r应用在量化输入信号上的 3D 卷积
几个量化输入平面。
有关输入参数、参数和实现的详细信息，请参阅
`torch.nn.Conv3d` 类。
.. 注意::
仅支持 `zeros` 作为 `padding_mode` 参数。
.. 注意::
仅支持输入数据类型为 `torch.quint8`。
属性：
weight (张量)：从可学习权重派生出的打包张量
参数。
scale (张量)：输出缩放比例的标量
zero_point (Tensor)：输出零点的标量
请参阅 :class:`~torch.nn.Conv3d` 了解其他属性。
示例：
>>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_QENGINE)
>>> # 使用方形核和相等步长
>>> m = nn.quantized.Conv3d(16, 33, 3, stride=2)
>>> # 非方形核、不等步长和填充
>>> m = nn.quantized.Conv3d(16, 33, (3, 5, 5), stride=(1, 2, 2), padding=(1, 2, 2))
>>> # 非正方形核、不等步长、带填充和膨胀
>>> m = nn.quantized.Conv3d(16, 33, (3, 5, 5), stride=(1, 2, 2), padding=(1, 2, 2), dilation=(1, 2, 2))
>>> input = torch.randn(20, 16, 56, 56, 56)
>>> # quantize input to quint8
>>> # xdoctest: +SKIP
>>> q_input = torch.quantize_per_tensor(input, scale=1.0, zero_point=0, dtype=torch.quint8)
>>> output = m(q_input)
```python
# 假设输入文本为：
input_text = '"""'
# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
# 这里应该调用真实的翻译 API 进行翻译
# 由于示例中不使用真实的 API，以下为模拟翻译结果
return text
# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
_FLOAT_MODULE: 类变量[
类型[nn.
卷积 3D]] = nn.Conv3d
_NNIQAT_CONV_BN_MODULE: 类变量[
可选[
类型[nn.
模块]]] = nniqat.ConvBn3d
_NNI_CONV_RELU_MODULE: 类变量[
可选[
类型[nn.
模块]]] = nni.ConvReLU3d
_NNI_CONV_ADD_MODULE: 类变量[
可选[
类型[nn.
模块]]] = None
_NNI_CONV_ADD_RELU_MODULE: 类变量[
可选[
类型[nn.
模块]]] = None
定义
初始化(
自身,
输入通道,
输出通道,
核心大小,
步长=1,
填充=0,
扩展率=1,
群组=1,
偏置=True,
填充模式=
零,
设备=
无,
数据类型=
无,
):
断言
填充模式 !=
反射,
"Conv3d 不支持反射填充"
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
核心大小 =
_三倍_(
核心大小)
步长 =
_三倍_(
步长)
填充 =
_三倍_(
填充)
扩展率 =
_三倍_(
扩展率)
# _ConvNd 的子类需要调用_init 而不是__init__。参见
# PR #49702 的讨论
超级().
_初始化(
输入通道,
输出通道,
核心大小,
步长,
填充,
扩展率,
错误,
_三倍_(0),
群组,
偏置,
填充模式,
**factory_kwargs,
)
定义
_获取名称(
自身):
返回
"量化卷积 3D"
定义
设置权重偏差(
自身, w:
火炬.
张量, b:
可选[
火炬.
张量]) ->
无:
如果
自身.
填充模式 ==
零:
自身._packed_params =
火炬.
操作.
量化.conv3d_prepack(
w, b, 自身.
步长,
自身.
填充,
自身.
扩展率,
自身.
组们
)
否则:
自身._packed_params =
火炬.
操作.
量化.conv3d_prepack(
w, b, 自身.
步长,
_三倍_(0),
自身.
扩展率,
自身.
组们
)
定义
_权重偏置(
自身):
返回
自身.
_打包参数.
解包()
定义
重量(
自身):
返回
自身.
_权重偏置()[0]
定义
偏置(
自身):
返回
自身.
_权重偏置()[1]
定义
前向(
自身,
输入):
由于 JIT 问题，暂时使用 len(shape)代替 ndim
https://github.com/pytorch/pytorch/issues/23890
如果
长度(
输入.shape) != 5:
抛出异常 ValueError(
"输入形状必须是`(N, C, D, H, W)`！")
如果
自身.
填充模式 !=
零:
反复填充反转两次 =
反转重复填充(
自身.
填充)
输入 = F.
填充(
输入,
反转填充重复两次,
模式=
自身.
填充模式
)
返回
操作.
量化.
卷积 3D(
输入,
自身.
_打包参数,
自身.
比例,
自身.
零点
)
[文档] @classmethod
def from_float(cls, mod, use_precomputed_fake_quant=False):
r"""从浮点模块或 qparams_dict 创建量化模块。
Args:
模（模块）：一个浮点模块，由 torch.ao.quantization 产生
工具或由用户提供的
```python
# 输入文本
input_text = '"""'
# 翻译函数（此处为示例，实际翻译功能需调用真实的翻译 API）
def translate_to_simplified_chinese(text):
# 假设的翻译结果
return text
# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
返回 _ConvNd.from_float(
cls, mod, 使用预计算的假量化=使用预计算的假量化
)
# === 转置卷积 ===
类
_卷积转置算子(
_卷积 Nd):
_FLOAT_MODULE: 类变量[
类型[nn.
模块.conv.
_卷积 Nd]]
定义
初始化(
自身,
输入通道,
输出通道,
核心大小,
步长,
填充,
扩展率,
交换,
输出填充,
群组,
偏置,
填充模式,
设备=
无,
数据类型=
无,
):
如果
填充模式 !=
零:
抛出异常 ValueError(
f仅支持 "zeros" 填充模式{
自身.
类.__name__}'
)
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
# _ConvNd 的子类需要调用_init 而不是__init__。参见
# PR #49702 的讨论
超级().
_初始化(
输入通道,
输出通道,
核心大小,
步长,
填充,
扩展率,
交换,
输出填充,
群组,
偏置,
填充模式,
**factory_kwargs,
)
定义
_输入填充(
自身,
核心大小:
列表[int
]
扩展率:
列表[int
]
填充:
列表[int]
) -> 列表[int
]：
res = 火炬.
算子.
标注(
列表[int
]
[]
为 kdx
在
范围(
长度(
核心大小)):
填充 =
扩展率[
可达] * (
核心大小[
可达] - 1) -
填充[kdx]
资源.
追加(
填充)
返回 res
@classmethod
定义
从浮点数(
类,
模块,
使用预计算的假量化=
错误):
r从浮点模块或 qparams_dict 创建一个量化模块。
参数：
mod (模块)：一个浮点模块，可以是 torch.ao.quantization
utilities 生成的，或者由用户提供的。
mod (模块)：一个浮点模块，可以是 torch.ao.quantization
utilities 生成的，或者由用户提供的。
```python
# 假设输入文本为：
input_text = '"""'
# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
# 这里应该调用真实的翻译 API 进行翻译
# 由于示例中不使用真实的 API，以下为模拟翻译结果
return text
# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
派生类必须覆盖 cls._FLOAT_MODULE 属性
msg = (
" nnq."
+ 类.__name__
+ ".from_float 仅适用于 "
+ 类._FLOAT_MODULE.__name__
# 类型: 忽略[attr-defined]
)
断言
类型(
模块) ==
类._FLOAT_MODULE, msg
断言
有属性(
模块,
qconfig),
"输入浮点模块必须定义 qconfig。"
权重后处理 =
模块.qconfig.
重量()
# 类型：忽略[运算符，联合属性]
权重后处理(
模块.
重量)
断言 (
权重后处理.dtype ==
火炬.qint8
), 权重观察者必须具有 qint8 数据类型
权重 =
量化权重(
模块.
重量.float(),
权重后处理)
从派生类中使用的 __init__ 调用，而不是从 _ConvTransposeNd 中使用的调用
qconv = 类(
模块.
输入通道,
模块.
输出通道,
模块.
核心大小,
忽略调用参数
模块.
步长,
模块.
填充,
模块.
输出填充,
模块.
群组,
模块.
偏差
是 not
无,
模块.
扩展率,
模块.
填充模式,
)
qconv.设置权重和偏置(qweight,
模块.
偏置)
如果 (
not 有属性(
模块,
激活后处理)
或
模块.
激活后处理.dtype ==
火炬.
浮点数
):
返回 qconv
动态量化不需要 scale/zero_point
否则:
act_scale, act_zp = 模块.
激活后处理.
计算 q 参数()
# 类型：忽略[运算符，联合属性]
qconv.缩放 = float(act_scale)
qconv.零点 = int(
活动零偏置)
返回 qconv
@staticmethod
定义
来自参考(
类, ref_qconvt,
输出尺度,
输出零点):
r从参考量化模块创建一个（fbgemm/qnnpack）量化模块
参数：
ref_qconvt（模块）：一个参考量化模块，可以是 torch.ao.quantization
utilities 生成的，也可以是由用户提供的
utilities 或由用户提供的
输出尺度（浮点数）：输出张量的尺度
输出零点（整数）：输出张量的零点
```python
# 假设输入文本为：
input_text = '"""'
# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
# 这里应该调用真实的翻译 API 进行翻译
# 由于示例中不使用真实的 API，以下为模拟翻译结果
return text
# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
qconv = 类(
ref_qconvt.输入通道,
ref_qconvt.输出通道,
ref_qconvt.核心大小, # type: ignore[arg-type]
ref_qconvt.步长, # type: ignore[arg-type]
ref_qconvt.填充, # type: ignore[arg-type]
ref_qconvt.输出填充, # type: ignore[arg-type]
ref_qconvt.群组,
ref_qconvt.偏差
是 not
无, # type: ignore[arg-type]
ref_qconvt.扩展率, # type: ignore[arg-type]
ref_qconvt.填充模式,
设备=ref_qconvt.
重量.
设备,
数据类型=ref_qconvt.
重量.
数据类型,
)
权重 =
引用量化转换.
获取量化权重()
qconv.设置权重偏差(qweight,
引用量化转换.
偏置)
qconv.缩放 = float(
输出尺度)
qconv.零点 = int(
输出零点)
返回 qconv
[文档]
类 ConvTranspose1d(
_卷积转置算子):
r对输入图像应用 1D 转置卷积算子
由几个输入平面组成。
关于输入参数、参数和实现的详细信息，请参阅
class:`~torch.nn.ConvTranspose1d`。
.. note:: 目前仅实现了 QNNPACK 引擎。
请设置 `torch.backends.quantized.engine = 'qnnpack'`。
对于特殊说明，请参阅：:class:`~torch.ao.nn.quantized.Conv1d`
属性：
weight（张量）：从可学习参数派生出的打包张量
参数。
scale（张量）：输出缩放比例的标量
零点（Tensor）：输出零点的标量
请参阅：class:`~torch.nn.ConvTranspose2d` 了解其他属性。
示例：
>>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_QENGINE)
>>> torch.backends.quantized.engine = 'qnnpack'
>>> 从 torch.ao.nn 导入 quantized 作为 nnq
>>> # 使用方形核和相等步长
>>> m = nnq.ConvTranspose1d(16, 33, 3, stride=2)
>>> # 非方形核、不等步长和填充
>>> m = nnq.ConvTranspose1d(16, 33, (3, 5), stride=(2, 1), padding=(4, 2))
>>> input = torch.randn(20, 16, 50)
>>> q_input = torch.quantize_per_tensor(input, scale=1.0, zero_point=0, dtype=torch.quint8)
>>> output = m(q_input)
>>> # 精确输出大小也可以作为参数指定
>>> input = torch.randn(1, 16, 12)
>>> q_input = torch.quantize_per_tensor(input, scale=1.0, zero_point=0, dtype=torch.quint8)
>>> downsample = nnq.Conv1d(16, 16, 3, stride=2, padding=1)
>>> upsample = nnq.ConvTranspose1d(16, 16, 3, stride=2, padding=1)
>>> h = downsample(q_input)
>>> h.size()
torch.Size([1, 16, 6])
>>> # xdoctest: +SKIP("FIXME: output_size 不是参数)
>>> output = upsample(h, output_size=input.size())
>>> output.size()
torch.Size([1, 16, 12])
```python
# 假设输入文本为：
input_text = '"""'
# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
# 这里应该调用真实的翻译 API 进行翻译
# 由于示例中不使用真实的 API，以下为模拟翻译结果
return text
# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
_FLOAT_MODULE: 类变量[
类型[nn.ConvTranspose1d]] = nn.ConvTranspose1d
定义
初始化(
自身,
输入通道,
输出通道,
核心大小,
步长=1,
填充=0,
输出填充=0,
群组=1,
偏置=True,
扩展率=1,
填充模式=
零,
设备=
无,
数据类型=
无,
):
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
核心大小 = _single(
核心大小)
步长 = _single(
步长)
填充 = _single(
填充)
扩展率 = _single(
扩展率)
输出填充 = _single(
输出填充)
超级().
初始化(
输入通道,
输出通道,
核心大小,
步长,
填充,
扩展率,
True,
输出填充,
群组,
偏置,
填充模式,
**factory_kwargs,
)
定义
_获取名称(
自身):
返回
"量化卷积转置 1D"
定义
设置权重偏差(
自身, w:
火炬.
张量, b:
可选[
火炬.
张量]) ->
无:
自身._packed_params =
火炬.
操作.
量化.
卷积转置 1D 预打包(
w,
b,
自身.
步长,
自身.
填充,
自身.
输出填充,
自身.
扩展率,
自身.
群组,
)
定义 _weight_bias(
自身):
w, b = 火炬.
操作.
量化.
卷积转置 1D 解包(
自身.
_打包参数)
返回 w, b
定义
重量(
自身):
(w, _) = 自身._weight_bias()
返回 w
定义
偏置(
自身):
(_, b) = 自身._weight_bias()
返回 b
定义
前向(
自身,
输入):
由于 JIT 问题，暂时使用 len(shape)代替 ndim
https://github.com/pytorch/pytorch/issues/23890
如果
长度(
输入.shape) != 3:
抛出异常 ValueError(
"输入形状必须是 `(N, C, L)`！")
返回
火炬.
操作.
量化.
卷积转置 1D(
输入,
自身.
_打包参数,
自身.
比例,
自身.
零点
)
@classmethod
定义
从参考(
类, ref_qconvt,
输出尺度,
输出零点):
返回
_卷积转置算子.
从参考(
类, ref_qconvt,
输出尺度,
输出零点
)
[文档]
类 ConvTranspose2d(
_卷积转置算子):
r应用 2D 转置卷积算子到输入图像上
由几个输入平面组成。
关于输入参数、参数和实现的详细信息，请参阅
class:`~torch.nn.ConvTranspose2d`。
对于特殊说明，请参阅 :class:`~torch.ao.nn.quantized.Conv2d`
属性：
weight (Tensor)：从可学习权重派生出的打包张量
参数。
scale (Tensor)：输出缩放值的标量
zero_point (Tensor)：输出零点的标量
请参阅 :class:`~torch.nn.ConvTranspose2d` 了解其他属性。
示例：
>>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_QENGINE)
>>> # QNNPACK 或 FBGEMM 作为后端
>>> torch.backends.quantized.engine = 'qnnpack'
>>> # 使用方形核和相等步长
>>> 导入 torch.ao.nn.quantized as nnq
>>> m = nnq.ConvTranspose2d(16, 33, 3, stride=2)
>>> # 非方形核、不等步长和填充
>>> m = nnq.ConvTranspose2d(16, 33, (3, 5), stride=(2, 1), padding=(4, 2))
>>> input = torch.randn(20, 16, 50, 100)
>>> q_input = torch.quantize_per_tensor(input, scale=1.0, zero_point=0, dtype=torch.quint8)
>>> output = m(q_input)
>>> # 精确输出大小也可以作为参数指定
>>> input = torch.randn(1, 16, 12, 12)
>>> q_input = torch.quantize_per_tensor(input, scale=1.0, zero_point=0, dtype=torch.quint8)
>>> downsample = nnq.Conv2d(16, 16, 3, stride=2, padding=1)
>>> upsample = nnq.ConvTranspose2d(16, 16, 3, stride=2, padding=1)
>>> h = downsample(q_input)
>>> h.size()
torch.Size([1, 16, 6, 6])
>>> # xdoctest: +SKIP("FIXME: output_size is not a parameter)
>>> output = upsample(h, output_size=input.size())
>>> output.size()
torch.Size([1, 16, 12, 12])
```python
# 假设输入文本为：
input_text = '"""'
# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
# 这里应该调用真实的翻译 API 进行翻译
# 由于示例中不使用真实的 API，以下为模拟翻译结果
return text
# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
_FLOAT_MODULE: 类变量[
类型[nn.ConvTranspose2d]] = nn.ConvTranspose2d
定义
初始化(
自身,
输入通道,
输出通道,
核心大小,
步长=1,
填充=0,
输出填充=0,
群组=1,
偏置=True,
扩展率=1,
填充模式=
零,
设备=
无,
数据类型=
无,
):
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
核心大小 = _pair(
核心大小)
步长 = _pair(
步长)
填充 = _pair(
填充)
扩展率 = _pair(
扩展率)
输出填充 = _pair(
输出填充)
超级().
初始化(
输入通道,
输出通道,
核心大小,
步长,
填充,
扩展率,
True,
输出填充,
群组,
偏置,
填充模式,
**factory_kwargs,
)
定义
_获取名称(
自身):
返回
"量化卷积转置 2D"
定义
设置权重偏差(
自身, w:
火炬.
张量, b:
可选[
火炬.
张量]) ->
无:
自身.
_打包参数 =
火炬.
操作.
量化.
卷积转置 2D 预打包(
w,
b,
自身.
步长,
自身.
填充,
自身.
输出填充,
自身.
扩展率,
自身.
群组,
)
定义 _weight_bias(
自身):
w, b = 火炬.
操作.
量化.conv2d_unpack(
自身.
_打包参数)
返回 w, b
定义
重量(
自身):
(w, _) = 自身._weight_bias()
返回 w
定义
偏置(
自身):
(_, b) = 自身._weight_bias()
返回 b
定义
前向(
自身,
输入):
由于 JIT 问题，暂时使用 len(shape)代替 ndim
https://github.com/pytorch/pytorch/issues/23890
如果
长度(
输入.shape) != 4:
抛出异常 ValueError(
"输入形状必须是 `(N, C, H, W)`！")
返回
操作.
量化.
转置卷积 2D(
输入,
自身.
_打包参数,
自身.
比例,
自身.
零点
)
@classmethod
定义
从参考(
类, ref_qconvt,
输出尺度,
输出零点):
返回
_卷积转置算子.
从参考(
类, ref_qconvt,
输出尺度, output_zero_point
)
[文档]
类 ConvTranspose3d(
_卷积转置算子):
r对输入图像应用 3D 转置卷积算子
由几个输入平面组成。
关于输入参数、参数和实现的详细信息，请参阅
`torch.nn.ConvTranspose3d` 类。
目前仅实现了 FBGEMM 引擎。
请设置 `torch.backends.quantized.engine = 'fbgemm'`。
对于特殊说明，请参阅 :class:`~torch.ao.nn.quantized.Conv3d`。
属性：
weight (Tensor)：从可学习权重派生出的打包张量。
参数。
scale (Tensor)：输出缩放值的标量
zero_point (Tensor)：输出零点的标量
请参阅 :class:`~torch.nn.ConvTranspose3d` 了解其他属性。
示例：
>>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_QENGINE)
>>> torch.backends.quantized.engine = 'fbgemm'
>>> from torch.ao.nn import quantized as nnq
>>> # 使用立方核和等距步长
>>> m = nnq.ConvTranspose3d(16, 33, 3, stride=2)
>>> # 非立方核、不等步长和填充
>>> m = nnq.ConvTranspose3d(16, 33, (3, 3, 5), stride=(2, 1, 1), padding=(4, 2, 2))
>>> input = torch.randn(20, 16, 50, 100, 100)
>>> q_input = torch.quantize_per_tensor(input, scale=1.0, zero_point=0, dtype=torch.quint8)
>>> output = m(q_input)
>>> # 精确输出大小也可以作为参数指定
>>> input = torch.randn(1, 16, 12, 12, 12)
>>> q_input = torch.quantize_per_tensor(input, scale=1.0, zero_point=0, dtype=torch.quint8)
>>> downsample = nnq.Conv3d(16, 16, 3, stride=2, padding=1)
>>> upsample = nnq.ConvTranspose3d(16, 16, 3, stride=2, padding=1)
>>> h = downsample(q_input)
>>> h.size()
torch.Size([1, 16, 6, 6, 6])
>>> # xdoctest: +SKIP("FIXME: output_size is not a parameter)
>>> output = upsample(h, output_size=input.size())
>>> output.size()
torch.Size([1, 16, 12, 12, 12])
```python
# 假设输入文本为：
input_text = '"""'
# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
# 这里应该调用真实的翻译 API 进行翻译
# 由于示例中不使用真实的 API，以下为模拟翻译结果
return text
# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
_FLOAT_MODULE: 类变量[
类型[nn.ConvTranspose3d]] = nn.ConvTranspose3d
定义
初始化(
自身,
输入通道,
输出通道,
核心大小,
步长=1,
填充=0,
输出填充=0,
群组=1,
偏置=True,
扩展率=1,
填充模式=
零,
设备=
无,
数据类型=
无,
):
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
核心大小 =
_三倍_(
核心大小)
步长 =
_三倍_(
步长)
填充 =
_三倍_(
填充)
扩展率 =
_三倍_(
扩展率)
输出填充 =
_三倍_(
输出填充)
超级().
初始化(
输入通道,
输出通道,
核心大小,
步长,
填充,
扩展率,
True,
输出填充,
群组,
偏置,
填充模式,
**factory_kwargs,
)
定义
_获取名称(
自身):
返回
量化卷积转置 3D
定义
设置权重偏差(
自身, w:
火炬.
张量, b:
可选[
火炬.
张量]) ->
无:
自身.
_打包参数 =
火炬.
操作.
量化.conv_transpose3d_prepack(
w,
b,
自身.
步长,
自身.
填充,
自身.
输出填充,
自身.
扩展率,
自身.
群组,
)
定义 _weight_bias(
自身):
w, b = 火炬.
操作.
量化.conv3d_unpack(
自身.
_打包参数)
返回 w, b
定义
重量(
自身):
(w, _) = 自身._weight_bias()
返回 w
定义
偏置(
自身):
(_, b) = 自身._weight_bias()
返回 b
定义
前向(
自身,
输入):
由于 JIT 问题，暂时使用 len(shape)代替 ndim
https://github.com/pytorch/pytorch/issues/23890
如果
长度(
输入.shape) != 5:
抛出异常 ValueError(
输入形状必须是 `(N, C, T, H, W)`!)
返回
操作.
量化.
3D 转置卷积(
输入,
自身.
_打包参数,
自身.
比例,
自身.
零点
)
@classmethod
定义
从参考(
类, ref_qconvt,
输出尺度,
输出零点):
返回
_卷积转置算子.
从参考(
类, ref_qconvt,
输出尺度,
输出零点
)
