correctifs TRT-LLM : mappage MXFP4A16 et peripherique mRoPE

patches_trtllm/README.md

@@ -0,0 +1,54 @@
+# Correctifs TensorRT-LLM 1.3.0rc22 (23/08/2026)
+
+Deux correctifs Python — aucun CUDA nécessaire — qui débloquent TensorRT-LLM sur nos modèles.
+Testés sur RTX 6000 Ada (sm89), TRT-LLM 1.3.0rc22.
+
+## Le raisonnement
+
+TRT-LLM refusait nos MoE à cause du **format d'entrée**, pas d'une absence de noyau :
+
+| checkpoint | ce qui se passe |
+|---|---|
+| INT4 groupwise (AWQ) | routé vers `WInt4AFP8FusedMoEMethod` (chemin **W4A8**) → `input_scale` absent → `'NoneType' object has no attribute 'device'` |
+| FP8 officiel d'Ornith | `QuantMode 536` = `FP8_ROWWISE \| PER_TOKEN \| PER_CHANNEL` → aucune méthode MoE → `Unsupported quantization mode` |
+| **MXFP4** | `get_mxfp4_quant_algo()` renvoie `W4A16_MXFP4` pour `sm < 100` → **`WFP4A16FusedMoEMethod`, qui existe** |
+
+La voie MXFP4 était donc ouverte — mais deux verrous restaient.
+
+## `patch_mxfp4.py` — mappage compressed-tensors → W4A16_MXFP4
+
+`update_quant_config_from_compressed_tensors()` (dans `models/quant_config_utils.py`) gère le
+FP8 par canal, le FP8 par blocs et le NVFP4 (`strategy: "tensor_group"`, groupe 16), mais pas le
+MXFP4 weight-only que produit le préréglage `MXFP4A16` de `llmcompressor` :
+`strategy: "group"`, `group_size: 32`, `input_activations: null`.
+
+Deux défauts corrigés :
+1. la fonction fait `inputs_quant_config["strategy"]` **sans vérifier que `input_activations`
+   n'est pas `None`** → `TypeError` avant même d'atteindre un test utile ;
+2. aucune branche ne mappe le MXFP4 vers `QuantAlgo.W4A16_MXFP4`.
+
+## `patch_mrope.py` — périphérique du cache mRoPE
+
+`_prepare_qwen_vl_mrope_config()` (dans `_torch/models/modeling_qwen2vl.py`) construit `deltas`
+par `torch.cat()` de tenseurs venant des paramètres multimodaux — donc du **CPU** — puis les écrit
+dans `mrope_position_deltas_cache`, qui vit sur le **GPU** :
+
+```
+RuntimeError: Expected all tensors to be on the same device,
+              but got source is on cpu, different from other tensors on cuda:0
+```
+
+Le modèle charge entièrement et l'exécuteur démarre ; c'est la première génération qui tombe
+dessus, ce qui rend le symptôme (`AssertionError: Sampling failed`) trompeur.
+
+## Utilisation
+
+```bash
+python patch_mxfp4.py      # idempotent, sauvegarde en .orig
+python patch_mrope.py
+python quant_mxfp4.py      # produit un checkpoint MXFP4A16 depuis du BF16
+python trt_mxfp4.py        # sert le MoE MXFP4 en TRT-LLM
+```
+
+`quant_mxfp4.py` laisse les portes de routage en pleine précision : quantifier un routeur dégrade
+la sélection d'experts bien plus que les experts eux-mêmes.

patches_trtllm/patch_mrope.py

@@ -0,0 +1,25 @@
+# Correctif du bug de peripherique dans le mRoPE multimodal de TRT-LLM.
+#
+# _prepare_qwen_vl_mrope_config() construit `deltas` par torch.cat() de tenseurs
+# venant des parametres multimodaux, qui vivent sur le CPU, puis les ecrit dans
+# mrope_position_deltas_cache qui vit sur le GPU :
+#   RuntimeError: source is on cpu, different from other tensors on cuda:0
+# Un .to(device) manquant. Le modele charge et l'executeur demarre : c'est la
+# toute premiere generation qui tombe dessus.
+import shutil, sys
+F = "/opt/trtvenv/lib/python3.12/site-packages/tensorrt_llm/_torch/models/modeling_qwen2vl.py"
+src = open(F, encoding="utf-8").read()
+avant = "        deltas = torch.cat(delta_tensors, dim=0)\n        mrope_position_deltas_cache.index_copy_(0, seq_slots, deltas)"
+apres = ("        # les deltas viennent des parametres multimodaux, donc du CPU ;\n"
+         "        # le cache vit sur le GPU -> aligner avant index_copy_\n"
+         "        deltas = torch.cat(delta_tensors, dim=0).to(\n"
+         "            device=mrope_position_deltas_cache.device,\n"
+         "            dtype=mrope_position_deltas_cache.dtype)\n"
+         "        mrope_position_deltas_cache.index_copy_(0, seq_slots, deltas)")
+if apres.strip() in src:
+    print("PATCH_MROPE_DEJA"); sys.exit(0)
+if avant not in src:
+    print("ANCRAGE_INTROUVABLE"); sys.exit(1)
+shutil.copy(F, F + ".orig")
+open(F, "w", encoding="utf-8").write(src.replace(avant, apres, 1))
+print("PATCH_MROPE_APPLIQUE")

