torch.ao.nn.intrinsic.quantized.modules.linear_relu 的源代码

# mypy: 允许未类型化定义
导入 火炬
导入 torch.ao.nn.intrinsic 作为 nni
导入 torch.ao.nn.quantized 作为 nnq
来自 torch.ao.nn.quantized.modules.utils 导入 _quantize_weight


__all__ = [
    LinearReLU,
    "LinearLeakyReLU",
    线性双曲正切,
]


[文档]类 LinearReLU(nnq.Linear)
r"""
线性 ReLU 模块，由线性模块和 ReLU 模块融合而成

我们采用与 :class:`torch.ao.nn.quantized.Linear` 相同的接口

属性：
与 torch.ao.nn.quantized.Linear 相同

示例::

>>> # xdoctest: +SKIP
>>> m = nn.intrinsic.LinearReLU(20, 30)
>>> input = torch.randn(128, 20)
>>> output = m(input)
>>> print(output.size())
torch.Size([128, 30])
"""
_FLOAT_MODULE = nni.LinearReLU  # type: ignore[assignment]

def __init__(self, in_features, out_features, bias=True, dtype=torch.qint8):
super().__init__(in_features, out_features, bias, dtype)

def forward(self, x: torch.Tensor) -> torch.Tensor:
return torch.ops.quantized.linear_relu(
x, self._packed_params._packed_params, self.scale, self.zero_point
        )

def _get_name(self):
return "QuantizedLinearReLU"

    @classmethod
def from_float(cls, mod, use_precomputed_fake_quant=False):
return super().from_float(mod, use_precomputed_fake_quant)

    @classmethod
def from_reference(cls, ref_linear_relu, output_scale, output_zero_point):
return super().from_reference(
ref_linear_relu[0], 输出比例，输出零点
        )


类 线性 LeakyReLU(氮气.线性):
    r""
仅适用于 onednn 后端
由线性模块和 LeakyReLU 模块融合而成的 LinearLeakyReLU 模块
我们采用与 :class:`torch.ao.nn.quantized.Linear` 相同的接口。
属性：
与 torch.ao.nn.quantized.Linear 相同。
+ 负斜率
示例：
        >>> # xdoctest: +SKIP
        >>> m = nn.intrinsic.LinearLeakyReLU(20, 30, 0.01)
        >>> input = torch.randn(128, 20)
        >>> output = m(input)
>>> 打印(output.size())
        torch.Size([128, 30])
```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)
```
    浮点模块 = nni.线性泄漏 ReLU  # 类型：忽略[赋值]

    定义 初始化(
        自身, 输入特征, 输出特征, 负斜率, 偏置=True, 数据类型=火炬.qint8
    ):
        超级().初始化(输入特征, 输出特征, 偏置, 数据类型)
        自身.负斜率 = 负斜率

    定义 前向(自身, x: 火炬.张量) -> 火炬.张量:
        返回 火炬.操作.量化.线性泄漏 ReLU(
            x,
            自身._packed_params._packed_params,
            自身.比例,
            自身.零点,
            自身.负斜率,
        )

    定义 _获取名称(自身):
        返回 量化线性泄漏 ReLU

    @classmethod
    定义 从浮点数(类, mod, 使用预计算的假量化=错误):
        断言 (
            类型(mod) == nni.线性泄漏 ReLU
        ), 输入浮点模块应为 LinearLeakyReLU
        断言 有属性(mod, qconfig), 输入浮点模块必须定义 qconfig
        activation_post_process = mod.activation_post_process
        leaky_relu = mod[1]
        修饰 = mod[0]
        权重后处理 = mod.qconfig.重量()
        权重后处理(mod.重量)
        dtype = 权重后处理.dtype
        act_scale, act_zp = 激活后处理.计算 q 参数()  # type: ignore[union-attr,operator]
        断言 dtype == 火炬.qint8, 权重观察者必须具有 torch.qint8 数据类型
        权重 = _quantize_weight(mod.重量.float(), 权重后处理)
        qlinear_leaky_relu = 类(
            mod.输入特征, mod.输出特征, 漏波 ReLU.负斜率, 数据类型=dtype
        )
        qlinear_leaky_relu.设置权重偏差(权重, mod.偏置)
        qlinear_leaky_relu.缩放 = float(act_scale)
        qlinear_leaky_relu.零点 = int(活动零偏置)
        返回 qlinear_leaky_relu

    @classmethod
    定义 来自参考(类, ref_mod, 输出尺度, 输出零点):
        线性 = 引用模块[0]
        leaky_relu = 引用模块[1]
        Q 线性泄漏 ReLU = 类(
            线性.输入特征, 线性.输出特征, 漏波 ReLU.负斜率
        )
        权重 = 线性.获取量化权重()
        Q 线性泄漏 ReLU.设置权重偏差(权重, 线性.偏置)
        qlinear_leaky_relu.缩放 = float(输出尺度)
        qlinear_leaky_relu.零点 = int(输出零点)
        返回 qlinear_leaky_relu


