源代码 for torch.ao.nn.quantized.functional

# mypy: 允许未类型化定义
r功能接口（量化）。
导入 警告
来自 打字 导入 可选

导入 火炬
来自 火炬 导入 张量
来自 torch.jit.annotations 导入 广播列表 2
来自 torch.nn 模块.utils 导入 _pair, _triple

来自 .模块.utils 导入 _从第一个配对


# 尽管一些函数和文档字符串是从 torch.nn 中镜像过来的，
#此处留空以备将来修改

__all__ = [
    平均池化 2D,
    平均池化 3D,
    自适应平均池化 2D,
    "自适应平均池化 3D",
    "conv1d",
    "conv2d",
    "conv3d",
    "插值",
    线性,
    池化 1d,
    最大池化 2d,
    "celu",
    "leaky_relu",
    "hardtanh",
    "hardswish",
    "threshold",
    "elu",
    硬饱和度,
    "clamp",
    "上采样",
    "双线性上采样",
    "最近邻上采样",
]


[文档]def avg_pool2d(
输入,
核大小,
步长=None,
填充=0,
ceil_mode=False,
count_include_pad=True,
divisor_override=None,
):
r"""
在 :math:`kH \times kW` 区域内通过步长 :math:`sH \times sW` 应用 2D 平均池化操作。输出特征的数量等于输入平面的数量。
输出特征的数量等于输入平面的数量。
输出特征的数量等于输入平面的数量。

.. 注意:: 输入量化参数会传播到输出。

详细信息和输出形状请参阅 :class:`~torch.ao.nn.quantized.AvgPool2d`。

Args:
input: 量化输入张量 :math:`(\text{minibatch} , \text{in\_channels} , iH , iW)`
核心大小：池化区域的大小。可以是单个数字或一个元组 `(kH, kW)`
元组 `(kH, kW)`
步长：池化操作的步长。可以是单个数字或一个元组 `(sH, sW)`。默认值：:attr:`kernel_size`
元组 `(sH, sW)`。默认值：:attr:`kernel_size`
输入填充：在输入两侧隐式添加零填充。可以是单个数字或一个元组（padH, padW）。默认：0
ceil_mode：当为 True 时，将使用`ceil`而不是`floor`来计算输出形状。默认：``False``
ceil_mode：当为 True 时，将使用`ceil`而不是`floor`来计算输出形状。默认：``False``
ceil_mode：当为 True 时，将使用`ceil`而不是`floor`来计算输出形状。默认：``False``
count_include_pad: 当为 True 时，将包括零填充在计数中。
averaging calculation. Default: ``True``
divisor_override: 如果指定，则用作除数，否则使用池化区域的大小。Default: None
size of the pooling region will be used. Default: None
"""
如果没有 input.is_quantized:
抛出 ValueError 异常("输入到 'quantized.avg_pool2d' 必须是量化过的！")
return torch.nn.functional.avg_pool2d(
输入,
核大小,
步长,
填充,
ceil_mode,
count_include_pad,
divisor_override,
    )


