目录表
快捷方式

torch.ao.quantization.fake_quantize 的源代码

# mypy: 允许未类型化装饰器
# mypy: 允许未类型化定义
实现用于执行模拟量化的模块

导入 重新
从 abc 导入 ABC, 抽象方法
从 打字 导入 任意

导入 火炬
来自 torch.ao.quantization.observer 导入 (
    _with_args,
    默认固定量化参数范围 0 到 1 的观察者,
    默认固定 Q 参数范围-1 到 1 的观察者,
    固定 Q 参数观察者,
    直方图观察者,
    移动平均最小最大观察者,
    每通道移动平均最小最大观察者,
)
来自 torch.nn 导入 模块


__all__ = [
    "FakeQuantizeBase",
    "伪量化",
    "固定 Q 参数伪量化",
    "融合移动平均观测伪量化",
    "禁用伪量化",
    "禁用观察者",
    "启用伪量化",
    "启用观察者",
    "默认伪量化",
    "默认权重伪量化",
    "默认动态伪量化",
    "默认固定 Q 参数范围-1 到 1 伪量化",
    "默认固定 Q 参数范围 0 到 1 伪量化",
    "默认对称固定量化参数伪量化",
    "默认仿射固定量化参数伪量化",
    "默认通道权重伪量化",
    "默认嵌入伪量化",
    "默认嵌入伪量化 4 位",
    "默认直方图伪量化",
    "默认融合激活伪量化",
    "默认融合权重伪量化",
    "默认融合通道权重伪量化",
    "融合权重伪量化范围-127 到 127",
    "融合通道权重伪量化范围-127 到 127",
]


定义 _是否为通道(qscheme: "torch.qscheme") -> 布尔:
    返回 质量方案 在 [
        torch.每通道对称,
        torch.每通道仿射变换,
        torch.每通道仿射浮点 Q 参数,
    ]


定义 _是否为张量(穿梭模式: "torch.qscheme") -> 布尔类型:
    返回 质量方案 在 [torch.每张张量对称, torch.每张图像仿射]


定义 _是对称量化(穿梭模式: torch.qscheme) -> 布尔:
    返回 质量方案 在 [torch.每张张量对称, torch.每通道对称]


定义 _是否浮点数参数(穿梭模式: torch.qscheme) -> 布尔:
    返回 质量方案 在 [
        torch.每通道仿射浮点 Q 参数,
    ]



[文档]类 假量化基础(ABC, 模块):
    r基础伪量化模块。

基础伪量化模块
任何伪量化实现都应从此类派生。

