量化运算符

量化是一种模型优化技术，旨在减小大型模型的尺寸，以在精度略有损失的情况下实现更好的存储性能。

CUDA 运算符

at::Tensor _float_to_bfloat16_gpu(const at::Tensor &输入)

将 `float` 值的张量转换为 Brain Floating Point (`bfloat16`) 值的张量。

参数:

输入 – 一个 `float` 值的张量

返回:

一个新张量，其值从输入张量转换为 `bfloat16`。

at::Tensor _bfloat16_to_float_gpu(const at::Tensor &输入)

将 Brain Floating Point (`bfloat16`) 值的张量转换为 `float` 值的张量。

参数:

输入 – 一个 `bfloat16` 值的张量

返回:

一个新张量，其值从输入张量转换为 `float`。

Tensor _float_to_FP8rowwise_gpu(const Tensor &输入, const bool 前向)

将 `float` 值的张量转换为 `fp8` 值的张量。

参数:

• 输入 – 一个 `float` 值的张量。dtype 可以是 `SparseType::FP32`、`SparseType::FP16` 或 `SparseType::BF16`

• 前向 –

抛出:

c10::Error – 如果 `input.dtype` 不是 (`SparseType::FP32`、`SparseType::FP16` 或 `SparseType::BF16`) 之一。

返回:

一个新张量，其值从输入张量转换为 `fp8`。

at::Tensor _FP8rowwise_to_float_gpu(const at::Tensor &输入, bool 前向, const int64_t 输出 dtype)

将 `fp8` 值的张量转换为 `float` 值的张量。

参数:

• 输入 – 一个 `fp8` 值的张量

• 前向 –

• 输出 dtype – 目标浮点类型，指定为 `SparseType` 枚举的整数表示

抛出:

c10::Error – 如果 `output_dtype` 不是 (`SparseType::FP32`、`SparseType::FP16` 或 `SparseType::BF16`) 之一。

返回:

一个新张量，其值从输入张量转换为 `float` (dtype 为 `SparseType::FP32`、`SparseType::FP16` 或 `SparseType::BF16` 之一)。

Tensor _float_to_fused8bitrowwise_gpu(const Tensor &输入)

将 `float` 值的张量转换为融合的 8 位行式值的张量。

参数:

输入 – 一个 `float` 值的张量

返回:

一个新张量，其值从输入张量转换为融合的 8 位行式值。

Tensor _half_to_fused8bitrowwise_gpu(const Tensor &输入)

将 `at::Half` 值的张量转换为融合的 8 位行式值的张量。

参数:

输入 – 一个 `at::Half` 值的张量

返回:

一个新张量，其值从输入张量转换为融合的 8 位行式值。

Tensor _single_or_half_precision_to_fused8bitrowwise_gpu(const Tensor &输入)

将 `at::Single` 或 `at::Half` 值的张量转换为融合的 8 位行式值的张量。

参数:

输入 – 一个 `at::Single` 或 `at::Half` 值的张量

返回:

一个新张量，其值从输入张量转换为融合的 8 位行式值。

at::Tensor _fused8bitrowwise_to_float_gpu(const at::Tensor &输入)

将融合的 8 位行式值的张量转换为 `float` 值的张量。

参数:

输入 – 一个融合的 8 位行式值的张量

返回:

一个新张量，其值从输入张量转换为 `float`。

at::Tensor _fused8bitrowwise_to_half_gpu(const at::Tensor &输入)

将融合的 8 位行式值的张量转换为 `at::Half` 值的张量。

参数:

输入 – 一个融合的 8 位行式值的张量

返回:

一个新张量，其值从输入张量转换为 `at::Half`。

at::Tensor _fused8bitrowwise_to_single_or_half_precision_gpu(const at::Tensor &输入, const int64_t 输出 dtype, const bool scale_bias_last, const bool quant_padding_float_type)

将融合的 8 位行式值的张量转换为 `float`、`at::Half` 或 `at::BFloat16` 值的张量。

参数:

• 输入 – 一个融合的 8 位行式值的张量

• 输出 dtype – 目标浮点类型，指定为 `SparseType` 枚举的整数表示

抛出:

c10::Error – 如果 `output_dtype` 不是 (`SparseType::FP32`、`SparseType::FP16` 或 `SparseType::BF16`) 之一。

返回:

一个新张量，其值从输入张量转换为 `float`、`at::Half` 或 `at::BFloat16`。