patches_trtllm/patch_mxfp4.py

@@ -0,0 +1,65 @@
+# Correctif : faire reconnaitre a TRT-LLM un checkpoint compressed-tensors
+# MXFP4A16 (poids 4 bits flottants, groupe 32, activations non quantifiees).
+#
+# update_quant_config_from_compressed_tensors() gere trois cas -- FP8 par canal,
+# FP8 par blocs, NVFP4 (strategy "tensor_group", groupe 16) -- mais pas le
+# MXFP4 weight-only produit par le prereglage MXFP4A16 de llmcompressor
+# (strategy "group", groupe 32, input_activations = None).
+#
+# Deux defauts a corriger, dans cet ordre :
+#   1. la fonction fait inputs_quant_config["strategy"] sans verifier que
+#      input_activations n'est pas None -> TypeError avant tout test utile ;
+#   2. aucune branche ne mappe le MXFP4 vers QuantAlgo.W4A16_MXFP4, alors que
+#      c'est precisement l'algo que get_mxfp4_quant_algo() choisit pour sm < 100
+#      et qu'il route vers WFP4A16FusedMoEMethod, qui est implementee.
+import re, shutil, sys
+
+F = "/opt/trtvenv/lib/python3.12/site-packages/tensorrt_llm/models/quant_config_utils.py"
+src = open(F, encoding="utf-8").read()
+if "W4A16_MXFP4" in src:
+    print("PATCH_DEJA_APPLIQUE"); sys.exit(0)
+shutil.copy(F, F + ".orig")
+
+# 1. ne pas dereferencer input_activations quand il vaut None
+avant = '''    weights_quant_strategy = weights_quant_config["strategy"]
+    inputs_quant_strategy = inputs_quant_config["strategy"]'''
+apres = '''    weights_quant_strategy = weights_quant_config["strategy"]
+    # MXFP4A16 laisse input_activations a None (poids seuls) : ne pas
+    # dereferencer avant d'avoir teste ce cas.
+    inputs_quant_strategy = (
+        inputs_quant_config["strategy"] if inputs_quant_config is not None else None
+    )'''
+assert avant in src, "ancrage 1 introuvable"
+src = src.replace(avant, apres)
+
+# 2. brancher le MXFP4 weight-only avant la branche NVFP4
+ancre = '''    elif (
+        weights_quant_config["num_bits"] == 4
+        and weights_quant_config.get("type") == "float"
+        and weights_quant_strategy == "tensor_group"
+    ):'''
+nouveau = '''    elif (
+        weights_quant_config["num_bits"] == 4
+        and weights_quant_config.get("type") == "float"
+        and weights_quant_strategy == "group"
+        and inputs_quant_config is None
+    ):
+        # llm-compressor MXFP4A16 : poids FP4 avec echelles E8M0 par groupe de
+        # 32, activations laissees en 16 bits. Sur sm < 100, c'est exactement ce
+        # que get_mxfp4_quant_algo() demande, et cela route vers
+        # WFP4A16FusedMoEMethod.
+        group_size = weights_quant_config["group_size"]
+        if group_size != 32:
+            raise ValueError(f"Unsupported group_size: {group_size}. Supported: 32 for MXFP4.")
+        quant_config.quant_algo = QuantAlgo.W4A16_MXFP4
+        quant_config.group_size = group_size
+    elif (
+        weights_quant_config["num_bits"] == 4
+        and weights_quant_config.get("type") == "float"
+        and weights_quant_strategy == "tensor_group"
+    ):'''
+assert ancre in src, "ancrage 2 introuvable"
+src = src.replace(ancre, nouveau, 1)
+
+open(F, "w", encoding="utf-8").write(src)
+print("PATCH_MXFP4_APPLIQUE")

patches_trtllm/quant_mxfp4.py

