Mistral – Fondations & Bonnes pratiques

Architecture, entraînement, variantes, optimisation, fine-tuning, RAG, sécurité & LLMOps. Modales ultra-densifiées avec checklists, tableaux, snippets et anti-patterns.

Focus: Web, Backend, Ops Garde-fous & conformité Snippets Python / JSON / Shell

Architecture (decoder-only)

Entrée → [Embeddings + RoPE] → (Self-Attention + MLP + Norm) × N → Logits → Softmax

FlashAttention/GQA selon variantes → meilleure per-token latency.
MoE (Mixtral) : routeur active 2 experts sur 8 → qualité ↑, FLOPs ≈ constants.
KV cache paginé : réduit swaps mémoire & améliore throughput en stream.

Tokenisation & contextes

BPE/SentencePiece multi-lingue optimisée pour le code et langues EU.
Contexte usuels : 8k/16k/32k (selon builds & RoPE scaling).
Compression moyenne : fr/en1.3–1.5 tok/mot

Pré-entraînement (schéma)

Collecte (web, docs, code) → dé-dup, heuristiques qualité, NSFW/PII filter.
Tokenisation → shards → mélange par tâches (texte/code).
Optim : AdamW, sched warmup+cosine, grad-clip, checkpoints fréquents.

Bonnes pratiques

Router 7B ↔ Mixtral selon complexité, longueur, tolérance d’erreur.
Limiter le bruit contextuel, baliser les sections (<spec>,<data>,<format>).
Contrats de sortie (JSON/Pydantic) + validateurs côté serveur.
Versionner prompts & modèles + jeux d’évaluation “or” (golden set).

Anti-patterns

Sur-dimensionner le modèle pour des tâches extractives simples.
Ignorer la borne de contexte → perte d’info en queue.
Pas de stop sequences → sorties bavardes ou mal terminées.
Stocker des secrets dans le prompt (logs/observabilité!).

Tip : si tu dois résumer de longs historiques, utilise un pattern map-reduce + “state packs” (résumés hiérarchiques), puis conserve les décisions clés (ADR) en base hors contexte.

Contrat de sortie minimal

{"role":"system","content":"Réponds UNIQUEMENT en JSON: {title, steps[], risks[], sources[]}. Pas de prose."}

Validation Pydantic

class Plan(BaseModel):
  title: str
  steps: list[str]
  risks: list[str]
  sources: list[str] = []
obj = Plan.model_validate_json(response_text)

# Transformers (génération)
from transformers import AutoTokenizer, AutoModelForCausalLM
tok = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-v0.2")
model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.2")
x = tok("Explique l'attention en 3 points.", return_tensors="pt")
y = model.generate(**x, max_new_tokens=180, temperature=0.2, top_p=0.9)
print(tok.decode(y[0], skip_special_tokens=True))

Modèle	Type	Contexte	VRAM (indic.)	Forces	Usages conseillés
Mistral-7B	Dense	8k–32k	~14–16 GB fp16 (↓ en 8/4-bit)	Rapide, footprint réduit	Extraction, classification, QA court, code simple
Mixtral-8x7B	MoE	8k–32k	≥ 40 GB (tp>1 conseillé)	Très bon ratio qualité/FLOPs	Rédaction longue, reasoning, assistants
Instruct/Chat	Aligné	idem	idem	Réponses plus sûres/pertinentes	Copilotes, bots, support

Heuristique de choix

# Router très simple
if len(prompt_tokens) < 1500 and task in {"extract","classify","regex"}:
    model = "mistral-7b-instruct"
else:
    model = "mixtral-8x7b-instruct"

Évaluation (pratique)

Golden set métier (20–50 prompts) versionné en repo.
Métriques: exact-match, groundedness, coût, latence p95/p99.
CI: exécuter benchmarks à chaque bump de modèle/prompt.

Pièges

Comparer des sampling différents (temp/top-p) → biais.
Bench “jouets” (GSM8K) non représentatifs de ton domaine.

Structure recommandée

System: rôle + objectifs + contraintes (format/ton/longueur)
User: consignes + data (balises <spec>,<data>,<rules>)
Assistant: few-shot réalistes (1–3) + contre-exemple

Balises très visibles pour guider l’attention.
Décomposer les tâches (orchestration multi-étapes).
Stop sequences et longueur max contrôlée.

Chunking avancé

500–1500 tok, overlap 10–20 %, titres sémantiques.
Hybride BM25 + embeddings → meilleur rappel.
Re-rank cross-encoder si nécessaire (latence vs qualité).

{"doc":"Guide SSO","chunks":[{"id":"c1","title":"Intro","text":"..."},{"id":"c2","title":"OIDC vs SAML","text":"..."}]}

Anti-patterns

Prompt “fourre-tout” sans sections.
Pas d’exemples → style/format instables.
RAG sans citations → faible vérifiabilité.

Contrôle du format

# Pseudo-SDK
client.chat.completions.create(
  messages=msgs, temperature=0.2, top_p=0.9, stop=["\nEND_JSON"]
)

Serveurs d’inférence

vLLM : PagedAttention, très bon throughput, OpenAI-compatible.
TensorRT-LLM : excellents p95 sur H100/A100 (compilation préalable).
TGI : robuste, multi-backends, features prod (rate-limit, logs).

Réglages clés

Batching dynamique + KV cache ON.
Quantization 8/4-bit (QLoRA) → VRAM ↓ x2–x3, parfois qualité quasi intacte.
Limiter max_new_tokens, ajuster top-p/temperature selon l’usage.