[文档]def avg_pool3d(
输入,
核大小,
步长=None,
padding=0,
ceil_mode=False,
count_include_pad=True,
divisor_override=None,
):
r"""
应用在`:math:`kD \times kH \times kW`区域内的 3D 平均池化操作，步长为
`sD × sH × sW` 步。输出特征的数量等于
输入平面。

.. 注意:: 输入量化参数会传播到输出。

Args:
input: 量化输入张量 :math:`(\\text{minibatch} , \\text{in\_channels} , iH , iW)`
核心大小：池化区域的大小。可以是单个数字或一个元组 `(kD, kH, kW)`
元组 `(kD, kH, kW)`
步长：池化操作的步长。可以是单个数字或一个元组 `(sD, sH, sW)`。默认值：:attr:`kernel_size`
元组 `(sD, sH, sW)`。默认值：:attr:`kernel_size`
输入填充：在输入两侧隐式添加零填充。可以是单个数字或一个元组 `(padD, padH, padW)`。默认：0
ceil_mode：当为 True 时，将使用 `ceil` 而不是 `floor` 来计算输出形状。默认：``False``
ceil_mode：当为 True 时，将使用 `ceil` 而不是 `floor` 来计算输出形状。默认：``False``
ceil_mode：当为 True 时，将使用 `ceil` 而不是 `floor` 来计算输出形状。默认：``False``
count_include_pad: 当为 True 时，将包括零填充在计数中。
averaging calculation. Default: ``True``
divisor_override: 如果指定，则用作除数，否则使用池化区域的大小。Default: None
size of the pooling region will be used. Default: None
"""
如果没有 input.is_quantized:
抛出 ValueError 异常("输入到 'quantized.avg_pool3d' 必须是量化过的！")
return torch.nn.functional.avg_pool3d(
输入,
核大小,
步长,
填充,
ceil_mode,
count_include_pad,
divisor_override,
    )


[docs]def adaptive_avg_pool2d(input: Tensor, output_size: BroadcastingList2[int]) -> Tensor:
r"""
在由多个量化输入平面组成的量化输入信号上应用 2D 自适应平均池化。
在由多个量化输入平面组成的量化输入信号上应用 2D 自适应平均池化。

.. 注意：输入的量化参数会传播到输出。

详细信息和输出形状请参阅 :class:`~torch.ao.nn.quantized.AdaptiveAvgPool2d`。

Args:
output_size: 目标输出大小（单个整数或
双整数元组
```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)
```
如果 input 未量化：
引发 ValueError(
"输入到 'quantized.functional.adaptive_avg_pool2d' 必须是量化过的！"
        )
返回 torch.nn.functional.adaptive_avg_pool2d(input, output_size)


[文档]def adaptive_avg_pool3d(input: Tensor, output_size: 广播列表 2[int]) -> Tensor:
r"""
对由多个量化输入平面组成的量化输入信号应用 3D 自适应平均池化。
量化输入参数会传播到输出。

.. 注意:: 输入量化参数会传播到输出。

查看 :class:`~torch.ao.nn.quantized.AdaptiveAvgPool3d` 获取详细信息及输出形状。