具体的伪量化模块应遵循相同的 API。在正向传播中，它们将更新
观察到的张量的统计信息并对输入进行伪量化。它们还应提供
`calculate_qparams`函数，用于计算量化参数。
收集的统计数据。

    """

    假量化使能: torch.张量
    观察器启用: torch.张量

    定义 __init__(自身) -> 无:
        设置 fake_quant_enabled 和 observer_enabled。
        超级().__init__()
        # fake_quant_enabled 和 observer_enabled 是缓冲区，用于支持它们的
        # 在 DDP 中的复制。数据类型为 uint8，因为 NCCL 不支持
        布尔张量
        自身.注册缓冲区("伪量化已启用", torch.张量([1] 数据类型=torch.uint8))
        自身.注册缓冲区(observer 启用, torch.张量([1] 数据类型=torch.uint8))

    @abstractmethod
    定义 前进(自身, x):
        通过

    @abstractmethod
    定义 计算 q 参数(自身, **kwargs):
        通过

    @torch.jit.导出
    定义 启用伪量化(自身, 启用: 布尔 = 真的) -> 无:
        自身.假量化使能[0] = 1 如果 启用 否则 0

    @torch.jit.导出
    定义 禁用伪量化(自身):
        自身.启用伪量化(假的)

    @torch.jit.导出
    定义 启用观察者(自身, 启用: 布尔 = 真的) -> 无:
        自身.观察器启用[0] = 1 如果 启用 否则 0

    @torch.jit.导出
    定义 禁用观察者(自身):
        自身.启用观察者(假的)

    @classmethod
    定义 带参数(cls, **kwargs):
        假量化构造函数 = _with_args(cls, **kwargs)
        # 需要分配正确的模块给 fake_quantize
        # 构造函数以满足公共和私有要求
        模拟量化构造函数.__module__ = "torch.ao.quantization.fake_quantize"
        返回 模拟量化构造函数




[文档]类 伪量化(假量化基础):
    r在训练时模拟量化与反量化操作。

本模块的输出由以下公式给出：

        x_out = (
          clamp(round(x/scale + zero_point), quant_min, quant_max) - zero_point
        ) * scale

* :attr:`is_dynamic` 表示伪量化是否为动态量化的占位符
操作符（choose_qparams -> q -> dq）或静态量化操作符（q -> dq）

* :attr:`scale` 定义了用于量化的缩放因子。

* :attr:`zero_point` 指定了浮点数中的 0 映射到的量化值。

* :attr:`fake_quant_enabled` 控制在张量上应用伪量化，请注意，
统计信息仍然可以更新。

* :attr:`observer_enabled` 控制张量上的统计信息收集

* :attr:`dtype` 指定被仿真的量化数据类型
允许的值是 torch.qint8 和 torch.quint8。

    Args:

观察器（模块）：用于观察输入张量的统计信息并计算尺度
以及零点。
observer_kwargs（可选）：观察器模块的参数

属性：
激活后处理（模块）：用户提供的模块，用于收集输入张量的统计信息，
提供了一种计算比例尺和零点的方法。

""

    比例尺: torch.张量
    零点: PyTorch.张量

    定义 __init__(
        自身,
        观察者=移动平均最小最大观察者,
        量化最小值=无,
        量化最大值=无,
        是否动态=假的,
        **observer_kwargs,
    ):
        超级().__init__()
        # 如果有效，将 quant_min/quant_max 填充到 observer 参数中
        如果 量化最小值 是 不 无 和 量化最大值 是 不 无:
            断言 (
                量化最小值 <= 量化最大值
            ), "量化最小值必须小于或等于量化最大值"
            数据类型 = observer_kwargs.获取(数据类型, torch.quint8)
            如果 hasattr(观察者, p):
                如果观察者是_PartialWrapper，则数据类型可以存储在
                观察者.p.keywords["dtype"]
                数据类型 = getattr(getattr(观察者, p, {}), 关键词, {}).获取(
                    数据类型, 数据类型
                )
            断言 torch.信息(数据类型).最小 <= 量化最小值, "量最小超出范围"
            断言 量化最大值 <= torch.信息(数据类型).最大值, "超出最大值范围"
            observer_kwargs.更新({量化最小值: 量化最小值, "量化最大值": 量化最大值})
        observer_kwargs["是否动态"] = 是否动态
        自身.激活后处理 = 观察者(**observer_kwargs)
        # TODO: 保留 self.quant_min/max 以便向后兼容；在几轮发布后删除
        # 用户应使用 self.activation_post_process.quant_min
        自身.量化最小值 = 自身.激活后处理.量化最小值
        自身.量化最大值 = 自身.激活后处理.量化最大值
        自身.是否动态 = 自身.激活后处理.是否动态
        如果 _是否浮点数参数(自身.激活后处理.穿梭模式):
            零点数据类型 = torch.浮点数
        否则:
            零点数据类型 = torch.整型
        自身.注册缓冲区("缩放", torch.张量([1.0] 数据类型=torch.浮点数))
        自身.注册缓冲区(零点, torch.张量([0] 数据类型=零点数据类型))
        自身.数据类型 = 自身.激活后处理.数据类型
        自身.质量方案 = 自身.激活后处理.质量方案
        自身.通道轴 = (
            自身.激活后处理.ch 轴
            如果 hasattr(自身.激活后处理, "ch 轴")
            否则 -1
        )
        断言 _按通道(自身.穿梭模式) 或 _按张量(自身.穿梭模式), (
            "仅支持在模拟量化中按通道和按张量量化"
            + "获取 qscheme: "
            + 字符串(自身.穿梭模式)
        )
        自身.是按通道 = _is_per_channel(自身.穿梭模式)

    @torch.jit.导出
    定义 计算 q 参数(自身):
        返回 自身.激活后处理.计算 q 参数()

    定义 前进(自身, X):
        如果 自身.观察器启用[0] == 1:
            我.激活后处理(X.分离())
            _缩放, 零点 = 自身.计算 q 参数()
            比例, 零点 = 比例.到(自我.规模.设备), 零点.到(
                自己.零点.设备
            )
            如果 自己.尺度.形状 != _scale.形状:
                自身.尺度.调整大小_(_scale.形状)
                自身.零点.调整大小_(_zero_point.形状)
            自身.尺度.复制_(_scale)
            我.零点.复制(_零点)

        如果 自身.假量化使能[0] == 1:
            如果 自身.是否按通道:
                X = torch.通道仿射伪量化(
                    X,
                    自身.尺度,
                    自身.零点,
                    自身.坐标轴,
                    自身.激活后处理.量化最小值,
                    自身.激活后处理.量化最大值,
                )
            否则:
                X = torch.基于张量的仿射假量化(
                    X,
                    自身.尺度,
                    自身.零点,
                    自身.激活后处理.量化最小值,
                    自身.激活后处理.量化最大值,
                )
        返回 X

    @torch.jit.导出
    定义 extra_repr(自身):
        返回 (
            f"fake_quant_enabled=已启用"{自身.假量化使能}, 观察者使能={自身.观察器启用}，““
            f"最小量="{自身.激活后处理.量化最小值}, 量化最大值={自身.激活后处理.量化最大值}，““
            f"数据类型="{自身.数据类型}, qscheme={自身.穿梭模式}, ch_axis={自身.坐标轴}，““
            f"缩放="{自身.尺度}零点={自身.零点}"
        )

    定义 _保存到状态字典(自身, 目的地, 前缀, 保持变量):
        # 我们目前无法将标量值注册为缓冲区，因此需要手动
        # specify serialization here.
        超级()._保存到状态字典(目的地, 前缀, 保持变量)
        目的地[前缀 + "缩放"] = 自身.规模
        目的地[前缀 + 零点] = 自身.零点

    定义 从状态字典加载(
        自身,
        状态字典,
        前缀,
        本地元数据,
        严格,
        缺少键,
        预期之外的键,
        错误信息,
    ):
        # 删除此功能会抛出一个错误，表明加载的张量大小与原始大小不匹配
        # 即，这些缓冲区最初具有 numel 0，一旦它们完成第一次前向传递，numel 就变为 1。
        本地状态 = ["缩放", 零点]
        对于 名称 在 本地状态:
            关键字 = 前缀 + 名称
            如果 关键字 在 状态字典:
                val = 状态字典[键]
                # 自定义处理以允许加载比例和零点
                # 将大小为 N 的值放入大小为 0 的未初始化缓冲区中。
                # 这里调整缓冲区大小，并将值复制进去
                父类的默认状态字典加载代码
                如果 名称 == "缩放":
                    自身.尺度.调整大小_(val.形状)
                否则:
                    断言 名称 == 零点
                    自身.零点.调整大小_(val.形状)
                # 对于 torchscript 模块，我们需要在此处更新属性，因为我们没有调用
                # 定义在 module.py 中的`_load_from_state_dict`函数
                如果 torch.jit.是否是脚本():
                    如果 名称 == "缩放":
                        自身.尺度.复制_(val)
                    否则:
                        断言 名称 == 零点
                        自身.零点.复制_(val)
            如果...否则 严格:
                缺少键.添加(键)
        超级().从状态字典加载(
            状态字典,
            前缀,
            本地元数据,
            严格,
            缺少键,
            预期之外的键,
            错误信息,
        )




[文档]class FixedQParamsFakeQuantize(FakeQuantize):
模拟训练时间中的量化和反量化。

模拟使用固定量化进行量化和解量化
训练时间参数。仅对每个张量量化
支持该功能。
"""

