Aller au contenu principal

Comment exécuter Xiaomi MiMo-V2-Flash localement : un guide complet d’installation

BlogsXiaomiMiMo-V2-FlashLocal AIAI ModelsSGLangEnviron 5 min

Comment exécuter Xiaomi MiMo-V2-Flash localement : un guide complet d’installation

Le MiMo-V2-Flash de Xiaomi représente une avancée dans la conception efficace des modèles IA, avec 309 milliards de paramètres totaux dont seulement 15 milliards sont actifs lors de l’inférence. Cette architecture Mixture-of-Experts offre une performance exceptionnelle tout en maintenant des exigences matérielles raisonnables pour un déploiement local. Dans ce guide complet, nous vous présentons plusieurs méthodes pour exécuter MiMo-V2-Flash localement sur votre machine.

Pourquoi exécuter MiMo-V2-Flash localement ?

Exécuter MiMo-V2-Flash localement présente de nombreux avantages :

  • Confidentialité des données : vos données sensibles ne quittent jamais votre machine
  • Efficacité des coûts : pas de frais API par token ni d’abonnement
  • Faible latence : accès direct au hardware pour des temps d’inférence plus rapides
  • Personnalisation : contrôle total des paramètres du modèle et du fine-tuning
  • Fonctionnement hors-ligne : aucune connexion internet nécessaire après installation
  • Performance : exploite votre GPU local pour une vitesse optimale

Exigences matérielles

Configuration système minimale

ComposantExigenceRecommandé
GPUNVIDIA RTX 3080 (12GB VRAM)RTX 4090 (24GB VRAM) ou A6000
RAM32GB64GB ou plus
Stockage100GB d’espace libreSSD NVMe 200GB+
CPUIntel i7-10700K / AMD Ryzen 7 3700XIntel i9-12900K / AMD Ryzen 9 5900X
CUDA11.8+12.4+

Considérations sur la taille du modèle

  • Taille totale du modèle : ~180GB (formats quantifiés)
  • Mémoire GPU maximale utilisée : 15-20GB VRAM (paramètres actifs)
  • Longueur du contexte : 256K tokens (consomme beaucoup de RAM)

Prérequis logiciels

Avant l’installation, assurez-vous de disposer de :

  1. Python 3.10+ installé
  2. CUDA Toolkit 11.8+ ou 12.4+
  3. Drivers NVIDIA (version la plus récente)
  4. Git pour cloner le dépôt

Vérifier l’installation de CUDA

nvidia-smi
nvcc --version

Méthode 1 : Installation via SGLang (Recommandé)

SGLang est la plateforme recommandée pour MiMo-V2-Flash, offrant des performances optimisées pour les modèles MoE.

Étape 1 : Installer SGLang

# Créer un environnement virtuel
python -m venv mimo-env
source mimo-env/bin/activate  # Sur Windows : mimo-env\Scripts\activate

# Installer PyTorch avec support CUDA
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

# Installer SGLang
pip install sglang

Étape 2 : Télécharger le modèle

# Se connecter à Hugging Face
huggingface-cli login

# Télécharger MiMo-V2-Flash
huggingface-cli download XiaomiMiMo/MiMo-V2-Flash --local-dir ./models/MiMo-V2-Flash

Étape 3 : Lancer le serveur SGLang

python -m sglang.launch_server \
    --model-path ./models/MiMo-V2-Flash \
    --host 0.0.0.0 \
    --port 30000 \
    --trust-remote-code \
    --dtype float16 \
    --max-model-len 262144 \
    --gpu-memory-utilization 0.9

Étape 4 : Tester l’installation

import requests
import json

url = "http://localhost:30000/v1/chat/completions"
headers = {"Content-Type": "application/json"}
data = {
    "model": "MiMo-V2-Flash",
    "messages": [
        {"role": "user", "content": "Écris une fonction Python pour calculer les nombres de Fibonacci"}
    ],
    "temperature": 0.7,
    "max_tokens": 500
}

response = requests.post(url, headers=headers, data=json.dumps(data))
print(response.json())

Méthode 2 : Installation avec Hugging Face Transformers

Étape 1 : Installer les dépendances

pip install transformers==4.51.0
pip install accelerate
pip install bitsandbytes
pip install torch --index-url https://download.pytorch.org/whl/cu124

