# mypy: 允许未类型化定义
导入
火炬
__all__ = [
层归一化,
"GroupNorm",
实例归一化 1d,
实例归一化 2d,
实例归一化 3d,
]
[文档]
类
层归一化(
火炬.nn.
层归一化):
r这是`:class:`~torch.nn.LayerNorm`的量化版本。
附加参数：
* **scale** - 输出的量化尺度，类型：双精度浮点数。
* **zero_point** - 输出的量化零点，类型：长整型。
```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)
```
定义
初始化(
自身,
归一化形状,
重量,
偏置,
比例,
零点,
eps=0.00001,
元素级仿射=True,
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
超级().
初始化(
归一化形状,
eps=eps,
元素级仿射=
元素级仿射,
**factory_kwargs,
)
自身.
权重 =
权重
自身.
偏差 =
偏差
自身.
注册缓冲区(
"缩放",
火炬.
张量(
比例, **factory_kwargs))
自身.
注册缓冲区(
零点,
火炬.
张量(
零点, **factory_kwargs))
定义
前向(
自身,
输入):
返回
火炬.
操作.
量化.
层归一化(
输入,
自身.
归一化形状,
重量=
自身.
重量,
偏置=
自身.
偏置,
eps=自身.eps,
输出尺度=
自身.
比例,
输出零点=
自身.
零点,
)
定义
_获取名称(
自身):
返回
"量化层归一化"
@classmethod
定义
从浮点数(
类, mod,
使用预计算的假量化=
错误):
比例,
零点 = mod.
激活后处理.
计算 q 参数()
new_mod = 类(
mod.归一化形状,
mod.重量,
mod.偏置,
float(比例),
int(零点),
mod.eps,
mod.元素级仿射,
)
返回 new_mod
@classmethod
定义
来自参考(
类, mod,
比例,
零点):
返回
类(
mod.归一化形状,
mod.重量,
mod.偏置,
float(比例),
int(零点),
mod.eps,
mod.元素级仿射,
)
[文档]
类
组归一化(
火炬.nn.
组归一化):
r"""这是 :class:`~torch.nn.GroupNorm` 的量化版本。
额外参数：
* **scale** - 输出的量化尺度，类型：double。
* **zero_point** - 输出的量化零点，类型：long。
```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)
```
常量 = [
num_groups,
"通道数",
eps,
"仿射"]
定义
初始化(
自身,
群组数量,
通道数,
重量,
偏置,
比例,
零点,
eps=0.00001,
线性=True,
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
超级().
初始化(
群组数量,
通道数, eps,
线性, **factory_kwargs)
自身.
权重 =
权重
自身.
偏差 =
偏差
自身.
注册缓冲区(
"缩放",
火炬.
张量(
比例, **factory_kwargs))
自身.
注册缓冲区(
零点,
火炬.
张量(
零点, **factory_kwargs))
定义
前向(
自身,
输入):
返回
火炬.
操作.
量化.
群组归一化(
输入,
自身.
群组数量,
自身.
重量,
自身.
偏置,
自身.eps,
自身.
比例,
自身.
零点,
)
定义
_获取名称(
自身):
返回 "QuantizedGroupNorm"
@classmethod
定义
从浮点数(
类, mod,
使用预计算的假量化=
错误):
比例,
零点 = mod.
激活后处理.
计算 q 参数()
new_mod = 类(
mod.群组数量,
mod.通道数,
mod.重量,
mod.偏置,
float(比例),
int(零点),
mod.eps,
mod.线性,
)
返回
新模块
[文档]
类 InstanceNorm1d(
火炬.nn.InstanceNorm1d):
r这是`:class:`~torch.nn.InstanceNorm1d`的量化版本。
附加参数：
* **scale** - 输出的量化尺度，类型：double。
* **zero_point** - 输出的量化零点，类型：long。
```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)
```
定义
初始化(
自身,
特征数量,
重量,
偏置,
比例,
零点,
eps=0.00001,
动量=0.1,
线性=
错误,
跟踪运行统计=
错误,
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
超级().
初始化(
特征数量, eps,
动量,
线性,
跟踪运行统计, **
工厂参数
)
自身.
权重 =
权重
自身.
偏差 =
偏差
自身.
注册缓冲区(
"缩放",
火炬.
张量(
比例, **factory_kwargs))
自身.
注册缓冲区(
零点,
火炬.
张量(
零点, **factory_kwargs))
定义
前向(
自身,
输入):
返回
火炬.
操作.
量化.instance_norm(
输入,
自身.
重量,
自身.
偏置,
自身.eps,
自身.
比例,
自身.
零点
)
定义
_获取名称(
自身):
返回
量化 InstanceNorm1d
@classmethod
定义
从浮点数(
类, mod,
使用预计算的假量化=
错误):
比例,
零点 = mod.
激活后处理.
计算 q 参数()
new_mod = 类(
mod.特征数量,
mod.重量,
mod.偏置,
float(比例),
int(零点),
mod.eps,
mod.线性,
)
返回 new_mod
@classmethod
定义
来自参考(
类, mod,
比例,
零点):
返回
类(
mod.特征数量,
mod.重量,
mod.偏置,
float(比例),
int(零点),
mod.eps,
mod.线性,
)
[文档]
类
实例归一化 2d(
火炬.nn.
实例归一化 2d):
r这是`:class:`~torch.nn.InstanceNorm2d`的量化版本。
附加参数：
* **scale** - 输出的量化尺度，类型：double。
* **zero_point** - 输出的量化零点，类型：long。
```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)
```
定义
初始化(
自身,
特征数量,
重量,
偏置,
比例,
零点,
eps=0.00001,
动量=0.1,
线性=
错误,
跟踪运行统计=
错误,
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
超级().
初始化(
特征数量, eps,
动量,
线性,
跟踪运行统计, **
工厂参数
)
自身.
权重 =
权重
自身.
偏差 =
偏差
自身.
注册缓冲区(
"缩放",
火炬.
张量(
比例, **factory_kwargs))
自身.
注册缓冲区(
零点,
火炬.
张量(
零点, **factory_kwargs))
定义
前向(
自身,
输入):
返回
火炬.
操作.
量化.instance_norm(
输入,
自身.
重量,
自身.
偏置,
自身.eps,
自身.
比例,
自身.
零点
)
定义
_获取名称(
自身):
返回
"量化 InstanceNorm2d"
@classmethod
定义
从浮点数(
类, mod,
使用预计算的假量化=
错误):
比例,
零点 = mod.
激活后处理.
计算 q 参数()
new_mod = 类(
mod.特征数量,
mod.重量,
mod.偏置,
float(比例),
int(零点),
mod.eps,
mod.线性,
)
返回 new_mod
@classmethod
定义
来自参考(
类, mod,
比例,
零点):
返回
类(
mod.特征数量,
mod.重量,
mod.偏置,
float(比例),
int(零点),
mod.eps,
mod.线性,
)
[文档]
类 InstanceNorm3d(
火炬.nn.InstanceNorm3d):
r"""这是 :class:`~torch.nn.InstanceNorm3d` 的量化版本。
附加参数：
* **缩放** - 输出的量化缩放比例，类型：双精度浮点数。
* **零点** - 输出的量化零点，类型：长整型。
```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)
```
定义
初始化(
自身,
特征数量,
重量,
偏置,
比例,
零点,
eps=0.00001,
动量=0.1,
线性=
错误,
跟踪运行统计=
错误,
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
超级().
初始化(
特征数量, eps,
动量,
线性,
跟踪运行统计, **
工厂参数
)
自身.
权重 =
权重
自身.
偏差 =
偏差
自身.
注册缓冲区(
"缩放",
火炬.
张量(
比例, **factory_kwargs))
自身.
注册缓冲区(
零点,
火炬.
张量(
零点, **factory_kwargs))
定义
前向(
自身,
输入):
返回
火炬.
操作.
量化.instance_norm(
输入,
自身.
重量,
自身.
偏置,
自身.eps,
自身.
比例,
自身.
零点
)
定义
_获取名称(
自身):
返回 "QuantizedInstanceNorm3d"
@classmethod
定义
从浮点数(
类, mod,
使用预计算的假量化=
错误):
比例,
零点 = mod.
激活后处理.
计算 q 参数()
new_mod = 类(
mod.特征数量,
mod.重量,
mod.偏置,
float(比例),
int(零点),
mod.eps,
mod.线性,
)
返回 new_mod
@classmethod
定义
来自参考(
类, mod,
比例,
零点):
返回
类(
mod.特征数量,
mod.重量,
mod.偏置,
float(比例),
int(零点),
mod.eps,
mod.线性,
)