参数:
输出大小：目标输出大小（单个整数或）
双整数元组
"""
如果没有 input.is_quantized:
抛出 ValueError 异常(
"输入到 'quantized.functional.adaptive_avg_pool3d' 必须是量化过的！"
        )
return torch.nn.functional.adaptive_avg_pool3d(input, output_size)


def 卷积 1D(
    输入,
    重量,
    偏差,
    步长=1,
    填充=0,
    扩展率=1,
    群组=1,
    填充模式=零,
    比例=1.0,
    零点=0,
    数据类型=火炬.quint8,
):
    r""
应用在由多个输入组成的量化 1D 输入上的 1D 卷积
飞机。

详细信息和输出形状请参阅 :class:`~torch.ao.nn.quantized.Conv1d`

参数：
输入：形状为 :math:`(\text{minibatch} , \text{in\_channels} , iW)` 的量化输入张量
权重：形状为 :math:`(\text{out\_channels} , \frac{\text{in\_channels}}{\text{groups}} , iW)` 的量化滤波器
偏置：**非量化**的偏置张量，形状为 :math:`(\text{out\_channels})`。张量类型必须是 `torch.float`。
步长：卷积核的步长。可以是单个数字或一个元组（sT, sH, sW）。默认：1
元组 `(sW,)`。默认值：1
输入两侧的隐式填充。默认为 1
单个数字或一个元组 `(padW,)`。默认：0
扩展：卷积核元素之间的间隔。可以是单个数字或
一个元组`(dW,)`。默认：1
分组：将输入拆分为组，:math:`\text{in\_channels}` 应该是组数的倍数。
组数。默认：1
padding_mode：要使用的填充模式。目前仅支持用于量化卷积的"zeros"。默认："zeros"
scale：输出量化的尺度。默认：1.0
zero_point: 输出的量化零点。默认值：0
dtype: 使用的数据类型。默认值：`torch.quint8`

示例：

        >>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_QENGINE)
        >>> from torch.ao.nn.quantized import functional as qF
        >>> filters = torch.randn(33, 16, 3, dtype=torch.float)
        >>> inputs = torch.randn(20, 16, 50, dtype=torch.float)
        >>> bias = torch.randn(33, dtype=torch.float)
...
        >>> scale, zero_point = 1.0, 0
        >>> dtype_inputs = torch.quint8
        >>> dtype_filters = torch.qint8
...
        >>> q_filters = torch.quantize_per_tensor(filters, scale, zero_point, dtype_filters)
        >>> q_inputs = torch.quantize_per_tensor(inputs, scale, zero_point, dtype_inputs)
        >>> qF.conv1d(q_inputs, q_filters, bias, padding=1, scale=scale, zero_point=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)
```  # noqa: E501
    如果 填充模式 != 零:
        提升 不支持的操作异常(仅支持零填充！)
    如果 输入.dtype != 火炬.quint8:
        提升 不支持的操作异常(
            仅支持 torch.quint8 用于激活张量！
        )
    如果 重量.dtype != 火炬.qint8:
        提升 不支持的操作异常(仅支持 torch.qint8 用于权重张量！)
    如果 输入.维数 != 3:
        提升 ValueError("输入形状必须是 `(N, C, L)`！")
    步长 = _从第一个中获取对_(步长)
    填充 = _从第一个中获取对_(填充)
    扩展率 = _从第一个中获取对_(扩展率)

    打包参数 = 火炬.操作.量化.conv1d 预打包(
        重量, 偏差, 步长, 填充, 扩展率, 组们
    )
    返回 火炬.操作.量化.卷积 1D(输入, 打包参数, 比例, 零点)



def 卷积 2D(
    输入,
    重量,
    偏差,
    步长=1,
    填充=0,
    扩展率=1,
    群组=1,
    填充模式=零,
    比例=1.0,
    零点=0,
    数据类型=火炬.quint8,
):
    r""
对由多个输入组成的量化 2D 输入应用 2D 卷积
飞机。

详细信息和输出形状请参阅：:class:`~torch.ao.nn.quantized.Conv2d`

参数：
输入：形状为 :math:`(\text{minibatch} , \text{in\_channels} , iH , iW)` 的量化输入张量
权重：形状为 :math:`(\text{out\_channels} , \frac{\text{in\_channels}}{\text{groups}} , kH , kW)` 的量化滤波器
偏置：**未量化**的偏置张量，形状为 :math:`(\text{out\_channels})`。张量类型必须是 `torch.float`。
步长：卷积核的步长。可以是单个数字或一个元组（sT, sH, sW）。默认：1
元组 `(sH, sW)`。默认：1
填充：输入两侧的隐式填充。可以是
单个数字或一个元组 `(padH, padW)`。默认：0
扩展：卷积核元素之间的间隔。可以是单个数字或
一个元组 `(dH, dW)`。默认：1
分组：将输入拆分为组，:math:`\text{in\_channels}` 应该是组数的倍数。
组数。默认：1
padding\_mode：要使用的填充模式。目前仅支持“zeros”用于量化卷积。默认：“zeros”
scale：输出量化的尺度。默认：1.0
zero_point: 输出的量化零点。默认值：0
dtype: 使用的数据类型。默认值：`torch.quint8`

示例：

        >>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_QENGINE)
        >>> from torch.ao.nn.quantized import functional as qF
        >>> filters = torch.randn(8, 4, 3, 3, dtype=torch.float)
        >>> inputs = torch.randn(1, 4, 5, 5, dtype=torch.float)
        >>> bias = torch.randn(8, dtype=torch.float)
...
        >>> scale, zero_point = 1.0, 0
        >>> dtype_inputs = torch.quint8
        >>> dtype_filters = torch.qint8
...
        >>> q_filters = torch.quantize_per_tensor(filters, scale, zero_point, dtype_filters)
        >>> q_inputs = torch.quantize_per_tensor(inputs, scale, zero_point, dtype_inputs)
        >>> qF.conv2d(q_inputs, q_filters, bias, padding=1, scale=scale, zero_point=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)
```  # noqa: E501
    如果 填充模式 != 零:
        提升 不支持的操作异常(仅支持零填充！)
    如果 输入.dtype != 火炬.quint8:
        提升 不支持的操作异常(
            仅支持 torch.quint8 用于激活张量！
        )
    如果 重量.dtype != 火炬.qint8:
        提升 不支持的操作异常(仅支持 torch.qint8 用于权重张量！)
    如果 输入.维数 != 4:
        提升 ValueError("输入形状必须是 `(N, C, H, W)`！")
    步长 = _pair(步长)
    填充 = _pair(填充)
    扩展率 = _pair(扩展率)

    打包参数 = 火炬.操作.量化.conv2d_prepack(
        重量, 偏差, 步长, 填充, 扩展率, 组们
    )
    返回 火炬.操作.量化.卷积 2D(输入, 打包参数, 比例, 零点)



def 卷积 3D(
    输入,
    重量,
    偏差,
    步长=1,
    填充=0,
    扩展率=1,
    群组=1,
    填充模式=零,
    比例=1.0,
    零点=0,
    数据类型=火炬.quint8,
):
    r""
对由多个输入组成的量化 3D 输入应用 3D 卷积
飞机。

详细信息和输出形状请参阅 :class:`~torch.ao.nn.quantized.Conv3d`

参数：
输入：形状为的量化输入张量
math:`(\text{minibatch} , \text{in\_channels} , iD , iH , iW)`
权重：形状为的量化滤波器
math:`(\text{out\_channels} , \frac{\text{in\_channels}}{\text{groups}} , kD , kH , kW)`
偏置：**非量化**的偏置张量，形状为
math:`(\text{out\_channels})`。张量类型必须是 `torch.float`。
步长：卷积核的步长。可以是单个数字或一个元组（sT, sH, sW）。默认：1
元组 `(sD, sH, sW)`。默认值：1
填充：输入两侧的隐式填充。可以是
单个数字或元组 `(padD, padH, padW)`。默认值：0
扩展：卷积核元素之间的间隔。可以是单个数字或
元组 `(dD, dH, dW)`。默认值：1
分组：将输入拆分为组，:math:`\text{in\_channels}` 应该是组数的倍数。默认：1
填充模式：使用的填充模式。目前仅支持“zeros”进行量化卷积。默认：“zeros”
padding\_mode：使用的填充模式。目前仅支持“zeros”进行量化卷积。默认：“zeros”
填充模式：使用的填充模式。目前仅支持“zeros”进行量化卷积。默认：“zeros”
输出量化尺度。默认值：1.0
输出量化零点。默认值：0
输出量化数据类型。默认值：`torch.quint8`

示例：

        >>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_QENGINE)
>>> 从 torch.ao.nn.quantized 导入 functional 作为 qF
        >>> filters = torch.randn(8, 4, 3, 3, 3, dtype=torch.float)
        >>> inputs = torch.randn(1, 4, 5, 5, 5, dtype=torch.float)
        >>> bias = torch.randn(8, dtype=torch.float)
...
>>> 缩放比例，零点 = 1.0，0
        >>> dtype_inputs = torch.quint8
        >>> dtype_filters = torch.qint8
...
        >>> q_filters = torch.quantize_per_tensor(filters, scale, zero_point, dtype_filters)
        >>> q_inputs = torch.quantize_per_tensor(inputs, scale, zero_point, dtype_inputs)
        >>> qF.conv3d(q_inputs, q_filters, bias, padding=1, scale=scale, zero_point=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)
```  # noqa: E501
    如果 填充模式 != 零:
        提升 不支持的操作异常("仅支持零填充！")
    如果 输入.dtype != 火炬.quint8:
        提升 不支持的操作异常(
            "仅支持 torch.quint8 作为激活张量！"
        )
    如果 重量.dtype != 火炬.qint8:
        提升 不支持的操作异常("仅支持 torch.qint8 的权重张量！")
    如果 输入.维数 != 5:
        提升 ValueError("输入形状必须是`(N, C, D, H, W)`！")
    步长 = _三倍_(步长)
    填充 = _三倍_(填充)
    扩展率 = _三倍_(扩展率)

    packed_params = 火炬.操作.量化.conv3d_prepack(
        重量, 偏差, 步长, 填充, 扩展率, 组们
    )
    返回 火炬.操作.量化.卷积 3D(输入, packed_params, 比例, 零点)



[文档]def 插值(
输入, 大小=None, 缩放因子=None, 模式="最近邻", 对齐角点=None
):
r"""向下/向上采样输入到给定的 :attr:`size` 或给定的 :attr:`scale_factor`"""
attr:`缩放因子`

查看 :func:`torch.nn.functional.interpolate` 以获取实现细节。

输入维度以以下形式解释：
`批量 x 通道 x [可选深度] x [可选高度] x 宽度`

.. 注意:: 输入量化参数会传播到输出。

.. 注意:: 仅支持 2D/3D 输入的量化输入。

.. 注意:: 仅支持以下模式进行量化输入：

双线性
最近邻

Args:
输入 (Tensor): 输入张量
size (int 或 Tuple[int] 或 Tuple[int, int] 或 Tuple[int, int, int]):
输出空间大小。
scale_factor (float 或 Tuple[float]): 空间大小的乘数。如果是一个元组，必须与输入大小匹配。
mode (str): 用于上采样的算法：
``'最近邻'`` | ``'双线性'``
align_corners (布尔值，可选)：从几何角度考虑，我们将输入和输出的像素视为正方形而不是点。
输入和输出被视为正方形而不是点。
如果设置为 ``True``，则输入和输出张量将通过几何方式对齐。
中心点位于其角落像素，保留角落像素的值。
如果设置为 ``False``，输入和输出张量将按角对齐
其角落像素的点，插值使用边缘值填充
对于越界值，使此操作与输入大小无关
当保持 :attr:`scale_factor` 不变时。这仅在 :attr:`mode` 为
``'bilinear'`` 时有效。
默认：``False``
"""
如果输入未量化：
则引发 ValueError 异常："传递给 'quantized.interpolate' 的输入必须已量化！"
返回 torch.nn.functional.interpolate(
input, size, scale_factor, mode, align_corners
    )


