Mixture of Experts (MoE) : L'Architecture derrière Mixtral et Grok

14 min de lecture 2941 mots

tl;dr: Mixture of Experts (MoE) utilise plusieurs sous-réseaux spécialisés (experts) et un router qui active seulement 2-3 experts par token. Mixtral 8x7B a 47B paramètres mais coûte comme 13B. Avantages : efficacité, spécialisation, scalabilité. Défis : load balancing, mémoire.

Le dilemme fondamental de l’IA :

Plus un modèle a de paramètres, plus il est puissant… mais plus il coûte cher à entraîner et à exécuter.

GPT-3 : 175B paramètres, $4.6M d’entraînement
GPT-4 : ~1.7T paramètres (estimé), >$100M d’entraînement
Llama 3.1 405B : 405B paramètres, ~$5M GPU coût

Le problème : Pour rivaliser avec GPT-4, il faudrait des modèles encore plus massifs. Impossible pour la plupart des acteurs.

La solution MoE : Mixture of Experts (Mélange d’Experts) résout ce problème élégamment :

Mixtral 8x7B = 47 milliards de paramètres, mais coût computationnel de seulement 13B.

Comment ? En n’activant qu’une fraction du modèle à la fois.

💡 Mixture of Experts (MoE) est une architecture où le modèle contient plusieurs sous-réseaux spécialisés (experts). Un mécanisme de routing décide dynamiquement quels experts activer pour chaque token, permettant des modèles massifs avec coût computationnel réduit.

Illustration détaillée de l’architecture Mixture of Experts (MoE)

Métaphore

Imaginez une équipe de médecins spécialistes :

Cardiologue (expert cœur)
Neurologue (expert cerveau)
Dermatologue (expert peau)
etc.

Approche classique (modèle dense) : Tous les médecins examinent chaque patient → Lent et coûteux.

Approche MoE : Un médecin généraliste (router) évalue le patient et l’envoie seulement aux 2 spécialistes pertinents → Rapide et efficace.

Résultat : Expertise de 10 spécialistes, coût de 2 consultations.

Qu’est-ce que Mixture of Experts ?

Historique

MoE n’est pas nouveau :

1991 : Concept introduit par Jacobs et Jordan (MIT)
2017 : Shazeer et al. (Google) appliquent aux Transformers (1 000+ experts)
2021 : Switch Transformer (Google) - 1.6T paramètres avec MoE
2023 : Mixtral 8x7B (Mistral AI) - Premier MoE accessible et performant
2024 : Grok-1 (xAI), Qwen-MoE (Alibaba), DeepSeek-MoE

Pourquoi maintenant ? Combinaison de :

Hardware moderne (GPUs puissants)
Techniques de training stabilisées
Demande pour modèles efficient

Principe fondamental

Modèle dense traditionnel :

Input → [Tous les paramètres activés] → Output
        175B paramètres actifs

Modèle MoE :

Input → [Router] → [2-3 experts sur 8 activés] → Output
         47B total, mais seulement 13B actifs

Avantage clé : Multiplier les paramètres (capacité) sans multiplier le coût (compute).

Architecture technique

Les 3 composants

1. Experts : Sous-réseaux spécialisés (FFN - FeedForward Networks)

2. Router/Gating Network : Décide quels experts activer

3. Sparse Activation : Activation sélective (top-K experts)

# Architecture simplifiée conceptuelle
class MixtureOfExpertsLayer:
    def __init__(self, num_experts=8, expert_dim=4096, num_experts_per_token=2):
        # Experts : FFN indépendants
        self.experts = [
            FeedForwardNetwork(dim=expert_dim)
            for _ in range(num_experts)
        ]

        # Router : Décide quels experts utiliser
        self.router = nn.Linear(expert_dim, num_experts)

        self.num_experts_per_token = num_experts_per_token  # Top-K

    def forward(self, x):
        # x shape: (batch, seq_len, dim)

        # 1. Router calcule scores pour chaque expert
        router_logits = self.router(x)  # (batch, seq_len, num_experts)
        routing_weights = F.softmax(router_logits, dim=-1)

        # 2. Sélectionner top-K experts
        top_k_weights, top_k_indices = torch.topk(
            routing_weights,
            k=self.num_experts_per_token,
            dim=-1
        )  # (batch, seq_len, K)

        # Normaliser poids des experts sélectionnés
        top_k_weights = top_k_weights / top_k_weights.sum(dim=-1, keepdim=True)

        # 3. Calculer output de chaque expert sélectionné
        output = torch.zeros_like(x)

        for i in range(self.num_experts_per_token):
            expert_idx = top_k_indices[..., i]  # Quel expert ?
            expert_weight = top_k_weights[..., i]  # Avec quel poids ?

            # Appliquer l'expert (batched)
            for batch_idx in range(x.shape[0]):
                for seq_idx in range(x.shape[1]):
                    expert_id = expert_idx[batch_idx, seq_idx].item()
                    weight = expert_weight[batch_idx, seq_idx]

                    expert_output = self.experts[expert_id](x[batch_idx, seq_idx])
                    output[batch_idx, seq_idx] += weight * expert_output

        return output

