# mypy: 允许未类型化定义
导入
火炬
来自
火炬
导入
张量
来自 torch._ops
导入
操作
所有 = [
浮点功能,
外部浮点功能,
功能性]
[文档]
类
浮点功能性(
火炬.
神经网络.
模块):
r"""浮点运算状态收集器类。
这个类的实例可以用作代替 ``torch.`` 前缀
一些操作。以下为示例用法。
.. 注意：
此类不提供 `forward` 钩子。相反，您必须使用
基底函数之一（例如 ``add``）。
示例::
>>> f_add = FloatFunctional()
>>> a = torch.tensor(3.0)
>>> b = torch.tensor(4.0)
>>> f_add.add(a, b) # 等价于 ``torch.add(a, b)``
有效的操作名称：
- add
猫
多
加 ReLU
加标量
- 多乘标量
"""
定义 __init__(
我) ->
无:
超级().__init__()
self.activation_post_process = torch.神经网络.
身份()
定义
前进(
我, x):
提升
运行时错误(
"FloatFunctional 不应该使用 "
+ "向前。请使用底层操作"
)
r"与 `torch.add(Tensor, Tensor)` 操作等价"
def add(我, x:
张量, y:
张量) ->
张量:
r = PyTorch.
加(x, y)
r = 自己的.
激活后处理(r)
返回 r
r等价于 `torch.add(Tensor, float)` 的操作
定义
添加标量(self, x:
张量, y:
浮点数) ->
张量:
r = PyTorch.
加(x, y)
# 注意：此操作未观察到，因为观察尚未进行
# 不需要此量化操作
返回 r
r"""相当于 ``torch.mul(Tensor, Tensor)`` 的操作"""
定义
乘(
自身, x:
张量, y:
张量) ->
张量:
r = 火炬.
多(x, y)
r = 自身.
激活后处理(r)
返回 r
r等效于 `torch.mul(Tensor, float)` 的操作
def mul_scalar(self, x: 张量, y:
浮点数) ->
张量:
r = 火炬.
乘(x, y)
# 注意：此操作未观察到，因为观察未
# 需要量化操作。
返回 r
r等价于 `torch.cat` 的操作
定义 cat(
我, x:
列表[
张量
]，
暗淡:
整数 = 0) ->
张量:
r = 火炬.
猫(x,
维度=
维度)
r = 我.
激活后处理(r)
返回 r
r等价于 `relu(torch.add(x,y))` 的操作
def add_relu(self, x: Tensor, y: 张量) ->
张量:
r = 火炬.
添加(x, y)
r = 火炬.
神经网络.
函数式.relu(r)
r = 自.
激活后处理(r)
返回 r
r等效于 `torch.matmul(Tensor, Tensor)` 的操作
def 矩阵乘法(self, x:
张量, y:
张量) ->
张量:
r = 火炬.
矩阵乘法(x, y)
r = 自身.
激活后处理(r)
返回 r
[文档]
类 FXFloatFunctional(
火炬.
神经网络.
模块):
r"""在 FX 图模式量化之前替换 FloatFunctional 模块的模块，
由于 activation_post_process 将直接插入顶层模块
有效的操作名称：
- 添加
- 类别
- 乘
- 加 ReLU
- 加标量
- 乘标量
"沉浸式翻译"
定义
前进(
自己, x):
提升高度
运行时错误(
"FloatFunctional 不打算使用“"
+ "‘forward’。请使用底层操作"
)
r等效于 `torch.add(Tensor, Tensor)` 的操作
def add(self, x: 张量, y:
张量) ->
张量:
r = 火炬.
添加(x, y)
返回 r
r"""操作等价于 ``torch.add(Tensor, float)``"""
def 添加标量(self, x:
张量, y:
浮点数) ->
张量:
r = 火炬.
添加(x, y)
返回 r
r等价于 `torch.mul(Tensor, Tensor)` 的操作
定义
多(
自身, x:
张量, y:
张量) ->
张量:
r = PyTorch.
乘(x, y)
返回 r
r等价于 `torch.mul(Tensor, float)` 的操作
定义 mul_scalar(
我, x:
张量, y:
浮点数) ->
张量:
r = PyTorch.
乘(x, y)
返回 r
r等效于 `torch.cat` 的操作
def cat(self, x: 列表[
张量
]
维度:
整型 = 0) ->
张量:
r = 火炬.
猫(x,
暗=
暗)
返回 r
r等价于 `relu(torch.add(x,y))` 的操作
def add_relu(self, x: 张量, y:
张量) ->
张量:
r = 火炬.
添加(x, y)
r = 火炬.
神经网络.
功能性.relu(r)
返回 r
r等价于 `torch.matmul(Tensor, Tensor)` 的操作
def 矩阵乘法(self, x:
张量, y:
张量) ->
张量:
r = 火炬.
矩阵乘法(x, y)
返回 r
文档
类
Q 函数式(
PyTorch.nn.
模块):
r"""量化操作的包装类。
该类的实例可以用作代替的
``torch.ops.quantized`` 前缀。下面是示例用法。
.. 注意::
此类不提供 ``forward`` 钩子。相反，您必须使用
基底函数之一（例如 ``add``）。
示例::
>>> q_add = QFunctional()
>>> # xdoctest: +SKIP
>>> a = torch.quantize_per_tensor(torch.tensor(3.0), 1.0, 0, torch.qint32)
>>> b = torch.quantize_per_tensor(torch.tensor(4.0), 1.0, 0, torch.qint32)
>>> q_add.add(a, b) # 等价于 ``torch.ops.quantized.add(a, b, 1.0, 0)``
有效的操作名称：
- add
猫
多
加 ReLU
加标量
- 多乘标量
"""
定义 __init__(
我) ->
无:
超级().__init__()
self.scale = 1.0
self.零点 = 0
自我.
激活后处理 =
火炬.
神经网络.
身份()
定义
保存到状态字典(
我,
目的地,
前缀,
保持变量):
超级().
_保存到状态字典(
目的地,
前缀,
保持变量)
目标[
前缀 +
缩放] =
火炬.
张量(
自身.
规模)
目的地[
前缀 +
零点] =
火炬.
张量(
自.
零点)
定义
从状态字典加载(
self,
状态字典,
前缀,
本地元数据,
严格,
缺少键,
预期之外的键,
错误信息,
):
自身.
比例 =
浮点(state_dict.pop(prefix + "scale"))
我.
零点 =
整数(
状态字典.
流行(
前缀 +
零点))
超级().
从状态字典加载(
状态字典,
前缀,
本地元数据,
错误,
缺少键,
预期之外的键,
错误消息,
)
def _get_name(self):
return "Q 功能"
def extra_repr(self):
返回 f
"缩放="{self.
缩放}
零点={
自身.
零点}"
定义
前进(
自己, x):
提升
运行时错误(
"功能不打算使用“”
+ "请使用底层操作“”
)
r"相当于 ``torch.ops.quantized.add`` 的操作"
def 添加(
自己, x:
张量, y:
张量) ->
张量:
r = 操作.
量化.
添加(x, y,
缩放=
自己.
缩放,
零点=
自我.
零点)
r = 自我.
激活后处理(r)
返回 r
r等价于 `torch.ops.quantized.add(Tensor, float)` 的操作
定义
添加标量(self, x:
张量, y:
浮点数) ->
张量:
r = 操作.
量化.
添加标量(x, y)
# 注意：此操作未观察到，因为观察尚未进行
# 此操作不需要，因为量化操作不需要
返回 r
r等效于 `torch.ops.quantized.mul(Tensor, Tensor)` 的操作
def mul(self, x: 张量, y:
张量) ->
张量:
r = 操作.
量化.
乘(x, y,
缩放=
我.
规模,
零点=
我.
零点)
r = 自我.
激活后处理(r)
返回 r
r等效于 `torch.ops.quantized.mul(Tensor, float)` 的操作
def mul_scalar(self, x: 张量, y:
浮点数) ->
张量:
r = 操作.
量化.
矩阵乘以标量(x, y)
# 注意：此操作未观察到，因为观察未进行
# 需要用于量化操作的。
返回 r
r"""与 ``torch.ops.quantized.cat`` 相等的操作"""
def 猫(
自我, x:
列表[
张量
] dim: int = 0) ->
张量:
r = 操作.
量化.
猫(x,
尺度=
自身.
尺度,
零点=
我.
零点,
暗淡=
暗淡)
r = 我.
激活后处理(r)
返回 r
r等价于 `torch.ops.quantized.add_relu` 的操作
def add_relu(self, x: Tensor, y: 张量) ->
张量:
r = 操作.
量化.
添加 ReLU(x, y,
缩放=
自身.
尺度,
零点=
自身.
零点)
r = 我.
激活后处理(r)
返回 r
r等价于 `torch.ops.quantized.matmul(Tensor, Tensor)` 的操作
def 矩阵乘法(self, x:
张量, y:
张量) ->
张量:
r = 操作.
量化.
矩阵乘法(x, y,
缩放=
自身.
尺度,
零点=
自身.
零点)
# 注意：此操作不被观察，因为观察尚未进行
# 不需要为量化操作提供
返回 r
@classmethod
定义 from_float(cls, mod, use_precomputed_fake_quant=
错误):
断言 (
类型(
模块) ==
浮点功能
), "QFunctional.from_float 期望一个 FloatFunctional 实例"
缩放,
零点 =
模块.
激活后处理.
计算 q 参数()
# 类型：忽略[运算符]
新模块 =
Q 功能()
新模块.
缩放 =
浮点数(
缩放)
新模块.
零点 =
整数(
零点)
返回
新模块
