目录
快捷方式

量化运算符

量化是一种模型优化技术，用于减小大型模型的尺寸，从而以少量精度损失实现更好的存储性能。

CUDA 运算符

at::Tensor _float_to_bfloat16_gpu(const at::Tensor &input)

将一个包含 float 值的张量转换为包含 Brain Floating Point (bfloat16) 值的张量。

参数:

input – 一个包含 float 值的张量

返回:

一个新张量，其中包含从输入张量转换而来的 bfloat16 值。

at::Tensor _bfloat16_to_float_gpu(const at::Tensor &input)

将一个包含 Brain Floating Point (bfloat16) 值的张量转换为包含 float 值的张量。

参数:

input – 一个包含 bfloat16 值的张量

返回:

一个新张量，其中包含从输入张量转换而来的 float 值。

Tensor _float_to_FP8rowwise_gpu(const Tensor &input, const bool forward)

将一个包含 float 值的张量转换为包含 fp8 值的张量。

参数:

  • input – 一个包含 float 值的张量。dtype 可以是 SparseType::FP32、SparseType::FP16 或 SparseType::BF16

  • forward –

抛出:

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

返回:

一个新张量，其中包含从输入张量转换而来的 fp8 值。

at::Tensor _FP8rowwise_to_float_gpu(const at::Tensor &input, bool forward, const int64_t output_dtype)

将一个包含 fp8 值的张量转换为包含 float 值的张量。

参数:

  • input – 一个包含 fp8 值的张量

  • forward –

  • output_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 &input)

将一个包含 float 值的张量转换为包含融合 8 位行式值的张量。

参数:

input – 一个包含 float 值的张量

返回:

一个新张量，其中包含从输入张量转换而来的融合 8 位行式值。

Tensor _half_to_fused8bitrowwise_gpu(const Tensor &input)

将一个包含 at::Half 值的张量转换为包含融合 8 位行式值的张量。

参数:

input – 一个包含 at::Half 值的张量

返回:

一个新张量，其中包含从输入张量转换而来的融合 8 位行式值。

Tensor _single_or_half_precision_to_fused8bitrowwise_gpu(const Tensor &input)

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

参数:

input – 一个包含 at::Single 或 at::Half 值的张量

返回:

一个新张量，其中包含从输入张量转换而来的融合 8 位行式值。

at::Tensor _fused8bitrowwise_to_float_gpu(const at::Tensor &input)

将一个包含融合 8 位行式值的张量转换为包含 float 值的张量。

参数:

input – 一个包含融合 8 位行式值的张量

返回:

一个新张量，其中包含从输入张量转换而来的 float 值。

at::Tensor _fused8bitrowwise_to_half_gpu(const at::Tensor &input)

将一个包含融合 8 位行式值的张量转换为包含 at::Half 值的张量。

参数:

input – 一个包含融合 8 位行式值的张量

返回:

一个新张量，其中包含从输入张量转换而来的 at::Half 值。

at::Tensor _fused8bitrowwise_to_single_or_half_precision_gpu(const at::Tensor &input, const int64_t output_dtype, const bool scale_bias_last, const bool quant_padding_float_type)

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

参数:

  • input – 一个包含融合 8 位行式值的张量

  • output_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 &input, const at::Tensor &D_offsets, const int64_t output_dtype)

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

参数:

  • input – 一个包含融合 8 位行式值的张量

  • D_offsets –

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

抛出:

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

返回:

一个新张量，其中包含从输入张量转换而来的 at::kFloat 或 at::kHalf 值。

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

将一个包含 float 值的张量转换为包含融合 N 位行式值的张量。

参数:

  • input – 一个包含 float 值的张量

  • bit_rate –

返回:

一个新张量，其中包含从输入张量转换而来的融合 N 位行式值。

at::Tensor _half_to_fusednbitrowwise_gpu(const at::Tensor &input, const int64_t bit_rate)

将一个包含 at::Half 值的张量转换为包含融合 N 位行式值的张量。

参数:

  • input – 一个包含 at::Half 值的张量

  • bit_rate –

返回:

一个新张量，其中包含从输入张量转换而来的融合 N 位行式值。

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

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

参数:

  • input – 一个包含 float 或 at::Half 值的张量

  • bit_rate –

返回:

一个新张量，其中包含从输入张量转换而来的融合 N 位行式值。

at::Tensor _fusednbitrowwise_to_float_gpu(const at::Tensor &input, const int64_t bit_rate)

将一个包含融合 N 位行式值的张量转换为包含 float 值的张量。

参数:

  • input – 一个包含融合 N 位行式值的张量

  • bit_rate –

返回:

一个新张量，其中包含从输入张量转换而来的 float 值。

at::Tensor _fusednbitrowwise_to_half_gpu(const at::Tensor &input, const int64_t bit_rate)

将一个包含融合 N 位行式值的张量转换为包含 at::Half 值的张量。

参数:

  • input – 一个包含融合 N 位行式值的张量

  • bit_rate –

返回:

一个新张量，其中包含从输入张量转换而来的 at::Half 值。

at::Tensor _fusednbitrowwise_to_single_or_half_precision_gpu(const at::Tensor &input, const int64_t bit_rate, const int64_t output_dtype, const bool scale_bias_last)

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

参数:

  • input – 一个包含融合 N 位行式值的张量

  • bit_rate –

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

抛出:

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

返回:

一个新张量，其中包含从输入张量转换而来的 float、at::Half 或 at::Bf16 值，具体取决于 output_dtype。

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) 值的张量。

参数:

  • input – 一个包含 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 Floating Point (msfp) 值的张量。

参数:

  • input – 一个包含 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 Floating Point (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 行式值的张量。

参数:

  • input – 一个包含 float 值的张量。dtype 可以是 SparseType::FP32、SparseType::FP16 或 SparseType::BF16

  • forward –

  • 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, const bool scale_bias_last, const bool quant_padding_float_type)
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_bfloat16_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)
Tensor FP8rowwise_to_float_cpu(const Tensor &input, bool, const int64_t)
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 行与 scale 和 bias 解量化为 float32/float16/Bfloat16。

将存储在前端的 int4/int2 行与 scale 和 bias 解量化为 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)

文档

访问全面的 PyTorch 开发者文档

查看文档

教程

为初学者和高级开发者提供深入的教程

查看教程

资源

查找开发资源并让您的问题得到解答

查看资源

为了分析流量并优化您的体验，我们在此网站上使用 Cookie。点击或浏览即表示您同意我们使用 Cookie。作为本网站的当前维护者，Facebook 的 Cookie 政策适用。了解更多信息，包括可用的控件： Cookie 政策。