@@ -0,0 +1,29 @@
+# Quantification MXFP4A16 -- la cle du deblocage TensorRT-LLM.
+#
+# Rappel du raisonnement : get_mxfp4_quant_algo() de TRT-LLM renvoie, pour
+# sm < 100 (donc notre Ada sm89), QuantAlgo.W4A16_MXFP4, qui route vers
+# WFP4A16FusedMoEMethod -- une methode MoE 4 bits a activations 16 bits qui
+# EXISTE, contrairement au W4A16 groupwise (absent) et au FP8 rowwise (refuse).
+#
+# On quantifie l'A12B et non Ornith : la question posee est architecturale
+# ("TRT-LLM sait-il charger un MoE Qwen3.5 en MXFP4 sur sm89 ?"), et Ornith
+# demanderait de retelecharger 70 Go de BF16 pour la meme reponse.
+#
+# Les portes de routage restent en pleine precision : quantifier un routeur
+# degrade la selection d'experts bien plus que les experts eux-memes.
+import torch
+from llmcompressor import oneshot
+from llmcompressor.modifiers.quantization import QuantizationModifier
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+SRC = "/workspace/a12b"
+DST = "/workspace/a12b-mxfp4"
+
+model = AutoModelForCausalLM.from_pretrained(SRC, dtype=torch.bfloat16, device_map="cpu")
+tok = AutoTokenizer.from_pretrained(SRC)
+recette = QuantizationModifier(
+    targets="Linear", scheme="MXFP4A16",
+    ignore=["lm_head", "re:.*mlp\.gate$", "re:.*shared_expert_gate$"])
+oneshot(model=model, recipe=recette, output_dir=DST)
+tok.save_pretrained(DST)
+print("QUANT_MXFP4_OK")

patches_trtllm/trt_dense.py

@@ -0,0 +1,26 @@
+# TRT-LLM sur Qwen3.8-27B-FP8 (dense, block-scales -> chemin supporte).
+#
+# Deux corrections par rapport aux essais precedents :
+#  1. garde __main__ : MPI re-importe le script dans chaque worker et
+#     respawnait a l'infini -> MPI_ABORT.
+#  2. budget VRAM : le modele FP8 fait 27 Go sur une carte de 49 Go. Par
+#     defaut TRT-LLM reserve le reste pour le cache KV et depasse -> cudaMalloc
+#     out of memory. On borne explicitement la fraction libre et la longueur.
+import time
+
+def main():
+    from tensorrt_llm import LLM, SamplingParams
+    from tensorrt_llm.llmapi import KvCacheConfig
+    llm = LLM(model="/workspace/qwen38-fp8",
+              max_seq_len=4096, max_batch_size=1,
+              kv_cache_config=KvCacheConfig(free_gpu_memory_fraction=0.25))
+    sp = SamplingParams(max_tokens=256, temperature=0.0)
+    prompts = ["Ecris une fonction Python qui calcule la mediane d'une liste, avec docstring."]
+    llm.generate(prompts, sp)
+    t0 = time.time(); outs = llm.generate(prompts, sp); dt = time.time() - t0
+    n = len(outs[0].outputs[0].token_ids)
+    print(f"TRTLLM_DENSE {n} jetons en {dt:.2f}s = {n/dt:.1f} tok/s")
+    print("TEXTE:", outs[0].outputs[0].text[:400].replace("\n", " | "))
+
+if __name__ == '__main__':
+    main()

patches_trtllm/trt_mxfp4.py

@@ -0,0 +1,32 @@
+# LE test decisif : TRT-LLM sait-il servir un MoE Qwen3.5 en MXFP4 sur sm89 ?
+#
+# Attendu d'apres la lecture du code :
+#   load_hf_quant_config() voit quant_method == "mxfp4"
+#     -> get_mxfp4_quant_algo(), sm89 < 100 -> QuantAlgo.W4A16_MXFP4
+#       -> CutlassFusedMoE._get_quant_method() -> WFP4A16FusedMoEMethod
+#
+# Trois issues possibles, toutes informatives :
+#   - ca charge et genere      -> le deblocage est reel, on peut viser Ornith
+#   - "Unsupported quantization mode" -> le mapping HF->QuantMode ne prend pas
+#     le format compressed-tensors (il faudrait ecrire l'adaptateur)
+#   - autre erreur             -> a diagnostiquer, mais on aura depasse le mur
+import time, json, sys
+
+def main():
+    d = "/workspace/a12b-mxfp4"
+    print("quantization_config du checkpoint:",
+          json.dumps(json.load(open(d + "/config.json")).get("quantization_config", {}), indent=1)[:400])
+    from tensorrt_llm import LLM, SamplingParams
+    from tensorrt_llm.llmapi import KvCacheConfig
+    llm = LLM(model=d, max_seq_len=4096, max_batch_size=1,
+              kv_cache_config=KvCacheConfig(free_gpu_memory_fraction=0.35))
+    sp = SamplingParams(max_tokens=128, temperature=0.0)
+    p = ["Ecris une fonction Python qui calcule la mediane d'une liste."]
+    llm.generate(p, sp)
+    t0 = time.time(); outs = llm.generate(p, sp); dt = time.time() - t0
+    n = len(outs[0].outputs[0].token_ids)
+    print(f"TRTLLM_MXFP4 {n} jetons en {dt:.2f}s = {n/dt:.1f} tok/s")
+    print("TEXTE:", outs[0].outputs[0].text[:300].replace("\n", " | "))
+
+if __name__ == '__main__':
+    main()