Wikipedia bannit les LLM : anatomie technique d'une politique éditoriale radicale

La décision de Wikipedia de bannir formellement les contenus générés par LLM soulève des questions techniques fondamentales sur la capacité des modèles de langage à produire du contenu encyclopédique fiable. Cette politique, adoptée début 2025, ne repose pas sur une opposition idéologique à l'IA mais sur des limitations architecturales bien documentées des LLM actuels.

Fondements techniques du problème

Architecture des LLM et génération de contenu factuel

Les modèles de langage modernes (GPT-4, Claude 3, Llama 3) reposent sur une architecture Transformer avec un mécanisme d'attention qui prédit le token suivant en fonction d'une distribution de probabilités. Cette approche présente des limitations intrinsèques pour la production de contenu encyclopédique :

Absence de mémoire épisodique structurée : contrairement à un système de gestion de connaissances, un LLM encode l'information dans ses poids durant l'entraînement. La récupération d'un fait spécifique n'implique pas une requête sur une base de données mais une reconstruction probabiliste. La probabilité qu'un modèle génère "Paris est la capitale de la France" est élevée car cette séquence apparaît fréquemment dans les données d'entraînement, mais pour des faits moins communs, le modèle interpole entre des patterns similaires.

Compression avec pertes : un modèle de 70 milliards de paramètres (environ 140 Go en FP16) est entraîné sur plusieurs téraoctets de texte. Cette compression massive implique nécessairement des pertes d'information. Les faits rares, les détails précis et les nuances sont souvent sacrifiés au profit de patterns généraux.

Hallucinations structurelles : le phénomène d'hallucination n'est pas un bug mais une conséquence de l'objectif d'entraînement. Un modèle optimisé pour minimiser la perplexité (cross-entropy loss sur la prédiction du token suivant) apprend à générer des séquences plausibles plutôt que véridiques. La fonction de perte standard s'exprime comme la moyenne négative du log de la probabilité du token correct, sans pénalité explicite pour la factualité.

Mécanismes de détection actuels

Wikipedia s'appuie sur plusieurs approches pour détecter le contenu généré par IA :

Analyse statistique du texte : les détecteurs comme GPTZero ou le détecteur d'OpenAI (désormais abandonné) analysent la distribution de perplexité. Les textes générés par LLM présentent souvent une perplexité anormalement basse (le texte est "trop prévisible") et une variance réduite dans la longueur des phrases. Cependant, ces détecteurs présentent des taux de faux positifs importants (15-30% selon les benchmarks) et peuvent être contournés par paraphrasing itératif.

Watermarking sémantique : des techniques comme celle proposée par l'Université du Maryland modifient légèrement la distribution de probabilités durant la génération en favorisant certains tokens selon une règle pseudo-aléatoire. Cette empreinte reste détectable même après modification. L'implémentation consiste à partitionner le vocabulaire en "liste verte" et "liste rouge" pour chaque position, puis à biaiser le sampling vers la liste verte avec un paramètre delta ajouté aux logits.

Détection par modèle adversarial : entraîner un classifieur (typiquement un RoBERTa fine-tuné) sur des paires texte humain/texte IA. Cette approche atteint environ 95% de précision sur du contenu clairement généré, mais échoue sur les hybrides humain-IA ou les textes fortement édités.

Implémentation d'un pipeline de détection

Voici une architecture typique pour détecter du contenu généré par LLM à l'échelle de Wikipedia :

import numpy as np
from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