[文档]def 线性(
输入: Tensor,
权重: Tensor,
偏置: Optional[Tensor] = None,
scale: 可选[float] = None,
zero_point: 可选[int] = None,
) -> Tensor:
r"""
对输入的量化数据进行线性变换：
\( y = xA^T + b \)。
查看 :class:`~torch.ao.nn.quantized.Linear`。

.. 注意::

当前实现每次调用都会打包权重，这会对性能造成惩罚。
如果你想避免开销，请使用 :class:`~torch.ao.nn.quantized.Linear`。

参数：
输入 (Tensor)：类型为 `torch.quint8` 的量化输入
重量（张量）：类型为 `torch.qint8` 的量化权重
偏置（张量）：None 或类型为 `torch.float` 的浮点数偏置
缩放因子（双精度浮点数）：输出缩放因子。如果为 None，则从输入缩放因子推导
零点（长整型）：输出零点。如果为 None，则从输入零点推导

形状：
- 输入：:math:`(N, *, in\_features)` 其中 `*` 表示任意数量的
额外维度
- 权重：:math:`(out\_features, in\_features)`
偏差: :math:`(out\_features)`
输出: :math:`(N, *, out\_features)`
"""
如果 scale 为 None:
scale = input.q_scale()
if zero_point is None:
zero_point = input.q_zero_point()
_packed_params = torch.ops.quantized.linear_prepack(weight, bias)
return torch.ops.quantized.linear(input, _packed_params, scale, zero_point)


