#!/usr/bin/env python3 """ Benchmark complet pour dataset QA avec toutes les métriques standard Métriques : EM, ROUGE-1/2/L, BLEU-1/4, Perplexité, Diversité, Robustesse """ import json import numpy as np import math from collections import Counter, defaultdict import re from typing import List, Dict, Tuple, Set import hashlib from difflib import SequenceMatcher import time ECHANTILLIONS = 175000 class CompleteBenchmark: def __init__(self, dataset_path: str): self.dataset_path = dataset_path self.data = self.load_data() self.vocab = self.build_vocab() print(f"📊 Dataset chargé : {len(self.data)} échantillons") def load_data(self) -> List[Dict]: """Charge le dataset JSONL avec validation""" data = [] with open(self.dataset_path, 'r', encoding='utf-8') as f: for i, line in enumerate(f): try: item = json.loads(line.strip()) if "question" in item and "answer" in item: data.append(item) else: print(f"⚠️ Ligne {i+1} : clés manquantes") except json.JSONDecodeError: print(f"⚠️ Ligne {i+1} : JSON invalide") return data def build_vocab(self) -> Set[str]: """Construit le vocabulaire pour calcul de perplexité""" vocab = set() for item in self.data: vocab.update(self.tokenize(item["question"])) vocab.update(self.tokenize(item["answer"])) return vocab def tokenize(self, text: str) -> List[str]: """Tokenisation robuste""" return re.findall(r'\w+', text.lower()) def calculate_exact_match(self, reference: str, candidate: str) -> float: """Exact Match : 1.0 si identique, 0.0 sinon""" return 1.0 if reference.strip() == candidate.strip() else 0.0 def calculate_bleu(self, reference: str, candidate: str, n: int = 4) -> Dict[str, float]: """BLEU-1 à BLEU-n avec optimisations""" ref_tokens = self.tokenize(reference) cand_tokens = self.tokenize(candidate) if len(cand_tokens) == 0: return {f"bleu_{i}": 0.0 for i in range(1, n+1)} # Brevity penalty bp = min(1.0, len(cand_tokens) / max(1, len(ref_tokens))) results = {} for i in range(1, n + 1): ref_ngrams = [tuple(ref_tokens[j:j+i]) for j in range(max(1, len(ref_tokens) - i + 1))] cand_ngrams = [tuple(cand_tokens[j:j+i]) for j in range(max(1, len(cand_tokens) - i + 1))] if len(cand_ngrams) == 0: results[f"bleu_{i}"] = 0.0 continue ref_counter = Counter(ref_ngrams) cand_counter = Counter(cand_ngrams) matches = sum(min(ref_counter[ng], cand_counter[ng]) for ng in cand_counter) precision = matches / len(cand_ngrams) results[f"bleu_{i}"] = bp * precision if precision > 0 else 0.0 return results def calculate_rouge_metrics(self, reference: str, candidate: str) -> Dict[str, Dict[str, float]]: """ROUGE-1, ROUGE-2, ROUGE-L en une fois""" ref_tokens = self.tokenize(reference) cand_tokens = self.tokenize(candidate) results = {} # ROUGE-1 (unigrammes) results["rouge_1"] = self._rouge_n(ref_tokens, cand_tokens, 1) # ROUGE-2 (bigrammes) results["rouge_2"] = self._rouge_n(ref_tokens, cand_tokens, 2) # ROUGE-L (LCS) results["rouge_l"] = self._rouge_lcs(ref_tokens, cand_tokens) return results def _rouge_n(self, ref_tokens: List[str], cand_tokens: List[str], n: int) -> Dict[str, float]: """ROUGE-N générique""" if len(ref_tokens) < n or len(cand_tokens) < n: return {"precision": 0.0, "recall": 0.0, "f1": 0.0} ref_ngrams = Counter([tuple(ref_tokens[i:i+n]) for i in range(len(ref_tokens) - n + 1)]) cand_ngrams = Counter([tuple(cand_tokens[i:i+n]) for i in range(len(cand_tokens) - n + 1)]) matches = sum(min(ref_ngrams[ng], cand_ngrams[ng]) for ng in cand_ngrams) precision = matches / sum(cand_ngrams.values()) if sum(cand_ngrams.values()) > 0 else 0.0 recall = matches / sum(ref_ngrams.values()) if sum(ref_ngrams.values()) > 0 else 0.0 f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0.0 return {"precision": precision, "recall": recall, "f1": f1} def _rouge_lcs(self, ref_tokens: List[str], cand_tokens: List[str]) -> Dict[str, float]: """ROUGE-L avec LCS optimisé""" if len(ref_tokens) == 0 or len(cand_tokens) == 0: return {"precision": 0.0, "recall": 0.0, "f1": 0.0} # LCS avec matrice DP lcs_matrix = [[0] * (len(cand_tokens) + 1) for _ in range(len(ref_tokens) + 1)] for i in range(1, len(ref_tokens) + 1): for j in range(1, len(cand_tokens) + 1): if ref_tokens[i-1] == cand_tokens[j-1]: lcs_matrix[i][j] = lcs_matrix[i-1][j-1] + 1 else: lcs_matrix[i][j] = max(lcs_matrix[i-1][j], lcs_matrix[i][j-1]) lcs_length = lcs_matrix[len(ref_tokens)][len(cand_tokens)] precision = lcs_length / len(cand_tokens) recall = lcs_length / len(ref_tokens) f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0.0 return {"precision": precision, "recall": recall, "f1": f1} def calculate_perplexity(self, text_list: List[str]) -> float: """Perplexité approximative basée sur fréquence des mots""" if not text_list: return float('inf') # Compte des mots dans le corpus word_counts = Counter() total_words = 0 for text in text_list: tokens = self.tokenize(text) word_counts.update(tokens) total_words += len(tokens) if total_words == 0: return float('inf') # Calcul de la perplexité log_prob_sum = 0.0 for text in text_list: tokens = self.tokenize(text) for token in tokens: prob = word_counts[token] / total_words log_prob_sum += math.log(prob) if prob > 0 else -10 # Lissage avg_log_prob = log_prob_sum / total_words return math.exp(-avg_log_prob) def analyze_diversity(self) -> Dict: """Analyse de diversité du dataset""" questions = [item["question"] for item in self.data] answers = [item["answer"] for item in self.data] # Longueurs q_lengths = [len(self.tokenize(q)) for q in questions] a_lengths = [len(self.tokenize(a)) for a in answers] # Vocabulaire unique q_vocab = set() a_vocab = set() for q, a in zip(questions, answers): q_vocab.update(self.tokenize(q)) a_vocab.update(self.tokenize(a)) # Domaines approximatifs (mots-clés) domain_keywords = { "science": ["science", "physique", "chimie", "biologie", "mathématiques"], "histoire": ["histoire", "guerre", "année", "siècle", "ancien"], "géographie": ["pays", "ville", "continent", "montagne", "rivière"], "culture": ["livre", "film", "musique", "art", "littérature"], "sport": ["sport", "football", "match", "équipe", "joueur"], "technologie": ["ordinateur", "internet", "logiciel", "données", "algorithme"] } domain_counts = defaultdict(int) for item in self.data: text = (item["question"] + " " + item["answer"]).lower() for domain, keywords in domain_keywords.items(): if any(kw in text for kw in keywords): domain_counts[domain] += 1 break else: domain_counts["autre"] += 1 return { "total_samples": len(self.data), "avg_question_length": np.mean(q_lengths), "avg_answer_length": np.mean(a_lengths), "question_vocab_size": len(q_vocab), "answer_vocab_size": len(a_vocab), "total_vocab_size": len(q_vocab | a_vocab), "domain_distribution": dict(domain_counts) } def analyze_robustness(self) -> Dict: """Analyse de robustesse : doublons, ambiguïté""" questions = [item["question"] for item in self.data] answers = [item["answer"] for item in self.data] # Détection de doublons (hash MD5) q_hashes = [hashlib.md5(q.encode()).hexdigest() for q in questions] a_hashes = [hashlib.md5(a.encode()).hexdigest() for a in answers] duplicate_questions = len(q_hashes) - len(set(q_hashes)) duplicate_answers = len(a_hashes) - len(set(a_hashes)) # Réponses ambiguës ambiguous_words = ["peut-être", "dépend", "probablement", "possible", "incertain", "environ"] ambiguous_count = sum(1 for a in answers if any(word in a.lower() for word in ambiguous_words)) # Similarité élevée (>90%) similar_pairs = 0 sample_size = min(1000, len(questions)) # Échantillon pour performance for i in range(sample_size): for j in range(i+1, sample_size): similarity = SequenceMatcher(None, questions[i], questions[j]).ratio() if similarity > 0.9: similar_pairs += 1 return { "duplicate_questions": duplicate_questions, "duplicate_answers": duplicate_answers, "duplicate_rate": (duplicate_questions + duplicate_answers) / (2 * len(self.data)), "ambiguous_answers": ambiguous_count, "ambiguous_rate": ambiguous_count / len(self.data), "similar_pairs_sample": similar_pairs, "estimated_similarity_rate": similar_pairs / (sample_size * (sample_size-1) / 2) } def benchmark_model(self, model_answers: List[str], subset_size: int = None) -> Dict: """Benchmark complet avec toutes les métriques""" start_time = time.time() # Validation des données if subset_size: data_subset = self.data[:subset_size] if len(model_answers) != subset_size: raise ValueError(f"Taille incohérente : {len(model_answers)} réponses != {subset_size} échantillons") else: data_subset = self.data if len(model_answers) != len(self.data): raise ValueError(f"Taille incohérente : {len(model_answers)} réponses != {len(self.data)} échantillons") print(f"🔄 Benchmark en cours sur {len(data_subset)} échantillons...") # Initialisation des scores em_scores = [] bleu_scores = defaultdict(list) rouge_scores = defaultdict(lambda: defaultdict(list)) # Calcul des métriques for i, (item, pred_answer) in enumerate(zip(data_subset, model_answers)): if i % 10000 == 0 and i > 0: print(f" Progression : {i}/{len(data_subset)} ({i/len(data_subset)*100:.1f}%)") true_answer = item["answer"] # Exact Match em_scores.append(self.calculate_exact_match(true_answer, pred_answer)) # BLEU bleu_results = self.calculate_bleu(true_answer, pred_answer) for key, value in bleu_results.items(): bleu_scores[key].append(value) # ROUGE rouge_results = self.calculate_rouge_metrics(true_answer, pred_answer) for rouge_type, metrics in rouge_results.items(): for metric, value in metrics.items(): rouge_scores[rouge_type][metric].append(value) # Perplexité perplexity = self.calculate_perplexity(model_answers) # Moyennes finales final_results = { "exact_match": np.mean(em_scores), "bleu": {key: np.mean(scores) for key, scores in bleu_scores.items()}, "rouge": {rouge_type: {metric: np.mean(scores) for metric, scores in metrics.items()} for rouge_type, metrics in rouge_scores.items()}, "perplexity": perplexity, "total_samples": len(data_subset), "processing_time": time.time() - start_time } return final_results def print_results(self, results: Dict, diversity: Dict = None, robustness: Dict = None): """Affichage formaté des résultats""" print(f"\n🎯 RÉSULTATS BENCHMARK ({results['total_samples']} échantillons)") print("=" * 60) # Métriques principales print(f"📊 EXACT MATCH : {results['exact_match']:.4f}") print(f"📊 PERPLEXITÉ : {results['perplexity']:.2f}") # BLEU print(f"\n📈 BLEU SCORES:") for key, value in results['bleu'].items(): print(f" {key.upper()}: {value:.4f}") # ROUGE print(f"\n📈 ROUGE SCORES:") for rouge_type, metrics in results['rouge'].items(): print(f" {rouge_type.upper()}:") for metric, value in metrics.items(): print(f" {metric}: {value:.4f}") # Diversité if diversity: print(f"\n🌈 DIVERSITÉ:") print(f" Questions moy: {diversity['avg_question_length']:.1f} mots") print(f" Réponses moy : {diversity['avg_answer_length']:.1f} mots") print(f" Vocabulaire : {diversity['total_vocab_size']} mots uniques") print(f" Domaines principaux:") for domain, count in sorted(diversity['domain_distribution'].items(), key=lambda x: x[1], reverse=True)[:5]: print(f" {domain}: {count} ({count/diversity['total_samples']*100:.1f}%)") # Robustesse if robustness: print(f"\n🛡️ ROBUSTESSE:") print(f" Doublons : {robustness['duplicate_rate']*100:.2f}%") print(f" Ambiguïté : {robustness['ambiguous_rate']*100:.2f}%") print(f" Similarité : {robustness['estimated_similarity_rate']*100:.2f}%") print(f"\n⏱️ Temps de traitement : {results['processing_time']:.1f}s") print("=" * 60) # Exemple d'utilisation if __name__ == "__main__": # Initialisation benchmark = CompleteBenchmark("output/qa_dataset.jsonl") # Analyse préliminaire print("🔍 Analyse de diversité...") diversity = benchmark.analyze_diversity() print("🔍 Analyse de robustesse...") robustness = benchmark.analyze_robustness() # Test avec réponses parfaites (100 échantillons) print("\n🧪 Test avec réponses parfaites...") perfect_answers = [item["answer"] for item in benchmark.data[:ECHANTILLIONS]] results = benchmark.benchmark_model(perfect_answers, subset_size=ECHANTILLIONS) benchmark.print_results(results, diversity, robustness) # Test avec réponses modifiées print("\n🧪 Test avec réponses modifiées...") modified_answers = [item["answer"] + " (test)" for item in benchmark.data[:ECHANTILLIONS]] results2 = benchmark.benchmark_model(modified_answers, subset_size=ECHANTILLIONS) benchmark.print_results(results2) print("\n✅ Benchmark terminé !")