# mypy: 允许未类型化定义
来自
未来
导入
注释
来自 dataclasses
导入
数据类
来自
枚举
导入
枚举
来自
打字
导入
任意,
可调用,
可选,
类型检查,
联合
导入
火炬
如果
类型检查:
来自 torch.ao.quantization.utils
导入
模式
__all__ = [
后端配置,
后端模式配置,
"DType 配置",
"带约束的 DType",
"观测类型",
]
# DType 配置字典键
输入数据类型字典键 =
输入数据类型
输出数据类型字典键 =
输出数据类型
重量数据类型字典键 =
重量数据类型
偏差数据类型字典键 =
偏差数据类型
动态字典键 =
is_dynamic
后端配置字典键
名称字典键 =
"名称"
配置字典键 =
"配置"
# 后端模式配置字典键
模式字典键 =
模式
PATTERN_COMPLEX_FORMAT_DICT_KEY = 模式复杂格式
观察类型字典键 =
"观测类型"
DTYPE 配置字典键 =
"dtype 配置"
根模块字典键 =
根模块
QAT 模块字典键 =
qat 模块
参考量化模块字典键 =
"根节点参考量化模块"
融合模块字典键 =
"融合模块"
融合方法字典键 =
"fuser 方法"
根节点获取器字典键 = "root_node_getter"
EXTRA_INPUTS_GETTER 字典键 =
"额外输入获取器"
NUM_TENSOR_ARGS_TO_OBSERVATION_TYPE_DICT_KEY = "num_tensor_args_to_observation_type"
INPUT_TYPE_TO_INDEX_DICT_KEY = 输入类型到索引
# TODO: 可能需要重命名，避免与观察者相关
# 例如 QParamsType
[文档]class ObservationType(Enum):
一个表示如何观察操作符/操作符模式的枚举
应该被观察的方式
""
输出使用不同的观察者作为输入 = 0
这意味着输入和输出由不同的观察者观察，基于 qconfig.activation
例如：卷积、线性、softmax
"
"""
输出共享观察者与输入 = 1
这意味着输出将使用与输入相同的观察者实例
在 qconfig 激活
示例：torch.cat，最大池化
"``"
INPUT_OUTPUT_NOT_OBSERVED = 2
"这意味着输入和输出从未被观察"
示例：x.shape, x.size
"``"
[文档]@dataclass
类 DTypeWithConstraints:
"``"
配置指定给定数据类型的额外约束，例如量化
的值范围、缩放值范围和固定量化参数，用于
`:class:`~torch.ao.quantization.backend_config.DTypeConfig`。
当前支持的约束包括：
`quant_min_lower_bound` 和 `quant_max_upper_bound`：下限和上限
边界分别为最小和最大量化值的范围。如果
QConfig 的`quant_min`和`quant_max`超出了此范围
然后 QConfig 将被忽略。
`scale_min_lower_bound` 和 `scale_max_upper_bound`：最小和最大比例值的下限和上限。如果 QConfig 的最小比例值（目前以 `eps` 展示）低于下限，则 QConfig 将被忽略。注意上限
的值。如果 QConfig 的最大比例值（目前以 `eps` 展示）高于上限，则 QConfig 将被忽略。
如果 QConfig 的最小比例值（目前以 `eps` 展示）低于下限，则 QConfig 将被忽略。注意上限
的值。如果 QConfig 的最大比例值（目前以 `eps` 展示）高于上限，则 QConfig 将被忽略。
绑定当前未强制执行。
* `scale_exact_match` 和 `zero_point_exact_match`：精确匹配要求
用于具有固定量化的操作员，例如 sigmoid 和 tanh。如果观察者在 QConfig 中指定
参数，例如 sigmoid 和 tanh。如果观察者在 QConfig 中指定
既不是 `FixedQParamsObserver` 也不是 `FixedQParamsFakeQuantize`，或者如果量化参数不匹配，则将忽略 QConfig。
如果量化参数不匹配，则 QConfig 将被忽略。
"""
dtype: Optional[torch.dtype] = None
quant_min_lower_bound: 联合类型[int, float, None] = None
quant_max_upper_bound: 联合类型[int, float, None] = None
scale_min_lower_bound: 联合类型[int, float, None] = None
scale_max_upper_bound: 联合类型[int, float, None] = None
scale_exact_match: 可选 [浮点数] = None
zero_point_exact_match: 可选[int] = None
[文档]@dataclass
类 DTypeConfig:
""
配置对象，指定作为参数传递的支持数据类型
量化参考模型规范中的操作，对于输入和输出激活
权重和偏差。
例如，考虑以下参考模型：
quant1 - [dequant1 - fp32_linear - quant2] - dequant2
方括号中的模式指的是参考模式。
静态量化线性。设置输入数据类型为 `torch.quint8`
在 DTypeConfig 中意味着我们将 `torch.quint8` 作为数据类型参数传入
传递给第一个量化操作（quant1）。同样，设置输出数据类型为 `torch.quint8` 意味着我们将 `torch.quint8` 作为数据类型参数传入
`torch.quint8` 意味着我们将 `torch.quint8` 作为数据类型参数传入
第二次量化操作（quant2）。
请注意，这里的 dtype 并不指代接口的 dtype 类型
例如，这里的“input dtype”不是输入的 dtype
传递给量化线性操作的张量。尽管它仍然可以是
与接口 dtype 相同，这并不总是如此，例如，这
接口数据类型在动态量化中为 fp32，但“输入数据类型”
指定在 DTypeConfig 中仍为 quint8。语义为
此处数据类型与在指定的数据类型语义中指定的数据类型相同
观察者。
这些数据类型与用户指定的类型相匹配
QConfig。如果存在匹配，并且 QConfig 满足约束
指定在 DTypeConfig（如果有），然后我们将量化给定的
使用此 DTypeConfig 模式的模式。否则，QConfig 将被忽略
模式将不会被量化。
演示用法：
>>> # xdoctest: +SKIP(失败)
>>> dtype_config1 = DTypeConfig(
... 输入数据类型=torch.quint8,
... 输出数据类型=torch.quint8,
... 权重数据类型=torch.qint8,
... bias_dtype=torch.float)
>>> dtype_config2 = DTypeConfig(
... 输入数据类型配置= DTypeWithConstraints(
... 数据类型=torch.quint8,
... quant_min_lower_bound=0,
... quant_max_upper_bound=255,
... ),
... 输出数据类型=DTypeWithConstraints(
... 数据类型=torch.quint8,
... quant_min_lower_bound=0,
... quant_max_upper_bound=255,
... ),
... weight_dtype=DTypeWithConstraints(
... dtype=torch.qint8,
... quant_min_lower_bound=-128,
... quant_max_upper_bound=127,
... ),
... bias_dtype=torch.float)
>>> dtype_config1.input_dtype
torch.quint8
>>> dtype_config2.input_dtype
torch.quint8
>>> dtype_config2.input_dtype_with_constraints
DTypeWithConstraints(dtype=torch.quint8, quant_min_lower_bound=0, quant_max_upper_bound=255,
scale_min_lower_bound=None, scale_max_upper_bound=None)
```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)
```
输入数据类型及约束:
具有约束的 DType
输出数据类型及约束:
具有约束的 DType
带约束的权重数据类型:
具有约束的 DType
偏差数据类型:
可选[
火炬.
数据类型]
动态的:
可选[
布尔]
def 初始化(
自身,
输入数据类型:
联盟[
火炬.
数据类型,
带约束的数据类型,
无] =
无,
输出数据类型:
联盟[
火炬.
数据类型,
带约束的数据类型,
无] =
无,
权重数据类型:
联盟[
火炬.
数据类型,
带约束的数据类型,
无] =
无,
偏差数据类型:
可选[
火炬.
数据类型] =
无,
动态的:
可选[
布尔] =
无,
):
如果 isinstance(
输入数据类型,
带约束的数据类型):
自身.
输入数据类型及约束 =
输入数据类型
否则:
自身.
输入数据类型及约束 =
带约束的数据类型(
数据类型=
输入数据类型)
如果 isinstance(
输出数据类型,
带约束的数据类型):
自身.
带约束的输出数据类型 =
输出数据类型
否则:
自身.
带约束的输出数据类型 =
带约束的数据类型(
数据类型=
输出数据类型
)
如果 isinstance(
权重数据类型,
带约束的数据类型):
自身.
带约束的权重数据类型 =
权重数据类型
否则:
自身.
带约束的权重数据类型 =
带约束的数据类型(
数据类型=
权重数据类型
)
自身.
偏置数据类型 =
偏置数据类型
自身.
动态的 =
动态的
@property
def 输入数据类型(
自身) ->
可选[
火炬.
数据类型
]：
返回
自身.
输入数据类型及约束.dtype
@property
def 输出数据类型(
自身) ->
可选[
火炬.
数据类型
]：
返回
自身.
输出数据类型及约束.dtype
@property
def 权重数据类型(
自身) ->
可选[
火炬.
数据类型
]：
返回
自身.
带约束的权重数据类型.dtype
[文档] @类方法
def from_dict(cls, dtype_config_dict: dict[str, Any]) -> DTypeConfig:
"""
从以下项目（全部为可选）创建一个 `DTypeConfig`：
"input_dtype": torch.dtype 或 `DTypeWithConstraints`
"output_dtype": torch.dtype 或 `DTypeWithConstraints`
"weight_dtype": torch.dtype 或 `DTypeWithConstraints`
"bias_type": torch.dtype
"is_dynamic": 布尔值
"""
input_dtype = dtype_config_dict.get(INPUT_DTYPE_DICT_KEY, None)
如果 input_dtype 不为 None 且不是 torch.dtype 或 DTypeWithConstraints 类型
则 input_dtype，(torch.dtype, DTypeWithConstraints)
):
则引发 ValueError(
预期输入数据类型应为 torch.dtype 或 DTypeWithConstraints
)
output_dtype = dtype_config_dict.get(OUTPUT_DTYPE_DICT_KEY, None)
如果 output_dtype 不为 None 且不是 isinstance(
输出数据类型，(torch.dtype, DTypeWithConstraints)
):
raise ValueError(
"期望 output_dtype 为 torch.dtype 或 DTypeWithConstraints"
)
weight_dtype = dtype_config_dict.get(WEIGHT_DTYPE_DICT_KEY, None)
if weight_dtype is not None and not isinstance(weight_dtype, (torch.dtype, DTypeWithConstraints))
weight_dtype, (torch.dtype, DTypeWithConstraints)
):
raise ValueError(
预期 weight_dtype 是一个 torch.dtype 或 DTypeWithConstraints
)
bias_dtype = dtype_config_dict.get(BIAS_DTYPE_DICT_KEY, None)
is_dynamic = dtype_config_dict.get(IS_DYNAMIC_DICT_KEY, None)
return cls(input_dtype, output_dtype, weight_dtype, bias_dtype, is_dynamic)
[文档] def to_dict(self) -> dict[str, Any]:
"""
将此 ``DTypeConfig`` 转换为包含以下内容的字典：
func:`~torch.ao.quantization.backend_config.DTypeConfig.from_dict`.
"""
dtype_config_dict: dict[str, Any] = {}
if self.input_dtype is not None:
dtype_config_dict[INPUT_DTYPE_DICT_KEY] = self.input_dtype_with_constraints
if self.output_dtype is not None:
dtype_config_dict[
OUTPUT_DTYPE_DICT_KEY
] = self.output_dtype_with_constraints
if self.weight_dtype is not None:
dtype_config_dict[
WEIGHT_DTYPE_DICT_KEY
] = self.weight_dtype_with_constraints
如果 self.bias_dtype 不为 None:
dtype_config_dict[BIAS_DTYPE_DICT_KEY] = self.bias_dtype
如果 self.is_dynamic 不为 None:
dtype_config_dict[IS_DYNAMIC_DICT_KEY] = self.is_dynamic
返回 dtype_config_dict
[文档]
类
后端配置:
# TODO: 参考 NativeBackendConfig 一旦实现
定义了在特定后端上可以进行量化的模式集，以及如何从这些模式生成量化模型。
在此上下文中，模式指的是一个模块、一个函数、一个算子或一个有向无环图。
A pattern in this context refers to a module, a functional, an operator, or a directed acyclic graph
上述内容。目标后端支持的每种模式都可以通过
class:`~torch.ao.quantization.backend_config.BackendPatternConfig` 来进行单独配置，具体包括：
（1）支持的输入/输出激活、权重和偏置数据类型
（2）如何插入观察器和量化/反量化操作以构建参考模式，以及
（3）（可选）融合、QAT 和参考模块映射。
模式格式描述如下：
https://github.com/pytorch/pytorch/blob/master/torch/ao/quantization/backend_config/README.md
演示用法：
导入 torch
从 torch.ao.quantization.backend_config 导入(
后端配置，
后端模式配置,
数据类型配置,
观测类型,
)
weighted_int8_dtype_config = 数据类型配置(
input_dtype=torch.quint8
output_dtype=torch.quint8
weight_dtype=torch.qint8
bias_dtype=torch.float
def fuse_conv2d_relu(is_qat, conv, relu):
return torch.ao.nn.intrinsic.ConvReLU2d(conv, relu)
# 用于量化线性层
linear_config = BackendPatternConfig(torch.nn.Linear) \
.set_observation_type(ObservationType.OUTPUT_USE_DIFFERENT_OBSERVER_AS_INPUT)
.add_dtype_config(weighted_int8_dtype_config)
.set_root_module(torch.nn.Linear)
.set_qat_module(torch.ao.nn.qat.Linear)
.set_reference_quantized_module(torch.ao.nn.quantized.reference.Linear)
# 将 Conv2d + ReLU 融合为 ConvReLU2d
conv_relu_config = BackendPatternConfig((torch.nn.Conv2d, torch.nn.ReLU))
.set_observation_type(ObservationType.OUTPUT_USE_DIFFERENT_OBSERVER_AS_INPUT)
.add_dtype_config(weighted_int8_dtype_config)
.set_fused_module(torch.ao.nn.intrinsic.ConvReLU2d)
.set_fuser_method(fuse_conv2d_relu)
# For quantizing ConvReLU2d
fused_conv_relu_config = BackendPatternConfig(torch.ao.nn.intrinsic.ConvReLU2d)
.set_observation_type(ObservationType.OUTPUT_USE_DIFFERENT_OBSERVER_AS_INPUT)
.add_dtype_config(weighted_int8_dtype_config)
.set_root_module(torch.nn.Conv2d)
.set_qat_module(torch.ao.nn.intrinsic.qat.ConvReLU2d)
.set_reference_quantized_module(torch.ao.nn.quantized.reference.Conv2d)
backend_config = BackendConfig("my_backend")
.set_backend_pattern_config(linear_config)
.设置后端模式配置(conv_relu_config)
.设置后端模式配置(fused_conv_relu_config)
```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)
```
def 初始化(
自身,
名称:
字符串 = ""):
自身.
名称 =
名称
# 将所有 BackendPatternConfigs 存储在映射中以便处理重复项
# 注意：映射中的键使用复杂的反向元组格式。
仅限内部使用；希望访问原始模式的用户应通过 `self.configs` 进行。
原始模式应通过 `self.configs` 进行。
自身._pattern_complex_format_to_config:
字典[
模式, BackendPatternConfig] = {}
def __repr__(自身):
返回 f
"BackendConfig("{
自身.
字典})"
[文档] def set_name(self, name: str) -> BackendConfig:
"""
设置目标后端的名称。
"""
self.name = name
return self
[文档] def set_backend_pattern_config(self, config: BackendPatternConfig) -> BackendConfig:
"""
设置可以在目标后端运行的模式的配置。
这将覆盖给定模式的任何现有配置。
"""
避免循环依赖
pattern_complex_format = torch.ao.quantization.backend_config.utils._get_pattern_in_reversed_nested_tuple_format(
配置
) # type: ignore[attr-defined]
self._pattern_complex_format_to_config[pattern_complex_format] = config
返回自身
[文档] def 设置后端模式配置(
self, configs: list[BackendPatternConfig]
) -> BackendConfig:
""
设置可以在目标后端上运行的模式的配置。
如果该模式之前已注册，则此操作将覆盖任何现有的配置。
""
for conf in configs:
self.set_backend_pattern_config(conf)
return self
@property
def configs(自身) ->
列表[BackendPatternConfig
]：
""
返回在此 `BackendConfig` 中设置的配置列表的副本。
```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)
```
返回
列表(
自身._pattern_complex_format_to_config.
值())
[文档] @classmethod
def from_dict(cls, backend_config_dict: dict[str, Any]) -> BackendConfig:
"````"
从字典中创建一个 ``BackendConfig``，包含以下项：
" \"name\": 目标后端名称"
" \"configs\": 一个列表，其中每个字典代表一个 `BackendPatternConfig`"
"""
conf = cls(backend_config_dict.get(NAME_DICT_KEY, ""))
for d in backend_config_dict.get(CONFIGS_DICT_KEY, []):
if isinstance(d, BackendPatternConfig):
conf.set_backend_pattern_config(d)
elif isinstance(d, dict):
conf.set_backend_pattern_config(BackendPatternConfig.from_dict(d))
else:
raise ValueError(
f"期望 backend_config_dict['{CONFIGS_DICT_KEY}'] 是一个字典"
)
return conf
[文档] def to_dict(self) -> dict[str, Any]:
"""
将此 ``BackendConfig`` 转换为包含以下项的字典。
func:`~torch.ao.quantization.backend_config.BackendConfig.from_dict`.
"""
返回 {
NAME_DICT_KEY: self.name,
CONFIGS_DICT_KEY: [c.to_dict() for c in self.configs],
}
[文档]
类 BackendPatternConfig:
""
指定给定算子模式的量化行为的配置对象。
详细示例用法请参阅：:class:`~torch.ao.quantization.backend_config.BackendConfig`。
```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)
```
def 初始化(
自身,
模式:
可选[
模式] =
无):
自身.
模式:
可选[
模式] =
模式
自身.
观察类型 =
观察类型.
输出使用不同的观察者作为输入
自身.
dtype 配置:
列表[DTypeConfig] = []
自身.
根模块:
可选[
类型[
火炬.nn.
模块]] = None
自身.
qat 模块:
可选[
类型[
火炬.nn.
模块]] = None
自身.
参考量化模块:
可选[
类型[
火炬.nn.
模块]] = None
自身.
融合模块:
可选[
类型[
火炬.nn.
模块]] = None
自身.
融合方法:
可选[
可调用] = None
# 临时/内部配置
自身._root_node_getter:
可选[
可调用] = None
自身._extra_inputs_getter:
可选[
可调用] = None
自身._num_tensor_args_to_observation_type:
字典[int,
观察类型] = {}
自身.
输入类型到索引:
字典[
字符串, int] = {}
自身.
复杂格式模式:
可选[
模式] = None
def __repr__(自身):
字典非空 = {
k: v
为 k, v
在
自身.
字典.
项目()
如果 (
(not isinstance(v, (列表,
字典))
和 v
是 not
无)
或 (isinstance(v, (
列表,
字典))
和
长度(v) > 0)
)
}
返回 f
BackendPatternConfig({dict_nonempty})"
[文档] def set_pattern(self, pattern: Pattern) -> BackendPatternConfig:
"""
设置配置模式。
模式可以是浮点模块、函数运算符、PyTorch 运算符或元组。
上述模式的组合。元组模式被视为顺序模式，并且
目前仅支持 2 个或 3 个元素的元组。
"""
如果 self._pattern_complex_format 不是 None：
raise ValueError(
"只能设置'pattern'或'pattern_complex_format'中的一个"
)
self.pattern = pattern
return self
[文档] def set_observation_type(
self, 观察类型: ObservationType
) -> BackendPatternConfig:
"""
设置此模式中观察者应在图中如何插入。
观测类型此处指的是观测者（或量化和反量化的操作）的放置方式
在图中。这用于生成被理解所需的参考模式
后端。线性、卷积等加权操作需要不同的观察者
（或传递给参考模型中量化操作的量化参数）
输入和输出。
有两种观察类型：
`OUTPUT_USE_DIFFERENT_OBSERVER_AS_INPUT`（默认）：输出观察者实例
将与输入不同。这是最常见的观察类型。
`OUTPUT_SHARE_OBSERVER_WITH_INPUT`: 输出观察者实例将与输入相同。这对于像`cat`这样的操作符很有用。
注意：这将在不久的将来被重命名，因为我们很快将插入带有观察者（和假量化）的 QuantDeQuantStubs，而不是观察者本身。
注意：这将在不久的将来被重命名，因为我们很快将插入带有观察者（和假量化）的 QuantDeQuantStubs，而不是观察者本身。
注意：这将在不久的将来被重命名，因为我们很快将插入带有观察者（和假量化）的 QuantDeQuantStubs，而不是观察者本身。
"``"
self.observation_type = 观察类型
返回 self
[文档] def add_dtype_config(self, dtype_config: DTypeConfig) -> BackendPatternConfig:
"""
将一组支持的数据类型作为参数传递给量化操作，添加到参考模型规范中。
"
"""
self.dtype_configs.append(dtype_config)
返回 self
[文档] def 设置 dtype_configs(
self, dtype_configs: list[DTypeConfig]
) -> BackendPatternConfig:
"""
设置传递给量化操作的受支持数据类型
参考模型规范，覆盖所有之前注册的数据类型。
"""
self.dtype_configs = dtype_configs
返回 self
[文档] def set_root_module(
self, root_module: type[torch.nn.Module]
) -> BackendPatternConfig:
"""
设置表示此模式根的模块。
当我们在转换阶段构建参考量化模型时，
根模块（例如 torch.nn.Linear 用于 torch.ao.nn.intrinsic.LinearReLU）
将被交换到相应的参考量化模块（例如）
torch.ao.nn.reference.quantized.Linear). 这允许自定义后端
指定自定义参考量化模块实现以匹配
数值降低算子的数值。由于这是一个一对一映射，
两个根模块和参考量化模块都必须指定
在同一个 BackendPatternConfig 中，以便进行转换。
"""
self.root_module = root_module
返回 self
[文档] def set_qat_module(self, qat_module: type[torch.nn.Module]) -> BackendPatternConfig:
"""
设置表示此模式 QAT 实现的模块。
"""
self.qat_module = qat_module
return self
[文档] def set_reference_quantized_module(
self, reference_quantized_module: type[torch.nn.Module]
-> BackendPatternConfig:
"""
设置表示此模式根模块的引用量化实现的模块。
为此模式的根模块设置引用量化实现的模块。
更多详情，请参阅：func:`~torch.ao.quantization.backend_config.BackendPatternConfig.set_root_module`.
"""
self.reference_quantized_module = reference_quantized_module
返回 self
[文档] def set_fused_module(
self, fused_module: type[torch.nn.Module]
) -> BackendPatternConfig:
"""
设置表示此模式融合实现的模块。
```python
# 输入文本
input_text = '"""'
# 翻译函数（此处为示例，实际翻译功能需调用真实的翻译 API）
def translate_to_simplified_chinese(text):
# 假设的翻译结果
return text
# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
self.fused_module = fused_module
返回 self
[文档] def set_fuser_method(self, fuser_method: Callable) -> BackendPatternConfig:
"""
设置指定如何融合此 BackendPatternConfig 模式的函数。
此函数的第一个参数应为 `is_qat`，其余参数
应该是元组模式中的项。此函数的返回值应该是
结果融合模块。
例如，模式 `(torch.nn.Linear, torch.nn.ReLU)` 的融合方法可以是：
def fuse_linear_relu(is_qat, linear, relu):
return torch.ao.nn.intrinsic.LinearReLU(linear, relu)
更多复杂的示例，请参阅 https://gist.github.com/jerryzh168/8bea7180a8ba3c279f2c9b050f2a69a6。
"""
self.fuser_method = fuser_method
返回自身
def _设置根节点获取器(
自身,
根节点获取器:
可调用) -> BackendPatternConfig:
自身.
_根节点获取器_ =
根节点获取器
返回 self
def _设置额外输入获取器(
自身,
额外输入获取器:
可调用
) -> BackendPatternConfig:
自身.
_额外输入获取器 =
额外输入获取器
返回 self
def 将数字张量参数设置为观察类型(
自身,
num_tensor_args_to_observation_type 数量张量参数到观察类型:
字典[int,
观察类型]
) -> BackendPatternConfig:
自身._num_tensor_args_to_observation_type =
num_tensor_args_to_observation_type 数量张量参数到观察类型
返回 self
def _将输入类型设置为索引(
自身,
输入类型到索引:
字典[
字符串, int]
) -> BackendPatternConfig:
自身.
_输入类型到索引 =
输入类型到索引
返回 self
def 设置复杂格式模式(
自身,
模式:
模式) -> BackendPatternConfig:
""
设置配置模式，使用反向嵌套元组格式。
请参阅 BackendConfig README 获取更多详细信息：
https://github.com/pytorch/pytorch/blob/master/torch/ao/quantization/backend_config/README.md#advanced-pattern-specification
```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)
```
如果
自身.
模式
是 not
无:
提升 ValueError(
"只能设置 'pattern' 或 'pattern_complex_format' 中的一个"
)
自身._pattern_complex_format =
模式
返回 self
[文档] @classmethod
def from_dict(
类,
后端模式配置字典:
字典[
字符串,
任意]
) -> BackendPatternConfig:
""
从以下项的字典创建一个 ``BackendPatternConfig``：
"pattern": 正在配置的模式
"observation_type": 指定如何的 :class:`~torch.ao.quantization.backend_config.ObservationType`
应为此模式插入观察者
"dtype_configs": 表示 :class:`~torch.ao.quantization.backend_config.DTypeConfig` 的字典列表
"root_module": 表示此模式根的 :class:`torch.nn.Module`
"qat_module": 表示此模式 QAT 实现的 :class:`torch.nn.Module`
"reference_quantized_module": 一个代表此模式根模块的 :class:`torch.nn.Module` 类
此模式的根模块的引用量化实现。
"fused_module": 一个代表此模式融合实现的 :class:`torch.nn.Module` 类
"fuser_method": 一个指定如何融合此模式的函数
"pattern_complex_format": 反向嵌套元组格式的指定模式（已弃用）
```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)
```
def _get_dtype_config(对象:
任意) -> DTypeConfig:
""
将给定对象转换为 ``DTypeConfig``，如果可能，否则抛出异常。
```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)
```
如果 isinstance(
对象, DTypeConfig):
返回
对象
如果 isinstance(
对象,
字典):
返回 DTypeConfig.from_dict(
对象)
提升 ValueError(
f"在 " 预期一个 DTypeConfigs 列表"
fbackend_pattern_config_dict[
输入文本:
"Immersive Translate"
翻译:
沉浸式翻译{DTYPE 配置字典键}
输入文本:
"Immersive Translate"
翻译:
沉浸式翻译]，获取 '{
类型(
对象)}
'"'
)
配置 =
类()
如果
模式字典键
在
后端模式配置字典:
配置.
设置模式(
后端模式配置字典[
模式字典键])
如果
观察类型字典键
在
后端模式配置字典:
配置.
设置观测类型(
后端模式配置字典[OBSERVATION_TYPE_DICT_KEY]
)
为 d
在
后端模式配置字典.
获取(
DTYPE 配置字典键, []):
配置.
添加 dtype 配置(_get_dtype_config(d))
配置.
设置根模块(
后端模式配置字典.
获取(
根模块字典键,
无)
)
配置.
设置 QAT 模块(
后端模式配置字典.
获取(
QAT 模块字典键,
无))
配置.
设置参考量化模块(
后端模式配置字典.
获取(
参考量化模块字典键,
无)
)
配置.
设置融合模块(
后端模式配置字典.
获取(
FUSED 模块字典键,
无)
)
配置.
设置融合方法(
后端模式配置字典.
获取(
FUSER 方法字典键,
无)
)
配置.
_设置根节点获取器(
后端模式配置字典.
获取(
根节点获取器字典键,
无)
)
配置.
_设置额外输入获取器(
后端模式配置字典.
获取(EXTRA_INPUTS_GETTER_DICT_KEY,
无)
)
配置.
将数字张量参数设置为观察类型(
后端模式配置字典.
获取(
NUM_TENSOR_ARGS_TO_OBSERVATION_TYPE_DICT_KEY, {}
)
)
配置.
_将输入类型设置为索引(
后端模式配置字典.
获取(
输入类型到索引字典键, {})
)
如果 PATTERN_COMPLEX_FORMAT_DICT_KEY
在
后端模式配置字典:
配置.
设置复杂格式模式(
后端模式配置字典[PATTERN_COMPLEX_FORMAT_DICT_KEY]
)
返回
配置
[文档] 转换为字典，字典项如下：
"""
将此 ``BackendPatternConfig`` 转换为包含以下项的字典：
`torch.ao.quantization.backend_config.BackendPatternConfig.from_dict` 函数。
"""
backend_pattern_config_dict: dict[str, Any] = {
观察类型字典键: self.observation_type,
DTYPE_CONFIGS_DICT_KEY: [c.to_dict() for c in self.dtype_configs],
}
如果 self.pattern 不为 None:
backend_pattern_config_dict[PATTERN_DICT_KEY] = self.pattern
如果 self.root_module 不是 None：
backend_pattern_config_dict[ROOT_MODULE_DICT_KEY] = self.root_module
如果 self.qat_module 不是 None：
backend_pattern_config_dict[QAT_MODULE_DICT_KEY] = self.qat_module
if self.reference_quantized_module is not None:
backend_pattern_config_dict[
REFERENCE_QUANTIZED_MODULE_DICT_KEY
] = self.reference_quantized_module
如果 self.fused_module 不为空：
将 backend_pattern_config_dict[FUSED_MODULE_DICT_KEY]设置为 self.fused_module
如果 self.fuser_method 不为空：
将 backend_pattern_config_dict[FUSER_METHOD_DICT_KEY]设置为 self.fuser_method
如果 self._root_node_getter 不是 None：
backend_pattern_config_dict[
ROOT_NODE_GETTER_DICT_KEY
] = self._root_node_getter
如果 self._extra_inputs_getter 不是 None：
backend_pattern_config_dict[
EXTRA_INPUTS_GETTER_DICT_KEY
] = self._extra_inputs_getter
如果 self._num_tensor_args_to_observation_type 的长度大于 0：
backend_pattern_config_dict[
NUM_TENSOR_ARGS_TO_OBSERVATION_TYPE_DICT_KEY
] = self._num_tensor_args_to_observation_type
如果 self._input_type_to_index 的长度大于 0：
backend_pattern_config_dict[
INPUT_TYPE_TO_INDEX_DICT_KEY
] = self._input_type_to_index
如果 self._pattern_complex_format 不是 None：
backend_pattern_config_dict[
PATTERN_COMPLEX_FORMAT_DICT_KEY
] = self._pattern_complex_format
返回后端模式配置字典