类 线性双曲正切函数(氮气.线性):
    r""
由线性模块和 Tanh 模块融合而成的 LinearTanh 模块

我们采用与 :class:`torch.ao.nn.quantized.Linear` 相同的接口。

属性：
与 torch.ao.nn.quantized.Linear 相同。

示例：

        >>> # xdoctest: +SKIP
        >>> m = nn.intrinsic.LinearTanh(20, 30)
        >>> input = torch.randn(128, 20)
        >>> output = m(input)
>>> 打印(output.size())
        torch.Size([128, 30])
```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)
```
    浮点模块 = nni.线性双曲正切  # 类型：忽略[赋值]

    定义 初始化(自身, 输入特征, 输出特征, 偏置=True, 数据类型=火炬.qint8):
        超级().初始化(输入特征, 输出特征, 偏置, 数据类型)

    定义 前向(自身, x: 火炬.张量) -> 火炬.张量:
        返回 火炬.操作.量化.linear_tanh(
            x, 自身._packed_params._packed_params, 自身.比例, 自身.零点
        )

    定义 _获取名称(自身):
        返回 "量化线性双曲正切"

    @classmethod
    定义 从浮点数(类, mod, 使用预计算的假量化=错误):
        断言 类型(mod) == nni.线性双曲正切函数, "输入浮点模块应为线性双曲正切"
        断言 有属性(mod, qconfig), 输入浮点模块必须定义 qconfig
        activation_post_process = mod.activation_post_process
        修饰 = mod[0]
        权重后处理 = mod.qconfig.重量()
        权重后处理(mod.重量)
        dtype = 权重后处理.dtype
        act_scale, act_zp = 激活后处理.计算 q 参数()  #类型：忽略[联合属性，运算符]
        断言 dtype == 火炬.qint8, 权重观察者必须具有 torch.qint8 数据类型
        权重 = _quantize_weight(mod.重量.float(), 权重后处理)
        qlinear_tanh = 类(mod.输入特征, mod.输出特征, 数据类型=数据类型)
        qlinear_tanh.设置权重偏差(权重, mod.偏置)
        qlinear_tanh.缩放 = float(act_scale)
        qlinear_tanh.零点 = int(活动零偏置)
        返回 qlinear_tanh

    @classmethod
    定义 来自参考(类, ref_mod, 输出尺度, 输出零点):
        线性 = ref_mod[0]
        q 线性双曲正切 = 类(线性.输入特征, 线性.输出特征)
        权重 = 线性.获取量化权重()
        q 线性双曲正切.设置权重偏差(权重, 线性.偏置)
        q 线性双曲正切.缩放 = float(输出尺度)
        q 线性双曲正切.零点 = int(输出零点)
        返回 qlinear_tanh