┌─────────────────────────────────────────────────────────────────┐
│                  OBJECTIFS DE L'ÉVALUATION                       │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  1. COMPARER les modèles entre eux                              │
│     GPT-4 vs Claude vs Gemini                                   │
│                                                                  │
│  2. SUIVRE les progrès au fil du temps                          │
│     GPT-3 → GPT-4 → GPT-4o                                      │
│                                                                  │
│  3. IDENTIFIER les forces et faiblesses                         │
│     Bon en code, faible en maths                                │
│                                                                  │
│  4. VALIDER le déploiement                                      │
│     Le modèle est-il prêt pour la production ?                  │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│                         MMLU                                     │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  Exemple - Physique:                                            │
│  "Un objet de 2kg tombe de 10m. Quelle est son énergie          │
│   cinétique juste avant l'impact ? (g = 10 m/s²)"               │
│                                                                  │
│  A) 100 J    B) 200 J    C) 20 J    D) 50 J                    │
│                                                                  │
│  Réponse correcte: B (E = mgh = 2 × 10 × 10 = 200 J)           │
│                                                                  │
├─────────────────────────────────────────────────────────────────┤
│  Résultats (2024):                                              │
│  ├── GPT-4o:       88.7%                                        │
│  ├── Claude 3.5:   88.3%                                        │
│  ├── Gemini 1.5:   85.9%                                        │
│  ├── Llama 3 70B:  82.0%                                        │
│  └── Humain expert: ~89%                                        │
└─────────────────────────────────────────────────────────────────┘

# Exemple de question ARC
{
    "question": "Qu'est-ce qui cause les saisons sur Terre ?",
    "choices": [
        "La distance au Soleil",
        "L'inclinaison de l'axe terrestre",
        "La rotation de la Terre",
        "La forme de l'orbite"
    ],
    "answer": "B"
}

# Exemple HumanEval
def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """
    Check if in given list of numbers, are any two numbers
    closer to each other than given threshold.

    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0], 0.3)
    True
    """
    # Le modèle doit compléter cette fonction

┌─────────────────────────────────────────────────────────────────┐
│                       SWE-BENCH                                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  Input: Issue GitHub (bug report)                               │
│  Task: Générer un patch qui résout le problème                  │
│  Validation: Les tests du repo passent                          │
│                                                                  │
│  Résultats:                                                     │
│  ├── Claude 3.5 + Aider: 49%                                    │
│  ├── GPT-4o + Aider:     45%                                    │
│  ├── Devin (agent):      13.9%                                  │
│  └── Humain senior:      ~70%                                   │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Problème: Sally a 3 pommes. Elle en achète 5 de plus,
puis en donne la moitié à son frère.
Combien lui reste-t-il de pommes ?

Solution attendue:
1. Sally commence avec 3 pommes
2. Elle en achète 5: 3 + 5 = 8 pommes
3. Elle donne la moitié: 8 / 2 = 4 pommes
Réponse: 4 pommes

Tâches incluses:
├── Boolean Expressions
├── Causal Judgment
├── Date Understanding
├── Logical Deduction
├── Navigate
├── Penguins in a Table
├── Salient Translation
└── Web of Lies

┌─────────────────────────────────────────────────────────────────┐
│                       MT-BENCH                                   │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  Tour 1: "Compose un poème sur l'automne"                       │
│  Réponse: [poème généré]                                        │
│                                                                  │
│  Tour 2: "Réécris-le pour qu'il rime en -oir"                  │
│  Réponse: [poème modifié]                                       │
│                                                                  │
│  Évaluation par LLM juge (GPT-4):                              │
│  ├── Qualité de la réponse 1: 8/10                             │
│  ├── Qualité de la réponse 2: 7/10                             │
│  └── Score final: 7.5/10                                        │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│                    CHATBOT ARENA (ELO)                           │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  Méthodologie:                                                  │
│  1. L'utilisateur pose une question                             │
│  2. Deux modèles répondent (anonymes)                          │
│  3. L'utilisateur vote pour le meilleur                         │
│  4. Score ELO calculé (comme aux échecs)                        │
│                                                                  │
│  Leaderboard (Dec 2024):                                        │
│  1. GPT-4o           1287                                       │
│  2. Claude 3.5       1282                                       │
│  3. Gemini 1.5 Pro   1267                                       │
│  4. Llama 3.1 405B   1253                                       │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

# Perplexité - mesure la surprise du modèle
import torch
from transformers import GPT2LMHeadModel, GPT2Tokenizer

def compute_perplexity(text, model, tokenizer):
    inputs = tokenizer(text, return_tensors="pt")
    with torch.no_grad():
        outputs = model(**inputs, labels=inputs["input_ids"])
    return torch.exp(outputs.loss).item()

# BLEU - similarité avec référence (traduction)
from nltk.translate.bleu_score import sentence_bleu
reference = ["the", "cat", "sat", "on", "the", "mat"]
hypothesis = ["the", "cat", "is", "on", "the", "mat"]
score = sentence_bleu([reference], hypothesis)

# ROUGE - recall sur n-grams (résumé)
from rouge_score import rouge_scorer
scorer = rouge_scorer.RougeScorer(['rouge1', 'rougeL'])
scores = scorer.score(reference_summary, generated_summary)

def llm_judge(question, response_a, response_b):
    prompt = f"""
    Compare ces deux réponses à la question suivante.

    Question: {question}

    Réponse A: {response_a}

    Réponse B: {response_b}

    Évalue chaque réponse sur:
    1. Exactitude (1-10)
    2. Clarté (1-10)
    3. Complétude (1-10)

    Quelle réponse est meilleure ? Explique ton raisonnement.
    """
    return judge_model.generate(prompt)

# Installation
pip install lm-evaluation-harness

# Évaluer un modèle sur MMLU
lm_eval --model hf \
    --model_args pretrained=meta-llama/Llama-2-7b-hf \
    --tasks mmlu \
    --batch_size 8

from openai import evals

# Définir une évaluation custom
class MyEvaluation(evals.Evaluation):
    def run(self, recorder):
        for sample in self.get_samples():
            response = self.completion_fn(sample["prompt"])
            is_correct = self.check(response, sample["expected"])
            recorder.record({"correct": is_correct})

┌─────────────────────────────────────────────────────────────────┐
│                 BONNES PRATIQUES                                 │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ✓ Utiliser plusieurs benchmarks (pas un seul)                 │
│  ✓ Tester sur des données hors distribution                    │
│  ✓ Vérifier la contamination des données                       │
│  ✓ Inclure des évaluations humaines                            │
│  ✓ Mesurer la variance (plusieurs runs)                        │
│  ✓ Documenter les prompts utilisés                             │
│                                                                  │
│  ✗ Se fier uniquement aux benchmarks publics                   │
│  ✗ Optimiser pour un seul benchmark                            │
│  ✗ Ignorer les cas limites                                     │
│  ✗ Comparer des modèles avec différents prompts                │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

def check_contamination(test_sample, training_data):
    """
    Vérifie si l'exemple de test était dans les données d'entraînement
    """
    # N-gram overlap
    test_ngrams = set(get_ngrams(test_sample, n=10))
    train_ngrams = set(get_ngrams(training_data, n=10))

    overlap = len(test_ngrams & train_ngrams) / len(test_ngrams)

    if overlap > 0.5:
        return "LIKELY_CONTAMINATED"
    return "CLEAN"