Router/Gating Network

Le router est la clé de MoE. C’est un petit réseau (souvent une seule couche linéaire) qui prédit la pertinence de chaque expert.

Fonctionnement :

Input : Embedding du token (ex: 4096 dimensions)
Linear projection : Token → Scores experts (8 valeurs)
Softmax : Convertir en probabilités
Top-K selection : Garder les K meilleurs (typiquement K=2)

# Exemple concret
token_embedding = torch.randn(4096)  # Embedding d'un token

router_weights = torch.randn(8, 4096)  # Router : 8 experts
router_bias = torch.randn(8)

# Calculer scores
scores = torch.matmul(router_weights, token_embedding) + router_bias
# scores = [2.3, 0.1, 5.7, 1.2, 4.8, 0.5, 3.1, 1.9]

# Softmax → Probabilités
probs = F.softmax(scores, dim=0)
# probs = [0.08, 0.01, 0.26, 0.03, 0.10, 0.01, 0.18, 0.06]

# Top-2 selection
top2_values, top2_indices = torch.topk(probs, k=2)
# top2_indices = [2, 6]  ← Experts 2 et 6 activés
# top2_values = [0.26, 0.18]

# Normaliser
normalized = top2_values / top2_values.sum()
# normalized = [0.59, 0.41]

Résultat : Pour ce token, Expert 2 contribue 59%, Expert 6 contribue 41%.

Sparse Activation

Sparse = Creux, non-dense. Seule une fraction des paramètres est active.

Mixtral 8x7B :

Total paramètres : 8 experts × 7B = 56B (+ couches partagées) = 47B total
Paramètres actifs : 2 experts × 7B / 8 = 13B actifs
Sparsity : 13B / 47B = 27.7% actif

Graphique conceptuel :

Token 1 : [■ □ □ ■ □ □ □ □]  Experts 0 et 3
Token 2 : [□ □ ■ □ □ ■ □ □]  Experts 2 et 5
Token 3 : [□ ■ □ □ □ □ ■ □]  Experts 1 et 6
Token 4 : [■ □ □ □ ■ □ □ □]  Experts 0 et 4

■ = Actif, □ = Inactif

Chaque token active une combinaison différente d’experts.

Fonctionnement étape par étape

Prenons l’exemple de Mixtral 8x7B traitant la phrase :

“Paris est la capitale de la France”

Tokenization

Tokens : ["Paris", " est", " la", " capitale", " de", " la", " France"]
Token IDs : [4815, 1826, 1208, 6230, 409, 1208, 3201]

Embeddings

Chaque token → Vecteur 4096 dimensions.

embeddings = embed_layer(token_ids)
# Shape : (7 tokens, 4096 dim)

Passage dans les couches Transformer

Mixtral a 32 couches. Les couches 0, 2, 4, …, 30 (paires) sont MoE layers.

Couche MoE typique :

for token_idx, token_emb in enumerate(embeddings):
    # 1. Self-attention (classique, pas MoE)
    attended = self_attention(token_emb, all_embeddings)

    # 2. Router décide quels experts
    router_scores = router(attended)
    # Scores : [0.05, 0.12, 0.34, 0.08, 0.29, 0.04, 0.06, 0.02]

    top2_experts = topk(router_scores, k=2)
    # Sélectionnés : Experts 2 (34%) et 4 (29%)

    # 3. Experts traitent le token
    expert_2_output = experts[2](attended)  # 7B paramètres
    expert_4_output = experts[4](attended)  # 7B paramètres

    # 4. Combinaison pondérée
    combined = 0.54 * expert_2_output + 0.46 * expert_4_output

    # 5. Residual connection + LayerNorm
    output = layer_norm(attended + combined)

