Mistral dévoile de nouveaux modèles locaux : Le Chat et Mistral Large 2

Mistral dévoile de nouveaux modèles locaux : Le Chat et Mistral Large 2

Mistral AI continue de repousser les limites des modèles de langage open-weight avec deux nouvelles versions majeures : **Le Chat**, un assistant conversationnel léger exécutable localement, et **Mistral Large 2**, un modèle phare puissant conçu pour le raisonnement avancé et les tâches de codage. Ces modèles représentent un changement stratégique visant à rendre l'IA de haute qualité accessible sur du matériel grand public sans sacrifier les performances. Dans cet article, nous explorerons leurs capacités, détaillerons l'installation pas à pas avec Ollama et Hugging Face, et fournirons des exemples pratiques d'utilisation.

Prérequis

Avant de commencer l'installation, assurez-vous que votre système répond aux exigences minimales suivantes pour exécuter ces modèles localement :

Configuration matérielle

• **Processeur** : 4 cœurs ou plus (x86_64 ou ARM64)
• **RAM** : 8 Go pour Le Chat, 32 Go pour Mistral Large 2 (les versions quantifiées peuvent réduire cette exigence)
• **Stockage** : 10 Go libres pour Le Chat, 40 Go pour Mistral Large 2
• **GPU (optionnel mais recommandé)** : GPU NVIDIA avec 6 Go+ de VRAM (ex. RTX 3060 ou supérieur) pour une inférence accélérée

Configuration logicielle

• **Système d'exploitation** : Linux (Ubuntu 22.04+), macOS 12+ ou Windows 10/11 avec WSL2
• **Python** : 3.10 ou version ultérieure
• **Dépendances** : Ollama (pour un déploiement simple) ou Hugging Face `transformers` (pour une intégration avancée)
• **Internet** : requis pour télécharger les poids des modèles

Installation pas à pas

Nous aborderons deux approches : l'utilisation d'Ollama pour une configuration sans tracas et l'utilisation de Hugging Face pour un contrôle plus précis des paramètres du modèle.

Méthode 1 : Installation via Ollama

Ollama simplifie l'exécution de modèles locaux avec une seule commande. Installez d'abord Ollama :

# Téléchargement et installation d'Ollama (Linux/macOS)
curl -fsSL https://ollama.com/install.sh | sh

Vérifiez l'installation :

ollama --version
# Sortie attendue : ollama version 0.3.0 ou ultérieure

Téléchargez maintenant le modèle Le Chat de Mistral (2,7 milliards de paramètres, optimisé pour la conversation) :

ollama pull mistral:le-chat

Pour Mistral Large 2 (70 milliards de paramètres, nécessite plus de mémoire) :

ollama pull mistral:large2

Si votre système dispose de RAM limitée, utilisez la version quantifiée 4 bits de Mistral Large 2 :

ollama pull mistral:large2-q4_0

Méthode 2 : Installation via Hugging Face Transformers

Pour les développeurs qui ont besoin d'un contrôle précis, utilisez la bibliothèque `transformers` de Hugging Face. Créez d'abord un environnement virtuel Python :

python3 -m venv mistral_env
source mistral_env/bin/activate  # Sur Windows : mistral_env\Scripts\activate

Installez les paquets requis :

pip install torch transformers accelerate bitsandbytes

Téléchargez les poids du modèle Le Chat :

from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "mistralai/Le-Chat-2.7B"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype="auto",
    device_map="auto"
)
print("Modèle chargé avec succès")

Pour Mistral Large 2 (nécessite un token Hugging Face avec accès accordé par Mistral) :

from huggingface_hub import login

login()  # Saisissez votre token lorsque demandé

model_name = "mistralai/Mistral-Large-2-70B"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype="auto",
    device_map="auto",
    load_in_4bit=True  # Réduit la mémoire à environ 40 Go
)

Exemples d'utilisation

Exemple 1 : Conversation avec Le Chat via Ollama

Lancez une session interactive :

ollama run mistral:le-chat

Vous verrez une invite. Essayez une requête conversationnelle :

>>> Écris une courte fonction Python pour inverser une chaîne de caractères.

Le Chat répond :

def inverser_chaine(s):
    return s[::-1]

# Exemple d'utilisation
print(inverser_chaine("bonjour"))  # Sortie : "ruojnob"

Exemple 2 : Inférence par lots avec Mistral Large 2

Utilisez Mistral Large 2 pour une tâche de raisonnement complexe. Créez un script Python `raisonnement.py` :

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# Chargement du modèle et du tokenizer
model_name = "mistralai/Mistral-Large-2-70B"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    load_in_4bit=True
)