at::Tensor _fused8bitrowwise_to_float_mixed_dim_gpu(const at::Tensor &输入, const at::Tensor &D_offsets, const int64_t 输出 dtype)

将融合的 8 位行式值的张量转换为 `at::kFloat` 或 `at::kHalf` 值的张量。

参数:

• 输入 – 一个融合的 8 位行式值的张量

• D_offsets –

• 输出 dtype – 目标浮点类型，指定为 `SparseType` 枚举的整数表示

抛出:

c10::Error – 如果 `output_dtype` 不是 (`SparseType::FP32`、`SparseType::FP16`) 之一

返回:

一个新张量，其值从输入张量转换为 `at::kFloat` 或 `at::kHalf`。

Tensor _float_to_fusednbitrowwise_gpu(const Tensor &输入, const int64_t bit_rate)

将 `float` 值的张量转换为融合的 N 位行式值的张量。

参数:

• 输入 – 一个 `float` 值的张量

• bit_rate –

返回:

一个新张量，其值从输入张量转换为融合的 N 位行式值。

at::Tensor _half_to_fusednbitrowwise_gpu(const at::Tensor &输入, const int64_t bit_rate)

将 `at::Half` 值的张量转换为融合的 N 位行式值的张量。

参数:

• 输入 – 一个 `at::Half` 值的张量

• bit_rate –

返回:

一个新张量，其值从输入张量转换为融合的 N 位行式值。

Tensor _single_or_half_precision_to_fusednbitrowwise_gpu(const Tensor &输入, const int64_t bit_rate)

将 `float` 或 `at::Half` 值的张量转换为融合的 N 位行式值的张量。

参数:

• 输入 – 一个 `float` 或 `at::Half` 值的张量

• bit_rate –

返回:

一个新张量，其值从输入张量转换为融合的 N 位行式值。

at::Tensor _fusednbitrowwise_to_float_gpu(const at::Tensor &输入, const int64_t bit_rate)

将融合的 N 位行式值的张量转换为 `float` 值的张量。

参数:

• 输入 – 一个融合的 N 位行式值的张量

• bit_rate –

返回:

一个新张量，其值从输入张量转换为 `float`。

at::Tensor _fusednbitrowwise_to_half_gpu(const at::Tensor &输入, const int64_t bit_rate)

将融合的 N 位行式值的张量转换为 `at::Half` 值的张量。

参数:

• 输入 – 一个融合的 N 位行式值的张量

• bit_rate –

返回:

一个新张量，其值从输入张量转换为 `at::Half`。

at::Tensor _fusednbitrowwise_to_single_or_half_precision_gpu(const at::Tensor &输入, const int64_t bit_rate, const int64_t 输出 dtype, const bool scale_bias_last)

将融合的 N 位行式值的张量转换为 `float`、`at::Half` 或 `at::Bf16` 值的张量。

参数:

• 输入 – 一个融合的 N 位行式值的张量

• bit_rate –

• 输出 dtype – 目标浮点类型，指定为 `SparseType` 枚举的整数表示

抛出:

c10::Error – 如果 output_dtype 不是以下类型之一（SparseType::FP32 或 SparseType::FP16 或 SparseType::BF16）。

返回:

根据 output_dtype，返回一个新张量，其值由输入张量转换为 float 或 at::Half 或 at::Bf16。

at::Tensor _float_to_hfp8_gpu(const at::Tensor &input, const int64_t ebits, const int64_t exponent_bias, const double max_pos)

将 float 值的张量转换为混合 8 位浮点 (hfp8) 值的张量。

参数:

• 输入 – 一个 `float` 值的张量

• ebits –

• exponent_bias –

• max_pos –

抛出:

c10::Error – 如果 ebits > 0 或 exponent_bias > 0。

返回:

返回一个新张量，其值由输入张量转换为 hfp8。

at::Tensor _hfp8_to_float_gpu(const at::Tensor &input, const int64_t ebits, const int64_t exponent_bias)

将混合 8 位浮点 (hfp8) 值的张量转换为 float 值的张量。

参数:

• input – hfp8 值的张量

• ebits –

• exponent_bias –

抛出:

c10::Error – 如果 ebits > 0 或 exponent_bias > 0。

返回:

一个新张量，其值从输入张量转换为 `float`。

at::Tensor _float_to_msfp_gpu(const at::Tensor &input, const int64_t bounding_box_size, const int64_t ebits, const int64_t mbits, const int64_t bias, const double min_pos, const double max_pos)

