MiMo-V2-Flash

Déployez MiMo-V2-Flash (MoE 309B) avec décodage spéculatif sur Clore.ai — inférence ultra-rapide à plus de 150 tok/s

MiMo-V2-Flash est un Mixture-of-Experts de 309 milliards de paramètres modèle de langage qui active 15 milliards de paramètres par jeton. Construit avec un décodage spéculatif avancé (EAGLE/MTP), il offre plus de 150 jetons/seconde sur 8×H100 tout en maintenant des performances de pointe. Publié sous licence MIT, il représente la pointe de l’inférence efficace à grande échelle.

En un coup d'œil

• Taille du modèle: 309B au total / 15B paramètres actifs (MoE)

• Licence: MIT (entièrement commercial)

• Contexte: 32K jetons

• Performances: à la pointe sur les benchmarks de raisonnement

• VRAM: ~320 Go en FP16 (minimum 4×A100 80 Go)

• Vitesse: plus de 150 tok/s sur 8×H100 avec décodage spéculatif

Pourquoi MiMo-V2-Flash ?

Vitesse révolutionnaireMiMo-V2-Flash atteint des vitesses d’inférence sans précédent grâce à EAGLE (Extrapolation Algorithm for Greater Language model Efficiency) et à MTP (Multi-Token Prediction). Là où les modèles traditionnels génèrent un jeton à la fois, MiMo-V2 prédit et valide plusieurs jetons en parallèle.

Échelle prête pour la production: Avec 309B paramètres, MiMo-V2-Flash rivalise avec les plus grands modèles de pointe tout en restant déployable sur des configurations matérielles réalistes. Les 15B paramètres actifs garantissent une inférence efficace malgré l’énorme nombre de paramètres.

Architecture avancée: Au-delà du MoE standard, MiMo-V2-Flash intègre nativement le décodage spéculatif dans l’architecture du modèle. Ce n’est pas une optimisation post-entraînement — c’est intégré dès la base, permettant des accélérations garanties.

Qualité entreprise: Licence MIT sans restriction d’utilisation. Déployez à grande échelle, affinez ou intégrez dans des produits commerciaux sans inquiétude liée à la licence.

Recommandations GPU

Les configurations multi-GPU de classe 80 Go ne sont pas répertoriées sur la place de marché Clore.ai. Les plus grosses machines répertoriées aujourd’hui sont 4× RTX PRO 6000 Blackwell (96 Go chacune, 380 Go au total) et 8–11× RTX 5090 (32 Go chacune). La capacité A100 / H200 / B200 est proposée en bare metal sur demande. Consultez bare metal sur demande. Consultez Tarifs et disponibilité des GPU avant de dimensionner un déploiement.

Configuration	VRAM	Performances	Coût journalier*
4×A100 80GB	320 Go	~80 tok/s	~$16.00
8×A100 40GB	320 Go	~70 tok/s	~$28.00
2×H100	160 Go	~90 tok/s	~$12.00
8×H100	640 Go	150+ tok/s	~$48.00
4×H200	564GB	~120 tok/s	~$32.00

Meilleur rapport qualité-prix: 4×A100 80 Go offre d’excellentes performances par dollar, disponible en tant que bare metal. Sur la place de marché, l’équivalent est une configuration 4× RTX PRO 6000 Blackwell (380 Go). Performances maximales: 8×H100 libère tout le potentiel du décodage spéculatif.

*Prix estimés sur la place de marché Clore.ai

Déployer avec SGLang (recommandé)

SGLang offre la meilleure prise en charge des fonctionnalités de décodage spéculatif de MiMo-V2-Flash :

Installer SGLang

pip install "sglang[all]>=0.3.0"
# ou la version la plus récente
pip install git+https://github.com/sgl-project/sglang.git

Configuration multi-GPU avec MTP

python -m sglang.launch_server \\
  --model-path mimo-ai/MiMo-V2-Flash \
  --tp-size 8 \
  --enable-mtp \
  --mtp-max-draft-tokens 8 \
  --mtp-acceptance-rate 0.8 \
  --mem-fraction-static 0.85 \
  --dtype float16 \
  --context-length 32768 \
  --served-model-name mimo-v2-flash

Interroger avec l’API OpenAI

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:30000/v1", 
    api_key="EMPTY"
)

response = client.chat.completions.create(
    model="mimo-v2-flash",
    messages=[
        {"role": "system", "content": "Vous êtes un chercheur en IA expert."},
        {"role": "user", "content": "Expliquez l’algorithme de décodage spéculatif EAGLE et pourquoi il permet une inférence plus rapide"}
    ],
    max_tokens=1024,
    temperature=0.7,
    stream=True  # Recommandé pour une latence optimale
)

for chunk in response:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end='', flush=True)

Déployer avec vLLM

vLLM prend également en charge MiMo-V2-Flash avec décodage spéculatif :

pip install vllm>=0.6.0

vllm serve mimo-ai/MiMo-V2-Flash \
  --tensor-parallel-size 8 \
  --speculative-model mimo-ai/MiMo-V2-Flash-Draft \
  --speculative-max-model-len 32768 \
  --speculative-draft-tensor-parallel-size 2 \
  --use-v2-block-manager \
  --dtype float16 \
  --served-model-name mimo-v2-flash \
  --trust-remote-code

Modèle Docker

FROM nvidia/cuda:12.8.1-devel-ubuntu22.04