# Préparez une invite pour le raisonnement mathématique
prompt = """Résous étape par étape :
Si un train quitte la gare A à 60 mph et un autre train quitte la gare B à 90 mph,
et que les gares sont distantes de 300 miles, quand se rencontreront-ils ?

Raisonnement étape par étape :"""

# Tokenisation et génération
inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
outputs = model.generate(
    inputs.input_ids,
    max_new_tokens=512,
    temperature=0.7,
    do_sample=True
)

# Décodage et affichage
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)

Exécutez le script :

python raisonnement.py

La sortie attendue comprend une décomposition étape par étape :

Étape 1 : Vitesse combinée = 60 + 90 = 150 mph
Étape 2 : Temps = Distance / Vitesse = 300 / 150 = 2 heures
Réponse : Ils se rencontrent après 2 heures.

Exemple 3 : Complétion de code avec Le Chat

Le Chat excelle dans la génération de code. Utilisez Ollama pour une complétion de code rapide :

ollama run mistral:le-chat

Saisissez :

>>> Complète cette fonction JavaScript :
function fibonacci(n) {
  if (n <= 1) return n;

Le Chat complète :

  return fibonacci(n - 1) + fibonacci(n - 2);
}

Exemple 4 : Pipeline RAG avec Mistral Large 2 (Avancé)

Intégrez Mistral Large 2 dans un pipeline de génération augmentée par récupération en utilisant Hugging Face et FAISS :

from sentence_transformers import SentenceTransformer
import faiss
import numpy as np
from transformers import pipeline

# Chargement du modèle d'embedding et création de l'index
embedder = SentenceTransformer("all-MiniLM-L6-v2")
documents = [
    "Mistral Large 2 prend en charge une fenêtre de contexte de 128K.",
    "Le Chat est optimisé pour les conversations à faible latence.",
    "Les deux modèles sont disponibles sous licence Apache 2.0."
]
embeddings = embedder.encode(documents)
index = faiss.IndexFlatL2(embeddings.shape[1])
index.add(np.array(embeddings))

# Requête
query = "Quelle est la fenêtre de contexte de Mistral Large 2 ?"
query_embedding = embedder.encode([query])
distances, indices = index.search(np.array(query_embedding), k=1)
document_recupere = documents[indices[0][0]]

# Génération de réponse avec Mistral Large 2
generator = pipeline("text-generation", model="mistralai/Mistral-Large-2-70B", device=0)
prompt = f"D'après ce document : {document_recupere}\nRéponse : {query}"
result = generator(prompt, max_new_tokens=100)
print(result[0]["generated_text"])

Considérations sur les performances

• **Le Chat (2,7B)** : Fonctionne sur CPU avec 8 Go de RAM à environ 10 tokens/seconde. Avec accélération GPU (ex. RTX 3060), les vitesses atteignent 50+ tokens/seconde.
• **Mistral Large 2 (70B)** : Nécessite 32 Go de RAM en pleine précision. Utilisez la quantification 4 bits pour tenir dans 20 Go. Sur un RTX 4090, attendez-vous à 15-20 tokens/seconde.
• **Fenêtre de contexte** : Les deux modèles prennent en charge jusqu'à 128K tokens, mais la mémoire augmente linéairement — Le Chat utilise ~0,5 Go pour 32K tokens, Mistral Large 2 utilise ~4 Go.

Conclusion

Les nouveaux modèles locaux de Mistral — Le Chat et Mistral Large 2 — représentent une avancée significative dans la démocratisation de l'IA. Le Chat offre un assistant léger et réactif idéal pour les tâches quotidiennes et la génération de code, tandis que Mistral Large 2 apporte un raisonnement de niveau professionnel aux configurations locales. En utilisant des outils comme Ollama et Hugging Face, les développeurs peuvent déployer ces modèles en quelques minutes, que ce soit pour du prototypage ou de la production.

Le point essentiel à retenir : vous n'avez plus besoin d'API cloud pour accéder à des modèles de langage de pointe. Avec un matériel adapté et les étapes décrites ici, vous pouvez exécuter les dernières innovations de Mistral entièrement hors ligne, garantissant ainsi la confidentialité des données et une faible latence. Alors que Mistral continue d'affiner ces modèles en fonction des retours de la communauté, attendez-vous à une intégration encore plus poussée avec les flux de travail de développement locaux. Commencez à expérimenter dès aujourd'hui — votre machine locale est plus puissante que vous ne le pensez.