将 float 值的张量转换为 Microsoft 浮点 (msfp) 值的张量。

参数:

• 输入 – 一个 `float` 值的张量

• bounding_box_size –

• ebits –

• mbits –

• bias –

• min_pos –

• max_pos –

返回:

返回一个新张量，其值由输入张量转换为 msfp。

at::Tensor _msfp_to_float_gpu(const at::Tensor &input, const int64_t ebits, const int64_t mbits, const int64_t bias)

将 Microsoft 浮点 (msfp) 值的张量转换为 float 值的张量。

参数:

• input – msfp 值的张量

• ebits –

• mbits –

• bias –

返回:

一个新张量，其值从输入张量转换为 `float`。

Tensor _float_to_paddedFP8rowwise_gpu(const Tensor &input, const bool forward, const int64_t row_dim)

将 float 值的张量转换为填充的 fp8 行式值的张量。

参数:

• 输入 – 一个 `float` 值的张量。dtype 可以是 `SparseType::FP32`、`SparseType::FP16` 或 `SparseType::BF16`

• 前向 –

• row_dim –

返回:

返回一个新张量，其值由输入张量转换为填充的 fp8 行式。

at::Tensor _paddedFP8rowwise_to_float_gpu(const at::Tensor &input, const bool forward, const int64_t row_dim, const int64_t output_last_dim, const int64_t output_dtype)

将填充的 fp8 行式值的张量转换为 float / values 的张量。

@param input A tensor of `float` values.  The dtype can be either
             `SparseType::FP32`, `SparseType::FP16`, or `SparseType::BF16`
@param forward
@param row_dim
@param output_last_dim
@param output_dtype The target floating point type, specified as integer
                    representation of `SparseType` enum

@return A new tensor with values from the input tensor converted to `float`.

@throw c10::Error if `output_dtype` is not one of (`SparseType::FP32`,
`SparseType::FP16`, `SparseType::BF16`).

CPU 算子

Tensor &_fused8bitrowwise_to_float_cpu_out(Tensor &output, const Tensor &input)

Tensor &_float_to_fused8bitrowwise_cpu_out(Tensor &output, const Tensor &input)

Tensor float_to_fused8bitrowwise_cpu(const Tensor &input)

Tensor half_to_fused8bitrowwise_cpu(const Tensor &input)

Tensor float_or_half_to_fused8bitrowwise_cpu(const Tensor &input)

Tensor fused8bitrowwise_to_float_cpu(const Tensor &input)

Tensor fused8bitrowwise_to_half_cpu(const Tensor &input)

Tensor fused8bitrowwise_to_float_or_half_cpu(const Tensor &input, const int64_t output_dtype, const bool scale_bias_last, const bool quant_padding_float_type)

Tensor float_to_FP8rowwise_cpu(const Tensor &input, bool forward)

Tensor FP8rowwise_to_float_cpu(const Tensor &input, bool forward, const int64_t output_dtype)

Tensor fusednbitrowwise_to_float_cpu(const Tensor &input, const int64_t bit_rate)

Tensor fusednbitrowwise_sbfront_to_float_cpu(const Tensor &input, const int64_t bit_rate, const int64_t output_dtype)

将尺度和偏差存储在前面的 int4/int2 行反量化为 float32/float16/Bfloat16。

将尺度和偏差存储在前面的 int4/int2 行反量化为 float32。输入张量应具有 torch.quint4x2 或 torch.quint2x4 dtype 和 QuantizedCPU 后端。此算子仅建议用于测试目的，因为其内核是参考实现，未进行优化。

参数:

• input – 尺度和偏差存储在前面的 int4/int2 行张量。

• bit_rate – 每个元素的比特率。应为 4 或 2。

返回:

float32 张量，包含反量化后的数字。

Tensor fusednbitrowwise_to_half_cpu(const Tensor &input, const int64_t bit_rate)

Tensor fusednbitrowwise_to_float_or_half_cpu(const Tensor &input, const int64_t bit_rate, const int64_t output_dtype, const bool scale_bias_last)

void FloatToFP8Quantized_ref(const float *const input, const size_t nrows, const size_t ncols, uint8_t *const output, const int ebits, const int exponent_bias, const double max_pos)

void FP8QuantizedToFloat_ref(const uint8_t *const input, const size_t nrows, const size_t ncols, float *const output, const int ebits, const int exponent_bias)