Mistral – 📚 Entraînement

Objectif & pertes

# Cross-entropy (LM)
L = - Σ_t log pθ(x_t | x_{<t})

• Masque causal ; séquences tronquées/paddées.
• Schedule warmup → cosine (ou plateau) + AdamW.
• AMP/bfloat16 + grad-clip pour stabilité.

Hyperparamètres (ordres de grandeur)

Bonnes pratiques

• Mix de données équilibré (texte/code/multi-langue).
• Dedup agressif + filtres qualité (langue, toxicité, PII).
• Checkpointing fréquent + reprise idempotente.

Snippets (Transformers)

from transformers import AutoModelForCausalLM, AutoTokenizer, Trainer, TrainingArguments
tok = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-v0.2")
model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.2")
args = TrainingArguments(per_device_train_batch_size=2, fp16=True, lr_scheduler_type="cosine",
                         learning_rate=2e-5, warmup_ratio=0.02, gradient_accumulation_steps=16)
trainer = Trainer(model=model, args=args, train_dataset=lm_dataset)
trainer.train()

Anti-patterns

• Mélanger sources bruyantes sans filtres → dérive & biais.
• Sous-estimer la VRAM séquence-longue (OOM tardifs).
• Pas de golden set pré-train → difficile de détecter régressions.

QLoRA (schéma)

from peft import LoraConfig, get_peft_model
peft_cfg = LoraConfig(r=64, lora_alpha=16, target_modules=["q_proj","v_proj"])
model = get_peft_model(model, peft_cfg)  # puis SFT sur dataset d'instructions

Éval SFT

• Exact-match, conformité de schéma, longueur, refus appropriés.
• Golden set versionné + CI (non-régression à chaque bump).
• Red-team prompts (jailbreak, PII, toxicité) en post-SFT.

Trois approches

• PPO (avec RM) : policy vs reward model, KL-penalty.
• DPO/ORPO : directement sur préférences (pairs win/lose), sans RM explicite.
• RLAIF : préférences produites par un modèle IA (proxy humain).

Pertes (intuition)

# PPO (sketch)
L = E[ r_t - β KL(π_θ || π_ref) ]  (avec avantage/clip)
# DPO (préférences y⁺ > y⁻)
L = - log σ(β (log π_θ(y⁺|x) - log π_θ(y⁻|x)))

Comparatif

Snippets (pseudo)

# DPO mini
for x, y_pos, y_neg in prefs:
    loss = -logsigmoid(beta*(logp(y_pos|x)-logp(y_neg|x)))
    loss.backward(); opt.step()

# PPO (idée)
adv = compute_advantage(rm_scores, kl_penalty)
loss = ppo_clip(policy, old_policy, adv)

Bonnes pratiques

• Curate préférences cohérentes (consigne/format/sécurité).
• Contrôler la dérive via KL/similarité à une policy de référence.
• Évaluer refus justifiés, toxicité, hallucinations guidées.

Pipeline de curation (ASCII)

Crawl → Dé-dup → Lang/Qualité → PII/NSFW → Tokenisation → Shards → Mix → Train
            

Anti-patterns

• Ignorer la dé-duplication → sur-apprentissage/local modes.
• Mélanger des licences incompatibles → risques juridiques.
• Pas de versioning dataset → non-reproductible.

CI (pipeline)

- run: schema tests
- run: golden set (exact-match, groundedness)
- run: red-team suite (seuils min)
- deploy: canary + alerting + rollback

Anti-patterns

• Ne bencher que des scores publics hors-domaine.
• Confondre “style” avec “vérité” (hallucinations non pénalisées).
• Ignorer p95/p99 (SLAs non tenus en prod).

Stratégies mémoire

• ZeRO (stage 1–3) : sharding optim/grad/poids.
• Activation checkpoint : recompute fwd → mémoire↓.
• Offload (CPU/NVMe) si VRAM contrainte.

Choix de précision

• bfloat16 recommandé si HW compatible (stabilité).
• fp16 + loss-scaling si bfloat16 indisponible.
• Int8/4-bit pour SFT avec QLoRA (poids gelés + adapters).

Throughput & coûts

# indicatif
tokens/s ≈ (batch_eff × seq_len) / latence_step
coût ≈ tokens_total × prix_tok (compute + IO)

Snippets (DeepSpeed/Accelerate)

{
  "zero_optimization": {"stage": 2},
  "bf16": {"enabled": true},
  "gradient_accumulation_steps": 16
}

Bonnes pratiques

• Reprise de checkpoint idempotente (seed, sampler, mix).
• Profiler GPU : temps en comms vs compute (optimiser buckets).
• Alerting sur OOM tardifs & nan-loss (arrêt propre).