deploy: 2026-03-29T18:02:04Z

Dockerfile

@@ -0,0 +1,32 @@
+FROM python:3.11-slim
+
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    libgl1 \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY requirements.txt .
+# Install torch CPU-only first (~250MB vs ~2GB for the default CUDA build)
+RUN \
+    pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu
+RUN \
+    pip install --timeout 300 -r requirements.txt
+
+COPY app/ ./app/
+COPY scripts/ ./scripts/
+
+EXPOSE 8000
+
+HEALTHCHECK --interval=30s --timeout=10s --start-period=300s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Models download on first cold start and are cached by HF Spaces persistently.
+# preload_models.py runs before uvicorn so the API is ready when /health passes.
+CMD ["sh", "-c", "python scripts/preload_models.py && uvicorn app.main:app --host 0.0.0.0 --port 8000 --workers 1"]

README.md

@@ -0,0 +1,372 @@
+---
+title: KAMY Vision AI
+emoji: 🛡️
+colorFrom: purple
+colorTo: blue
+sdk: docker
+app_port: 8000
+pinned: false
+---
+
+# AuthenticVision — Détection Deepfake & IA Générative
+
+Outil complet de détection de contenus synthétiques (images, vidéos, audio) générés par IA.
+Disponible en API REST, CLI et interface web.
+
+---
+
+## Architecture v3.0
+
+```
+AuthenticVision
+├── api.py               — API FastAPI (images + vidéos + audio)
+├── video_analyzer.py    — Module d'analyse vidéo multi-couches
+├── cli.py               — Interface ligne de commande
+├── verify_robustness.py — Script de benchmark avec métriques
+└── frontend/            — Interface web HTML/CSS/JS
+```
+
+### Modèles utilisés
+
+**Images (ensemble de 3 modèles ViT fusionnés) :**
+| Modèle | Rôle | Poids |
+|--------|------|-------|
+| `prithivMLmods/Deep-Fake-Detector-Model` | Deepfake faces | 35% |
+| `prithivMLmods/AI-vs-Deepfake-vs-Real` | 3 classes : AI / Deepfake / Real | 40% |
+| `Ateeqq/ai-vs-human-image-detector` | AI vs Humain (120k images) | 25% |
+
+**Audio :** `MelodyMachine/Deepfake-audio-detection-V2`
+
+**Optionnel :** `openai/clip-vit-base-patch32` (analyse sémantique, activable via `?use_clip=true`)
+
+### Couches forensiques — Images
+- Ensemble 3 modèles ViT (score fusionné pondéré)
+- Analyse EXIF étendue (19 sources IA détectées : Gemini, DALL-E, Firefly, Flux, SynthID...)
+- Spectre FFT (détection sur-lissage et pics GAN)
+- Texture & Bruit (uniformité anormale)
+- Palette chromatique (entropie couleur artificielle)
+- Détection filtre social (Snapchat/Instagram) avec seuils adaptatifs
+
+### Couches forensiques — Vidéo
+- Ensemble modèles sur frames extraites (crop visage prioritaire)
+- Cohérence temporelle inter-frames (variation anormalement faible = deepfake)
+- Cohérence de teinte de peau entre visages (incohérence = manipulation)
+
+---
+
+## Installation
+
+```bash
+# Dépendances de base
+pip install fastapi uvicorn torch transformers pillow piexif librosa python-multipart
+
+# Support vidéo (requis pour analyser des vidéos)
+pip install opencv-python-headless
+
+# Support HEIC (photos iPhone)
+pip install pillow-heif
+```
+
+### Lancer l'API
+
+```bash
+python api.py
+# API disponible sur http://localhost:8000
+```
+
+### Lancer l'interface web
+
+Ouvrir `frontend/index.html` dans un navigateur (l'API doit être lancée).
+
+---
+
+## API — Endpoints
+
+### `POST /predict` — Analyse complète
+Supporte : images (JPEG, PNG, WebP, HEIC), vidéos (MP4, MOV, AVI, WebM), audio (WAV, MP3, M4A)
+
+```bash
+# Image
+curl -X POST http://localhost:8000/predict \
+  -F "file=@photo.jpg" \
+  -F "sensitivity=50" \
+  -F "robust_mode=false"
+
+# Vidéo
+curl -X POST http://localhost:8000/predict \
+  -F "file=@video.mp4" \
+  -F "sensitivity=50"
+
+# Avec CLIP (GPU recommandé)
+curl -X POST "http://localhost:8000/predict?use_clip=true" \
+  -F "file=@photo.jpg"
+```
+
+### `POST /predict/fast` — Mode rapide
+Modèle principal seul, sans couches forensiques complètes (~5-15s CPU).
+
+```bash
+curl -X POST http://localhost:8000/predict/fast \
+  -F "file=@photo.jpg" \
+  -F "sensitivity=50"
+```
+
+### `GET /health` — Statut de l'API
+
+```bash
+curl http://localhost:8000/health
+```
+
+**Exemple de réponse (image) :**
+```json
+{
+  "status": "success",
+  "verdict": "DEEPFAKE",
+  "fake_prob": 0.8731,
+  "real_prob": 0.1269,
+  "media_type": "IMAGE",
+  "ai_source": "Google Gemini",
+  "forensic_details": {
+    "fusion_profile": "EXIF_IA_DETECTE",
+    "layer_scores": {
+      "ensemble": 0.82,
+      "exif": 0.97,
+      "fft": 0.61,
+      "texture": 0.55,
+      "color": 0.70
+    }
+  }
+}
+```
+
+---
+
+## CLI
+
+```bash
+# Installation globale
+pip install authenticvision-cli
+
+# Analyse d'une image
+deepfake photo.jpg
+
+# Avec options
+deepfake photo.jpg --sensitivity 70 --robust --audit
+
+# Sortie JSON (pour scripts/pipelines)
+deepfake photo.jpg --json
+
+# Mode rapide (ViT seul)
+deepfake photo.jpg --fast
+
+# Audio
+deepfake voix.mp3 --sensitivity 60
+```
+
+**Exemple de sortie :**
+```
+==================================================
+  RÉSULTAT DE L'ANALYSE — AuthenticVision v2.0
+==================================================
+  Fichier    : photo.jpg
+  Type       : IMAGE
+  Sensibilité: 50%  |  Robustesse: OFF
+--------------------------------------------------
+  VERDICT  : AUTHENTIQUE
+  Confiance : 96.0% réel
+==================================================
+```
+
+---
+
+## Benchmark
+
+Le script `verify_robustness.py` évalue les performances sur un dataset local.
+
+```bash
+# Benchmark complet avec rapport
+python verify_robustness.py \
+  --real_dir datasets/real \
+  --fake_dir datasets/fake \
+  --output rapport.json
+
+# Mode rapide
+python verify_robustness.py \
+  --real_dir datasets/real \
+  --fake_dir datasets/fake \
+  --mode fast
+
+# Test unitaire sur une image
+python verify_robustness.py --image photo.jpg
+```
+
+**Métriques calculées :** Accuracy, Precision, Recall, F1, AUC-ROC, TP/TN/FP/FN
+
+---
+
+## Datasets de test recommandés
+
+### Images
+
+| Dataset | Contenu | Accès | Lien |
+|---------|---------|-------|------|
+| **Deepfake-Eval-2024** | 759 réelles + 1191 fakes "in-the-wild" (réseaux sociaux 2024) | Direct HuggingFace | [lien](https://huggingface.co/datasets/nuriachandra/Deepfake-Eval-2024) |
+| **CIFAKE** | 60k réelles vs générées (Stable Diffusion) | Kaggle | [lien](https://www.kaggle.com/datasets/birdy654/cifake-real-and-ai-generated-synthetic-images) |
+| **DeepfakeJudge** | Benchmark VLM avec labels réel/fake + reasoning | HuggingFace | [lien](https://huggingface.co/datasets/MBZUAI/DeepfakeJudge-Dataset) |
+
+```bash
+# Télécharger CIFAKE via Kaggle CLI
+pip install kaggle
+kaggle datasets download -d birdy654/cifake-real-and-ai-generated-synthetic-images
+unzip cifake-real-and-ai-generated-synthetic-images.zip -d datasets/cifake
+
+# Lancer le benchmark
+python verify_robustness.py \
+  --real_dir datasets/cifake/test/REAL \
+  --fake_dir datasets/cifake/test/FAKE \
+  --output rapport_cifake.json
+```
+
+### Vidéos
+
+| Dataset | Contenu | Accès | Lien |
+|---------|---------|-------|------|
+| **DFDC (Facebook)** | 128k clips 10s, acteurs consentants, très diversifié | Kaggle (gratuit) | [lien](https://www.kaggle.com/competitions/deepfake-detection-challenge/data) |
+| **FaceForensics++** | 1000 vidéos originales + 4 méthodes de manipulation (Deepfakes, Face2Face, FaceSwap, NeuralTextures) | Formulaire Google (gratuit) | [lien](https://github.com/ondyari/FaceForensics) |
+| **Celeb-DF v2** | 5639 deepfakes haute qualité de célébrités | Formulaire (gratuit) | [lien](https://github.com/yuezunli/celeb-deepfakeforensics) |
+| **Deepfake-Eval-2024** | 45h de vidéos "in-the-wild" 2024 | HuggingFace | [lien](https://huggingface.co/datasets/nuriachandra/Deepfake-Eval-2024) |
+| **UniDataPro deepfake-videos** | 10k+ fichiers, 7k+ personnes | HuggingFace | [lien](https://huggingface.co/datasets/UniDataPro/deepfake-videos-dataset) |
+
+**Vidéos de test rapides (sans inscription) :**
+
+Pour tester immédiatement sans télécharger un dataset complet, tu peux utiliser ces sources :
+
+1. **Vidéos réelles** — télécharge quelques clips depuis [Pexels](https://www.pexels.com/videos/) (licence gratuite, visages réels)
+
+2. **Vidéos deepfake** — le repo [deepfakes-in-the-wild](https://github.com/jmpu/webconf21-deepfakes-in-the-wild) contient des liens vers des exemples publics
+
+3. **Générer tes propres tests** avec [Deep-Live-Cam](https://github.com/hacksider/Deep-Live-Cam) (open source) sur une vidéo Pexels
+
+```bash
+# Tester une vidéo directement via l'API
+curl -X POST http://localhost:8000/predict \
+  -F "file=@ma_video.mp4" \
+  -F "sensitivity=50" | python -m json.tool
+```
+
+---
+
+## Paramètres
+
+| Paramètre | Valeurs | Description |
+|-----------|---------|-------------|
+| `sensitivity` | 1–99 (défaut: 50) | Rigueur de détection. 80+ = strict, 20- = indulgent |
+| `robust_mode` | true/false | Compense les filtres Snap/Insta, réduit les faux positifs |
+| `use_clip` | true/false | Active l'analyse sémantique CLIP (GPU recommandé) |
+
+---
+
+## Profils de fusion
+
+L'API adapte automatiquement les poids selon le contexte détecté :
+
+| Profil | Déclencheur | Comportement |
+|--------|-------------|--------------|
+| `EXIF_IA_DETECTE` | Source IA trouvée dans les métadonnées | EXIF = 60% du score |
+| `FILTRE_SOCIAL` | Filtre Snap/Insta détecté | EXIF ignoré, ensemble ViT prioritaire |
+| `EXIF_FIABLE` | Appareil photo identifié dans EXIF | EXIF = 32% du score |
+| `EXIF_ABSENT` | Pas de métadonnées (strip réseau social) | FFT + texture renforcés |
+| `STANDARD` | Cas général | Pondération équilibrée |
+
+---
+
+## Structure du projet
+
+```
+deepfake_detection/
+├── api.py                  — API FastAPI v3.0 (image + vidéo + audio)
+├── video_analyzer.py       — Analyse vidéo multi-couches
+├── cli.py                  — CLI (commande globale `deepfake`)
+├── verify_robustness.py    — Benchmark avec métriques complètes
+├── setup.py                — Configuration PyPI
+├── frontend/
+│   ├── index.html          — Interface web (tabs Image / Audio / Vidéo / Texte)
+│   ├── script.js           — Logique frontend
+│   └── style.css           — Styles
+└── README.md
+```
+
+---
+
+## Corrections & Améliorations récentes
+
+### v2.1 — Garde-fous filtre social (correctif faux positifs)
+
+Problème identifié : avec `--sensitivity 85`, le shift de +0.18 était appliqué **avant** les garde-fous, ce qui pouvait faire passer une photo filtrée (Snapchat/Instagram) en DEEPFAKE.
+
+Corrections apportées dans `cli.py` et `api.py` :
+
+1. Les garde-fous sont maintenant appliqués sur le **score brut** (avant le shift sensitivity)
+2. Seuil filtre social élargi : `vit_fake < 0.70` (au lieu de `< 0.55`) pour couvrir la zone grise
+3. Seuil de déclenchement filtre abaissé : `fc > 0.45` (au lieu de `> 0.60`)
+
+Comportement attendu après correction :
+- Photo réelle avec filtre Snap + sensitivity=85 → AUTHENTIQUE (score brut plafonné à 0.46, final ≤ 0.64)
+- Image Gemini/DALL-E + sensitivity=85 → DEEPFAKE maintenu (vit_fake > 0.70, garde-fou inactif)
+
+---
+
+## Vidéos de test recommandées
+
+### Sans inscription (accès immédiat)
+
+| Source | Type | Lien |
+|--------|------|------|
+| **Pexels** | Vidéos réelles (visages, portraits) — licence gratuite | [pexels.com/videos](https://www.pexels.com/videos/) |
+| **Pixabay** | Vidéos réelles libres de droits | [pixabay.com/videos](https://pixabay.com/videos/) |
+| **FaceForensics++ samples** | Exemples deepfake publics (GitHub) | [github.com/ondyari/FaceForensics](https://github.com/ondyari/FaceForensics) |
+| **Deepfakes-in-the-wild** | Liens vers deepfakes publics collectés | [github.com/jmpu/webconf21-deepfakes-in-the-wild](https://github.com/jmpu/webconf21-deepfakes-in-the-wild) |
+
+### Datasets complets (formulaire ou Kaggle)
+
+| Dataset | Contenu | Accès | Lien |
+|---------|---------|-------|------|
+| **DFDC (Facebook)** | 128k clips 10s, très diversifié | Kaggle (gratuit) | [lien](https://www.kaggle.com/competitions/deepfake-detection-challenge/data) |
+| **FaceForensics++** | 1000 vidéos + 4 méthodes (Deepfakes, Face2Face, FaceSwap, NeuralTextures) | Formulaire Google | [lien](https://github.com/ondyari/FaceForensics) |
+| **Celeb-DF v2** | 5639 deepfakes haute qualité de célébrités | Formulaire gratuit | [lien](https://github.com/yuezunli/celeb-deepfakeforensics) |
+| **UniDataPro deepfake-videos** | 10k+ fichiers, 7k+ personnes | HuggingFace | [lien](https://huggingface.co/datasets/UniDataPro/deepfake-videos-dataset) |
+
+### Tester rapidement une vidéo
+
+```bash
+# Via l'API
+curl -X POST http://localhost:8000/predict \
+  -F "file=@ma_video.mp4" \
+  -F "sensitivity=50" | python -m json.tool
+
+# Mode rapide (moins de modèles, plus rapide)
+curl -X POST http://localhost:8000/predict/fast \
+  -F "file=@ma_video.mp4" \
+  -F "sensitivity=50"
+```
+
+**Vidéos de test suggérées (Pexels, téléchargement direct) :**
+- Portrait femme en intérieur : [pexels.com/video/3209828](https://www.pexels.com/video/3209828/) (réelle)
+- Portrait homme en extérieur : [pexels.com/video/3195394](https://www.pexels.com/video/3195394/) (réelle)
+- Pour les deepfakes : utilise les samples du repo FaceForensics++ (lien ci-dessus)
+
+---
+
+## Roadmap
+
+- [x] Détection image multi-couches (ViT + EXIF + FFT + Texture + Palette)
+- [x] Ensemble 3 modèles ViT
+- [x] Détection sources IA génératives (Gemini, DALL-E, Flux, Firefly...)
+- [x] Analyse vidéo (cohérence temporelle + ensemble frames)
+- [x] Détection audio (voix clonée)
+- [x] Interface web avec tab Vidéo
+- [x] Script de benchmark (Accuracy / F1 / AUC-ROC)
+- [x] Correctif garde-fous filtre social (v2.1)
+- [ ] Détection texte LLM (DeepSeek, ChatGPT, Claude) — en cours
+- [ ] Support streaming vidéo temps réel
+- [ ] Fine-tuning sur Deepfake-Eval-2024

app/core/config.py

@@ -0,0 +1,110 @@
+MAX_FILE_SIZE   = 20  * 1024 * 1024  # 20 MB
+MAX_VIDEO_SIZE  = 200 * 1024 * 1024  # 200 MB
+
+ALLOWED_IMAGE_MIMETYPES = [
+    "image/jpeg", "image/png", "image/webp",
+    "image/heic", "image/heif",
+    "image/jfif", "image/pjpeg", "image/bmp",
+    "image/gif",  "image/tiff", "image/avif",
+    "image/x-jfif",
+]
+
+ALLOWED_AUDIO_MIMETYPES = [
+    "audio/wav", "audio/mpeg", "audio/mp3",
+    "audio/ogg", "audio/flac", "audio/x-m4a", "audio/x-wav",
+]
+
+ALLOWED_VIDEO_MIMETYPES = [
+    "video/mp4", "video/quicktime", "video/x-msvideo",
+    "video/webm", "video/mpeg", "video/x-matroska",
+]
+
+# ── Image models ───────────────────────────────────────────────────────────────
+
+IMAGE_ENSEMBLE = [
+    {
+        "key":    "ai_vs_human",
+        "name":   "Ateeqq/ai-vs-human-image-detector",
+        "weight": 0.45,
+        "desc":   "AI vs Human 120k (ViT)",
+    },
+    {
+        "key":    "ai_vs_deepfake_vs_real",
+        "name":   "prithivMLmods/AI-vs-Deepfake-vs-Real",
+        "weight": 0.35,
+        "desc":   "AI/Deepfake/Real 3-class (ViT)",
+    },
+    {
+        "key":    "deepfake_detector",
+        "name":   "prithivMLmods/Deep-Fake-Detector-Model",
+        "weight": 0.20,
+        "desc":   "Deepfake faces (ViT)",
+    },
+]
+
+IMAGE_FAST_ENSEMBLE = [
+    {
+        "key":    "ai_vs_human",
+        "name":   "Ateeqq/ai-vs-human-image-detector",
+        "weight": 0.45,
+        "desc":   "AI vs Human 120k (ViT)",
+    },
+    {
+        "key":    "deepfake_detector",
+        "name":   "prithivMLmods/Deep-Fake-Detector-Model",
+        "weight": 0.55,
+        "desc":   "Deepfake faces (ViT)",
+    },
+]
+
+# ── Audio model ────────────────────────────────────────────────────────────────
+
+AUDIO_MODEL = {
+    "key":  "deepfake_audio_v2",
+    "name": "MelodyMachine/Deepfake-audio-detection-V2",
+    "desc": "Deepfake Audio Detection V2",
+}
+
+# ── Video ensemble (reuses ViT models) ────────────────────────────────────────
+
+VIDEO_ENSEMBLE = [
+    {
+        "key":    "deepfake_detector",
+        "name":   "prithivMLmods/Deep-Fake-Detector-Model",
+        "weight": 0.40,
+        "desc":   "Deepfake faces (ViT)",
+    },
+    {
+        "key":    "ai_vs_deepfake_vs_real",
+        "name":   "prithivMLmods/AI-vs-Deepfake-vs-Real",
+        "weight": 0.35,
+        "desc":   "AI/Deepfake/Real 3-class",
+    },
+    {
+        "key":    "ai_vs_human",
+        "name":   "Ateeqq/ai-vs-human-image-detector",
+        "weight": 0.25,
+        "desc":   "AI vs Human 120k",
+    },
+]
+
+# ── Text models ────────────────────────────────────────────────────────────────
+
+TEXT_MODELS = {
+    "ai1": {
+        "name": "fakespot-ai/roberta-base-ai-text-detection-v1",
+        "desc": "RoBERTa AI text detector (Fakespot)",
+    },
+    "ai2": {
+        "name": "Hello-SimpleAI/chatgpt-detector-roberta",
+        "desc": "RoBERTa ChatGPT detector",
+    },
+    "fn1": {
+        "name": "vikram71198/distilroberta-base-finetuned-fake-news-detection",
+        "desc": "DistilRoBERTa fake news detector",
+    },
+    "fn2": {
+        "name": "jy46604790/Fake-News-Bert-Detect",
+        "desc": "BERT fake news detector",
+    },
+}

app/core/device.py

@@ -0,0 +1,8 @@
+import torch
+
+if torch.backends.mps.is_available():
+    DEVICE = torch.device("mps")
+elif torch.cuda.is_available():
+    DEVICE = torch.device("cuda")
+else:
+    DEVICE = torch.device("cpu")

app/main.py

@@ -0,0 +1,35 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from app.routers import image as image_router
+from app.routers import audio as audio_router
+from app.routers import video as video_router
+from app.routers import text as text_router
+
+app = FastAPI(title="KAMY Vision AI", description="Plateforme de détection de deepfakes")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "http://localhost:3000",
+        "http://127.0.0.1:3000",
+        "http://localhost:5173",
+        "http://127.0.0.1:5173",
+        "http://localhost:8000",
+        "http://127.0.0.1:8000",
+        "null",
+    ],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(image_router.router)
+app.include_router(audio_router.router)
+app.include_router(video_router.router)
+app.include_router(text_router.router)
+
+
+@app.get("/health")
+async def health():
+    return {"status": "ok"}

app/models/loader.py

@@ -0,0 +1,42 @@
+import gc
+import torch
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+
+from app.core.device import DEVICE
+
+_cache: dict = {}
+
+
+def load_image_model(cfg: dict):
+    """Lazy-load a model by config key. Returns (processor, model) or None on failure."""
+    key = cfg["key"]
+    if key in _cache:
+        return _cache[key]
+
+    print(f"Loading {cfg['desc']} ({cfg['name']})...")
+    try:
+        proc  = AutoImageProcessor.from_pretrained(cfg["name"])
+        model = AutoModelForImageClassification.from_pretrained(cfg["name"]).to(DEVICE)
+        model.eval()
+        _cache[key] = (proc, model)
+        print(f"{key} ready — labels: {model.config.id2label}")
+    except Exception as e:
+        print(f"Failed to load {key}: {e}")
+        _cache[key] = None
+
+    return _cache[key]
+
+
+def unload_all():
+    global _cache
+    for entry in _cache.values():
+        if entry is not None:
+            proc, model = entry
+            del model
+            del proc
+    _cache = {}
+    gc.collect()
+    if torch.backends.mps.is_available():
+        torch.mps.empty_cache()
+    elif torch.cuda.is_available():
+        torch.cuda.empty_cache()

app/pipelines/audio.py

@@ -0,0 +1,84 @@
+import os
+import tempfile
+
+import librosa
+import numpy as np
+import torch
+from transformers import AutoFeatureExtractor, AutoModelForAudioClassification
+
+from app.core.config import AUDIO_MODEL
+from app.core.device import DEVICE
+
+_audio_model = None
+_audio_proc  = None
+
+
+def _get_audio_model():
+    global _audio_model, _audio_proc
+    if _audio_model is None:
+        name = AUDIO_MODEL["name"]
+        print(f"Loading {AUDIO_MODEL['desc']} ({name})...")
+        _audio_proc  = AutoFeatureExtractor.from_pretrained(name)
+        _audio_model = AutoModelForAudioClassification.from_pretrained(name).to(DEVICE)
+        _audio_model.eval()
+        print(f"{AUDIO_MODEL['key']} ready")
+    return _audio_proc, _audio_model
+
+
+def run(audio_bytes: bytes, sensitivity: int = 50) -> dict:
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tf:
+        tf.write(audio_bytes)
+        tmp = tf.name
+    try:
+        speech, sr = librosa.load(tmp, sr=16000)
+    finally:
+        if os.path.exists(tmp):
+            os.remove(tmp)
+
+    proc, model = _get_audio_model()
+    inputs = proc(speech, sampling_rate=sr, return_tensors="pt").to(DEVICE)
+    with torch.no_grad():
+        probs_tensor = torch.nn.functional.softmax(model(**inputs).logits, dim=-1)[0].cpu().numpy()
+
+    # Resolve fake/real indices dynamically — label order varies by model
+    id2label = {int(k): v.lower() for k, v in model.config.id2label.items()}
+    fake_kw  = ["fake", "spoof", "synthetic", "generated", "deepfake", "ai"]
+    real_kw  = ["real", "human", "authentic", "genuine", "bonafide", "natural"]
+    fake_idx = [i for i, lbl in id2label.items() if any(w in lbl for w in fake_kw)]
+    real_idx = [i for i, lbl in id2label.items() if any(w in lbl for w in real_kw)]
+    print(f"  audio id2label: {id2label} | fake_idx={fake_idx} real_idx={real_idx}")  # noqa: T201
+
+    if fake_idx:
+        fake_prob = float(sum(probs_tensor[i] for i in fake_idx))
+    elif real_idx:
+        fake_prob = float(1.0 - sum(probs_tensor[i] for i in real_idx))
+    else:
+        # Fallback: assume index 0 = fake (common for binary audio models)
+        fake_prob = float(probs_tensor[0])
+
+    shift    = (sensitivity - 50.0) / 50.0
+    adjusted = float(np.clip(fake_prob + shift * 0.18, 0.0, 1.0))
+
+    if adjusted > 0.65:
+        verdict, reason = "DEEPFAKE", "Signal vocal présentant des caractéristiques synthétiques détectées."
+    elif adjusted < 0.35:
+        verdict, reason = "AUTHENTIQUE", "Signal vocal naturel, aucun artefact de synthèse détecté."
+    else:
+        verdict, reason = "INDÉTERMINÉ", "Signal vocal ambigu, analyse non concluante."
+
+    confidence = "haute" if adjusted > 0.85 or adjusted < 0.15 else ("moyenne" if adjusted > 0.70 or adjusted < 0.30 else "faible")
+
+    return {
+        "verdict":          verdict,
+        "confidence":       confidence,
+        "reason":           reason,
+        "fake_prob":        round(adjusted, 4),
+        "real_prob":        round(1.0 - adjusted, 4),
+        "sensitivity_used": sensitivity,
+        "models": {
+            AUDIO_MODEL["key"]: {
+                "score": round(fake_prob, 4),
+                "desc":  AUDIO_MODEL["desc"],
+            }
+        },
+    }

app/pipelines/image.py

@@ -0,0 +1,344 @@
+import numpy as np
+import torch
+from PIL import Image, ImageFilter
+
+from app.core.config import IMAGE_ENSEMBLE, IMAGE_FAST_ENSEMBLE
+from app.core.device import DEVICE
+from app.models.loader import load_image_model
+
+
+# ── Model inference ────────────────────────────────────────────────────────────
+
+def _infer_fake_score(proc, model, img: Image.Image) -> float:
+    """
+    Stable inference: average over 3 passes to reduce variance.
+    Dynamically resolves fake/real indices from id2label — no hardcoded assumptions.
+    Returns a score 0→1 (1 = synthetic/fake).
+    """
+    inputs = proc(images=img, return_tensors="pt").to(DEVICE)
+    with torch.no_grad():
+        logits_list = [model(**inputs).logits for _ in range(3)]
+        logits_mean = torch.stack(logits_list).mean(dim=0)
+        probs = torch.nn.functional.softmax(logits_mean, dim=-1)[0].cpu().numpy()
+
+    id2label = {int(k): v.lower() for k, v in model.config.id2label.items()}
+    fake_kw = ["fake", "ai", "artificial", "synthetic", "generated", "deepfake"]
+    real_kw = ["real", "human", "authentic", "genuine"]
+
+    fake_indices = [i for i, lbl in id2label.items() if any(w in lbl for w in fake_kw)]
+    real_indices = [i for i, lbl in id2label.items() if any(w in lbl for w in real_kw)]
+
+    if not fake_indices and not real_indices:
+        return float(probs[1]) if len(probs) >= 2 else 0.5
+
+    fake_score = float(np.sum([probs[i] for i in fake_indices])) if fake_indices else 0.0
+    real_score = float(np.sum([probs[i] for i in real_indices])) if real_indices else 0.0
+    total = fake_score + real_score
+    return fake_score / total if total > 1e-9 else 0.5
+
+
+def _run_ensemble(img: Image.Image, ensemble: list) -> dict:
+    """Run all models in the ensemble and return weighted score + per-model details."""
+    results = {}
+    weighted_sum = 0.0
+    total_weight = 0.0
+
+    for cfg in ensemble:
+        loaded = load_image_model(cfg)
+        if loaded is None:
+            print(f"  {cfg['key']} skipped (load failed)")
+            continue
+        proc, model = loaded
+        try:
+            score = _infer_fake_score(proc, model, img)
+            results[cfg["key"]] = {"score": round(score, 4), "weight": cfg["weight"], "desc": cfg["desc"]}
+            weighted_sum += score * cfg["weight"]
+            total_weight += cfg["weight"]
+            print(f"  [{cfg['key']}] fake={score:.4f} × {cfg['weight']}")
+        except Exception as e:
+            print(f"  [{cfg['key']}] error: {e}")
+
+    ensemble_score = weighted_sum / total_weight if total_weight > 0 else 0.5
+    return {"models": results, "ensemble_score": round(ensemble_score, 4)}
+
+
+# ── Forensic layers ────────────────────────────────────────────────────────────
+
+def _analyze_exif(image_bytes: bytes) -> dict:
+    result = {"score": 0.50, "exif_absent": False, "has_camera_info": False,
+              "suspicious_software": False, "ai_source": None, "details": []}
+    try:
+        import piexif
+        exif_data   = piexif.load(image_bytes)
+        has_content = any(len(exif_data.get(b, {})) > 0 for b in ["0th", "Exif", "GPS", "1st"])
+        if not has_content:
+            result["exif_absent"] = True
+            result["details"].append("EXIF absent")
+            return result
+
+        zeroth   = exif_data.get("0th", {})
+        exif_ifd = exif_data.get("Exif", {})
+        gps_ifd  = exif_data.get("GPS", {})
+
+        sw     = zeroth.get(piexif.ImageIFD.Software, b"").decode("utf-8", errors="ignore").lower()
+        desc   = zeroth.get(piexif.ImageIFD.ImageDescription, b"").decode("utf-8", errors="ignore").lower()
+        artist = zeroth.get(piexif.ImageIFD.Artist, b"").decode("utf-8", errors="ignore").lower()
+        combined = sw + " " + desc + " " + artist
+
+        ai_sources = {
+            "stable diffusion": "Stable Diffusion", "midjourney": "Midjourney",
+            "dall-e": "DALL-E", "dall·e": "DALL-E", "comfyui": "ComfyUI/SD",
+            "automatic1111": "Automatic1111/SD", "generative": "IA Générative",
+            "diffusion": "Modèle Diffusion", "novelai": "NovelAI",
+            "firefly": "Adobe Firefly", "imagen": "Google Imagen",
+            "gemini": "Google Gemini", "flux": "Flux (BFL)",
+            "ideogram": "Ideogram", "leonardo": "Leonardo.ai",
+            "adobe ai": "Adobe AI", "ai generated": "IA Générique",
+            "synthid": "Google SynthID",
+        }
+        for kw, source in ai_sources.items():
+            if kw in combined:
+                result["suspicious_software"] = True
+                result["ai_source"] = source
+                result["score"] = 0.97
+                result["details"].append(f"Source IA détectée: {source}")
+                return result
+
+        make = zeroth.get(piexif.ImageIFD.Make, b"")
+        cam  = zeroth.get(piexif.ImageIFD.Model, b"")
+        iso  = exif_ifd.get(piexif.ExifIFD.ISOSpeedRatings)
+        shut = exif_ifd.get(piexif.ExifIFD.ExposureTime)
+        gps  = bool(gps_ifd and len(gps_ifd) > 2)
+
+        if make or cam:
+            result["has_camera_info"] = True
+            result["details"].append(
+                f"Appareil: {make.decode('utf-8', errors='ignore')} {cam.decode('utf-8', errors='ignore')}".strip()
+            )
+        if gps:
+            result["details"].append("GPS présent")
+
+        if result["has_camera_info"] and gps and iso and shut:
+            result["score"] = 0.05
+        elif result["has_camera_info"] and (iso or shut):
+            result["score"] = 0.12
+        elif result["has_camera_info"]:
+            result["score"] = 0.28
+        else:
+            result["score"] = 0.55
+
+    except Exception as e:
+        result["exif_absent"] = True
+        result["details"].append(f"Erreur EXIF: {str(e)[:60]}")
+    return result
+
+
+def _analyze_fft(img: Image.Image, fc: float = 0.0) -> dict:
+    result = {"score": 0.50, "details": []}
+    try:
+        gray = np.array(img.convert("L")).astype(np.float32)
+        mag  = np.log1p(np.abs(np.fft.fftshift(np.fft.fft2(gray))))
+        h, w = mag.shape
+        cy, cx = h // 2, w // 2
+        Y, X = np.ogrid[:h, :w]
+        dist = np.sqrt((X - cx) ** 2 + (Y - cy) ** 2)
+        rl, rm = min(h, w) // 8, min(h, w) // 4
+        le = np.mean(mag[dist <= rl])
+        he = np.mean(mag[(dist > rl) & (dist <= rm)])
+        fr = he / (le + 1e-9)
+        tl = 0.18 if fc > 0.45 else 0.25
+        th = 0.85 if fc > 0.45 else 0.72
+        ss = 0.70 if fr < tl else (0.55 if fr > th else 0.20)
+        result["details"].append(f"Ratio freq. {fr:.3f}" + (" → sur-lissage IA" if fr < tl else " ✓"))
+
+        pr = np.sum((mag * (dist > 5)) > (np.mean(mag) + 5 * np.std(mag))) / (h * w)
+        ps = 0.85 if pr > 0.003 else (0.50 if pr > 0.001 else 0.15)
+        result["details"].append(f"Pics GAN: {pr:.4f}" + (" ⚠️" if pr > 0.003 else " ✓"))
+
+        result["score"] = float(0.55 * ss + 0.45 * ps)
+    except Exception as e:
+        result["details"].append(f"Erreur FFT: {str(e)[:60]}")
+    return result
+
+
+def _analyze_texture(img: Image.Image, fc: float = 0.0) -> dict:
+    result = {"score": 0.50, "details": []}
+    try:
+        arr  = np.array(img).astype(np.float32)
+        gray = np.array(img.convert("L")).astype(np.float32)
+        lap  = np.array(img.convert("L").filter(ImageFilter.FIND_EDGES)).astype(np.float32)
+        nl   = float(np.std(lap))
+
+        if arr.shape[2] >= 3:
+            r, g, b = arr[:, :, 0], arr[:, :, 1], arr[:, :, 2]
+            if float(np.mean(np.abs(r - g) < 1)) > 0.98 and float(np.mean(np.abs(g - b) < 1)) > 0.98:
+                result["score"] = 0.85
+                result["details"].append("Canaux RGB identiques → image IA synthétique")
+                return result
+
+        ts, tm = (5.0, 14.0) if fc > 0.45 else (8.0, 20.0)
+        ns = 0.75 if nl > 20.0 else (0.72 if nl < ts else (0.42 if nl < tm else 0.15))
+        result["details"].append(f"Bruit: {nl:.1f}")
+
+        h, w, bl = gray.shape[0], gray.shape[1], 32
+        stds = [np.std(gray[y:y + bl, x:x + bl]) for y in range(0, h - bl, bl) for x in range(0, w - bl, bl)]
+        u  = np.std(stds) / (np.mean(stds) + 1e-9) if stds else 0.5
+        ul, uh = (0.20, 0.50) if fc > 0.45 else (0.30, 0.60)
+        us = 0.72 if u < ul else (0.38 if u < uh else 0.15)
+        result["details"].append(f"Uniformité: {u:.3f}")
+
+        bg_ratio   = float(np.mean(gray > 200))
+        border_std = float(np.std(gray[:h // 8, :]))
+        if bg_ratio > 0.50 and border_std < 6.0:
+            studio_score = 0.88
+        elif bg_ratio > 0.50 and border_std < 15.0:
+            studio_score = 0.82
+        elif bg_ratio > 0.35 and border_std < 25.0:
+            studio_score = 0.55
+        else:
+            studio_score = 0.10
+        result["details"].append(f"Fond: {bg_ratio:.0%}")
+
+        result["score"] = float(0.35 * ns + 0.25 * us + 0.40 * studio_score)
+    except Exception as e:
+        result["details"].append(f"Erreur texture: {str(e)[:60]}")
+    return result
+
+
+def _analyze_color(img: Image.Image) -> dict:
+    result = {"score": 0.50, "details": []}
+    try:
+        arr = np.array(img.convert("RGB")).astype(np.float32)
+        r, g, b = arr[:, :, 0].flatten(), arr[:, :, 1].flatten(), arr[:, :, 2].flatten()
+
+        def channel_entropy(ch):
+            hist, _ = np.histogram(ch, bins=64, range=(0, 255), density=True)
+            hist = hist[hist > 0]
+            return float(-np.sum(hist * np.log2(hist + 1e-9)))
+
+        er, eg, eb = channel_entropy(r), channel_entropy(g), channel_entropy(b)
+        mean_entropy = (er + eg + eb) / 3.0
+        entropy_std  = float(np.std([er, eg, eb]))
+
+        if mean_entropy > 5.2 and entropy_std < 0.15:
+            ent_score = 0.72
+        elif mean_entropy > 4.8 and entropy_std < 0.25:
+            ent_score = 0.45
+        else:
+            ent_score = 0.20
+        result["details"].append(f"Entropie couleur: {mean_entropy:.2f}")
+
+        lum = 0.299 * r + 0.587 * g + 0.114 * b
+        extreme_ratio = float(np.mean((lum < 8) | (lum > 247)))
+        ext_score = 0.65 if extreme_ratio < 0.005 else (0.35 if extreme_ratio < 0.02 else 0.15)
+        result["details"].append(f"Pixels extrêmes: {extreme_ratio:.4f}")
+
+        result["score"] = float(0.60 * ent_score + 0.40 * ext_score)
+    except Exception as e:
+        result["details"].append(f"Erreur palette: {str(e)[:60]}")
+    return result
+
+
+# ── Fusion ─────────────────────────────────────────────────────────────────────
+
+def _fuse(ensemble_score: float, exif_r: dict, fft_r: dict, tex_r: dict, color_r: dict) -> dict:
+    exif_absent = exif_r.get("exif_absent", False)
+
+    if exif_r.get("suspicious_software"):
+        profile = "EXIF_IA_DETECTE"
+        w = {"ensemble": 0.20, "exif": 0.60, "fft": 0.12, "texture": 0.05, "color": 0.03}
+    elif not exif_absent and exif_r["has_camera_info"] and exif_r["score"] < 0.20:
+        profile = "EXIF_FIABLE"
+        w = {"ensemble": 0.45, "exif": 0.32, "fft": 0.12, "texture": 0.07, "color": 0.04}
+    elif exif_absent:
+        profile = "EXIF_ABSENT"
+        w = {"ensemble": 0.52, "exif": 0.00, "fft": 0.24, "texture": 0.14, "color": 0.10}
+    else:
+        profile = "STANDARD"
+        w = {"ensemble": 0.48, "exif": 0.22, "fft": 0.16, "texture": 0.09, "color": 0.05}
+
+    scores = {
+        "ensemble": ensemble_score,
+        "exif":     exif_r["score"],
+        "fft":      fft_r["score"],
+        "texture":  tex_r["score"],
+        "color":    color_r["score"],
+    }
+
+    raw = sum(w[k] * scores[k] for k in w)
+
+    # Anti-false-positive guardrails
+    if ensemble_score < 0.35 and fft_r["score"] < 0.38:
+        raw = min(raw, 0.46)
+    if not exif_absent and exif_r["has_camera_info"] and exif_r["score"] < 0.15:
+        raw = min(raw, 0.82)
+    if exif_r.get("suspicious_software") and raw < 0.85:
+        raw = max(raw, 0.90)
+
+    # High-confidence ensemble override — modern diffusion models evade forensic layers;
+    # when all ML models agree strongly, trust them over FFT/texture/color heuristics.
+    if ensemble_score >= 0.80 and not exif_r.get("has_camera_info"):
+        raw = max(raw, ensemble_score * 0.90)
+    if ensemble_score <= 0.20:
+        raw = min(raw, ensemble_score * 1.10 + 0.05)
+
+    return {
+        "fake_prob":      round(raw, 4),
+        "real_prob":      round(1.0 - raw, 4),
+        "layer_scores":   {k: round(v, 4) for k, v in scores.items()},
+        "weights_used":   {k: round(v, 2) for k, v in w.items()},
+        "fusion_profile": profile,
+        "ai_source":      exif_r.get("ai_source"),
+    }
+
+
+# ── Verdict ────────────────────────────────────────────────────────────────────
+
+def _verdict(fake_prob: float, details: dict) -> dict:
+    if fake_prob > 0.65:
+        verdict    = "DEEPFAKE"
+        confidence = "haute" if fake_prob > 0.85 else "moyenne"
+        reason     = "Artefacts de synthèse détectés."
+    elif fake_prob < 0.35:
+        verdict    = "AUTHENTIQUE"
+        confidence = "haute" if fake_prob < 0.15 else "moyenne"
+        reason     = "Aucun artefact de synthèse détecté."
+    else:
+        verdict    = "INDÉTERMINÉ"
+        confidence = "faible"
+        reason     = "Signal ambigu, analyse non concluante."
+
+    if details.get("ai_source"):
+        reason = f"Source IA identifiée dans les métadonnées: {details['ai_source']}."
+
+    return {"verdict": verdict, "confidence": confidence, "reason": reason}
+
+
+# ── Public API ─────────────────────────────────────────────────────────────────
+
+def run(img: Image.Image, image_bytes: bytes) -> dict:
+    """Full analysis: 3-model ensemble + forensic layers."""
+    ensemble_result = _run_ensemble(img, IMAGE_ENSEMBLE)
+    exif_r  = _analyze_exif(image_bytes)
+    fft_r   = _analyze_fft(img)
+    tex_r   = _analyze_texture(img)
+    color_r = _analyze_color(img)
+
+    fusion = _fuse(ensemble_result["ensemble_score"], exif_r, fft_r, tex_r, color_r)
+    verdict = _verdict(fusion["fake_prob"], fusion)
+
+    return {**verdict, **fusion, "models": ensemble_result["models"]}
+
+
+def run_fast(img: Image.Image, image_bytes: bytes) -> dict:
+    """Fast analysis: 2-model ensemble + EXIF only."""
+    ensemble_result = _run_ensemble(img, IMAGE_FAST_ENSEMBLE)
+    exif_r  = _analyze_exif(image_bytes)
+    fft_r   = {"score": 0.50, "details": []}
+    tex_r   = {"score": 0.50, "details": []}
+    color_r = {"score": 0.50, "details": []}
+
+    fusion = _fuse(ensemble_result["ensemble_score"], exif_r, fft_r, tex_r, color_r)
+    verdict = _verdict(fusion["fake_prob"], fusion)
+
+    return {**verdict, **fusion, "models": ensemble_result["models"]}

app/pipelines/text_ai.py

@@ -0,0 +1,130 @@
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+from app.core.config import TEXT_MODELS
+from app.core.device import DEVICE
+
+_cache: dict = {"tokenizers": {}, "models": {}}
+
+
+def _get_text_model(model_key: str):
+    if model_key not in _cache["models"]:
+        cfg  = TEXT_MODELS[model_key]
+        name = cfg["name"]
+        print(f"Loading {cfg['desc']} ({name})...")
+        tok = AutoTokenizer.from_pretrained(name)
+        mod = AutoModelForSequenceClassification.from_pretrained(name).to(DEVICE)
+        mod.eval()
+        _cache["tokenizers"][model_key] = tok
+        _cache["models"][model_key]     = mod
+        print(f"{model_key} ready")
+    return _cache["tokenizers"][model_key], _cache["models"][model_key]
+
+
+def _predict(model_key: str, text: str) -> float:
+    """Returns fake/AI probability 0→1, resolved dynamically from id2label."""
+    tok, model = _get_text_model(model_key)
+    inputs = tok(text, return_tensors="pt", truncation=True, max_length=512).to(model.device)
+    with torch.inference_mode():
+        probs = torch.nn.functional.softmax(model(**inputs).logits, dim=-1)[0].cpu().numpy()
+
+    id2label = {int(k): v.lower() for k, v in model.config.id2label.items()}
+    fake_kw  = ["fake", "ai", "generated", "machine", "chatgpt", "artificial", "spam", "label_1"]
+    real_kw  = ["real", "human", "authentic", "genuine", "original", "label_0"]
+    fake_idx = [i for i, lbl in id2label.items() if any(w in lbl for w in fake_kw)]
+    real_idx = [i for i, lbl in id2label.items() if any(w in lbl for w in real_kw)]
+    print(f"  [{model_key}] id2label: {id2label} | fake_idx={fake_idx} real_idx={real_idx}")
+
+    if fake_idx:
+        return float(sum(probs[i] for i in fake_idx))
+    elif real_idx:
+        return float(1.0 - sum(probs[i] for i in real_idx))
+    else:
+        # Fallback: index 1 is conventionally the positive/fake class
+        return float(probs[1]) if len(probs) > 1 else float(probs[0])
+
+
+def run_ai_detection(text: str) -> dict:
+    """Detect AI-generated text using 2-model ensemble."""
+    prob_ai1 = _predict("ai1", text)
+    prob_ai2 = _predict("ai2", text)
+    avg = (prob_ai1 + prob_ai2) / 2.0
+
+    verdict    = "TEXTE IA" if avg > 0.65 else ("TEXTE HUMAIN" if avg < 0.35 else "INDÉTERMINÉ")
+    confidence = "haute"    if avg > 0.85 or avg < 0.15 else ("moyenne" if avg > 0.70 or avg < 0.30 else "faible")
+
+    if verdict == "TEXTE IA":
+        reason = "Distribution lexicale et perplexité caractéristiques d'un LLM."
+    elif verdict == "TEXTE HUMAIN":
+        reason = "Variations stylistiques naturelles, aucun pattern IA détecté."
+    else:
+        reason = "Signal textuel ambigu, analyse non concluante."
+
+    return {
+        "verdict":    verdict,
+        "confidence": confidence,
+        "reason":     reason,
+        "ai_prob":    round(avg, 4),
+        "human_prob": round(1.0 - avg, 4),
+        "models": {
+            "fakespot":         round(prob_ai1, 4),
+            "chatgpt_detector": round(prob_ai2, 4),
+        },
+    }
+
+
+def run_fakenews_detection(text: str) -> dict:
+    """Detect fake news using 2-model weighted ensemble."""
+    prob_fn1 = _predict("fn1", text)
+    prob_fn2 = _predict("fn2", text)
+    weighted = (prob_fn1 * 0.60) + (prob_fn2 * 0.40)
+
+    verdict    = "FAKE NEWS"   if weighted > 0.65 else ("INFO VRAIE" if weighted < 0.35 else "INDÉTERMINÉ")
+    confidence = "haute"       if weighted > 0.85 or weighted < 0.15 else ("moyenne" if weighted > 0.70 or weighted < 0.30 else "faible")
+
+    if verdict == "FAKE NEWS":
+        reason = "Patterns linguistiques associés à la désinformation détectés."
+    elif verdict == "INFO VRAIE":
+        reason = "Aucun pattern de désinformation détecté."
+    else:
+        reason = "Signal ambigu, analyse non concluante."
+
+    return {
+        "verdict":        verdict,
+        "confidence":     confidence,
+        "reason":         reason,
+        "fake_prob":      round(weighted, 4),
+        "real_prob":      round(1.0 - weighted, 4),
+        "models": {
+            "distilroberta_fake_news": round(prob_fn1, 4),
+            "bert_fake_news":          round(prob_fn2, 4),
+        },
+    }
+
+
+def run_full(text: str) -> dict:
+    """Combined AI detection + fake news detection."""
+    ai_result = run_ai_detection(text)
+    fn_result = run_fakenews_detection(text)
+
+    is_ai   = ai_result["ai_prob"]   > 0.50
+    is_fake = fn_result["fake_prob"] > 0.50
+
+    if is_ai and is_fake:
+        verdict = "DANGER MAX : Fake news générée par IA"
+    elif is_ai and not is_fake:
+        verdict = "Texte IA mais contenu vérifié"
+    elif not is_ai and is_fake:
+        verdict = "Désinformation humaine"
+    else:
+        verdict = "Texte humain, contenu vérifié"
+
+    return {
+        "verdict":          verdict,
+        "ai_prob":          ai_result["ai_prob"],
+        "fake_news_prob":   fn_result["fake_prob"],
+        "is_ai_generated":  is_ai,
+        "is_fake_news":     is_fake,
+        "ai_detection":     ai_result,
+        "fakenews_detection": fn_result,
+    }

app/pipelines/video.py

@@ -0,0 +1,102 @@
+import os
+import tempfile
+
+import cv2
+import numpy as np
+from PIL import Image
+
+from app.core.config import VIDEO_ENSEMBLE
+from app.pipelines.image import _run_ensemble
+
+# Number of frames sampled per video
+MAX_FRAMES = 16
+
+
+def _extract_frames(video_path: str, n: int = MAX_FRAMES) -> list[Image.Image]:
+    """Extract n evenly-spaced frames from a video file."""
+    cap = cv2.VideoCapture(video_path)
+    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    if total <= 0:
+        cap.release()
+        raise ValueError("Impossible de lire les frames de la vidéo.")
+
+    indices = np.linspace(0, total - 1, min(n, total), dtype=int)
+    frames = []
+    for idx in indices:
+        cap.set(cv2.CAP_PROP_POS_FRAMES, int(idx))
+        ret, frame = cap.read()
+        if ret:
+            rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            frames.append(Image.fromarray(rgb))
+    cap.release()
+    return frames
+
+
+def run(video_bytes: bytes) -> dict:
+    """
+    Analyze a video for deepfake content.
+    Samples MAX_FRAMES frames evenly across the video,
+    runs the image ensemble on each, then aggregates.
+    """
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tf:
+        tf.write(video_bytes)
+        tmp_path = tf.name
+
+    try:
+        frames = _extract_frames(tmp_path)
+    finally:
+        if os.path.exists(tmp_path):
+            os.remove(tmp_path)
+
+    if not frames:
+        raise ValueError("Aucune frame exploitable extraite de la vidéo.")
+
+    # Run ensemble on each frame
+    frame_scores = []
+    per_model_scores: dict[str, list[float]] = {}
+
+    for i, frame in enumerate(frames):
+        result = _run_ensemble(frame, VIDEO_ENSEMBLE)
+        frame_scores.append(result["ensemble_score"])
+        for key, data in result["models"].items():
+            per_model_scores.setdefault(key, []).append(data["score"])
+        print(f"  Frame {i + 1}/{len(frames)} → score={result['ensemble_score']:.4f}")
+
+    scores_arr = np.array(frame_scores)
+    fake_prob  = float(np.mean(scores_arr))
+    high_ratio = float(np.mean(scores_arr > 0.65))
+
+    # Boost when most frames agree on deepfake
+    if high_ratio > 0.60:
+        fake_prob = min(fake_prob * 1.10, 1.0)
+
+    fake_prob = round(fake_prob, 4)
+
+    model_summary = {
+        key: round(float(np.mean(v)), 4)
+        for key, v in per_model_scores.items()
+    }
+
+    if fake_prob > 0.65:
+        verdict    = "DEEPFAKE"
+        confidence = "haute" if fake_prob > 0.85 else "moyenne"
+        reason     = "Artefacts de synthèse détectés sur plusieurs frames."
+    elif fake_prob < 0.35:
+        verdict    = "AUTHENTIQUE"
+        confidence = "haute" if fake_prob < 0.15 else "moyenne"
+        reason     = "Aucun artefact de synthèse détecté."
+    else:
+        verdict    = "INDÉTERMINÉ"
+        confidence = "faible"
+        reason     = "Signal ambigu — les frames présentent des résultats mixtes."
+
+    return {
+        "verdict":                 verdict,
+        "confidence":              confidence,
+        "reason":                  reason,
+        "fake_prob":               fake_prob,
+        "real_prob":               round(1.0 - fake_prob, 4),
+        "frames_analyzed":         len(frames),
+        "suspicious_frames_ratio": round(high_ratio, 4),
+        "models":                  model_summary,
+    }

app/routers/audio.py

@@ -0,0 +1,21 @@
+from fastapi import APIRouter, File, HTTPException, UploadFile
+
+from app.core.config import ALLOWED_AUDIO_MIMETYPES, MAX_FILE_SIZE
+from app.pipelines import audio as audio_pipeline
+
+router = APIRouter()
+
+
+@router.post("/analyze/audio")
+async def analyze_audio(file: UploadFile = File(...)):
+    content_type = getattr(file, "content_type", "")
+    if content_type not in ALLOWED_AUDIO_MIMETYPES:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Format non supporté: {content_type}. Formats acceptés: WAV, MP3, OGG, FLAC, M4A.",
+        )
+    contents = await file.read()
+    if len(contents) > MAX_FILE_SIZE:
+        raise HTTPException(status_code=413, detail="Fichier trop volumineux (max 20 Mo).")
+    result = audio_pipeline.run(contents)
+    return {"status": "success", **result}

app/routers/image.py

@@ -0,0 +1,47 @@
+import io
+from fastapi import APIRouter, File, HTTPException, UploadFile
+from PIL import Image
+
+from app.core.config import ALLOWED_IMAGE_MIMETYPES, MAX_FILE_SIZE
+from app.pipelines import image as image_pipeline
+
+try:
+    from pillow_heif import register_heif_opener
+    register_heif_opener()
+except ImportError:
+    pass
+
+Image.MAX_IMAGE_PIXELS = 100_000_000
+
+router = APIRouter()
+
+
+def _validate_and_read(file: UploadFile, contents: bytes) -> Image.Image:
+    content_type = getattr(file, "content_type", "")
+    if content_type not in ALLOWED_IMAGE_MIMETYPES:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Format non supporté: {content_type}. Formats acceptés: JPEG, PNG, WEBP, HEIC.",
+        )
+    if len(contents) > MAX_FILE_SIZE:
+        raise HTTPException(status_code=413, detail="Fichier trop volumineux (max 20 Mo).")
+    try:
+        return Image.open(io.BytesIO(contents)).convert("RGB")
+    except Exception:
+        raise HTTPException(status_code=400, detail="Fichier image corrompu ou illisible.")
+
+
+@router.post("/analyze/image")
+async def analyze_image(file: UploadFile = File(...)):
+    contents = await file.read()
+    img = _validate_and_read(file, contents)
+    result = image_pipeline.run(img, contents)
+    return {"status": "success", **result}
+
+
+@router.post("/analyze/image/fast")
+async def analyze_image_fast(file: UploadFile = File(...)):
+    contents = await file.read()
+    img = _validate_and_read(file, contents)
+    result = image_pipeline.run_fast(img, contents)
+    return {"status": "success", **result}

app/routers/text.py

@@ -0,0 +1,18 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from app.pipelines import text_ai as text_pipeline
+
+router = APIRouter()
+
+
+class TextRequest(BaseModel):
+    text: str
+
+
+@router.post("/analyze/text")
+async def analyze_text(body: TextRequest):
+    if not body.text or not body.text.strip():
+        raise HTTPException(status_code=400, detail="Le texte ne peut pas être vide.")
+    result = text_pipeline.run_full(body.text)
+    return {"status": "success", **result}

app/routers/video.py

@@ -0,0 +1,24 @@
+from fastapi import APIRouter, File, HTTPException, UploadFile
+
+from app.core.config import ALLOWED_VIDEO_MIMETYPES, MAX_VIDEO_SIZE
+from app.pipelines import video as video_pipeline
+
+router = APIRouter()
+
+
+@router.post("/analyze/video")
+async def analyze_video(file: UploadFile = File(...)):
+    content_type = getattr(file, "content_type", "")
+    if content_type not in ALLOWED_VIDEO_MIMETYPES:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Format non supporté: {content_type}. Formats acceptés: MP4, MOV, AVI, WEBM, MKV.",
+        )
+    contents = await file.read()
+    if len(contents) > MAX_VIDEO_SIZE:
+        raise HTTPException(status_code=413, detail="Fichier trop volumineux (max 200 Mo).")
+    try:
+        result = video_pipeline.run(contents)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    return {"status": "success", **result}

docker-compose.yml

@@ -0,0 +1,39 @@
+version: '3.9'
+
+services:
+
+  api:
+    build: .
+    container_name: kamyvision-api
+    ports:
+      - "8000:8000"
+    volumes:
+      - ./app:/app/app                          # hot reload du code
+      - model-cache:/root/.cache/huggingface    # cache modèles HF
+      - ./models:/app/models                    # modèle ONNX Assietou
+    environment:
+      - PYTHONUNBUFFERED=1
+      - HF_HOME=/root/.cache/huggingface
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 90s
+
+  frontend:
+    image: nginx:alpine
+    container_name: kamyvision-frontend
+    ports:
+      - "3000:80"
+    volumes:
+      - ./frontend:/usr/share/nginx/html:ro
+      - ./nginx.conf:/etc/nginx/conf.d/default.conf:ro
+    depends_on:
+      api:
+        condition: service_healthy
+    restart: unless-stopped
+
+volumes:
+  model-cache:    # persiste les modèles HF entre les redémarrages

nginx.conf

@@ -0,0 +1,30 @@
+server {
+    listen 80;
+    server_name localhost;
+    root /usr/share/nginx/html;
+    index index.html;
+
+    # Fichiers statiques
+    location / {
+        try_files $uri $uri/ /index.html;
+    }
+
+    # Proxy vers l'API backend
+    location /predict {
+        proxy_pass         http://api:8000/predict;
+        proxy_set_header   Host $host;
+        proxy_set_header   X-Real-IP $remote_addr;
+        proxy_read_timeout 120s;
+    }
+
+    location /analyze/ {
+        proxy_pass         http://api:8000/analyze/;
+        proxy_set_header   Host $host;
+        proxy_set_header   X-Real-IP $remote_addr;
+        proxy_read_timeout 120s;
+    }
+
+    location /health {
+        proxy_pass http://api:8000/health;
+    }
+}

requirements.txt

@@ -0,0 +1,32 @@
+# AuthenticVision — Dépendances
+# Installation : pip install -r requirements.txt
+#
+# Note Windows : opencv-python-headless 4.8.x est requis (numpy < 2 compatible)
+# Si vous avez numpy >= 2 : pip install "opencv-python-headless==4.8.1.78" "numpy>=1.24,<2.0"
+
+# ── Core IA ──────────────────────────────────────────────────────────────────
+torch>=2.0.0
+torchvision>=0.15.0
+transformers>=4.40.0
+Pillow>=10.0.0
+
+# ── API ──────────────────────────────────────────────────────────────────────
+fastapi>=0.104.0
+uvicorn[standard]>=0.24.0
+python-multipart>=0.0.6
+
+# ── Audio ────────────────────────────────────────────────────────────────────
+librosa>=0.10.0
+soundfile>=0.12.0
+
+# ── Vidéo ────────────────────────────────────────────────────────────────────
+opencv-python-headless==4.8.1.78
+
+# ── Forensique ───────────────────────────────────────────────────────────────
+piexif>=1.1.3
+numpy>=1.24,<2.0
+scikit-learn>=1.3.0
+scipy>=1.11.0
+
+# ── Optionnel : HEIC (photos iPhone) ─────────────────────────────────────────
+# pillow-heif>=0.13.0

scripts/preload_models.py

@@ -0,0 +1,62 @@
+"""
+Preload all models into HuggingFace Hub cache at Docker build time.
+This avoids cold-start downloads on the first request in production.
+"""
+from transformers import (
+    AutoFeatureExtractor,
+    AutoModelForAudioClassification,
+    AutoModelForSequenceClassification,
+    AutoModelForImageClassification,
+    AutoTokenizer,
+)
+
+import sys
+
+MODEL_GROUPS = {
+    "Audio": [
+        ("AutoFeatureExtractor", "MelodyMachine/Deepfake-audio-detection-V2"),
+        ("AutoModelForAudioClassification", "MelodyMachine/Deepfake-audio-detection-V2"),
+    ],
+    "Text": [
+        ("AutoTokenizer", "fakespot-ai/roberta-base-ai-text-detection-v1"),
+        ("AutoModelForSequenceClassification", "fakespot-ai/roberta-base-ai-text-detection-v1"),
+        ("AutoTokenizer", "Hello-SimpleAI/chatgpt-detector-roberta"),
+        ("AutoModelForSequenceClassification", "Hello-SimpleAI/chatgpt-detector-roberta"),
+        ("AutoTokenizer", "vikram71198/distilroberta-base-finetuned-fake-news-detection"),
+        ("AutoModelForSequenceClassification", "vikram71198/distilroberta-base-finetuned-fake-news-detection"),
+        ("AutoTokenizer", "jy46604790/Fake-News-Bert-Detect"),
+        ("AutoModelForSequenceClassification", "jy46604790/Fake-News-Bert-Detect"),
+    ],
+    "Image": [
+        ("AutoModelForImageClassification", "Ateeqq/ai-vs-human-image-detector"),
+        ("AutoModelForImageClassification", "prithivMLmods/AI-vs-Deepfake-vs-Real"),
+        ("AutoModelForImageClassification", "prithivMLmods/Deep-Fake-Detector-Model"),
+    ],
+}
+
+LOADERS = {
+    "AutoFeatureExtractor": AutoFeatureExtractor,
+    "AutoModelForAudioClassification": AutoModelForAudioClassification,
+    "AutoModelForSequenceClassification": AutoModelForSequenceClassification,
+    "AutoModelForImageClassification": AutoModelForImageClassification,
+    "AutoTokenizer": AutoTokenizer,
+}
+
+errors = []
+for group, models in MODEL_GROUPS.items():
+    print(f"\n── {group} ──")
+    for loader_name, model_name in models:
+        try:
+            print(f"  Downloading {model_name} ({loader_name})...", end=" ", flush=True)
+            LOADERS[loader_name].from_pretrained(model_name)
+            print("OK")
+        except Exception as e:
+            print(f"FAILED: {e}")
+            errors.append((model_name, str(e)))
+
+if errors:
+    print(f"\n⚠️  {len(errors)} model(s) failed to preload (will download on first request):")
+    for name, err in errors:
+        print(f"  - {name}: {err}")
+else:
+    print("\nAll models preloaded successfully.")