181 lines
7.4 KiB
Python
181 lines
7.4 KiB
Python
#
|
|
# Copyright (c) 2025 Huawei Technologies Co., Ltd. All Rights Reserved.
|
|
# This file is a part of the vllm-ascend project.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
#
|
|
|
|
import math
|
|
from typing import Any
|
|
|
|
import torch
|
|
import torch_npu
|
|
from vllm.config import get_current_vllm_config
|
|
from vllm.distributed import get_tensor_model_parallel_world_size
|
|
from vllm.model_executor.layers.linear import RowParallelLinear
|
|
|
|
from vllm_ascend.device.mxfp_compat import ensure_mxfp4_flatquant_linear_available
|
|
|
|
from .base import AscendLinearScheme
|
|
from .registry import register_scheme
|
|
|
|
# Maximum supported dimension for Kronecker quantization left_trans_dim and right_trans_dim
|
|
MAX_SUPPORT_DIM = 256
|
|
|
|
|
|
def get_decompose_dim(n: int, m: int) -> tuple[int, int]:
|
|
"""Get decomposed dimensions for Kronecker quantization.
|
|
Args:
|
|
n: Dimension to decompose
|
|
m: Tensor parallelism size
|
|
Returns:
|
|
tuple[int, int]: Left decomposed dim, right decomposed dim
|
|
Raises:
|
|
ValueError: If decomposed dimension exceeds MAX_SUPPORT_DIM
|
|
"""
|
|
a = int(math.sqrt(n))
|
|
if a * a < n:
|
|
a += 1
|
|
|
|
while True:
|
|
tmp = a * a - n
|
|
b = int(math.sqrt(tmp))
|
|
if b * b == tmp:
|
|
break
|
|
a += 1
|
|
|
|
if (a + b) > MAX_SUPPORT_DIM:
|
|
raise ValueError(
|
|
f"Kronecker quantization left_trans_dim and right_trans_dim should be less than {MAX_SUPPORT_DIM}"
|
|
)
|
|
|
|
if (a - b) * m > MAX_SUPPORT_DIM:
|
|
return MAX_SUPPORT_DIM, m * n // MAX_SUPPORT_DIM
|
|
|
|
return a - b, a + b
|
|
|
|
|
|
@register_scheme("W4A4_MXFP4_FLATQUANT", "linear")
|
|
class AscendW4A4MXFP4FlatQuantDynamicLinearMethod(AscendLinearScheme):
|
|
"""Linear method for Ascend W4A4_MXFP4_FLATQUANT_DYNAMIC."""
|
|
|
|
def __init__(self):
|
|
ensure_mxfp4_flatquant_linear_available("W4A4_MXFP4_FLATQUANT linear quantization")
|
|
vllm_config = get_current_vllm_config()
|
|
self.group_size = vllm_config.quant_config.quant_description.get("group_size", 32)
|
|
self.max_supported_tp = vllm_config.quant_config.quant_description.get("max_supported_tp", 4)
|
|
self.tp_size = get_tensor_model_parallel_world_size()
|
|
if self.tp_size > self.max_supported_tp:
|
|
raise ValueError(
|
|
f"For W4A4_MXFP4_FLATQUANT, TP size ({self.tp_size}) is not supported. "
|
|
f"Max supported TP size is {self.max_supported_tp}, "
|
|
f"according to the max_supported_tp parameter in quant_description."
|
|
)
|
|
|
|
def get_weight(self, input_size: int, output_size: int, params_dtype: torch.dtype) -> dict[str, Any]:
|
|
if input_size % 2 != 0:
|
|
raise ValueError(f"input_size ({input_size}) must be divisible by 2 for fp4 packing")
|
|
self.input_size = input_size
|
|
params_dict = {"weight": torch.empty(output_size, input_size // 2, dtype=torch.uint8)}
|
|
|
|
return params_dict
|
|
|
|
def get_pertensor_param(self, params_dtype: torch.dtype, **kwargs: Any) -> dict[str, Any]:
|
|
params_dict = {}
|
|
layer_type = kwargs.get("layer_type")
|
|
if layer_type == "row":
|
|
origin_size = self.input_size * self.tp_size
|
|
_, right_trans_dim = get_decompose_dim(origin_size // self.max_supported_tp, self.max_supported_tp)
|
|
left_trans_dim = origin_size // right_trans_dim
|
|
else:
|
|
left_trans_dim, right_trans_dim = get_decompose_dim(self.input_size, 1)
|
|
|
|
params_dict["left_trans"] = torch.empty(left_trans_dim, left_trans_dim, dtype=params_dtype)
|
|
params_dict["right_trans"] = torch.empty(right_trans_dim, right_trans_dim, dtype=params_dtype)
|
|
params_dict["clip_ratio"] = torch.empty(1, dtype=torch.float32)
|
|
return params_dict
|
|
|
|
def get_pergroup_param(
|
|
self, input_size: int, output_size: int, params_dtype: torch.dtype, layer_type: str | None = None
|
|
) -> dict[str, Any]:
|
|
params_dict = {}
|
|
params_dict["weight_scale"] = torch.empty(output_size, input_size // self.group_size, dtype=torch.uint8)
|
|
|
|
return params_dict
|
|
|
|
def apply(
|
|
self,
|
|
layer: torch.nn.Module,
|
|
x: torch.Tensor,
|
|
bias: torch.Tensor | None = None,
|
|
tp_rank: int | None = 0,
|
|
) -> torch.Tensor:
|
|
original_dtype = x.dtype
|
|
input_shape = x.shape
|
|
in_features = input_shape[-1]
|
|
left_dim = layer.left_trans.shape[0]
|
|
right_dim = layer.right_trans.shape[0]
|
|
if left_dim * right_dim != in_features:
|
|
raise ValueError(
|
|
f"FlatQuant transform matrices dimension mismatch: "
|
|
f"left_dim({left_dim}) * right_dim({right_dim}) != in_features({in_features})"
|
|
)
|
|
x_reshaped = x.view(-1, left_dim, right_dim)
|
|
x_quantized_fp4, pertoken_scale = torch_npu.npu_kronecker_quant(
|
|
x_reshaped,
|
|
layer.left_trans,
|
|
layer.right_trans,
|
|
layer.aclnn_clip_ratio,
|
|
dst_dtype=torch_npu.float4_e2m1fn_x2,
|
|
)
|
|
|
|
output = torch_npu.npu_quant_matmul(
|
|
x_quantized_fp4,
|
|
layer.weight,
|
|
layer.weight_scale,
|
|
scale_dtype=torch_npu.float8_e8m0fnu,
|
|
pertoken_scale=pertoken_scale,
|
|
pertoken_scale_dtype=torch_npu.float8_e8m0fnu,
|
|
bias=bias,
|
|
output_dtype=original_dtype,
|
|
x1_dtype=torch_npu.float4_e2m1fn_x2,
|
|
x2_dtype=torch_npu.float4_e2m1fn_x2,
|
|
group_sizes=[1, 1, self.group_size],
|
|
)
|
|
output = output.view(*input_shape[:-1], -1)
|
|
return output
|
|
|
|
def process_weights_after_loading(self, layer):
|
|
if isinstance(layer, RowParallelLinear):
|
|
"""
|
|
Process weights after loading with TP diagonal block extraction.
|
|
This is the special weight loading logic for FlatQuant row parallelism.
|
|
"""
|
|
left_dim = layer.left_trans.data.shape[0]
|
|
# Calculate block sizes
|
|
left_block_size = left_dim // layer.tp_size
|
|
# Extract diagonal block for current rank
|
|
layer.left_trans.data = layer.left_trans.data[
|
|
layer.tp_rank * left_block_size : (layer.tp_rank + 1) * left_block_size,
|
|
layer.tp_rank * left_block_size : (layer.tp_rank + 1) * left_block_size,
|
|
]
|
|
|
|
layer.weight_scale.data = layer.weight_scale.data.view(-1, layer.weight_scale.shape[-1] // 2, 2)
|
|
layer.weight.data = layer.weight.data.transpose(0, 1)
|
|
layer.weight_scale.data = layer.weight_scale.data.transpose(0, 1)
|
|
|
|
layer.left_trans = torch.nn.Parameter(layer.left_trans.data.t().contiguous())
|
|
layer.right_trans = torch.nn.Parameter(layer.right_trans.data)
|
|
layer.clip_ratio = torch.nn.Parameter(layer.clip_ratio.data.to(torch.float32))
|
|
layer.aclnn_clip_ratio = layer.clip_ratio.item()
|