torch.ao.nn.quantized.modules.embedding_ops 的源代码

# mypy: 允许未类型化装饰器
# mypy: 允许未类型化定义
导入 火炬
导入 torch.nn 作为 然后
来自 火炬 导入 张量  # noqa: F401
来自 torch._jit_internal 导入 列表, 可选  # noqa: F401

来自 .工具 导入 _hide_packed_params_repr, _quantize_weight


__all__ = [嵌入打包参数, 嵌入, 嵌入包]


类 嵌入打包参数(火炬.nn.模块):
    _version = 1

    定义 初始化(自身, 嵌入数量, 嵌入维度, 数据类型=火炬.quint8):
        超级().初始化()
        自身.dtype = dtype
        如果 自身.dtype 在 [火炬.quint8, 火炬.quint4x2]：
            尺度 = 火炬.一(嵌入数量, 数据类型=火炬.float)
            零点 = 火炬.零(嵌入数量, 数据类型=火炬.float)
            wq = 火炬._空通道仿射量化(
                [嵌入数量, 嵌入维度]
                尺度=尺度,
                零点=零点,
                轴=0,
                数据类型=自身.数据类型,
            )
            自身.set_weight(wq)
        否则:
            抛出异常 不支持的操作异常(
                f"不支持量化嵌入的 dtype！支持 quint8 和 quint4x2。获取到的 dtype："{数据类型}"
            )

    @torch.算子.导出
    定义 set_weight(自身, 重量: 火炬.张量) -> 无:
        如果 自身.dtype 在 [火炬.quint8, 火炬.quint4x2]：
            自身.包装重量 = 火炬.操作.量化.预打包嵌入包(重量)
        否则:
            抛出异常 不支持的操作异常(
                "不支持量化嵌入预打包的 dtype！支持 quint8 和 quint4x2。"
            )

    @torch.算子.导出
    定义 权重(自身):
        如果 自身.dtype 在 [火炬.quint8, 火炬.quint4x2]：
            返回 火炬.操作.量化.解包嵌入包(自身.包装重量)
        否则:
            抛出异常 不支持的操作异常(
                "不支持的量化嵌入解包数据类型！支持 quint8 和 quint4x2。"
            )

    定义 前向(自身, x):
        返回 x

    # 版本 1
    #   self
    #   |--- 包装重量 : 表示 EmbeddingPackedParamsBase 权重的 Tensor
    torch.dtype

    定义 保存到状态字典(自身, 目的地, 前缀, 保留变量):
        超级().保存到状态字典(目的地, 前缀, 保留变量)
        目的地[前缀 + "dtype"] = 自身.dtype
        目的地[前缀 + _packed_weight] = 自身.权重()

    定义 从状态字典加载(
        自身,
        state_dict,
        前缀,
        本地元数据,
        严格的,
        缺少键,
        预期之外的键,
        错误信息,
    ):
        自身.dtype = state_dict[前缀 + "dtype"]
        state_dict.弹出(前缀 + "dtype")

        权重 = state_dict[前缀 + _packed_weight]
        state_dict.弹出(前缀 + _packed_weight)
        自身.set_weight(重量)

        超级().从状态字典加载(
            state_dict,
            前缀,
            本地元数据,
            错误,
            缺少键,
            预期之外的键,
            错误信息,
        )

    定义 __repr__(自身):
        返回 自身.权重().__repr__()


类 嵌入(火炬.nn.模块):
    r""
基于量化打包权重的量化嵌入模块。
我们采用与 `torch.nn.Embedding` 相同的接口，请参阅
https://pytorch.org/docs/stable/generated/torch.nn.Embedding.html 以获取文档。

与 :class:`~torch.nn.Embedding` 类似，属性将随机
初始化于模块创建时，稍后将被覆盖

属性：
权重（Tensor）：模块的非可学习量化权重
形状：math:`(\text{num\_embeddings}, \text{embedding\_dim})`。

示例：
        >>> m = nn.quantized.Embedding(num_embeddings=10, embedding_dim=12)
        >>> indices = torch.tensor([9, 6, 5, 7, 8, 8, 9, 2, 8])
        >>> output = m(indices)