Exemple de spécialisation

Token “Paris” (géographie) :

Router active : Expert 3 (géographie) + Expert 5 (culture)

Token “capitale” (politique/admin) :

Router active : Expert 1 (politique) + Expert 6 (définitions)

Token “France” (pays) :

Router active : Expert 3 (géographie) + Expert 1 (politique)

🔎 Tip
Auto-spécialisation : Les experts ne sont pas pré-assignés à des domaines. Pendant l’entraînement, ils se spécialisent naturellement selon les patterns récurrents des données.

Génération

Après les 32 couches, l’embedding final passe par la tête de langage (LM head) pour prédire le prochain token.

# Embedding final du dernier token
final_embedding = output_layer_32[-1]  # (4096,)

# Projection vers vocabulaire (32K tokens)
logits = lm_head(final_embedding)  # (32000,)

# Softmax → Probabilités
probs = softmax(logits)

# Token le plus probable
next_token_id = argmax(probs)

Avantages de MoE

Efficacité : 8x paramètres, 2x compute

Comparaison Mixtral 8x7B vs Llama 2 70B :

Métrique	Mixtral 8x7B	Llama 2 70B	Gain
Paramètres totaux	47B	70B	-
Paramètres actifs	13B	70B	5.4x moins
FLOPS par token	~150B	~840B	5.6x moins
Vitesse inference	80 t/s	20 t/s	4x plus rapide
VRAM (INT4)	26 GB	40 GB	1.5x moins
Performance MMLU	70.6%	68.9%	+1.7%

Résultat : Mixtral surpasse Llama 70B en utilisant 5x moins de compute.

Spécialisation des experts

Les experts se spécialisent automatiquement pendant l’entraînement.

Exemple d’analyse (Mixtral) :

# Analyser quels experts sont activés par domaine
def analyze_expert_usage(model, prompts):
    expert_counts = {i: {"math": 0, "code": 0, "text": 0} for i in range(8)}

    for domain, prompt in prompts.items():
        with torch.no_grad():
            outputs = model(prompt, output_router_logits=True)
            for layer_router_logits in outputs.router_logits:
                top_experts = torch.topk(layer_router_logits, k=2).indices
                for expert_id in top_experts:
                    expert_counts[expert_id][domain] += 1

    return expert_counts

prompts = {
    "math": "Solve: 2x + 5 = 13",
    "code": "Write a Python function to sort a list",
    "text": "Describe the Eiffel Tower"
}

usage = analyze_expert_usage(mixtral_model, prompts)
# Résultat exemple :
# Expert 0 : math 85%, code 10%, text 5%   ← Spécialiste math
# Expert 2 : math 5%, code 80%, text 15%   ← Spécialiste code
# Expert 5 : math 8%, code 12%, text 80%   ← Spécialiste texte

Observation réelle : Les experts se différencient effectivement selon les tâches.

Scalabilité : Ajouter des experts facilement

Approche traditionnelle : Doubler modèle de 70B à 140B = Réentraîner de zéro.

Approche MoE : Passer de 8 à 16 experts = Ajouter experts, fine-tuner router.

# Pseudo-code : Étendre MoE
original_model = Mixtral8x7B()  # 8 experts

# Dupliquer experts existants
new_experts = [copy.deepcopy(expert) for expert in original_model.experts]

# Ajouter au modèle
extended_model = MixtralMoE(
    experts=original_model.experts + new_experts,  # 16 experts
    num_experts_per_token=2
)

# Fine-tuner seulement le router et les nouveaux experts (rapide)
for epoch in range(fine_tune_epochs):
    train_step(extended_model, data, freeze_original_experts=True)

Coût : Fraction du réentraînement complet.

Performance : Meilleurs résultats à coût égal

Benchmarks :