# Installer les dépendances
RUN apt-get update && \
    apt-get install -y python3.10 python3-pip git && \
    rm -rf /var/lib/apt/lists/*

# Installer SGLang avec prise en charge de MTP
RUN pip install "sglang[all]>=0.3.0" transformers

# Définir les variables d'environnement
ENV PYTHONUNBUFFERED=1
ENV CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7

# Pré-télécharger le modèle (facultatif, permet de gagner du temps au démarrage)
# Exécutez python3 -c "from transformers import AutoModel; AutoModel.from_pretrained('mimo-ai/MiMo-V2-Flash', trust_remote_code=True)"

EXPOSE 30000

CMD ["python", "-m", "sglang.launch_server", \
     "--model-path", "mimo-ai/MiMo-V2-Flash", \
     "--host", "0.0.0.0", \
     "--port", "30000", \
     "--tp-size", "8", \
     "--enable-mtp", \
     "--mtp-max-draft-tokens", "8", \
     "--dtype", "float16"]

Exécuter avec tous les GPU :

docker build -t mimo-v2-flash .
docker run --gpus all -p 30000:30000 \
  --shm-size=64g \
  --ulimit memlock=-1 \
  --ulimit stack=67108864 \
  mimo-v2-flash

Configuration avancée

Optimiser le décodage spéculatif

Ajustez finement les paramètres spéculatifs en fonction de votre charge de travail :

# Pour la génération de code (taux d’acceptation plus élevé)
python -m sglang.launch_server \\
  --model-path mimo-ai/MiMo-V2-Flash \
  --tp-size 8 \
  --enable-mtp \
  --mtp-max-draft-tokens 12 \
  --mtp-acceptance-rate 0.9 \
  --temperature 0.1

# Pour l’écriture créative (taux d’acceptation plus faible)
python -m sglang.launch_server \\
  --model-path mimo-ai/MiMo-V2-Flash \
  --tp-size 8 \
  --enable-mtp \
  --mtp-max-draft-tokens 6 \
  --mtp-acceptance-rate 0.7 \
  --temperature 0.8

Optimisation de la mémoire

Pour les configurations à mémoire limitée :

# Réduire l’utilisation mémoire (plus lent mais tient sur 4×A100)
python -m sglang.launch_server \\
  --model-path mimo-ai/MiMo-V2-Flash \
  --tp-size 4 \
  --mem-fraction-static 0.75 \
  --context-length 16384 \
  --dtype float16 \
  --disable-cuda-graph  # Économise de la VRAM

Exemple de benchmark

Testez l’avantage de vitesse de MiMo-V2-Flash :

import time
from openai import OpenAI

client = OpenAI(base_url="http://localhost:30000/v1", api_key="EMPTY")

def benchmark_generation():
    start_time = time.time()
    
    response = client.chat.completions.create(
        model="mimo-v2-flash",
        messages=[
            {"role": "user", "content": "Rédigez une explication détaillée de l’informatique quantique en exactement 500 mots"}
        ],
        max_tokens=600,
        temperature=0.1,
        stream=False
    )
    
    end_time = time.time()
    content = response.choices[0].message.content
    
    tokens = len(content.split())  # Estimation approximative du nombre de jetons
    duration = end_time - start_time
    tokens_per_second = tokens / duration
    
    print(f"Généré {tokens} jetons en {duration:.2f}s")
    print(f"Vitesse : {tokens_per_second:.1f} jetons/seconde")
    
    return tokens_per_second

# Exécuter le benchmark
speed = benchmark_generation()
print(f"\nMiMo-V2-Flash a atteint {speed:.1f} tok/s")

Conseils pour les utilisateurs de Clore.ai

• Multi-GPU indispensable: MiMo-V2-Flash nécessite au minimum 4×A100 80 Go. Un déploiement sur un seul GPU n’est pas envisageable.

• Avantage NVLink: Choisissez des hôtes Clore.ai avec NVLink entre les GPU pour une communication multi-GPU optimale.

• Exigences en RAM: Assurez-vous d’avoir plus de 256 Go de RAM système pour un fonctionnement fluide avec 8 GPU.

• Réglage spéculatif: Ajustez mtp-max-draft-tokens en fonction de votre cas d’usage — plus élevé pour les tâches répétitives, plus faible pour le travail créatif.

• Longueur de contexte: Un contexte de 32K est optimal. Des contextes plus longs réduisent l’efficacité du décodage spéculatif.

Dépannage

Problème	Solution
OutOfMemoryError au démarrage	Réduisez mem-fraction-static ou tp-size
Communication inter-GPU lente	Vérifiez NVLink : nvidia-ml-py3 ou nvidia-smi topo -m
MTP n’accélère pas	Vérifiez mtp-acceptance-rate — des valeurs trop élevées désactivent la spéculation
Délai de chargement du modèle dépassé	Pré-téléchargement : huggingface-cli download mimo-ai/MiMo-V2-Flash
Faible taux d’acceptation des jetons	Vérifiez les paramètres de température — des températures très basses/élevées réduisent l’acceptation

Comparaison des performances

Modèle	Taille	Vitesse (8×H100)	Qualité
GPT-4 Turbo	~1.7T	~15-25 tok/s	★★★★★
Claude Sonnet 3.5	~200B	~25-35 tok/s	★★★★★
MiMo-V2-Flash	309B	150+ tok/s	★★★★☆
Llama 3.1 405B	405B	~30-45 tok/s	★★★★☆

MiMo-V2-Flash offre une accélération de 3 à 5 fois par rapport aux modèles comparables tout en conservant une qualité compétitive.

Ressources

• MiMo-V2-Flash sur Hugging Face

• Article EAGLE

• Documentation SGLang

• Prédiction multi-jetons

• Guide du décodage spéculatif