Autoscaling & coûts

Warm pools (pods standby), scale-to-zero pour hors pics.
Observabilité: latence p50/p95/p99, tokens, coûts par client.
Cache de réponses (fingerprint prompt+ctx) pour requêtes répétées.

vLLM (exemple)

python -m vllm.entrypoints.openai.api_server \
  --model mistralai/Mixtral-8x7B-Instruct-v0.1 \
  --tensor-parallel-size 2 --max-model-len 32768 --gpu-memory-utilization 0.92

FastAPI (proxy simple)

from fastapi import FastAPI
import requests, os
app = FastAPI()
@app.post("/chat")
def chat(payload: dict):
    r = requests.post(os.environ["VLLM_URL"]+"/v1/chat/completions", json=payload, timeout=30)
    return r.json()

Pipeline

Préparer dataset d’instructions propres (domain-specific, équilibré).
Adapter avec LoRA/QLoRA (4/8-bit) → VRAM modérée.
Post-alignement DPO/ORPO sur préférences (si nécessaire).
Éval offline + tests de non-régression + red-team.

Qualité des données

Dédupliquer, normaliser, retirer les PII, baliser les formats attendus.
Inclure des contre-exemples & cas limites (edge cases).
Split: train/val/test par source pour éviter la fuite.

Hyper-paramètres (indicatifs)

Paramètre	Valeur typique
r (LoRA)	8–64
α (LoRA)	8–32
lr	1e-4 → 2e-5 (cosine)
batch eff.	64–256 (grad-accum)

QLoRA (extrait)

peft = LoraConfig(r=64, lora_alpha=16, target_modules=["q_proj","v_proj"])
# entraînement adapters → export + merge si besoin

Sur-/Sous-apprentissage

Underfit : réponses vagues → augmenter pas, r, jeu d’instructions.
Overfit : verbatim dataset → augmenter régularisation, mixer public data.
Surveiller exact-match & groundedness vs. base (delta de qualité).

Pattern RAG (hybride)

# index: BM25 + embeddings
chunks = split(doc, size=1000, overlap=150)
bm25.add(chunks); vec.add(emb(chunks))
cands = union(bm25.search(q), vec.search(q, top_k=50))
ctx = rerank.cross_encoder(q, cands, top_k=5)

Qualité du retrieval

Normaliser titres, H1/H2, légendes de tableaux.
Stocker métadonnées (source, date, version) pour audit/affichage.
Re-rankers légers (MiniLM) si latence < 150 ms autorisée.

Contrats de sortie

class Answer(BaseModel):
  answer: str
  citations: list[str]
  confidence: float
obj = Answer.model_validate_json(text)

Prompt avec citations

<spec>Réponds en JSON {answer,citations[],confidence}.</spec>
<data></data>

Web-hooks & audit

Loguer: prompt hash, ids chunks, modèle, sampling, latence, coût.
Rejouer en sandbox pour débogage (repro exact).

Guardrails

Allow-lists d’outils + scopes & quotas par rôle.
Modération pré/post (PII, toxique, jailbreaks). Score & journalisation.
Time-outs, retries avec backoff, circuit-breakers.

Secrets & données

Stocker secrets en vault (KMS), jamais dans prompts/logs.
Masquer/hasher PII, définir rétention & purge automatisée.
Isolation par locataire (namespace index/documents/quotas).

Conformité & licences

Tracer provenance des données (data lineage).
Politique d’usage des poids open-weight (conditions, attribution).
Registre des modèles & prompts (versionnés, propriétaires).

Exemple de politique (extrait)

{
  "safe_tools": ["retrieval.search","db.read_only"],
  "deny": ["shell.exec","secrets.write","net.raw"],
  "refusal": "Expliquer le refus et proposer une alternative sûre."
}

KPIs sécurité

Refus justifiés ≥ 95 % sur prompts “rouges”.
Taux faux-positifs/negatifs de modération < 2 %.
MTTR incidents < 15 min (alerting + rollback prompt/modèle).

Hallucinations

RAG + citations obligatoires + post-validation schéma.
Demander incertitudes (confidence float) + règles d’escalade.
Refuser si informations non retrouvées dans le contexte.

Biais & équité

Masquage d’attributs sensibles non nécessaires.
Audits réguliers par échantillonnage + revue humaine.
Rapports automatisés (drift, toxicité, stéréotypes).

LLMOps & tests

Jeux “rouges” automatisés (prompt-attack, jailbreak, données toxiques).
Dash latence/coûts/erreurs + alertes p95/p99.
Canary releases, feature flags, rollback instantané.

CI/CD (extrait)

# pseudo-pipeline
- run: unit & schema tests
- run: golden set eval (exact-match, groundedness)
- run: red-team suite (fail > threshold → stop)
- deploy: canary 10% + alerting + auto-rollback

Formule coûts (indicative)

coût ≈ (tokens_in + tokens_out) × prix_tok
latence ≈ compute(ms/tok) × tokens_out + overhead(retrieval)

En production : timeouts, retries exponentiels, circuit-breakers, quotas par client, mise en file, idempotency-keys, journalisation détaillée.

Mistral – Fondations & Bonnes pratiques

1. Fondations du modèle

2. Famille & variantes

3. Prompting & contexte

4. Performance & coûts

5. Fine-tuning & adaptation

6. Intégration & RAG

7. Sécurité & gouvernance

8. Limites & validations