Modèle	Type	Params actifs	MMLU	HumanEval	Prix/1M tokens
Llama 2 13B	Dense	13B	54.8%	29.9%	$0.20
Mixtral 8x7B	MoE	13B	70.6%	40.2%	$0.24
Llama 2 70B	Dense	70B	68.9%	29.9%	$0.90
GPT-3.5	Dense	~175B	70.0%	48.1%	$0.50

Mixtral 8x7B (13B actifs) rivalise avec Llama 70B (70B actifs).

Modèles MoE en production

Mixtral 8x7B (Mistral AI)

Premier MoE grand public accessible (décembre 2023).

Spécifications :

8 experts de 7B chacun
Top-2 routing (2 experts actifs)
47B paramètres totaux, 13B actifs
Context 32K tokens

Performance :

MMLU : 70.6% (surpasse Llama 2 70B)
HumanEval : 40.2%
MT-Bench : 8.30/10

Utilisation :

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained(
    "mistralai/Mixtral-8x7B-v0.1",
    device_map="auto",
    load_in_4bit=True  # Quantization : 26 GB VRAM
)

tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-v0.1")

prompt = "Explain quantum entanglement simply"
inputs = tokenizer(prompt, return_tensors="pt").to("cuda")

outputs = model.generate(
    **inputs,
    max_new_tokens=200,
    output_router_logits=True  # ← Voir routing
)

print(tokenizer.decode(outputs[0]))

# Analyser routing
router_logits = outputs.router_logits
# Voir quels experts ont été activés pour chaque token

API Mistral :

from mistralai.client import MistralClient

client = MistralClient(api_key="your-api-key")

response = client.chat(
    model="mixtral-8x7b-32768",  # Avec 32K context
    messages=[{"role": "user", "content": "Write a Python sorting algorithm"}]
)

print(response.choices[0].message.content)

Mixtral 8x22B

Version plus puissante (avril 2024).

Caractéristiques :

8 experts de 22B chacun
141B paramètres totaux
39B paramètres actifs (top-2)
Context 64K tokens

Performance :

MMLU : 77.8% (proche GPT-4)
HumanEval : 45.0%
MT-Bench : 8.66/10

Trade-off : Plus puissant mais nécessite 80GB+ VRAM (même en INT4).

Grok-1 (xAI)

Modèle open source d’Elon Musk (mars 2024).

Spécifications :

8 experts de ~47B chacun (estimé)
314B paramètres totaux
86B actifs (top-2)
Entraîné sur 33B tokens

Performance :

MMLU : 73%
HumanEval : 63.2% (excellent sur code)
GSM8K (math) : 62.9%

Défis :

Taille massive : 300+ GB en FP16
Nécessite 4-8 GPUs A100 pour inference

# Exécuter Grok-1 (nécessite 8×80GB GPUs)
git clone https://github.com/xai-org/grok-1
pip install -r requirements.txt

python run.py --checkpoint grok-1-314B

GPT-4 : MoE sous le capot ?

Rumeurs : GPT-4 utiliserait MoE avec 8-16 experts de 220B chacun.

Indices :

Paramètres estimés : 1.7T total
Coût computationnel suggère sparse activation
Performances exceptionnelles avec latence raisonnable

OpenAI : N’a jamais confirmé officiellement.

Si vrai : MoE explique comment GPT-4 peut avoir 1.7T params et rester utilisable.

Défis et limitations

Load Balancing

Problème : Le router peut sur-utiliser certains experts, sous-utiliser d’autres.

Exemple pathologique :

Expert 0 : Activé 60% du temps   ← Surchargé
Expert 1 : Activé 5% du temps    ← Sous-utilisé
Expert 2 : Activé 4% du temps
Expert 3 : Activé 8% du temps
Expert 4 : Activé 3% du temps
Expert 5 : Activé 12% du temps
Expert 6 : Activé 5% du temps
Expert 7 : Activé 3% du temps

Conséquences :

Expert 0 devient bottleneck (ralentit tout)
Experts 1-7 sous-exploités (capacité gaspillée)

Solution : Load Balancing Loss :

def load_balancing_loss(router_probs, num_experts=8):
    """
    Encourage distribution uniforme des tokens entre experts
    """
    # Fréquence d'utilisation de chaque expert
    expert_usage = router_probs.mean(dim=0)  # (num_experts,)

    # Objectif : 1/num_experts pour chaque expert (uniforme)
    target = 1.0 / num_experts

    # Pénalité si déséquilibré
    balance_loss = torch.sum((expert_usage - target) ** 2)

    return balance_loss