>>> 打印(output.size())
        torch.Size([9, 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)
```
    _version = 1

    定义 初始化(
        自身,
        嵌入数量: int,
        嵌入维度: int,
        填充索引: 可选[int] = 无,
        最大范数: 可选[float] = 无,
        归一化类型: 浮点数 = 2.0,
        按频率缩放梯度: 布尔类型 = 错误,
        稀疏: 布尔类型 = 错误,
        权重: 可选[张量] = 无,
        数据类型=火炬.quint8,
    ) -> 无:
        超级().初始化()
        自身.嵌入数量 = 嵌入数量
        自身.嵌入维度 = 嵌入维度
        自身.dtype = dtype

        如果 _weight 是 无:
            尺度 = 火炬.一(嵌入数量, 数据类型=火炬.float)
            零点 = 火炬.零(嵌入数量, 数据类型=火炬.float)
            权重 = 火炬._空通道仿射量化(
                [嵌入数量, 嵌入维度]
                尺度=尺度,
                零点=零点,
                轴=0,
                数据类型=火炬.quint8,
            )
        否则:
            断言 列表(权重.shape) == [
                嵌入数量,
                嵌入维度,
            ] 权重的形状与 num_embeddings 和 embedding_dim 不匹配
            权重 = _weight

        自身._打包参数 = 嵌入打包参数(
            嵌入数量, 嵌入维度, dtype
        )
        自身._打包参数.设置权重(q 权重)

    定义 前向(自身, 索引: 张量) -> 张量:
        如果 自身.dtype == 火炬.quint4x2:
            返回 火炬.操作.量化.4 位嵌入(
                自身._打包参数._打包权重, 索引
            )
        否则:
            返回 火炬.操作.量化.嵌入字节(
                自身._packed_params._packed_weight, 索引
            )

    定义 _获取名称(自身):
        返回 量化嵌入

    定义 __repr__(自身):
        返回 _hide_packed_params_repr(自身, 嵌入打包参数)

    定义 额外表示(自身):
        额外的表示字符串 = (
            fnum_embeddings={自身.嵌入数量}, embedding_dim={自身.嵌入维度}，"
            fdtype={自身._packed_params.数据类型}, 协议方案={自身.重量().q 方案()}"
        )

        返回 extra_repr_str

    定义 设置权重(自身, w: 火炬.张量) -> 无:
        自身._packed_params.设置权重(w)

    定义 重量(自身):
        返回 自身._packed_params.权重()

    @classmethod
    定义 从浮点数(类, 模块, 使用预计算的假量化=错误):
        r从浮点模块创建一个量化嵌入模块

参数：
模块（Module）：一个浮点模块，可以是 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)
```
        如果 有属性(模块, "权重伪量化"):
            断言 类型(模块) == 火炬.ao.nn.qat.嵌入, (
                "nnq。"
                + 类.__name__
                + ".from_float "
                + "仅对使用伪量化的"
                + 火炬.ao.nn.qat.嵌入.__name__
            )
            重量观察者 = 模块.weight_fake_quant
        否则:
            断言 类型(模块) == nn.嵌入, (
                神经网络查询点
                + 类.__name__
                + ".from_float 仅适用于 "
                + nn.嵌入.__name__
            )
            断言 有属性(
                模块, "qconfig"
            ), "嵌入输入浮点模块必须定义 qconfig"
            来自 torch.ao.quantization 导入 float_qparams_weight_only_qconfig

            如果 模块.qconfig 是 not None 和 模块.qconfig.权重 是 not 无:  # 类型：忽略[联合属性]
                重量观察者 = 模块.qconfig.重量()  # type: ignore[union-attr, operator]
            否则:
                重量观察者 = float_qparams_weight_only_qconfig.重量()

        dtype = 重量观察者.dtype
        是_float_qparams_qconfig = (
            权重观察者.虚拟方案 == 火炬.单通道仿射浮点 Q 参数
        )
        断言 (
            is_float_qparams_qconfig
        ), "嵌入量化仅支持 float_qparams_weight_only_qconfig。"

        断言 (
            dtype == 火炬.无符号 8 位整数 或 dtype == 火炬.quint4x2
        ), f"nnq.Embedding 仅支持 torch.quint8 和 torch.quint4x2 数据类型，获取"{数据类型}"

        运行观察者以计算 qparams。
        权重观察者(模块.重量)
        权重 = _量化权重(模块.重量.float(), 权重观察者)

        创建量化嵌入模块并传入量化权重
        qembedding = 嵌入(模块.嵌入数量, 模块.嵌入维度)
        qembedding.设置权重(权重)
        返回 量子嵌入


    @classmethod
    定义 来自参考(类, 参考嵌入):
        q 嵌入 = 类(
            参考嵌入.嵌入数量,
            参考嵌入.嵌入维度,
            参考嵌入.填充索引,
            参考嵌入.最大范数,
            参考嵌入.归一化类型,
            参考嵌入.按频率缩放梯度,
            参考嵌入.稀疏,
            参考嵌入.获取量化权重(),
            参考嵌入.权重数据类型,
        )
        返回 q 嵌入



类 EmbeddingBag(嵌入):
    r""
具有量化打包权重的量化 EmbeddingBag 模块。
我们采用与`torch.nn.EmbeddingBag`相同的接口，请参阅
https://pytorch.org/docs/stable/generated/torch.nn.EmbeddingBag.html 以获取文档。

与 :class:`~torch.nn.EmbeddingBag` 类似，属性将随机
初始化于模块创建时，稍后将被覆盖

属性：
权重（Tensor）：模块的非可学习量化权重
形状：math:`(\text{num\_embeddings}, \text{embedding\_dim})`。

示例：
        >>> m = nn.quantized.EmbeddingBag(num_embeddings=10, embedding_dim=12, include_last_offset=True, mode='sum')
        >>> indices = torch.tensor([9, 6, 5, 7, 8, 8, 9, 2, 8, 6, 6, 9, 1, 6, 8, 8, 3, 2, 3, 6, 3, 6, 5, 7, 0, 8, 4, 6, 5, 8, 2, 3])
        >>> offsets = torch.tensor([0, 19, 20, 28, 28, 32])
        >>> output = m(indices, offsets)
>>> 打印(output.size())
        torch.Size([5, 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)
```
    _version = 1

    定义 初始化(
        自身,
        嵌入数量: int,
        嵌入维度: int,
        最大范数: 可选[float] = 无,
        归一化类型: 浮点数 = 2.0,
        按频率缩放梯度: 布尔类型 = 错误,
        模式: 字符串 = "求和",
        稀疏: 布尔类型 = 错误,
        权重: 可选[张量] = 无,
        include_last_offset: 布尔类型 = 错误,
        数据类型=火炬.quint8,
    ) -> 无:
        超级().初始化(嵌入数量, 嵌入维度, 权重=权重, 数据类型=数据类型)

        自身.模式 = 模式
        自身.剪枝权重 = 假
        自身.包含最后一个偏移量 = 包含最后一个偏移量
        自身.dtype = dtype

    定义 前向(
        自身,
        索引: 张量,
        偏移量: 可选[张量] = 无,
        每样本权重: 可选[张量] = 无,
        压缩索引映射: 可选[张量] = 无,
    ) -> 张量:
        如果 自身.dtype == 火炬.quint4x2:
            返回 火炬.操作.量化.4 位嵌入包(
                自身._packed_params._packed_weight,
                索引,
                偏移量,
                错误,
                0,
                自身.pruned_weights,
                每样本权重,
                compressed_indices_mapping,
                自身.include_last_offset,
            )
        否则:
            返回 火炬.操作.量化.嵌入包字节(
                自身._packed_params._packed_weight,
                索引,
                偏移量,
                错误,
                0,
                自身.pruned_weights,
                每样本权重,
                compressed_indices_mapping,
                自身.include_last_offset,
            )

    定义 _获取名称(自身):
        返回 "量化嵌入包"

    @classmethod
    定义 从浮点数(类, 模块, 使用预计算的假量化=错误):
        r"从浮点模块创建量化嵌入包模块"

参数：
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)
```
        如果 有属性(模块, "权重伪量化"):
            重量观察器 = 模块.weight_fake_quant
        否则:
            断言 类型(模块) == nn.EmbeddingBag, (
                nnq.
                + 类.__name__
                + ".from_float 仅适用于 "
                + nn.EmbeddingBag.__name__
            )
            断言 有属性(
                模块, qconfig
            ), 嵌入包输入浮点模块必须定义 qconfig
            来自 torch.ao.quantization.qconfig 导入 float_qparams_weight_only_qconfig

            如果 模块.qconfig 是 not None 和 模块.qconfig.权重 是 not 无:  # 类型：忽略[联合属性]
                重量观察者 = 模块.qconfig.重量()  # type: ignore[union-attr, operator]
            否则:
                重量观察者 = float_qparams_weight_only_qconfig.重量()

        dtype = 重量观察者.dtype
        is_float_qparams_qconfig = (
            weight_observer.虚拟方案 == 火炬.单通道仿射浮点 Q 参数
        )
        断言 (
            is_float_qparams_qconfig
        ), "EmbeddingBag 量化仅支持 float_qparams_weight_only_qconfig。"

        断言 (
            dtype == 火炬.无符号 8 位整数 或 dtype == 火炬.quint4x2
        ), fnnq.EmbeddingBag 仅支持 torch.quint8 和 torch.quint4x2 数据类型，获取{数据类型}"

        # 运行观察者以计算 qparams。
        权重观察者(模块.重量)
        权重 = _量化权重(模块.重量.float(), weight_observer)

        # 创建量化 EmbeddingBag 模块并传入量化权重
        qembedding_bag = EmbeddingBag(
            模块.嵌入数量,
            模块.嵌入维度,
            最大范数=模块.最大范数,
            归一化类型=模块.归一化类型,
            按频率缩放梯度=模块.按频率缩放梯度,
            模式=模块.模式,
            稀疏=模块.稀疏,
            include_last_offset=模块.include_last_offset,
            数据类型=数据类型,
        )
        q 嵌入包.设置权重(权重)
        返回 词袋嵌入


    @classmethod
    定义 从参考(类, 参考词袋嵌入):
        q 嵌入包 = 类(
            参考嵌入包.嵌入数量,
            参考嵌入包.嵌入维度,
            参考嵌入包.最大范数,
            参考嵌入包.归一化类型,
            参考嵌入包.按频率缩放梯度,
            参考嵌入包.模式,
            参考嵌入包.稀疏,
            参考嵌入包.获取量化权重(),
            参考嵌入包.include_last_offset,
            参考嵌入包.权重数据类型,
        )
        返回 qembedding_bag