[文档]def max_pool1d(
input,
kernel_size,
stride=None,
padding=0,
dilation=1,
ceil_mode=False,
return_indices=False,
):
对由多个量化输入平面组成的量化输入信号应用 1D 最大池化。
几个量化输入平面。

.. 注意：输入的量化参数被传播到输出。

详细信息请参阅 :class:`~torch.ao.nn.quantized.MaxPool1d`。
"""
如果 return_indices:
尚未实现返回索引，请抛出 NotImplementedError 异常！
如果 stride 为 None：
则 stride = torch.jit.annotate(list[int], [])
返回 torch.nn.functional.max_pool1d(
输入,
核大小,
步长,
填充,
扩张,
ceil_mode=ceil_mode,
return_indices=return_indices,
    )


[文档]def max_pool2d(
输入,
核大小,
步长=None,
padding=0,
dilation=1,
ceil_mode=False,
return_indices=False,
):
r"""对由多个量化输入平面组成的量化输入信号应用 2D 最大池化。
几个量化输入平面的量化输入信号。

.. note:: 输入量化参数被传递到输出。

查看详细信息请参阅：:class:`~torch.ao.nn.quantized.MaxPool2d`
"""
如果 return_indices:
抛出未实现异常："return_indices 尚未实现！"
如果步长为 None：
步长 = torch.jit.annotate(list[int], [])
return torch.nn.functional.max_pool2d(
input,
核心大小
步长
填充
扩展率
ceil_mode=ceil_mode,
return_indices=return_indices,
    )


[docs]def celu(input: Tensor, scale: float, zero_point: int, alpha: float = 1.0) -> Tensor:
r"""celu(input, scale, zero_point, alpha=1.) -> Tensor

