| # Détecteur de Textes Parlementaires Générés par IA (Ensemble Staké SOTA) |
|
|
| Ce projet fournit un pipeline complet en Python pour détecter si un discours politique ou une intervention parlementaire en français a été rédigé avec l'assistance d'une IA générative (ChatGPT, Claude, Qwen, Gemma, etc.). |
|
|
| Le modèle s'appuie sur une architecture **State-of-the-Art (SOTA)** de **Stacking d'Ensemble** combinant des indices stylométriques (structure, rythme de phrase, conjugaisons) et des marqueurs lexicaux (n-grams de mots et caractères). |
|
|
| --- |
|
|
| ## 📂 Structure du Projet |
|
|
| ```text |
| /workspace/ |
| ├── configs/ |
| │ └── config.yaml # Configuration centrale (chemins, hyperparamètres) |
| ├── data/ |
| │ ├── raw/ # Données brutes (discours réels HF + IA générés) |
| │ └── processed/ # Caractéristiques extraites (features prêtes pour l'entraînement) |
| ├── models/ |
| │ ├── best_detector.pkl # Le package du modèle SOTA (Base Models + Meta-Model) |
| │ ├── word_vectorizer.pkl # Vectoriseur TF-IDF pour les mots |
| │ └── char_vectorizer.pkl # Vectoriseur TF-IDF pour les caractères |
| ├── reports/ |
| │ ├── evaluation_report.md # Rapport de performance des modèles |
| │ ├── twitter_threads.md # Propositions de threads X (Grand public et Technique) |
| │ └── plots/ # Graphiques générés (PNG) et carte interactive (HTML) |
| ├── scripts/ |
| │ ├── models.py # Classe commune du StackingDetector (évite les erreurs pickle) |
| │ ├── text_generator.py # Simulateur stylistique de discours (Humains et IA) |
| │ ├── collect_data.py # Ingestion des discours HF et génération de l'IA |
| │ ├── generate_synthetic.py # Générateur du corpus synthétique IA (GPT, Claude, Qwen, Gemma) |
| │ ├── build_features.py # Extracteur de 23 caractéristiques stylométriques + n-grams |
| │ ├── train_sota_detector.py # Entraînement de l'ensemble staké (Cross-Validation OOF) |
| │ ├── infer_recent_debates.py# Inférence, scores hebdo log-scale et explications locales |
| │ ├── make_plots.py # Génération des plots matplotlib et de l'explorateur HTML Plotly |
| │ └── upload_to_hf.py # Script de sauvegarde du projet sur Hugging Face |
| └── README.md # Ce fichier d'explications |
| ``` |
|
|
| --- |
|
|
| ## 🛠️ Installation des Dépendances |
|
|
| Assurez-vous d'avoir Python 3.10+ installé, puis lancez la commande suivante pour installer toutes les bibliothèques requises : |
|
|
| ```bash |
| pip install pandas numpy scikit-learn xgboost matplotlib seaborn tqdm jinja2 pyarrow datasets plotly gradio huggingface_hub |
| ``` |
|
|
| --- |
|
|
| ## 🚀 Guide d'Exécution (Pas-à-Pas) |
|
|
| Pour exécuter ou ré-entraîner l'ensemble du pipeline, lancez les commandes dans l'ordre suivant : |
|
|
| ### 1. Ingestion et collecte des données |
| Cette commande télécharge les discours parlementaires historiques réels depuis Hugging Face (dataset `agokrani/fr-political-speeches`) et génère les textes IA équivalents. |
| ```bash |
| python scripts/collect_data.py |
| ``` |
| *(Sorties : `data/raw/human_corpus.csv`, `data/raw/ai_corpus.csv` et `data/raw/recent_debates.csv`).* |
|
|
| ### 2. Extraction des caractéristiques stylométriques et lexicales |
| Calcule les caractéristiques d'écriture sur les textes et ajuste les modèles TF-IDF. |
| ```bash |
| python scripts/build_features.py |
| ``` |
| *(Sorties : `data/processed/train_features.csv`, `data/processed/recent_features.csv`, et les vectoriseurs dans `models/`).* |
|
|
| ### 3. Entraînement du modèle SOTA (Stacking) |
| Entraîne les classifieurs de base (Régression Logistique Style, XGBoost Style, Régression Logistique N-grams) et le méta-classifieur final sur les prédictions hors-pli (Out-of-Fold). |
| ```bash |
| python scripts/train_sota_detector.py |
| ``` |
| *(Sorties : `models/best_detector.pkl` et `reports/evaluation_report.md`).* |
|
|
| ### 4. Calcul des scores sur la timeline |
| Applique le modèle staké sur les débats récents (2004–2026), calcule les probabilités d'IA et agrège les données par semaine. |
| ```bash |
| python scripts/infer_recent_debates.py |
| ``` |
| *(Sorties : `output/recent_debates_predictions.csv` et `output/stats_by_week.csv`).* |
|
|
| ### 5. Génération des visualisations et de la carte |
| Reconstruit les graphiques statiques (échelle logarithmique hebdomadaire) et exporte la carte Plotly interactive. |
| ```bash |
| python scripts/make_plots.py |
| ``` |
| *(Sorties : `output/interactive_map.html` et les graphiques PNG dans `reports/plots/`).* |
|
|
| --- |
|
|
| ## 📊 Fonctionnement Scientifique du Modèle SOTA |
|
|
| ### L'Architecture de Stacking (Ensemble Staké) |
| Pour maximiser la robustesse du modèle (généralisation hors-domaine), nous combinons plusieurs approches : |
| 1. **Modèle de Style Linéaire** : Évalue des règles d'écriture structurelles et grammaticales (explications très claires des coefficients). |
| 2. **Modèle de Style Non-Linéaire (XGBoost)** : Capture les interactions complexes de taille de phrases et de ponctuations. |
| 3. **Modèle Lexical (N-grams)** : Repère les enchaînements de mots et de sous-mots caractéristiques des LLMs. |
| 4. **Méta-Modèle** : Prend les prédictions des 3 modèles de base et décide de la probabilité finale. |
|
|
| ### Les 23 Caractéristiques Stylométriques Extraites |
| Le script `build_features.py` extrait des signatures propres au français politique : |
| - **Structure** : longueur moyenne des phrases, écart-type de longueur (le rythme), longueur moyenne des mots, ratio de mots longs (> 6 lettres). |
| - **Style discursif** : densité des connecteurs logiques (`connector_ratio`), ratio de répétitions lexicales (`repetition_ratio`), diversité du vocabulaire (`vocabulary_diversity` ou TTR), ratio d'Hapax (richesse). |
| - **Syntaxe & Grammaire** : score de propositions subordonnées (complexité syntaxique), ratio de phrases déclaratives, exclamatives et interrogatives, répartition des temps (futur, imparfait, conditionnel). |
|
|
| --- |
|
|
| ## 🌐 Lancement de l'Interface Web (Gradio) |
|
|
| Pour tester le détecteur en direct avec vos propres textes ou explorer les graphiques et classements directement dans votre navigateur, lancez l'application Gradio : |
|
|
| ```bash |
| python scripts/app.gradio.py |
| ``` |
| *(L'application démarre localement sur le port `7860`. L'argument `share=True` dans le code génère automatiquement un lien public temporaire `.gradio.live` idéal si vous exécutez le code sur une machine distante comme RunPod).* |
|
|
| --- |
|
|
| ## 💾 Sauvegarde du travail sur Hugging Face (Dataset / Dépôt de Code) |
|
|
| Si vous souhaitez sauvegarder uniquement vos scripts Python, configurations et documentations sous la forme d'un **Dataset de sauvegarde** (en excluant les dossiers de données lourds et les modèles `.pkl` binaires), utilisez la commande suivante : |
|
|
| ```bash |
| python scripts/upload_to_hf.py --repo_id "votre-username/nom-de-sauvegarde" --repo_type "dataset" --token "votre_write_token_hf" |
| ``` |
| *(Cette commande crée un dépôt Dataset sur Hugging Face et téléverse vos scripts et documentations, constituant une sauvegarde légère et propre de votre code).* |
|
|
