Spaces:
Running
Running
r""" Functional interface (quantized).""" | |
from typing import List, Optional | |
import warnings | |
import torch | |
from torch import Tensor | |
from torch.nn.modules.utils import _pair, _triple | |
from torch.jit.annotations import BroadcastingList2 | |
from .modules.utils import _pair_from_first | |
# Although some of the functions and docstrings are mirrored from the torch.nn, | |
# we want to have them here for future changes. | |
__all__ = [ | |
"avg_pool2d", | |
"avg_pool3d", | |
"adaptive_avg_pool2d", | |
"adaptive_avg_pool3d", | |
"conv1d", | |
"conv2d", | |
"conv3d", | |
"interpolate", | |
"linear", | |
"max_pool1d", | |
"max_pool2d", | |
"celu", | |
"leaky_relu", | |
"hardtanh", | |
"hardswish", | |
"threshold", | |
"elu", | |
"hardsigmoid", | |
"clamp", | |
"upsample", | |
"upsample_bilinear", | |
"upsample_nearest", | |
] | |
def avg_pool2d(input, kernel_size, stride=None, padding=0, ceil_mode=False, | |
count_include_pad=True, divisor_override=None): | |
r""" | |
Applies 2D average-pooling operation in :math:`kH \times kW` regions by step size | |
:math:`sH \times sW` steps. The number of output features is equal to the number of | |
input planes. | |
.. note:: The input quantization parameters propagate to the output. | |
See :class:`~torch.ao.nn.quantized.AvgPool2d` for details and output shape. | |
Args: | |
input: quantized input tensor :math:`(\text{minibatch} , \text{in\_channels} , iH , iW)` | |
kernel_size: size of the pooling region. Can be a single number or a | |
tuple `(kH, kW)` | |
stride: stride of the pooling operation. Can be a single number or a | |
tuple `(sH, sW)`. Default: :attr:`kernel_size` | |
padding: implicit zero paddings on both sides of the input. Can be a | |
single number or a tuple `(padH, padW)`. Default: 0 | |
ceil_mode: when True, will use `ceil` instead of `floor` in the formula | |
to compute the output shape. Default: ``False`` | |
count_include_pad: when True, will include the zero-padding in the | |
averaging calculation. Default: ``True`` | |
divisor_override: if specified, it will be used as divisor, otherwise | |
size of the pooling region will be used. Default: None | |
""" | |
if not input.is_quantized: | |
raise ValueError("Input to 'quantized.avg_pool2d' must be quantized!") | |
return torch.nn.functional.avg_pool2d(input, kernel_size, stride, padding, | |
ceil_mode, count_include_pad, | |
divisor_override) | |
def avg_pool3d(input, kernel_size, stride=None, padding=0, ceil_mode=False, | |
count_include_pad=True, divisor_override=None): | |
r""" | |
Applies 3D average-pooling operation in :math:`kD \ times kH \times kW` regions by step size | |
:math:`sD \times sH \times sW` steps. The number of output features is equal to the number of | |
input planes. | |
.. note:: The input quantization parameters propagate to the output. | |
Args: | |
input: quantized input tensor :math:`(\text{minibatch} , \text{in\_channels} , iH , iW)` | |
kernel_size: size of the pooling region. Can be a single number or a | |
tuple `(kD, kH, kW)` | |
stride: stride of the pooling operation. Can be a single number or a | |
tuple `(sD, sH, sW)`. Default: :attr:`kernel_size` | |
padding: implicit zero paddings on both sides of the input. Can be a | |
single number or a tuple `(padD, padH, padW)`. Default: 0 | |
ceil_mode: when True, will use `ceil` instead of `floor` in the formula | |
to compute the output shape. Default: ``False`` | |
count_include_pad: when True, will include the zero-padding in the | |
averaging calculation. Default: ``True`` | |
divisor_override: if specified, it will be used as divisor, otherwise | |
size of the pooling region will be used. Default: None | |
""" | |
if not input.is_quantized: | |
raise ValueError("Input to 'quantized.avg_pool3d' must be quantized!") | |
return torch.nn.functional.avg_pool3d(input, kernel_size, stride, padding, | |
ceil_mode, count_include_pad, | |
divisor_override) | |
def adaptive_avg_pool2d(input: Tensor, output_size: BroadcastingList2[int]) -> Tensor: | |
r""" | |
Applies a 2D adaptive average pooling over a quantized input signal composed | |
of several quantized input planes. | |
.. note:: The input quantization parameters propagate to the output. | |
See :class:`~torch.ao.nn.quantized.AdaptiveAvgPool2d` for details and output shape. | |
Args: | |
output_size: the target output size (single integer or | |
double-integer tuple) | |
""" | |
if not input.is_quantized: | |
raise ValueError("Input to 'quantized.functional.adaptive_avg_pool2d' must be quantized!") | |
return torch.nn.functional.adaptive_avg_pool2d(input, output_size) | |
def adaptive_avg_pool3d(input: Tensor, output_size: BroadcastingList2[int]) -> Tensor: | |
r""" | |
Applies a 3D adaptive average pooling over a quantized input signal composed | |
of several quantized input planes. | |
.. note:: The input quantization parameters propagate to the output. | |
See :class:`~torch.ao.nn.quantized.AdaptiveAvgPool3d` for details and output shape. | |
Args: | |
output_size: the target output size (single integer or | |
double-integer tuple) | |
""" | |
if not input.is_quantized: | |
raise ValueError( | |
"Input to 'quantized.functional.adaptive_avg_pool3d' must be quantized!") | |
return torch.nn.functional.adaptive_avg_pool3d(input, output_size) | |
def conv1d(input, weight, bias, | |
stride=1, padding=0, dilation=1, groups=1, | |
padding_mode='zeros', | |
scale=1.0, zero_point=0, | |
dtype=torch.quint8): | |
r""" | |
Applies a 1D convolution over a quantized 1D input composed of several input | |
planes. | |
See :class:`~torch.ao.nn.quantized.Conv1d` for details and output shape. | |
Args: | |
input: quantized input tensor of shape :math:`(\text{minibatch} , \text{in\_channels} , iW)` | |
weight: quantized filters of shape :math:`(\text{out\_channels} , \frac{\text{in\_channels}}{\text{groups}} , iW)` | |
bias: **non-quantized** bias tensor of shape :math:`(\text{out\_channels})`. The tensor type must be `torch.float`. | |
stride: the stride of the convolving kernel. Can be a single number or a | |
tuple `(sW,)`. Default: 1 | |
padding: implicit paddings on both sides of the input. Can be a | |
single number or a tuple `(padW,)`. Default: 0 | |
dilation: the spacing between kernel elements. Can be a single number or | |
a tuple `(dW,)`. Default: 1 | |
groups: split input into groups, :math:`\text{in\_channels}` should be divisible by the | |
number of groups. Default: 1 | |
padding_mode: the padding mode to use. Only "zeros" is supported for quantized convolution at the moment. Default: "zeros" | |
scale: quantization scale for the output. Default: 1.0 | |
zero_point: quantization zero_point for the output. Default: 0 | |
dtype: quantization data type to use. Default: ``torch.quint8`` | |
Examples:: | |
>>> # 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) | |
""" # noqa: E501 | |
if padding_mode != 'zeros': | |
raise NotImplementedError("Only zero-padding is supported!") | |
if input.dtype != torch.quint8: | |
raise NotImplementedError("Only torch.quint8 is supported for activation tensor!") | |
if weight.dtype != torch.qint8: | |
raise NotImplementedError("Only torch.qint8 is supported for weight tensor!") | |
if input.ndim != 3: | |
raise ValueError("Input shape must be `(N, C, L)`!") | |
stride = _pair_from_first(stride) | |
padding = _pair_from_first(padding) | |
dilation = _pair_from_first(dilation) | |
packed_params = torch.ops.quantized.conv1d_prepack( | |
weight, bias, stride, padding, dilation, groups) | |
return torch.ops.quantized.conv1d(input, packed_params, scale, zero_point) | |
def conv2d(input, weight, bias, | |
stride=1, padding=0, dilation=1, groups=1, | |
padding_mode='zeros', | |
scale=1.0, zero_point=0, | |
dtype=torch.quint8): | |
r""" | |
Applies a 2D convolution over a quantized 2D input composed of several input | |
planes. | |
See :class:`~torch.ao.nn.quantized.Conv2d` for details and output shape. | |
Args: | |
input: quantized input tensor of shape :math:`(\text{minibatch} , \text{in\_channels} , iH , iW)` | |
weight: quantized filters of shape :math:`(\text{out\_channels} , \frac{\text{in\_channels}}{\text{groups}} , kH , kW)` | |
bias: **non-quantized** bias tensor of shape :math:`(\text{out\_channels})`. The tensor type must be `torch.float`. | |
stride: the stride of the convolving kernel. Can be a single number or a | |
tuple `(sH, sW)`. Default: 1 | |
padding: implicit paddings on both sides of the input. Can be a | |
single number or a tuple `(padH, padW)`. Default: 0 | |
dilation: the spacing between kernel elements. Can be a single number or | |
a tuple `(dH, dW)`. Default: 1 | |
groups: split input into groups, :math:`\text{in\_channels}` should be divisible by the | |
number of groups. Default: 1 | |
padding_mode: the padding mode to use. Only "zeros" is supported for quantized convolution at the moment. Default: "zeros" | |
scale: quantization scale for the output. Default: 1.0 | |
zero_point: quantization zero_point for the output. Default: 0 | |
dtype: quantization data type to use. Default: ``torch.quint8`` | |
Examples:: | |
>>> # 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) | |
""" # noqa: E501 | |
if padding_mode != 'zeros': | |
raise NotImplementedError("Only zero-padding is supported!") | |
if input.dtype != torch.quint8: | |
raise NotImplementedError("Only torch.quint8 is supported for activation tensor!") | |
if weight.dtype != torch.qint8: | |
raise NotImplementedError("Only torch.qint8 is supported for weight tensor!") | |
if input.ndim != 4: | |
raise ValueError("Input shape must be `(N, C, H, W)`!") | |
stride = _pair(stride) | |
padding = _pair(padding) | |
dilation = _pair(dilation) | |
packed_params = torch.ops.quantized.conv2d_prepack( | |
weight, bias, stride, padding, dilation, groups) | |
return torch.ops.quantized.conv2d(input, packed_params, scale, zero_point) | |
def conv3d(input, weight, bias, stride=1, padding=0, dilation=1, groups=1, | |
padding_mode='zeros', scale=1.0, zero_point=0, dtype=torch.quint8): | |
r""" | |
Applies a 3D convolution over a quantized 3D input composed of several input | |
planes. | |
See :class:`~torch.ao.nn.quantized.Conv3d` for details and output shape. | |
Args: | |
input: quantized input tensor of shape | |
:math:`(\text{minibatch} , \text{in\_channels} , iD , iH , iW)` | |
weight: quantized filters of shape | |
:math:`(\text{out\_channels} , \frac{\text{in\_channels}}{\text{groups}} , kD , kH , kW)` | |
bias: **non-quantized** bias tensor of shape | |
:math:`(\text{out\_channels})`. The tensor type must be `torch.float`. | |
stride: the stride of the convolving kernel. Can be a single number or a | |
tuple `(sD, sH, sW)`. Default: 1 | |
padding: implicit paddings on both sides of the input. Can be a | |
single number or a tuple `(padD, padH, padW)`. Default: 0 | |
dilation: the spacing between kernel elements. Can be a single number or | |
a tuple `(dD, dH, dW)`. Default: 1 | |
groups: split input into groups, :math:`\text{in\_channels}` should be | |
divisible by the number of groups. Default: 1 | |
padding_mode: the padding mode to use. Only "zeros" is supported for | |
quantized convolution at the moment. Default: "zeros" | |
scale: quantization scale for the output. Default: 1.0 | |
zero_point: quantization zero_point for the output. Default: 0 | |
dtype: quantization data type to use. Default: ``torch.quint8`` | |
Examples:: | |
>>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_QENGINE) | |
>>> from torch.ao.nn.quantized import functional as 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) | |
>>> | |
>>> 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.conv3d(q_inputs, q_filters, bias, padding=1, scale=scale, zero_point=zero_point) | |
""" # noqa: E501 | |
if padding_mode != 'zeros': | |
raise NotImplementedError("Only zero-padding is supported!") | |
if input.dtype != torch.quint8: | |
raise NotImplementedError("Only torch.quint8 is supported for activation tensor!") | |
if weight.dtype != torch.qint8: | |
raise NotImplementedError("Only torch.qint8 is supported for weight tensor!") | |
if input.ndim != 5: | |
raise ValueError("Input shape must be `(N, C, D, H, W)`!") | |
stride = _triple(stride) | |
padding = _triple(padding) | |
dilation = _triple(dilation) | |
packed_params = torch.ops.quantized.conv3d_prepack( | |
weight, bias, stride, padding, dilation, groups) | |
return torch.ops.quantized.conv3d(input, packed_params, scale, zero_point) | |
def interpolate(input, size=None, scale_factor=None, mode='nearest', align_corners=None): | |
r"""Down/up samples the input to either the given :attr:`size` or the given | |
:attr:`scale_factor` | |
See :func:`torch.nn.functional.interpolate` for implementation details. | |
The input dimensions are interpreted in the form: | |
`mini-batch x channels x [optional depth] x [optional height] x width`. | |
.. note:: The input quantization parameters propagate to the output. | |
.. note:: Only 2D/3D input is supported for quantized inputs | |
.. note:: Only the following modes are supported for the quantized inputs: | |
- `bilinear` | |
- `nearest` | |
Args: | |
input (Tensor): the input tensor | |
size (int or Tuple[int] or Tuple[int, int] or Tuple[int, int, int]): | |
output spatial size. | |
scale_factor (float or Tuple[float]): multiplier for spatial size. Has to match input size if it is a tuple. | |
mode (str): algorithm used for upsampling: | |
``'nearest'`` | ``'bilinear'`` | |
align_corners (bool, optional): Geometrically, we consider the pixels of the | |
input and output as squares rather than points. | |
If set to ``True``, the input and output tensors are aligned by the | |
center points of their corner pixels, preserving the values at the corner pixels. | |
If set to ``False``, the input and output tensors are aligned by the corner | |
points of their corner pixels, and the interpolation uses edge value padding | |
for out-of-boundary values, making this operation *independent* of input size | |
when :attr:`scale_factor` is kept the same. This only has an effect when :attr:`mode` | |
is ``'bilinear'``. | |
Default: ``False`` | |
""" | |
if not input.is_quantized: | |
raise ValueError("Input to 'quantized.interpolate' must be quantized!") | |
return torch.nn.functional.interpolate(input, size, scale_factor, mode, | |
align_corners) | |
def linear( | |
input: Tensor, weight: Tensor, bias: Optional[Tensor] = None, | |
scale: Optional[float] = None, zero_point: Optional[int] = None | |
) -> Tensor: | |
r""" | |
Applies a linear transformation to the incoming quantized data: | |
:math:`y = xA^T + b`. | |
See :class:`~torch.ao.nn.quantized.Linear` | |
.. note:: | |
Current implementation packs weights on every call, which has penalty on performance. | |
If you want to avoid the overhead, use :class:`~torch.ao.nn.quantized.Linear`. | |
Args: | |
input (Tensor): Quantized input of type `torch.quint8` | |
weight (Tensor): Quantized weight of type `torch.qint8` | |
bias (Tensor): None or fp32 bias of type `torch.float` | |
scale (double): output scale. If None, derived from the input scale | |
zero_point (long): output zero point. If None, derived from the input zero_point | |
Shape: | |
- Input: :math:`(N, *, in\_features)` where `*` means any number of | |
additional dimensions | |
- Weight: :math:`(out\_features, in\_features)` | |
- Bias: :math:`(out\_features)` | |
- Output: :math:`(N, *, out\_features)` | |
""" | |
if scale is 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): | |
r"""Applies a 1D max pooling over a quantized input signal composed of | |
several quantized input planes. | |
.. note:: The input quantization parameters are propagated to the output. | |
See :class:`~torch.ao.nn.quantized.MaxPool1d` for details. | |
""" | |
if return_indices: | |
raise NotImplementedError("return_indices is not yet implemented!") | |
if stride is None: | |
stride = torch.jit.annotate(List[int], []) | |
return torch.nn.functional.max_pool1d(input, kernel_size, stride, padding, | |
dilation, ceil_mode=ceil_mode, return_indices=return_indices) | |
def max_pool2d(input, kernel_size, stride=None, padding=0, dilation=1, | |
ceil_mode=False, return_indices=False): | |
r"""Applies a 2D max pooling over a quantized input signal composed of | |
several quantized input planes. | |
.. note:: The input quantization parameters are propagated to the output. | |
See :class:`~torch.ao.nn.quantized.MaxPool2d` for details. | |
""" | |
if return_indices: | |
raise NotImplementedError("return_indices is not yet implemented!") | |
if stride is None: | |
stride = torch.jit.annotate(List[int], []) | |
return torch.nn.functional.max_pool2d(input, kernel_size, stride, padding, | |
dilation, ceil_mode=ceil_mode, return_indices=return_indices) | |
def celu(input: Tensor, scale: float, zero_point: int, alpha: float = 1.) -> Tensor: | |
r"""celu(input, scale, zero_point, alpha=1.) -> Tensor | |
Applies the quantized CELU function element-wise. | |
.. math:: | |
\text{CELU}(x) = \max(0,x) + \min(0, \alpha * (\exp(x / \alpha) - 1)) | |
Args: | |
input: quantized input | |
alpha: the :math:`\alpha` value for the CELU formulation. Default: 1.0 | |
""" | |
if not input.is_quantized: | |
raise ValueError("Input to 'quantized.celu' must be quantized!") | |
return torch.ops.quantized.celu(input, scale, zero_point, alpha) | |
def leaky_relu(input: Tensor, negative_slope: float = 0.01, inplace: bool = False, | |
scale: Optional[float] = None, zero_point: Optional[int] = None): | |
r""" | |
Quantized version of the. | |
leaky_relu(input, negative_slope=0.01, inplace=False, scale, zero_point) -> Tensor | |
Applies element-wise, | |
:math:`\text{LeakyReLU}(x) = \max(0, x) + \text{negative\_slope} * \min(0, x)` | |
Args: | |
input: Quantized input | |
negative_slope: The slope of the negative input | |
inplace: Inplace modification of the input tensor | |
scale, zero_point: Scale and zero point of the output tensor. | |
See :class:`~torch.nn.LeakyReLU` for more details. | |
""" | |
if scale is not None and zero_point is not None: | |
assert not inplace, "Cannot rescale with `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(input: Tensor, min_val: float = -1., max_val: float = 1., inplace: bool = False) -> Tensor: | |
r"""This is the quantized version of :func:`~torch.nn.functional.hardtanh`. | |
""" | |
if not input.is_quantized: | |
raise ValueError("Input to 'quantized.hardtanh' must be quantized!") | |
if inplace: | |
return torch._C._nn.hardtanh_(input, min_val, max_val) | |
return torch._C._nn.hardtanh(input, min_val, max_val) | |
def hardswish(input: Tensor, scale: float, zero_point: int) -> Tensor: | |
r"""This is the quantized version of :func:`~torch.nn.functional.hardswish`. | |
Args: | |
input: quantized input | |
scale: quantization scale of the output tensor | |
zero_point: quantization zero point of the output tensor | |
""" | |
if not input.is_quantized: | |
raise ValueError("Input to 'quantized.hardswish' must be quantized!") | |
return torch._ops.ops.quantized.hardswish(input, scale, zero_point) | |
def threshold(input: Tensor, threshold: float, value: float) -> Tensor: | |
r"""Applies the quantized version of the threshold function element-wise: | |
.. math:: | |
x = \begin{cases} | |
x & \text{if~} x > \text{threshold} \\ | |
\text{value} & \text{otherwise} | |
\end{cases} | |
See :class:`~torch.nn.Threshold` for more details. | |
""" | |
if not input.is_quantized: | |
raise ValueError("Input to 'quantized.threshold' must be quantized!") | |
if threshold is None: | |
raise ValueError("Input to 'threshold' must be specified!") | |
if value is None: | |
raise ValueError("Input to 'value' must be specified!") | |
return torch._ops.ops.quantized.threshold(input, threshold, value) | |
def elu(input: Tensor, scale: float, zero_point: int, alpha: float = 1.) -> Tensor: | |
r"""This is the quantized version of :func:`~torch.nn.functional.elu`. | |
Args: | |
input: quantized input | |
scale: quantization scale of the output tensor | |
zero_point: quantization zero point of the output tensor | |
alpha: the alpha constant | |
""" | |
if not input.is_quantized: | |
raise ValueError("Input to 'quantized.elu' must be quantized!") | |
return torch.ops.quantized.elu(input, scale, zero_point, alpha) | |
def hardsigmoid(input: Tensor, inplace: bool = False) -> Tensor: | |
r"""This is the quantized version of :func:`~torch.nn.functional.hardsigmoid`. | |
""" | |
if not input.is_quantized: | |
raise ValueError("Input to 'quantized.hardsigmoid' must be quantized!") | |
if inplace: | |
return torch._C._nn.hardsigmoid_(input) # type: ignore[attr-defined] | |
return torch._C._nn.hardsigmoid(input) | |
def clamp(input: Tensor, min_: float, max_: float) -> Tensor: | |
r"""float(input, min\_, max\_) -> Tensor | |
Applies the clamp function element-wise. | |
See :class:`~torch.ao.nn.quantized.clamp` for more details. | |
Args: | |
input: quantized input | |
min_: minimum value for clamping | |
max_: maximum value for clamping | |
""" | |
if not input.is_quantized: | |
raise ValueError("Input to 'quantized.clamp' must be quantized!") | |
return torch.clamp(input, min_, max_) | |
def upsample(input, size=None, scale_factor=None, mode='nearest', align_corners=None): | |
r"""Upsamples the input to either the given :attr:`size` or the given | |
:attr:`scale_factor` | |
.. warning:: | |
This function is deprecated in favor of | |
:func:`torch.ao.nn.quantized.functional.interpolate`. | |
This is equivalent with ``nn.quantized.functional.interpolate(...)``. | |
See :func:`torch.nn.functional.interpolate` for implementation details. | |
The input dimensions are interpreted in the form: | |
`mini-batch x channels x [optional depth] x [optional height] x width`. | |
.. note:: The input quantization parameters propagate to the output. | |
.. note:: Only 2D input is supported for quantized inputs | |
.. note:: Only the following modes are supported for the quantized inputs: | |
- `bilinear` | |
- `nearest` | |
Args: | |
input (Tensor): quantized input tensor | |
size (int or Tuple[int] or Tuple[int, int] or Tuple[int, int, int]): | |
output spatial size. | |
scale_factor (float or Tuple[float]): multiplier for spatial size. Has to be an integer. | |
mode (str): algorithm used for upsampling: | |
``'nearest'`` | ``'bilinear'`` | |
align_corners (bool, optional): Geometrically, we consider the pixels of the | |
input and output as squares rather than points. | |
If set to ``True``, the input and output tensors are aligned by the | |
center points of their corner pixels, preserving the values at the corner pixels. | |
If set to ``False``, the input and output tensors are aligned by the corner | |
points of their corner pixels, and the interpolation uses edge value padding | |
for out-of-boundary values, making this operation *independent* of input size | |
when :attr:`scale_factor` is kept the same. This only has an effect when :attr:`mode` | |
is ``'bilinear'``. | |
Default: ``False`` | |
.. warning:: | |
With ``align_corners = True``, the linearly interpolating modes | |
(`bilinear`) don't proportionally align the | |
output and input pixels, and thus the output values can depend on the | |
input size. This was the default behavior for these modes up to version | |
0.3.1. Since then, the default behavior is ``align_corners = False``. | |
See :class:`~torch.nn.Upsample` for concrete examples on how this | |
affects the outputs. | |
""" | |
warnings.warn("nn.quantized.functional.upsample is deprecated. Use nn.quantized.functional.interpolate instead.") | |
return interpolate(input, size, scale_factor, mode, align_corners) | |
def upsample_bilinear(input, size=None, scale_factor=None): | |
r"""Upsamples the input, using bilinear upsampling. | |
.. warning:: | |
This function is deprecated in favor of | |
:func:`torch.ao.nn.quantized.functional.interpolate`. | |
This is equivalent with | |
``nn.quantized.functional.interpolate(..., mode='bilinear', align_corners=True)``. | |
.. note:: The input quantization parameters propagate to the output. | |
.. note:: Only 2D inputs are supported | |
Args: | |
input (Tensor): quantized input | |
size (int or Tuple[int, int]): output spatial size. | |
scale_factor (int or Tuple[int, int]): multiplier for spatial size | |
""" | |
# DeprecationWarning is ignored by default | |
warnings.warn("nn.quantized.functional.upsample_bilinear is deprecated. Use nn.quantized.functional.interpolate instead.") | |
return interpolate(input, size, scale_factor, mode='bilinear', align_corners=True) | |
def upsample_nearest(input, size=None, scale_factor=None): | |
r"""Upsamples the input, using nearest neighbours' pixel values. | |
.. warning:: | |
This function is deprecated in favor of | |
:func:`torch.ao.nn.quantized.functional.interpolate`. | |
This is equivalent with ``nn.quantized.functional.interpolate(..., mode='nearest')``. | |
.. note:: The input quantization parameters propagate to the output. | |
.. note:: Only 2D inputs are supported | |
Args: | |
input (Tensor): quantized input | |
size (int or Tuple[int, int] or Tuple[int, int, int]): output spatial | |
size. | |
scale_factor (int): multiplier for spatial size. Has to be an integer. | |
""" | |
# DeprecationWarning is ignored by default | |
warnings.warn("nn.quantized.functional.upsample_nearest is deprecated. Use nn.quantized.functional.interpolate instead.") | |
return interpolate(input, size, scale_factor, mode='nearest') | |