# Ajouter à la loss totale pendant training
total_loss = language_modeling_loss + 0.01 * load_balancing_loss

Résultat : Experts utilisés plus équitablement.

Mémoire : Tous les experts en RAM

Problème : Même si seulement 2/8 experts actifs, tous les 8 doivent être en mémoire.

Mixtral 8x7B :

Paramètres actifs : 13B
Paramètres totaux : 47B en RAM (pas 13B)

Comparaison :

Modèle	Params actifs	VRAM requise (FP16)	VRAM requise (INT4)
Llama 13B	13B	26 GB	7 GB
Mixtral 8x7B	13B	94 GB	26 GB

MoE nécessite 3.6x plus de VRAM qu’un modèle dense de même compute.

Solution partielle : Expert Offloading :

# Offload experts non-utilisés vers CPU/disk
class EfficientMoE:
    def __init__(self, experts, device="cuda"):
        self.experts = experts
        self.device = device
        self.expert_cache = {}  # Cache GPU

    def forward(self, x, expert_indices):
        outputs = []

        for expert_id in expert_indices:
            # Charger expert en GPU si nécessaire
            if expert_id not in self.expert_cache:
                self.load_expert_to_gpu(expert_id)

            expert = self.expert_cache[expert_id]
            outputs.append(expert(x))

        return torch.stack(outputs)

    def load_expert_to_gpu(self, expert_id):
        # Éviction LRU si cache plein
        if len(self.expert_cache) >= 2:  # Garder seulement 2 experts en GPU
            lru_expert = self.get_lru_expert()
            self.offload_expert_to_cpu(lru_expert)

        # Charger depuis CPU/disk
        self.expert_cache[expert_id] = self.experts[expert_id].to(self.device)

Trade-off : Réduit VRAM mais ajoute latence (transferts CPU↔GPU).

Entraînement complexe

Défis :

Instabilité : Router peut converger vers mauvais minima
Mode collapse : Tous les tokens vers mêmes experts
Gradient imbalance : Experts peu utilisés reçoivent peu de gradients

Solutions :

Auxiliary losses : Load balancing, diversity encouragement
Expert dropout : Forcer exploration d’experts variés
Warmup progressif : Commencer avec plus d’experts actifs (top-4), réduire graduellement (top-2)

# Pseudo-code training MoE
def train_moe_step(model, batch):
    outputs = model(batch["input_ids"])
    lm_loss = cross_entropy(outputs.logits, batch["labels"])

    # Losses auxiliaires
    balance_loss = compute_load_balance_loss(outputs.router_probs)
    diversity_loss = compute_diversity_loss(outputs.expert_outputs)

    # Combiner
    total_loss = lm_loss + 0.01 * balance_loss + 0.001 * diversity_loss

    total_loss.backward()
    optimizer.step()

Fine-tuning délicat

Problème : Fine-tuner MoE sans catastrophic forgetting difficile.

Approches :

LoRA sur experts : Adapter seulement via LoRA
Router freezing : Geler router, fine-tuner experts
Expert-specific fine-tuning : Fine-tuner 1-2 experts seulement

from peft import LoraConfig, get_peft_model

# Appliquer LoRA seulement sur les experts
lora_config = LoraConfig(
    r=16,
    target_modules=["experts.*.w1", "experts.*.w2"],  # Seulement FFN experts
    lora_dropout=0.05
)

model = get_peft_model(mixtral_model, lora_config)

# Router et autres couches restent gelés
model.print_trainable_parameters()
# Trainable: 0.5% (seulement LoRA sur experts)

MoE pour l’IA locale

Avantages locaux

MoE est particulièrement adapté à l’IA locale :

Quantization : MoE quantize mieux que modèles denses
- Experts indépendants → Quantization per-expert
- Résultat : Moins de dégradation
Batch size 1 : MoE excelle en inference single-user
- Pas de parallelisme à gérer
- Chaque token active seulement 2 experts
Sparsity : CPU/GPU moderne optimisé pour sparse ops

Mixtral 8x7B sur GPU consumer