# TODO: 将 observer 重命名为 observer_ctr
def __init__(self, observer):
super().__init__(observer=observer)
assert (
类型(self.activation_post_process) == FixedQParamsObserver
), f"{self.__class__.__name__}'s observer must be a {FixedQParamsObserver.__name__}"
self._observer_ctr = 观察者
self.scale = self.activation_post_process.scale
self.zero_point = self.activation_post_process.zero_point
assert _is_per_tensor(self.qscheme), (
仅支持张量量化
+ "FixedQParamsFakeQuantize 模块，获取 qscheme："
+ str(self.qscheme)
        )

    @torch.jit.export
def calculate_qparams(self):
return self.scale, self.zero_point


[文档]    @torch.jit.export
def extra_repr(self): 
     # 获取额外的表示信息
定义对象属性的字符串表示。
返回（
f"fake_quant_enabled={self.fake_quant_enabled}, observer_enabled={self.observer_enabled}, "
f"缩放={self.scale}, 零点={self.zero_point}, "
f"数据类型={self.dtype}, 量化最小值={self.activation_post_process.quant_min}, "
f"量化最大值={self.activation_post_process.quant_max}, 量化方案={self.qscheme}"
        )




[文档]类 融合移动平均观测伪量化(伪量化):
    r定义一个融合模块来观察张量。