class LLMDetectionPipeline:
    def __init__(self, model_name="roberta-large-openai-detector"):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForSequenceClassification.from_pretrained(model_name)
        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        self.model.to(self.device)
        
    def compute_perplexity_features(self, text, reference_model="gpt2"):
        """Calcule des features basées sur la perplexité"""
        tokenizer = AutoTokenizer.from_pretrained(reference_model)
        model = AutoModelForCausalLM.from_pretrained(reference_model)
        
        encodings = tokenizer(text, return_tensors="pt")
        max_length = model.config.n_positions
        stride = 512
        
        nlls = []
        for i in range(0, encodings.input_ids.size(1), stride):
            begin_loc = max(i + stride - max_length, 0)
            end_loc = min(i + stride, encodings.input_ids.size(1))
            trg_len = end_loc - i
            
            input_ids = encodings.input_ids[:, begin_loc:end_loc].to(self.device)
            target_ids = input_ids.clone()
            target_ids[:, :-trg_len] = -100
            
            with torch.no_grad():
                outputs = model(input_ids, labels=target_ids)
                neg_log_likelihood = outputs.loss * trg_len
                
            nlls.append(neg_log_likelihood)
        
        perplexity = torch.exp(torch.stack(nlls).sum() / end_loc)
        return perplexity.item()
    
    def detect_watermark(self, text, vocab_size=50257, gamma=0.25, delta=2.0):
        """Détecte un watermark statistique (approche Maryland)"""
        tokens = self.tokenizer.encode(text)
        green_token_count = 0
        
        for i in range(1, len(tokens)):
            prev_token = tokens[i-1]
            curr_token = tokens[i]
            
            # Génère la partition pseudo-aléatoire basée sur le token précédent
            np.random.seed(prev_token)
            green_list_size = int(vocab_size * gamma)
            green_list = np.random.choice(vocab_size, green_list_size, replace=False)
            
            if curr_token in green_list:
                green_token_count += 1
        
        # Test z-score
        expected_count = len(tokens) * gamma
        variance = len(tokens) * gamma * (1 - gamma)
        z_score = (green_token_count - expected_count) / np.sqrt(variance)
        
        return z_score > 4.0  # p < 0.00003
    
    def classify_text(self, text):
        """Classification par modèle fine-tuné"""
        inputs = self.tokenizer(text, return_tensors="pt", 
                               truncation=True, max_length=512)
        inputs = {k: v.to(self.device) for k, v in inputs.items()}
        
        with torch.no_grad():
            outputs = self.model(**inputs)
            probabilities = torch.softmax(outputs.logits, dim=-1)
            
        return {
            "ai_probability": probabilities[0][1].item(),
            "human_probability": probabilities[0][0].item()
        }
    
    def full_detection(self, text):
        """Pipeline complet de détection"""
        classifier_result = self.classify_text(text)
        perplexity = self.compute_perplexity_features(text)
        has_watermark = self.detect_watermark(text)
        
        # Système de scoring pondéré
        score = (
            classifier_result["ai_probability"] * 0.5 +
            (1 / max(perplexity, 1)) * 0.3 +  # perplexité faible = suspect
            (1.0 if has_watermark else 0.0) * 0.2
        )
        
        return {
            "is_ai_generated": score > 0.7,
            "confidence": score,
            "details": {
                "classifier": classifier_result,
                "perplexity": perplexity,
                "watermark_detected": has_watermark
            }
        }

Ce pipeline combine trois approches complémentaires avec un seuil de décision ajustable selon les besoins de précision/rappel.

Benchmarks et performances

Métriques de détection

Les benchmarks récents (papiers de détection de 2024-2025) montrent des performances variables :

Méthode	Précision	Rappel	F1-Score	Faux Positifs
GPTZero	76%	82%	0.79	24%
OpenAI Detector (deprecated)	26%	50%	0.34	9%
RoBERTa fine-tuné	94%	91%	0.92	6%
Watermarking (Maryland)	99%	85%	0.91	<1%
Ensemble pipeline	96%	89%	0.92	4%

