[Model] Qwen3 support (#3218)

This PR supports the Qwen3 and Qwen3MoE models. The FP8 support is
still in progress.

A bug of topk-softmax is fixed in the PR.

Author: MasterJH5574

python/mlc_llm/interface/compiler_flags.py

@@ -5,8 +5,6 @@
 from io import StringIO
 from typing import Optional
 
-import tvm
-
 from mlc_llm.support import argparse, logging
 from mlc_llm.support.config import ConfigOverrideBase
 
@@ -91,8 +89,6 @@ def _flashinfer(target) -> bool:
                 return False
             if target.kind.name != "cuda":
                 return False
-            if tvm.get_global_func("support.GetLibInfo")()["USE_FLASHINFER"] != "ON":
-                return False
             arch_list = detect_cuda_arch_list(target)
             for arch in arch_list:
                 if arch < 80:

python/mlc_llm/model/model.py

@@ -39,6 +39,8 @@
 from .qwen import qwen_loader, qwen_model, qwen_quantization
 from .qwen2 import qwen2_loader, qwen2_model, qwen2_quantization
 from .qwen2_moe import qwen2_moe_loader, qwen2_moe_model, qwen2_moe_quantization
+from .qwen3 import qwen3_loader, qwen3_model, qwen3_quantization
+from .qwen3_moe import qwen3_moe_loader, qwen3_moe_model, qwen3_moe_quantization
 from .rwkv5 import rwkv5_loader, rwkv5_model, rwkv5_quantization
 from .rwkv6 import rwkv6_loader, rwkv6_model, rwkv6_quantization
 from .stable_lm import stablelm_loader, stablelm_model, stablelm_quantization
@@ -326,6 +328,34 @@ class Model:
             "ft-quant": qwen2_moe_quantization.ft_quant,
         },
     ),
+    "qwen3": Model(
+        name="qwen3",
+        model=qwen3_model.Qwen3LMHeadModel,
+        config=qwen3_model.Qwen3Config,
+        source={
+            "huggingface-torch": qwen3_loader.huggingface,
+            "huggingface-safetensor": qwen3_loader.huggingface,
+        },
+        quantize={
+            "no-quant": qwen3_quantization.no_quant,
+            "group-quant": qwen3_quantization.group_quant,
+            "ft-quant": qwen3_quantization.ft_quant,
+        },
+    ),
+    "qwen3_moe": Model(
+        name="qwen3_moe",
+        model=qwen3_moe_model.Qwen3MoeForCausalLM,
+        config=qwen3_moe_model.Qwen3MoeConfig,
+        source={
+            "huggingface-torch": qwen3_moe_loader.huggingface,
+            "huggingface-safetensor": qwen3_moe_loader.huggingface,
+        },
+        quantize={
+            "no-quant": qwen3_moe_quantization.no_quant,
+            "group-quant": qwen3_moe_quantization.group_quant,
+            "ft-quant": qwen3_moe_quantization.ft_quant,
+        },
+    ),
     "deepseek_v2": Model(
         name="deepseek_v2",
         model=deepseek_v2_model.DeepseekV2ForCausalLM,

python/mlc_llm/model/qwen3/__init__.py

@@ -0,0 +1,89 @@
+"""
+This file specifies how MLC's QWen2 parameter maps from other formats, for example HuggingFace
+PyTorch, HuggingFace safetensors.
+"""
+
+import functools
+
+import numpy as np
+
+from mlc_llm.loader import ExternMapping
+from mlc_llm.quantization import Quantization
+
+from .qwen3_model import Qwen3Config, Qwen3LMHeadModel
+
+
+def huggingface(model_config: Qwen3Config, quantization: Quantization) -> ExternMapping:
+    """Returns a parameter mapping that maps from the names of MLC LLM parameters to
+    the names of HuggingFace PyTorch parameters.
+
+    Parameters
+    ----------
+    model_config : Qwen3Config
+        The configuration of the Qwen3 model.
+
+    quantization : Quantization
+        The quantization configuration.
+
+    Returns
+    -------
+    param_map : ExternMapping
+        The parameter mapping from MLC to HuggingFace PyTorch.
+    """
+    model = Qwen3LMHeadModel(model_config)
+    if quantization is not None:
+        model.to(quantization.model_dtype)
+    _, _named_params, _ = model.export_tvm(  # type: ignore[misc]
+        spec=model.get_default_spec(),
+        allow_extern=True,
+    )
+    named_parameters = dict(_named_params)
+
+    mapping = ExternMapping()
+
+    for i in range(model_config.num_hidden_layers):
+        # map attention weight
+        attn = f"model.layers.{i}.self_attn"
+        weight_names = ["weight", "bias"] if model_config.attention_bias else ["weight"]
+        for weight_type in weight_names:
+            mlc_name = f"{attn}.c_attn.{weight_type}"
+            mlc_param = named_parameters[mlc_name]
+            mapping.add_mapping(
+                mlc_name,
+                [
+                    f"{attn}.q_proj.{weight_type}",
+                    f"{attn}.k_proj.{weight_type}",
+                    f"{attn}.v_proj.{weight_type}",
+                ],
+                functools.partial(
+                    lambda q, k, v, dtype: np.concatenate([q, k, v], axis=0).astype(dtype),
+                    dtype=mlc_param.dtype,
+                ),
+            )
+        # map mlp weight
+        mlp = f"model.layers.{i}.mlp"
+        mlc_name = f"{mlp}.gate_up_proj.weight"
+        mlc_param = named_parameters[mlc_name]
+        mapping.add_mapping(
+            mlc_name,
+            [
+                f"{mlp}.gate_proj.weight",
+                f"{mlp}.up_proj.weight",
+            ],
+            functools.partial(
+                lambda gate, up, dtype: np.concatenate([gate, up], axis=0).astype(dtype),
+                dtype=mlc_param.dtype,
+            ),
+        )
+
+    for mlc_name, mlc_param in named_parameters.items():
+        if mlc_name not in mapping.param_map:
+            mapping.add_mapping(
+                mlc_name,
+                [mlc_name],
+                functools.partial(
+                    lambda x, dtype: x.astype(dtype),
+                    dtype=mlc_param.dtype,
+                ),
+            )
+    return mapping