融合模块，用于观察输入张量（计算最小/最大值）
将张量进行缩放/零点调整和伪量化。
本模块使用类似 MovingAverageMinMaxObserver 的计算方法对输入进行处理
计算最小/最大值以计算缩放/零点。
观察者中的 qscheme 输入用于区分对称/仿射
量化方案。

此模块的输出由
    x_out = (clamp(round(x/scale + zero_point), quant_min, quant_max)-zero_point)*scale

与 :class:`~torch.ao.quantization.FakeQuantize` 相似，接受相同的属性
的基类。

    """

    定义 __init__(
        自身,
        观察者: 任意 = 移动平均最小最大观察者,
        量化最小值: 整型 = 0,
        量化最大值: 整型 = 255,
        **observer_kwargs: 任何,
    ) -> 无:
        超级().__init__(观察者, 量化最小值, 量化最大值, **observer_kwargs)
        断言 isinstance(
            自身.激活后处理,
            (移动平均最小最大观察者, 每通道移动平均最小最大观察者),
        ), “融合观察者+模拟量化模块仅与移动平均最小最大观察者兼容”
        self.注册缓冲区("伪量化已启用", torch.张量([1] 数据类型=torch.长整型))
        self.注册缓冲区("观察者启用", 火炬.张量[1], 数据类型=PyTorch.长整型))
        self（自身）.是对称量化 = _是对称量化(
            自身.激活后处理.质量方案
        )

    @torch.jit.导出
    定义 计算 q 参数(自身) -> 元组[torch.张量, torch.张量]
        返回 自身.激活后处理.计算 q 参数()

    @torch.jit.导出
    定义 extra_repr(自身) -> 字符串:
        返回 (
            f"fake_quant_enabled=已启用"{自身.假量化使能}, 观察者使能={自身.观察器启用}，““
            f"缩放="{自身.尺度}零点={自身.零点}数据类型={自身.数据类型}，““
            f"最小量="{自身.激活后处理.量化最小值}, 量化最大值={自身.激活后处理.量化最大值}，““
            fqscheme={自身.qscheme}, reduce_range={自身.激活后处理.缩小范围}"
        )

    定义 前进(自身, X: torch.张量) -> torch.张量:
        返回 torch.混合移动平均观察器伪量化(
            X,
            自身.观察器启用,
            自身.假量化使能,
            自身.激活后处理.最小值,
            自身.激活后处理.最大值,
            自身.比例尺,
            自身.零点,
            自身.激活后处理.平均常数,
            自身.激活后处理.量化最小值,
            自身.激活后处理.量化最大值,
            自身.坐标轴,
            自身.是否按通道,
            自身.是否对称量化,
        )



默认伪量化 = 伪量化.带参数(
    观察者=移动平均最小最大观察者,
    量化最小值=0,
    量化最大值=255,
    数据类型=torch.quint8,
    穿梭模式=torch.每张图像仿射,
    缩小范围=真的,
)
```python
# 假设输入文本为：
input_text = """Immersive Translate"""

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中无法调用外部 API，以下为模拟翻译结果
    return text  # 假设翻译结果与原文相同

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```

输出：
```
Immersive Translate
```
激活默认的 fake_quant
```python
# 假设输入文本为：
input_text = """Immersive Translate"""

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中无法调用外部 API，以下为模拟翻译结果
    return text  # 假设翻译结果与原文相同

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```

输出：
```
Immersive Translate
```

默认权重 fake_quant = 伪量化.带参数(
    观察者=移动平均最小最大观察者,
    量化最小值=-128,
    量化最大值=127,
    数据类型=torch.qint8,
    穿梭模式=torch.每张张量对称,
    缩小范围=假的,
)
```python
# 假设输入文本为：
input_text = """Immersive Translate"""

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中无法调用外部 API，以下为模拟翻译结果
    return text  # 假设翻译结果与原文相同

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```

输出：
```
Immersive Translate
```
默认权重 fake_quant
观察者是无记忆的，因为平均常数是 1。
```python
# 假设输入文本为：
input_text = """Immersive Translate"""

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中无法调用外部 API，以下为模拟翻译结果
    return text  # 假设翻译结果与原文相同

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```

输出：
```
Immersive Translate
```

默认动态伪量化 = 伪量化.带参数(
    观察者=移动平均最小最大观察者,
    量化最小值=0,
    量化最大值=255,
    是否动态=真的,
    数据类型=torch.quint8,
    平均常数=1,
)
```python
# 假设输入文本为：
input_text = """Immersive Translate"""

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中无法调用外部 API，以下为模拟翻译结果
    return text  # 假设翻译结果与原文相同

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```

输出：
```
Immersive Translate
```
默认激活的动态伪量化。
```python
# 假设输入文本为：
input_text = """Immersive Translate"""

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中无法调用外部 API，以下为模拟翻译结果
    return text  # 假设翻译结果与原文相同

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```

输出：
```
Immersive Translate
```

默认固定 qparams 范围-1 到 1 假量化 = 固定 Q 参数伪量化.带参数(
    观察者=默认固定 q 参数范围-1 到 1 观察者
)
默认固定量程范围 0 到 1 的伪量化 = 固定 Q 参数伪量化.带参数(
    观察者=默认固定 Q 参数范围 0 到 1 观察者
)
# TODO: 以下两个变量保留以供向后兼容；在几轮发布后删除
默认对称固定量化参数伪量化 = (
    默认固定 qparams 范围-1 到 1 假量化
)
默认仿射固定量化参数伪量化 = 默认固定量程范围 0 到 1 的伪量化

默认按通道权重伪量化 = 伪量化.带参数(
    观察者=每通道移动平均最小最大观察者,
    量化最小值=-128,
    量化最大值=127,
    数据类型=torch.qint8,
    穿梭模式=torch.每通道对称,
    缩小范围=假的,
    坐标轴=0,
)
```python
# 假设输入文本为：
input_text = """Immersive Translate"""

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中无法调用外部 API，以下为模拟翻译结果
    return text  # 假设翻译结果与原文相同

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```

输出：
```
Immersive Translate
```
默认的按通道权重 fake_quant。
观察者是无记忆的，因为平均常数是 1。
```python
# 假设输入文本为：
input_text = """Immersive Translate"""

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中无法调用外部 API，以下为模拟翻译结果
    return text  # 假设翻译结果与原文相同

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```

输出：
```
Immersive Translate
```
默认嵌入伪量化 = 伪量化.带参数(
    观察者=每通道移动平均最小最大观察者,
    穿梭模式=torch.每通道仿射浮点 Q 参数,
    数据类型=torch.quint8,
    量化最小值=0,
    量化最大值=255,
    坐标轴=0,
    平均常数=1,
)
```python
# 假设输入文本为：
input_text = """Immersive Translate"""

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中无法调用外部 API，以下为模拟翻译结果
    return text  # 假设翻译结果与原文相同

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```

输出：
```
Immersive Translate
```
默认的嵌入 fake_quant
观察者是无记忆的，因为平均常数是 1。
```python
# 假设输入文本为：
input_text = """Immersive Translate"""

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中无法调用外部 API，以下为模拟翻译结果
    return text  # 假设翻译结果与原文相同

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```

输出：
```
Immersive Translate
```

默认嵌入伪量化_4 位 = 伪量化.带参数(
    观察者=每通道移动平均最小最大观察者,
    穿梭模式=torch.每通道仿射浮点 Q 参数,
    坐标轴=0,
    数据类型=torch.五四二,
    平均常数=1,
)

默认直方图伪量化 = 伪量化.带参数(
    观察者=直方图观察者,
    量化最小值=0,
    量化最大值=255,
    数据类型=torch.quint8,
    穿梭模式=torch.每张图像仿射,
    缩小范围=真的,
)
```python
# 假设输入文本为：
input_text = """Immersive Translate"""

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中无法调用外部 API，以下为模拟翻译结果
    return text  # 假设翻译结果与原文相同

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```

输出：
```
Immersive Translate
```
使用直方图进行激活的伪量化。
```python
# 假设输入文本为：
input_text = """Immersive Translate"""

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中无法调用外部 API，以下为模拟翻译结果
    return text  # 假设翻译结果与原文相同

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```

输出：
```
Immersive Translate
```


默认融合激活假量化 = 融合移动平均观测伪量化.带参数(
    观察者=移动平均最小最大观察者,
    量化最小值=0,
    量化最大值=255,
    数据类型=torch.quint8,
)

```python
# 假设输入文本为：
input_text = """Immersive Translate"""

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中无法调用外部 API，以下为模拟翻译结果
    return text  # 假设翻译结果与原文相同

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```

输出：
```
Immersive Translate
```
`default_fake_quant`的融合版本，性能得到提升。
```python
# 假设输入文本为：
input_text = """Immersive Translate"""

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中无法调用外部 API，以下为模拟翻译结果
    return text  # 假设翻译结果与原文相同

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```

输出：
```
Immersive Translate
```


default_fused_wt_fake_quant = 融合移动平均观测伪量化.带参数(
    观察者=移动平均最小最大观察者,
    量化最小值=-128,
    量化最大值=127,
    数据类型=torch.qint8,
    穿梭模式=torch.每张张量对称,
)
```python
# 假设输入文本为：
input_text = """Immersive Translate"""

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中无法调用外部 API，以下为模拟翻译结果
    return text  # 假设翻译结果与原文相同

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```

输出：
```
Immersive Translate
```
`default_weight_fake_quant`的融合版本，性能得到提升。
```python
# 假设输入文本为：
input_text = """Immersive Translate"""

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中无法调用外部 API，以下为模拟翻译结果
    return text  # 假设翻译结果与原文相同

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```

输出：
```
Immersive Translate
```

默认融合通道权重伪量化 = 融合移动平均观测伪量化.带参数(
    观察者=每通道移动平均最小最大观察者,
    量化最小值=-128,
    量化最大值=127,
    数据类型=torch.qint8,
    穿梭模式=torch.每通道对称,
)
```python
# 假设输入文本为：
input_text = """Immersive Translate"""

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中无法调用外部 API，以下为模拟翻译结果
    return text  # 假设翻译结果与原文相同

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```

输出：
```
Immersive Translate
```
`default_per_channel_weight_fake_quant`的融合版本，性能提升。
```python
# 假设输入文本为：
input_text = """Immersive Translate"""

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中无法调用外部 API，以下为模拟翻译结果
    return text  # 假设翻译结果与原文相同

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```

输出：
```
Immersive Translate
```

融合_wt_伪量化范围_负 127 到 127 = 融合移动平均观测伪量化.带参数(
    观察者=移动平均最小最大观察者,
    量化最小值=-127,
    量化最大值=127,
    数据类型=torch.qint8,
    质量方案=火炬.每张张量对称,
    eps=2**-12,
)
```python
# 假设输入文本为：
input_text = """Immersive Translate"""

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中无法调用外部 API，以下为模拟翻译结果
    return text  # 假设翻译结果与原文相同

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```

输出：
```
Immersive Translate
```
融合版本的`default_weight_fake_quant`，将 8 位值限制在[-127, +127]范围内，不包括-128。
```python
# 假设输入文本为：
input_text = """Immersive Translate"""

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中无法调用外部 API，以下为模拟翻译结果
    return text  # 假设翻译结果与原文相同

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```

输出：
```
Immersive Translate
```

融合通道权重伪量化范围-127 到 127 = (
    融合移动平均观测伪量化.带参数(
        观察者=每通道移动平均最大最小观察者,
        量化最小值=-127,
        量化最大值=127,
        数据类型=PyTorch.qint8,
        qscheme=torch.per_channel_symmetric,
        eps=2**-12,
    )
)

" "
融合版本的`default_per_channel_weight_fake_quant`，8 位值限制在[-127, +127]范围内，不包括-128。
```python
# 假设输入文本为：
input_text = """Immersive Translate"""

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中无法调用外部 API，以下为模拟翻译结果
    return text  # 假设翻译结果与原文相同

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```

输出：
```
Immersive Translate
```


定义 _is_fake_quant_script_module(模块):
    "如果给定的模块是 FakeQuantize 脚本模块的实例，则返回 true。"
    如果 isinstance(模块, torch.jit.递归脚本模块):
        # 完整名称看起来像 '__torch__.torch.ao.quantization.fake_quantize.___torch_mangle_2.FakeQuantize'
        后缀 = 模块.__c.合法名称.分割("。", 1]1]
        名称 = 还.子(r__.torch_mangle_\d+, "", 后缀)
        返回 (
            名称 == torch.ao.quantization.fake_quantize.FakeQuantize
            或 名称
            == torch.ao.quantization.fake_quantize.FusedMovingAvgObsFakeQuantize
        )
    返回 False



[文档]def 禁用伪造量化(mod):
"""禁用模块的伪造量化。

