> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/mimo-v2-flash.md).

# MiMo-V2-Flash

> MiMo-V2-Flash est un **modèle Mixture-of-Experts de 309 milliards de paramètres** de modèle linguistique qui active 15B de paramètres par token. Construit avec un décodage spéculatif avancé (EAGLE/MTP), il offre **150+ tokens/seconde** sur 8×H100 tout en maintenant des performances de pointe. Distribué sous **licence MIT**, il représente l'avant-garde de l'inférence efficace à grande échelle.

## En un coup d'œil

* **Taille du modèle**: 309B total / 15B paramètres actifs (MoE)
* **Licence**: MIT (entièrement commercial)
* **Contexte**: 32K tokens
* **Performance**: État de l'art sur les benchmarks de raisonnement
* **VRAM**: \~320 Go FP16 (minimum 4×A100 80GB)
* **Vitesse**: 150+ tok/s sur 8×H100 avec décodage spéculatif

## Pourquoi MiMo-V2-Flash ?

**Vitesse révolutionnaire**: MiMo-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). Alors que les modèles traditionnels génèrent un token à la fois, MiMo-V2 prédit et valide plusieurs tokens en parallèle.

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

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

**Qualité entreprise**: Licence MIT sans restrictions d'utilisation. Déployez à grande échelle, affinez ou intégrez dans des produits commerciaux sans soucis de licence.

## Recommandations GPU

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

**Meilleur rapport qualité/prix**: 4×A100 80GB offre d'excellentes performances par dollar. **Performance maximale**: 8×H100 libère tout le potentiel du décodage spéculatif.

\*Prix estimés du marketplace Clore.ai

## Déployer avec SGLang (recommandé)

SGLang offre le meilleur support pour les fonctionnalités de décodage spéculatif de MiMo-V2-Flash :

### Installer SGLang

```bash
pip install "sglang[all]>=0.3.0"
# ou la dernière version
pip install git+https://github.com/sgl-project/sglang.git
```

### Configuration Multi-GPU avec MTP

```bash
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

```python
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": "You are an expert AI researcher."},
        {"role": "user", "content": "Explain the EAGLE speculative decoding algorithm and why it enables faster inference"}
    ],
    max_tokens=1024,
    temperature=0.7,
    stream=True  # Recommandé pour la meilleure latence
)

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 aussi en charge MiMo-V2-Flash avec décodage spéculatif :

```bash
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

```dockerfile
FROM nvidia/cuda:12.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 le support 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 (optionnel, réduit le temps de démarrage)
# RUN 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 :

```bash
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

### Optimisation du décodage spéculatif

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

```bash
# 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 :

```bash
# 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 benchmarking

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

```python
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": "Write a detailed explanation of quantum computing in exactly 500 words"}
        ],
        max_tokens=600,
        temperature=0.1,
        stream=False
    )
    
    end_time = time.time()
    content = response.choices[0].message.content
    
    tokens = len(content.split())  # Estimation approximative des tokens
    duration = end_time - start_time
    tokens_per_second = tokens / duration
    
    print(f"Generated {tokens} tokens in {duration:.2f}s")
    print(f"Speed: {tokens_per_second:.1f} tokens/second")
    
    return tokens_per_second

# Lancer le benchmark
speed = benchmark_generation()
print(f"\nMiMo-V2-Flash achieved {speed:.1f} tok/s")
```

## Conseils pour les utilisateurs de Clore.ai

* **Multi-GPU indispensable**: MiMo-V2-Flash nécessite au minimum 4×A100 80GB. Le déploiement sur un seul GPU n'est pas réalisable.
* **Avantage NVLink**: Choisissez des hôtes Clore.ai avec NVLink entre les GPU pour une communication multi-GPU optimale.
* **Exigences RAM**: Assurez-vous d'avoir 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'utilisation — plus élevé pour les tâches répétitives, plus bas pour le travail créatif.
* **Longueur de contexte**: 32K de contexte 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éduire `mem-fraction-static` ou `tp-size`                                                          |
| Communication inter-GPU lente   | Vérifier NVLink : `nvidia-ml-py3` ou `nvidia-smi topo -m`                                           |
| MTP n'accélère pas              | Vérifier `mtp-acceptance-rate` — des valeurs trop élevées désactivent la spéculation                |
| Timeout de chargement du modèle | Pré-téléchargement : `huggingface-cli download mimo-ai/MiMo-V2-Flash`                               |
| Mauvaise acceptation des tokens | Vérifiez les réglages 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 atteint une accélération de 3 à 5× par rapport aux modèles comparables tout en conservant une qualité compétitive.

## Ressources

* [MiMo-V2-Flash sur Hugging Face](https://huggingface.co/mimo-ai/MiMo-V2-Flash)
* [Article EAGLE](https://arxiv.org/abs/2401.15077)
* [Documentation SGLang](https://sgl-project.github.io/start/install.html)
* [Prédiction multi-token](https://arxiv.org/abs/2404.19737)
* [Guide du décodage spéculatif](https://huggingface.co/blog/assisted-generation)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/mimo-v2-flash.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
