# 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).*