Étape 2 : Script d’utilisation basique

Créez run_mimo.py :

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# ID du modèle
model_id = "XiaomiMiMo/MiMo-V2-Flash"

# Charger le tokenizer et le modèle
print("Chargement du tokenizer...")
tokenizer = AutoTokenizer.from_pretrained(
    model_id,
    trust_remote_code=True
)

print("Chargement du modèle...")
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto",
    trust_remote_code=True,
    load_in_8bit=True,  # Activation de la quantification 8 bits
    max_memory={0: "15GB"}  # Limitation de la mémoire GPU utilisée
)

# Générer du texte
prompt = "Explique le concept de machine learning"
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

print("Génération de la réponse...")
outputs = model.generate(
    **inputs,
    max_new_tokens=200,
    temperature=0.7,
    do_sample=True
)

response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(f"\n{response}")

Étape 3 : Exécuter le script

python run_mimo.py

Méthode 3 : Utilisation de Ollama (Expérimental)

Étape 1 : Installer Ollama

# macOS/Linux
curl -fsSL https://ollama.com/install.sh | sh

# Windows : Télécharger depuis ollama.com

Étape 2 : Créer un Modelfile personnalisé

Créez un fichier Modelfile pour MiMo-V2-Flash :

FROM ./models/MiMo-V2-Flash

# Définir les paramètres
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER top_k 50
PARAMETER num_ctx 262144

Étape 3 : Construire et lancer

# Créer le modèle
ollama create mimo-v2-flash -f Modelfile

# Lancer le modèle
ollama run mimo-v2-flash

Méthode 4 : Déploiement avec Docker

Étape 1 : Créer un Dockerfile

Créez un fichier Dockerfile :

FROM nvidia/cuda:12.4-devel-ubuntu20.04

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

WORKDIR /app

RUN pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124
RUN pip3 install sglang transformers accelerate

# Copier modèle et application
COPY models/MiMo-V2-Flash /app/models/MiMo-V2-Flash
COPY app.py /app/

# Exposer le port
EXPOSE 30000

# Lancer le serveur
CMD ["python3", "-m", "sglang.launch_server", "--model-path", "/app/models/MiMo-V2-Flash", "--host", "0.0.0.0", "--port", "30000"]

Étape 2 : Construire et lancer

# Construire l’image
docker build -t mimo-v2-flash .

# Lancer le conteneur
docker run --gpus all -p 30000:30000 -v $(pwd)/models:/app/models mimo-v2-flash

Configuration avancée

Activer Flash Attention

Pour de meilleures performances, installez Flash Attention :

pip install flash-attn --no-build-isolation

Puis ajoutez à la configuration de votre modèle :

from sglang import set_default_backend, RuntimeBackend

set_default_backend(RuntimeBackend.CUDA)

Optimisation de la mémoire

En cas d’erreurs de mémoire insuffisante :

# Utiliser la quantification
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    load_in_4bit=True,  # Utiliser quantification 4 bits
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True,
)

Configuration multi-GPU

Pour les systèmes avec plusieurs GPUs :

# Distribuer le modèle sur plusieurs GPUs
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    device_map="auto",
    max_memory={0: "10GB", 1: "10GB", 2: "10GB", 3: "10GB"}
)

Optimisation des performances

1. Ajuster l’utilisation mémoire GPU

python -m sglang.launch_server \
    --gpu-memory-utilization 0.95  # Utiliser 95 % de la mémoire GPU

2. Optimiser la longueur du contexte

# Réduisez la longueur du contexte pour plus de rapidité
--max-model-len 32768  # 32K au lieu de 256K

3. Activer le parallélisme tensoriel

# Utiliser plusieurs GPUs pour l’inférence
--tensor-parallel-size 4

Résolution des problèmes courants

Problème 1 : Mémoire insuffisante (OOM)

Solution :

# Activer le gradient checkpointing
model.gradient_checkpointing_enable()

# Ou utiliser des tailles de batch plus petites
batch_size = 1  # Au lieu de valeurs plus grandes

Problème 2 : CUDA out of memory

Solution :

  • Réduire --gpu-memory-utilization à 0.8
  • Activer la quantification (8 bits ou 4 bits)
  • Fermer les autres applications demandant la GPU