# RTX 4090 24GB
from transformers import AutoModelForCausalLM, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_quant_type="nf4"
)

model = AutoModelForCausalLM.from_pretrained(
    "mistralai/Mixtral-8x7B-Instruct-v0.1",
    quantization_config=quantization_config,
    device_map="auto"
)

# VRAM utilisée : ~23 GB (rentre sur 4090 !)
# Vitesse : ~12 tokens/sec (utilisable)

Ollama + Mixtral

# Installation Mixtral via Ollama
ollama pull mixtral

# Lancer
ollama run mixtral

# Quantization automatique (Q4_K_M)
# VRAM : ~26 GB
# CPU fallback si nécessaire

Performance Apple Silicon :

# M2 Ultra 192GB
ollama run mixtral
# Vitesse : ~25 tokens/sec (excellent via Metal)

# M3 Max 128GB
ollama run mixtral
# Vitesse : ~18 tokens/sec

L’avenir de MoE

Modular AI : Ajouter/retirer experts

Vision : Modèles modulaires où on peut changer les experts selon besoins.

# Pseudo-code futur
base_model = MixtralBase()  # Core + router

# Charger experts spécialisés
math_expert = load_expert("math-expert-v2")
medical_expert = load_expert("medical-expert-v1")
legal_expert = load_expert("legal-expert-v3")

# Composer modèle custom
custom_model = base_model.with_experts([
    math_expert,
    medical_expert,
    legal_expert,
    *base_model.general_experts[:5]  # 5 experts généraux
])

# Modèle optimisé pour math + médecine + légal

Avantages :

Personnalisation fine
Mise à jour d’experts sans réentraîner tout
Marketplace d’experts spécialisés

Experts ultra-spécialisés

Tendance : Experts de plus en plus spécialisés.

Exemples futurs :

Expert Python 3.11+
Expert contrats juridiques français
Expert imagerie médicale cardiaque
Expert SQL optimisation
Expert React hooks patterns

MoE à 100+ experts : Déjà exploré en recherche (Switch Transformer : 2048 experts).

MoE multimodal

Combiner MoE avec multimodal :

Router décide :
- Quel expert texte ?
- Quel expert vision ?
- Quel expert audio ?

Exemple token "photo de chat" :
→ Expert texte général (30%)
→ Expert vision animaux (50%)
→ Expert vocabulaire descriptif (20%)

Potentiel : Spécialisation poussée par modalité ET par domaine.

Conclusion

Mixture of Experts est l’architecture qui permet de créer des modèles massifs accessibles. En activant seulement une fraction des paramètres, MoE offre :

Points clés :

Architecture : Multiple experts + router + sparse activation
Efficacité : 8x paramètres, 2x compute (Mixtral 47B = coût 13B)
Spécialisation : Experts se différencient automatiquement
Modèles : Mixtral 8x7B (accessible), Grok-1 (314B), probablement GPT-4
Défis : Load balancing, mémoire (tous experts en RAM), training complexe
Local : Excellent pour IA locale (quantize bien, efficace)
Futur : Modular AI, 100+ experts, multimodal MoE

Recommandations :

Développement : Mixtral 8x7B via API Mistral ou Ollama
Production : Mixtral si budget serré, GPT-4 si qualité prioritaire
Recherche : Explorer Grok-1 (open source), Switch Transformer
IA locale : Mixtral 8x7B INT4 sur GPU 24GB+ ou Apple Silicon 64GB+

MoE n’est pas la solution à tout : pour petits modèles (<13B), dense reste plus simple. Mais pour rivaliser avec modèles 100B+ tout en restant efficient, MoE est incontournable.

L’avenir de l’IA sera probablement modulaire : des bases MoE où on peut brancher/débrancher des experts spécialisés selon besoins. Un écosystème d’experts émerge déjà.

Ressources

Articles liés :

Papers :

Outrageously Large Neural Networks (Shazeer et al., 2017) - Original MoE pour Transformers
Switch Transformers (Fedus et al., 2021) - Google, 1.6T params
GLaM (Du et al., 2021) - Google, 1.2T params
Mixtral of Experts (Mistral AI, 2023) - Technical report

Modèles :

Outils :

Mistral API
Ollama - Mixtral local
vLLM - Serving MoE optimisé