Limites importantes : ces chiffres sont mesurés sur du contenu 100% généré vs 100% humain. Sur du contenu hybride (humain qui utilise l'IA comme assistant puis édite substantiellement), les performances chutent drastiquement : F1-score autour de 0.55-0.65.

Tests adversariaux

Les attaquants peuvent contourner ces systèmes via :

• Paraphrasing itératif : faire générer par GPT-4, puis paraphraser avec Claude, puis éditer manuellement → taux de détection tombe à 40-50%
• Injection de bruit contrôlé : ajouter intentionnellement des erreurs grammaticales mineures ou variations stylistiques
• Mixage humain-IA : structure générée par IA, faits vérifiés et réécrits par humain

Limitations architecturales pour le contenu encyclopédique

Problème de la citation et traçabilité

Un article Wikipedia typique contient 20-40 citations vers des sources primaires. Les LLM actuels ne peuvent pas :

1. Générer des citations vérifiables : même avec RAG (Retrieval-Augmented Generation), le modèle peut halluciner le contenu exact d'une source ou inventer des références inexistantes
2. Maintenir la cohérence chronologique : sur des sujets d'actualité, les modèles ont une date de coupure (knowledge cutoff) et mélangent parfois les temporalités
3. Distinguer consensus scientifique et théories marginales : le modèle génère ce qui est statistiquement fréquent dans ses données, pas nécessairement ce qui est scientifiquement accepté

Biais systémiques

Les LLM héritent des biais de leurs données d'entraînement :

• Biais de représentation : surreprésentation de contenus anglophones et occidentaux
• Biais de récence : les événements récents (avant le cutoff) sont surreprésentés par rapport à leur importance historique
• Biais de popularité : les sujets populaires en ligne sont mieux représentés que des sujets académiques pointus

Ces biais sont documentés dans la politique de qualité éditoriale de Wikipedia qui exige vérifiabilité et sources secondaires fiables.

Recherche et évolutions futures

Architectures émergentes

Plusieurs pistes de recherche visent à améliorer la factualité :

Modèles avec mémoire externe : architectures comme RETRO (DeepMind) ou Atlas (Meta) qui intègrent un mécanisme de récupération sur une base de connaissances externe durant l'inférence. La récupération se fait via un encodeur dense (retriever) qui trouve les k documents les plus pertinents, puis le générateur conditionne sa prédiction sur ces documents.

class RetroGenerator:
    def __init__(self, retriever, generator, knowledge_base):
        self.retriever = retriever  # DPR ou ANCE
        self.generator = generator  # Transformer decoder
        self.kb = knowledge_base    # Index FAISS sur Wikipedia
        
    def generate_with_retrieval(self, query, k=5):
        # Récupère les k passages les plus pertinents
        retrieved_docs = self.retriever.retrieve(query, self.kb, k=k)
        
        # Concatène les documents au contexte
        augmented_context = f"{query}\n\nSources:\n"
        for doc in retrieved_docs:
            augmented_context += f"- {doc.text} [ref: {doc.url}]\n"
        
        # Génère avec le contexte augmenté
        output = self.generator.generate(
            augmented_context,
            max_length=512,
            cite_sources=True  # Force la citation
        )
        
        return output, retrieved_docs

Fine-tuning sur la factualité : RLHF (Reinforcement Learning from Human Feedback) avec des récompenses explicites pour la véracité. Anthropic a publié des résultats sur Constitutional AI qui pénalise les hallucinations.

Chain-of-Verification : technique où le modèle génère d'abord un draft, puis génère des questions de vérification, y répond, et corrige le draft. Efficace mais coûteux (3-4x le coût d'inférence standard).

Détection de nouvelle génération

Approches zero-shot : utiliser un LLM pour détecter du contenu généré par LLM via prompting sophistiqué. Contre-intuitif mais peut atteindre 80%+ de précision selon les papiers récents de Stanford.

Empreintes neuronales : analyser les activations internes du modèle plutôt que sa sortie. Nécessite un accès au modèle (impossible pour les API closed-source).

Analyse sémantique profonde : détecter les patterns de raisonnement typiques des LLM (ex: structuration en listes, transitions trop lisses, absence de digressions naturelles).

Implications pour la production

La décision de Wikipedia illustre un défi plus large pour l'industrialisation de l'IA en production : comment garantir la qualité et la traçabilité dans des systèmes autonomes ?

Pour les ingénieurs ML déployant des systèmes de génération de contenu :

1. Implémenter des guardrails multicouches : validation factuelle via