Problème 3 : Erreurs de chargement du modèle

Solution :

# Vider le cache et re-télécharger
huggingface-cli download XiaomiMiMo/MiMo-V2-Flash --local-dir ./models/MiMo-V2-Flash --resume-download

Problème 4 : Inférence lente

Solutions :

  1. Installer Flash Attention : pip install flash-attn
  2. Utiliser le parallélisme tensoriel multi-GPU
  3. Réduire la longueur du contexte
  4. Augmenter l’utilisation de la mémoire GPU

Problème 5 : Erreurs d’import

Solution :

# Réinstaller les dépendances
pip uninstall torch torchvision torchaudio
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

pip uninstall sglang
pip install sglang

Tester votre installation

Script de test complet

Créez test_mimo.py :

import requests
import json

def test_mimo():
    url = "http://localhost:30000/v1/chat/completions"
    headers = {"Content-Type": "application/json"}

    # Test 1 : Génération de texte basique
    data1 = {
        "model": "MiMo-V2-Flash",
        "messages": [{"role": "user", "content": "Écris un programme hello world en Python"}],
        "max_tokens": 100
    }

    # Test 2 : Génération de code
    data2 = {
        "model": "MiMo-V2-Flash",
        "messages": [{"role": "user", "content": "Crée une API REST avec FastAPI"}],
        "max_tokens": 200
    }

    # Test 3 : Raisonnement mathématique
    data3 = {
        "model": "MiMo-V2-Flash",
        "messages": [{"role": "user", "content": "Résous : Quelle est la dérivée de x^2 + 3x + 5 ?"}],
        "max_tokens": 100
    }

    for i, data in enumerate([data1, data2, data3], 1):
        response = requests.post(url, headers=headers, data=json.dumps(data))
        if response.status_code == 200:
            print(f"Test {i} réussi !")
            print(response.json()["choices"][0]["message"]["content"])
        else:
            print(f"Test {i} échoué : {response.status_code}")

if __name__ == "__main__":
    test_mimo()

Lancez le test :

python test_mimo.py

Bonnes pratiques

  1. Surveillez l’utilisation GPU : utilisez nvidia-smi pour contrôler la mémoire et la température GPU
  2. Ajustez la taille des batchs : commencez avec batch 1 et augmentez progressivement
  3. Utilisez des environnements virtuels : isolez les dépendances avec venv ou conda
  4. Mettez à jour régulièrement : gardez drivers et CUDA toolkit à jour
  5. Sauvegardez le modèle : conservez une copie de sauvegarde des fichiers du modèle téléchargé

Benchmarking des performances

Lancer un benchmark simple

import time
import torch

def benchmark_model(model, tokenizer, prompt):
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

    start_time = time.time()
    outputs = model.generate(**inputs, max_new_tokens=200)
    end_time = time.time()

    tokens_generated = len(outputs[0])
    tokens_per_second = tokens_generated / (end_time - start_time)

    return tokens_per_second

# Prompt de benchmark
prompt = "Écris une explication détaillée de l’informatique quantique"
tps = benchmark_model(model, tokenizer, prompt)
print(f"Tokens par seconde : {tps:.2f}")

Conclusion

Exécuter Xiaomi MiMo-V2-Flash localement est une manière puissante de tirer parti des capacités IA de pointe tout en garantissant confidentialité et contrôle. Que vous choisissiez SGLang pour la performance maximale ou Hugging Face Transformers pour la simplicité d’usage, ce guide vous fournit toutes les informations nécessaires pour démarrer.

Points clés à retenir :

  • SGLang est recommandé pour une performance optimale
  • Assurez-vous d’avoir suffisamment de mémoire GPU (15GB+ VRAM)
  • Utilisez la quantification si votre mémoire est limitée
  • Expérimentez avec la longueur du contexte pour équilibrer performances et vitesse
  • Surveillez l’utilisation GPU pour éviter la surchauffe

Pour dépasser les limites du hardware local ou en cas de contraintes matérielles, pensez aux fournisseurs de GPU dans le cloud. Commencez par la méthode recommandée SGLang et testez d’autres frameworks selon vos besoins spécifiques et votre configuration matérielle.

Ressources complémentaires :

Faites des économies sur l'hébergement VPS économique