AffineQuantizedTensor

class torchao.dtypes.AffineQuantizedTensor(tensor_impl: AQTTensorImpl, block_size: Tuple[int, ...], shape: Size, quant_min: Optional[Union[int, float]] = None, quant_max: Optional[Union[int, float]] = None, zero_point_domain: ZeroPointDomain = ZeroPointDomain.INT, dtype=None, strides=None)

仿射量化張量子類。仿射量化意味著我們使用仿射變換對浮點張量進行量化：quantized_tensor = float_tensor / scale + zero_point

要了解仿射量化的 choose_qparams、量化和反量化過程中發生的情況，請檢視 https://github.com/pytorch/ao/blob/main/torchao/quantization/quant_primitives.py 並檢查這三個量化基本操作：choose_qparams_affine、quantize_affine 和 dequantize_affine

張量子類的形狀和 dtype 代表了張量子類在外部的表現形式，與其內部表示的型別或方向無關。

欄位

• tensor_impl (AQTTensorImpl)：用作量化資料通用張量實現儲存的張量，

  例如，根據裝置和運算子/核心，儲存普通張量 (int_data, scale, zero_point) 或打包格式

• block_size (Tuple[int, …])：量化粒度，表示共享同一 qparam 的張量元素的大小

  例如，當大小與輸入張量維度相同時，我們使用的是逐張量量化

• shape (torch.Size)：原始高精度張量的形狀

• quant_min (Optional[int])：張量的最小量化值，如果未指定，將從 int_data 的 dtype 推匯出來

• quant_max (Optional[int])：張量的最大量化值，如果未指定，將從 int_data 的 dtype 推匯出來

• zero_point_domain (ZeroPointDomain)：零點所屬的域，應該是整數或浮點數

  如果零點在整數域，則在量化過程中將零點新增到量化後的整數值；如果零點在浮點域，則在量化過程中從浮點（未量化）值中減去零點，預設為 ZeroPointDomain.INT

• dtype：原始高精度張量的 dtype，例如 torch.float32

dequantize() → Tensor

給定一個量化張量，對其進行反量化並返回反量化後的浮點張量。

classmethod from_hp_to_floatx(input_float: Tensor, block_size: Tuple[int, ...], target_dtype: dtype, _layout: Layout, scale_dtype: Optional[dtype] = None)

將高精度張量轉換為 float8 量化張量。

classmethod from_hp_to_floatx_static(input_float: Tensor, scale: Tensor, block_size: Tuple[int, ...], target_dtype: dtype, _layout: Layout)

使用靜態引數從高精度張量建立 float8 AffineQuantizedTensor。

classmethod from_hp_to_fpx(input_float: Tensor, _layout: Layout)

從高精度張量建立 floatx AffineQuantizedTensor。Floatx 表示為 ebits 和 mbits，支援 float1-float7 的表示。

classmethod from_hp_to_intx(input_float: Tensor, mapping_type: MappingType, block_size: Tuple[int, ...], target_dtype: dtype, quant_min: Optional[int] = None, quant_max: Optional[int] = None, eps: Optional[float] = None, scale_dtype: Optional[dtype] = None, zero_point_dtype: Optional[dtype] = None, preserve_zero: bool = True, zero_point_domain: ZeroPointDomain = ZeroPointDomain.INT, _layout: Layout = PlainLayout(), use_hqq: bool = False)

將高精度張量轉換為整數仿射量化張量。

classmethod from_hp_to_intx_static(input_float: Tensor, scale: Tensor, zero_point: Optional[Tensor], block_size: Tuple[int, ...], target_dtype: dtype, quant_min: Optional[int] = None, quant_max: Optional[int] = None, zero_point_domain: ZeroPointDomain = ZeroPointDomain.INT, _layout: Layout = PlainLayout())

使用靜態引數從高精度張量建立整數 AffineQuantizedTensor。

to(*args, **kwargs) → Tensor

執行張量的 dtype 和/或裝置轉換。透過 self.to(*args, **kwargs) 的引數推斷出 torch.dtype 和 torch.device。

注意

如果 self 張量已經具有正確的 torch.dtype 和 torch.device，則返回 self。否則，返回的張量是 self 的副本，具有所需的 torch.dtype 和 torch.device。

以下是呼叫 to 的方法

to(dtype, non_blocking=False, copy=False, memory_format=torch.preserve_format) → Tensor

返回具有指定 dtype 的張量

引數

memory_format (torch.memory_format, 可選)：返回張量所需的記憶體格式。預設值：torch.preserve_format。

to(device=None, dtype=None, non_blocking=False, copy=False, memory_format=torch.preserve_format) → Tensor

返回具有指定 device 和（可選）dtype 的張量。如果 dtype 為 None，則推斷為 self.dtype。當指定 non_blocking 時，如果可能，會嘗試非同步轉換，例如將具有 pinned memory 的 CPU 張量轉換為 CUDA 張量。當設定 copy 時，即使張量已與所需轉換匹配，也會建立一個新張量。

引數

memory_format (torch.memory_format, 可選)：返回張量所需的記憶體格式。預設值：torch.preserve_format。

to(other, non_blocking=False, copy=False) → Tensor

返回具有與張量 other 相同的 torch.dtype 和 torch.device 的張量。當指定 non_blocking 時，如果可能，會嘗試非同步轉換，例如將具有 pinned memory 的 CPU 張量轉換為 CUDA 張量。當設定 copy 時，即使張量已與所需轉換匹配，也會建立一個新張量。

示例

>>> tensor = torch.randn(2, 2)  # Initially dtype=float32, device=cpu
>>> tensor.to(torch.float64)
tensor([[-0.5044,  0.0005],
        [ 0.3310, -0.0584]], dtype=torch.float64)

>>> cuda0 = torch.device('cuda:0')
>>> tensor.to(cuda0)
tensor([[-0.5044,  0.0005],
        [ 0.3310, -0.0584]], device='cuda:0')

>>> tensor.to(cuda0, dtype=torch.float64)
tensor([[-0.5044,  0.0005],
        [ 0.3310, -0.0584]], dtype=torch.float64, device='cuda:0')

>>> other = torch.randn((), dtype=torch.float64, device=cuda0)
>>> tensor.to(other, non_blocking=True)
tensor([[-0.5044,  0.0005],
        [ 0.3310, -0.0584]], dtype=torch.float64, device='cuda:0')