将量化 CELU 函数逐元素应用。

.. math::
\text{CELU}(x) = \max(0,x) + \min(0, \alpha * (\exp(x / \alpha) - 1))

Args:
input: 量化输入
alpha: 用于 CELU 公式的\alpha 值。默认：1.0
"""
如果没有 input.is_quantized:
抛出 ValueError 异常("输入到 'quantized.celu' 必须是量化过的！")
return torch.ops.quantized.celu(input, scale, zero_point, alpha)


[文档]def leaky_relu(
输入：Tensor，
负斜率：float = 0.01，
inplace：bool = False，
scale: 可选[float] = None,
zero_point: 可选[int] = None,
):
r"""
量化版本的。
leaky_relu(input, negative_slope=0.01, inplace=False, scale, zero_point) -> 张量

逐元素应用，
math:`\text{LeakyReLU}(x) = \max(0, x) + \text{negative\_slope} * \min(0, x)`

参数:
量化输入
negative_slope: 负输入的斜率
就地：输入张量的就地修改
输出张量的缩放和零点。

查看 :class:`~torch.nn.LeakyReLU` 获取更多详细信息。
```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)
```
如果 scale 不是 None 且 zero_point 不是 None：
assert not inplace, "不能使用 `inplace` 进行缩放"
output = torch._empty_affine_quantized(
input.shape, scale=scale, zero_point=int(zero_point), dtype=input.dtype
        )
torch._C._nn.leaky_relu(input, negative_slope, out=output)
return output
if inplace:
result = torch._C._nn.leaky_relu_(input, negative_slope)
else:
result = torch._C._nn.leaky_relu(input, negative_slope)
return result


