# mypy: 允许未类型化定义
来自
打字
导入
类变量,
联合
导入
火炬
导入 torch.nn
作为
然后
来自 torch.ao.nn.intrinsic
导入 _FusedModule
来自 torch.nn.common_types
导入 _size_1_t, _size_2_t,
_尺寸_3_t
来自
torch.nn 模块.utils
导入 _pair, _single, _triple
__all__ = [Conv1d,
Conv2d,
Conv3d]
类
_卷积 Nd(nn.
模块.
沟通.
_卷积 Nd):
_FLOAT_MODULE: 类变量[
类型[nn.
模块.
沟通.
_卷积 Nd]]
def 初始化(
自身,
输入通道: int,
输出通道: int,
核心大小:
元组[int, ...
]
步长:
元组[int, ...
]
填充:
联盟[
字符串,
元组[int, ...]],
扩展率:
元组[int, ...
]
交换:
布尔,
输出填充:
元组[int, ...
]
群组: int,
偏差:
布尔,
填充模式:
字符串,
qconfig=无,
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
nn.模块.
沟通.
_卷积 Nd.
初始化(
自身,
输入通道,
输出通道,
核心大小,
步长,
填充,
扩展率,
交换,
输出填充,
群组,
偏差,
填充模式,
**工厂参数,
)
断言 qconfig,
QAT 模块必须提供 qconfig
自身.qconfig = qconfig
自身.
权重伪量化 = qconfig.
重量(
工厂参数=
工厂参数)
def 前向(
自身,
输入):
返回
自身.
_卷积前向(
输入,
自身.
权重伪量化(
自身.
重量),
自身.
偏差)
@staticmethod
def 从浮点数(
类,
模块,
使用预计算的假量化=
错误):
r从浮点模块创建一个 qat 模块
参数：
`mod`：一个浮点模块，可以是 torch.ao.quantization 工具生成的，或者直接由用户生成
或直接从用户处获取
```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)
```
断言
类型(
模块) ==
类.
浮点模块, (
qat.
+ 类.__name__
+ ".from_float 仅适用于 "
+ 类.
浮点模块.__name__
)
断言
有属性(
模块,
qconfig),
输入浮点模块必须定义 qconfig
断言
模块.qconfig,
输入浮点模块必须有一个有效的 qconfig
如果
派生类(
类型(
模块),
混合模块):
修饰 =
模块[0]
qconfig = 模块.qconfig
qat_conv = 类(
模块.
输入通道,
模块.
输出通道,
模块.
核心大小,
步长=
模块.
步长,
填充=
模块.
填充,
扩展率=
模块.
扩展率,
群组=
模块.
群组,
偏差=
模块.bias
是 not
无,
填充模式=
模块.
填充模式,
qconfig=qconfig,
)
qat_conv.权重 =
模块.
权重
qat_conv.bias = 模块.bias
返回 qat_conv
def 转换为浮点数(
自身):
“这适用于单个 qat 卷积和 qat 卷积-relu 模块”
将 qat 模块转换为浮点模块
```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)
```
类 =
类型(
自身)
转换 =
类.
_浮点转换模块(
# 类型: 忽略[attr-defined]
自身.
输入通道,
自身.
输出通道,
自身.
核心大小,
自身.
步长,
自身.
填充,
自身.
扩展率,
自身.
群组,
自身.bias
是 not
无,
自身.
填充模式,
)
沟通.
权重 =
火炬.nn.
参数(
自身.
重量.detach())
如果
自身.bias
是 not
无:
沟通.bias =
火炬.nn.
参数(
自身.
偏差.detach())
# 转换 ReLU
如果
派生类(
类,
混合模块):
模块 = [
沟通]
断言
有属性(
类,
浮点 ReLU 模块)
relu = 类.
浮点 ReLU 模块()
模块.
追加(relu)
fused = 类.
浮点模块(*
模块)
融合.
训练(
自身.
训练)
返回 fused
否则:
返回
卷积
类
卷积 1D(
_卷积 Nd, nn.
卷积 1D):
r""
与 FakeQuantize 模块附加的 Conv1d 模块，用于权重量化感知训练。
我们采用与 :class:`~torch.nn.Conv1d` 相同的接口。
与 :class:`~torch.nn.Conv2d` 类似，FakeQuantize 模块已初始化。
与 :class:`~torch.nn.Conv2d` 类似，FakeQuantize 模块已初始化。
默认。
属性：
weight_fake_quant: 权重伪量化模块
```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
_FLOAT_CONV_MODULE: 类变量[
类型[nn.
卷积 1D]] = nn.Conv1d
def 初始化(
自身,
输入通道: int,
输出通道: int,
核心大小: _size_1_t,
步长:
_大小_1_t = 1,
填充:
联盟[
字符串, _size_1_t] = 0,
扩展率:
_大小_1_t = 1,
群组:
整型 = 1,
偏差:
布尔类型 = True,
填充模式:
字符串 =
零,
qconfig=无,
设备=
无,
数据类型=
无,
) -> 无:
核心大小_ = _single(
核心大小)
步长_ = _single(
步长)
填充_ =
填充
如果 isinstance(
填充,
字符串)
否则 _single(
填充)
扩展率_ = _single(
扩展率)
超级().
初始化(
输入通道,
输出通道,
核心大小_,
步长=
步长_,
填充=
填充_,
扩展率=
扩展率_,
交换=
错误,
输出填充=_single(0),
群组=
群组,
偏差=
偏差,
填充模式=
填充模式,
qconfig=qconfig,
设备=
设备,
数据类型=
数据类型,
)
@classmethod
def 从浮点数(
类,
模块,
使用预计算的假量化=
错误):
返回
超级().
从浮点数(
类,
模块,
使用预计算的假量化=
使用预计算的假量化
)
[文档]
类
卷积 2D(
_卷积 Nd, nn.
卷积 2D):
r""
一个与 FakeQuantize 模块附加的 Conv2d 模块，用于权重
用于量化感知训练。
我们采用与`torch.nn.Conv2d`相同的接口，请参阅
https://pytorch.org/docs/stable/nn.html?highlight=conv2d#torch.nn.Conv2d
用于文档。
与 `torch.nn.Conv2d` 类似，FakeQuantize 模块已初始化
默认。
属性：
weight_fake_quant：权重伪量化模块
```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
_FLOAT_CONV_MODULE: 类变量[
类型[nn.
卷积 2D]] = nn.Conv2d
def 初始化(
自身,
输入通道: int,
输出通道: int,
核心大小: _size_2_t,
步长:
_尺寸_2_t = 1,
填充:
联盟[
字符串, _size_2_t] = 0,
扩展率:
_尺寸_2_t = 1,
群组:
整型 = 1,
偏差:
布尔类型 = True,
填充模式:
字符串 =
零,
qconfig=无,
设备=
无,
数据类型=
无,
) -> 无:
核心大小_ = _pair(
核心大小)
步长_ = _pair(
步长)
填充_ =
填充
如果 isinstance(
填充,
字符串)
否则 _pair(
填充)
扩展率_ = _pair(
扩展率)
超级().
初始化(
输入通道,
输出通道,
核心大小_,
步长=
步长_,
填充=
填充_,
扩展率=
扩展率_,
交换=
错误,
输出填充=_pair(0),
群组=
群组,
偏差=
偏差,
填充模式=
填充模式,
qconfig=qconfig,
设备=
设备,
数据类型=
数据类型,
)
def 前向(
自身,
输入):
返回
自身.
_卷积前向(
输入,
自身.
权重伪量化(
自身.
重量),
自身.
偏差)
@classmethod
def 从浮点数(
类,
模块,
使用预计算的假量化=
错误):
返回
超级().
从浮点数(
类,
模块,
使用预计算的假量化=
使用预计算的假量化
)
[文档]
类
卷积 3D(
_卷积 Nd, nn.
卷积 3D):
r""
一个与 FakeQuantize 模块连接的 Conv3d 模块，用于权重
用于量化感知训练。
我们采用与`torch.nn.Conv3d`相同的接口，请参阅
https://pytorch.org/docs/stable/nn.html?highlight=conv3d#torch.nn.Conv3d
用于文档。
与 `torch.nn.Conv3d` 类似，FakeQuantize 模块已初始化
默认。
属性：
weight_fake_quant：权重伪量化模块
```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
_FLOAT_CONV_MODULE: 类变量[
类型[nn.
卷积 3D]] = nn.Conv3d
def 初始化(
自身,
输入通道: int,
输出通道: int,
核心大小: _size_3_t,
步长:
_尺寸_3_t = 1,
填充:
联盟[
字符串, _size_3_t] = 0,
扩展率:
_尺寸_3_t = 1,
群组:
整型 = 1,
偏差:
布尔类型 = True,
填充模式:
字符串 =
零,
qconfig=无,
设备=
无,
数据类型=
无,
) -> 无:
核心大小_ =
_三倍_(
核心大小)
步长_ =
_三倍_(
步长)
填充_ =
填充
如果 isinstance(
填充,
字符串)
否则
_三倍_(
填充)
扩展率_ =
_三倍_(
扩展率)
超级().
初始化(
输入通道,
输出通道,
核心大小_,
步长=
步长_,
填充=
填充_,
扩展率=
扩展率_,
交换=
错误,
输出填充=
_三倍_(0),
群组=
群组,
偏差=
偏差,
填充模式=
填充模式,
qconfig=qconfig,
设备=
设备,
数据类型=
数据类型,
)
def 前向(
自身,
输入):
返回
自身.
_卷积前向(
输入,
自身.
权重伪量化(
自身.
重量),
自身.
偏差)
@classmethod
def 从浮点数(
类,
模块,
使用预计算的假量化=
错误):
返回
超级().
从浮点数(
类,
模块,
使用预计算的假量化=
使用预计算的假量化
)