禁用此模块的伪量化（如果适用）。示例用法::

# 模型是任何 PyTorch 模型
model.apply(torch.ao.quantization.disable_fake_quant)

"""
如果实例化(mod)为 FakeQuantizeBase 或_is_fake_quant_script_module(mod):
mod 禁用伪量化()




[文档]def enable_fake_quant(mod):
"""启用模块的伪量化。

如果适用，为该模块启用伪量化。示例用法::

# model 是任何 PyTorch 模型
model.apply(torch.ao.quantization.enable_fake_quant)

"""
if isinstance(mod, FakeQuantizeBase) or _is_fake_quant_script_module(mod):
mod.enable_fake_quant()




[文档]def disable_observer(mod):
"""禁用此模块的观察。

如果适用，禁用此模块的观察。示例用法::

# model 是任何 PyTorch 模型
model.apply(torch.ao.quantization.disable_observer)

"""
if isinstance(mod, FakeQuantizeBase) or _is_fake_quant_script_module(mod):
mod.disable_observer()




[文档]def enable_observer(mod):
"""启用此模块的观察功能。

如果适用，启用此模块的观察功能。示例用法::

# model 是任何 PyTorch 模型
model.apply(torch.ao.quantization.enable_observer)

"""
if isinstance(mod, FakeQuantizeBase) or _is_fake_quant_script_module(mod):
mod.enable_observer()

© 版权所有 PyTorch 贡献者。

使用 Sphinx 构建，主题由 Read the Docs 提供。

文档

访问 PyTorch 的全面开发者文档

查看文档

教程

获取初学者和高级开发者的深入教程

查看教程

资源

查找开发资源并获得您的疑问解答

查看资源

为了分析流量并优化您的体验，我们在本网站上使用 cookies。通过点击或导航，您同意允许我们使用 cookies。作为本网站的当前维护者，适用 Facebook 的 Cookies 政策。了解更多信息，包括关于可用控制的信息：Cookies 政策。