[文档]def hardtanh(
输入：张量，min_val：浮点数 = -1.0，max_val：浮点数 = 1.0，inplace：布尔值 = False
) -> 张量：
r"""这是 :func:`~torch.nn.functional.hardtanh` 的量化版本。"""
if not input.is_quantized:
输入到 'quantized.hardtanh' 必须是量化过的！
如果 in-place:
返回 torch._C._nn.hardtanh_(input, min_val, max_val)
返回 torch._C._nn.hardtanh(input, min_val, max_val)


[文档]def hardswish(input: Tensor, scale: float, zero_point: int) -> Tensor:
r"""这是 :func:`~torch.nn.functional.hardswish` 的量化版本。"""

Args:
input: 量化输入
输出张量的量化尺度
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)
```
如果 input 未量化：
输入到 'quantized.hardswish' 必须是量化的！
返回 torch._ops.ops.quantized.hardswish(input, scale, zero_point)


[文档]def threshold(input: Tensor, threshold: float, value: float) -> Tensor:
r"""逐元素应用量化的阈值函数：

.. math::
x = \begin{cases}
x & \text{if~} x > \text{threshold} \\
\text{value} & \text{otherwise}
\end{cases}

更多详情请参阅 :class:`~torch.nn.Threshold`。
"""
如果 input.is_quantized 不为真：
输入到 'quantized.threshold' 必须是量化过的！
如果 threshold 为 None：
如果 threshold 未指定：
如果 value 为 None：
必须指定 'value' 的输入！
返回 torch._ops.ops.quantized.threshold(input, threshold, value)


文档：def elu(input: Tensor, scale: float, zero_point: int, alpha: float = 1.0) -> Tensor:
这是 :func:`~torch.nn.functional.elu` 的量化版本。

Args:
输入：量化输入
scale：输出张量的量化尺度
zero_point：输出张量的量化零点
alpha: α常数
"""
if not input.is_quantized:
raise ValueError("输入到 'quantized.elu' 的数据必须量化！")
return torch.ops.quantized.elu(input, scale, zero_point, alpha)


[文档]def hardsigmoid(input: Tensor, inplace: bool = False) -> Tensor:
r"""这是 :func:`~torch.nn.functional.hardsigmoid` 的量化版本。"""
if not input.is_quantized:
输入到 'quantized.hardsigmoid' 必须是量化过的！
如果 inplace:
返回 torch._C._nn.hardsigmoid_(input)  # 忽略未定义的属性
返回 torch._C._nn.hardsigmoid(input)


[文档]def clamp(input: Tensor, min_: float, max_: float) -> Tensor:
r"""float(input, min_, max_) -> Tensor

应用 clamp 函数逐元素。
更多详情请参阅 :class:`~torch.ao.nn.quantized.clamp`。

Args:
输入：量化输入
min_：钳位的最小值
max_：钳位的最大值
"""
如果没有 input.is_quantized:
抛出 ValueError 异常("输入到 'quantized.clamp' 必须是量化过的！")
return torch.clamp(input, min_, max_)


def 上采样(输入, 尺寸=无, 缩放因子=无, 模式=最近邻, align_corners=无):
    r将输入上采样到给定的 :attr:`size` 或给定的
使用哪种插值算法由 :attr:`mode` 决定。

.. 警告::
该函数已被弃用，推荐使用
func:`torch.ao.nn.quantized.functional.interpolate`。
这与 ``nn.quantized.functional.interpolate(...)`` 等价。

查看 :func:`torch.nn.functional.interpolate` 以获取实现细节。

输入维度以以下形式解释：
`批大小 x 通道 x [可选深度] x [可选高度] x 宽度`。

.. 注意:: 输入量化参数会传播到输出。

.. 注意:: 仅支持 2D 输入的量化输入。

.. 注意:: 仅支持以下模式进行量化输入：

双线性
最近邻

参数：
输入（张量）：量化输入张量
大小（int 或 Tuple[int]或 Tuple[int, int]或 Tuple[int, int, int]）：
输出空间大小。
scale_factor（浮点数或元组[浮点数]）：空间尺寸的乘数。必须是整数。
mode (字符串): 用于上采样的算法：
``'最近邻'`` | ``'双线性'``
align_corners (bool, 可选): 几何上，我们将输入和输出的像素视为正方形而不是点。
            input and output as squares rather than points.
如果设置为 ``True``，输入和输出张量将根据其角落像素的中心点对齐，保留角落像素的值。
如果设置为 ``True``，输入和输出张量将根据其角落像素的中心点对齐，保留角落像素的值。
如果设置为 ``False``，输入和输出张量将根据其角像素的角点对齐，并且插值使用边缘值填充。
如果设置为 ``False``，输入和输出张量将根据其角像素的角点对齐，并且插值使用边缘值填充。
对于超出边界值，使此操作与输入大小无关
当保持 :attr:`scale_factor` 不变时。这仅在 :attr:`mode`
是 ``'双线性'``。
默认：``False``

.. 警告::
使用 `align_corners = True` 时，线性插值模式（`linear`、`bilinear` 和 `trilinear`）不会按比例对齐输出和输入像素，因此输出值可能取决于输入大小。这些模式在此版本之前默认就是这样。
(`双线性`) 不按比例对齐的
这意味着输出和输入像素的比例关系不匹配，因此输出值可能取决于输入大小。
这意味着输出和输入像素的比例关系不匹配，因此输出值可能取决于输入大小。
0.3.1. 从那时起，默认行为是 `align_corners = False`。
请参阅 :class:`~torch.nn.Upsample` 以获取具体示例。
这会影响输出。
```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)
```
    warnings.警告(
        "nn.quantized.functional.upsample 已弃用。请使用 nn.quantized.functional.interpolate 代替。"
    )
    返回 interpolate(输入, 尺寸, 缩放因子, 模式, align_corners)



[文档]def upsample_bilinear(input, size=None, scale_factor=None):
r"""使用双线性插值上采样输入。

.. 警告::
该函数已被弃用，推荐使用
`torch.ao.nn.quantized.functional.interpolate`
这与等效
``nn.quantized.functional.interpolate(..., mode='bilinear', align_corners=True)``.

.. note:: 输入量化参数会传播到输出。

.. 注意:: 仅支持 2D 输入

Args:
input (Tensor): 量化输入
size (int 或 Tuple[int, int]): 输出空间大小。
scale_factor (int 或 Tuple[int, int]): 空间尺寸的乘数
"""
# DeprecationWarning 默认被忽略
warnings.warn(
"nn.quantized.functional.upsample_bilinear 已弃用。请使用 nn.quantized.functional.interpolate 代替。"
    )
返回 interpolate(input, size, scale_factor, mode=\"bilinear\", align_corners=True)


[文档]def upsample_nearest(input, size=None, scale_factor=None):
使用最近邻像素值上采样输入。

.. 警告::
该函数已被弃用，推荐使用
func:`torch.ao.nn.quantized.functional.interpolate`。
这与 ``nn.quantized.functional.interpolate(..., mode='nearest')`` 相当。

.. 注意:: 输入的量化参数会传播到输出。

.. 注意:: 仅支持 2D 输入。

Args:
输入（张量）：量化输入
大小（int 或 Tuple[int, int] 或 Tuple[int, int, int]）：输出空间大小
大小。
scale_factor（int）：空间大小的乘数。必须为整数。
"""
默认情况下忽略 DeprecationWarning
warnings.warn(
"nn.quantized.functional.upsample_nearest 已弃用。请使用 nn.quantized.functional.interpolate 代替。"
    )
返回 interpolate(input, size, scale_factor, mode="nearest")