deploy: 2026-04-02T00:05:48Z

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,220 @@
+---
+title: KAMY Vision AI
+emoji: 🛡️
+colorFrom: purple
+colorTo: blue
+sdk: docker
+app_port: 8000
+pinned: false
+---
+
+# KAMY Vision AI
+
+Multimodal forensic platform for deepfake detection. Analyzes images, audio, video, and text via a layered pipeline combining Vision Transformer ensembles with deterministic forensic signals.
+
+**Production:** [app.kamydev.com](https://app.kamydev.com) · API at [oyabun-dev-kamyvision.hf.space](https://oyabun-dev-kamyvision.hf.space) · Docs at [docs.kamydev.com](https://docs.kamydev.com)
+
+---
+
+## Stack
+
+- **Backend:** Python 3.10+, FastAPI, uvicorn, PyTorch, HuggingFace Transformers
+- **Frontend:** React 18, TypeScript, Vite — deployed on Vercel
+- **API hosting:** HuggingFace Spaces (Docker)
+- **Docs:** React + custom CSS — deployed on Vercel
+
+---
+
+## Models
+
+### Image ensemble (3 ViT models, weighted average)
+
+| Model | Weight | Task |
+|-------|--------|------|
+| `Ateeqq/ai-vs-human-image-detector` | 45% | AI-generated vs human photo |
+| `prithivMLmods/AI-vs-Deepfake-vs-Real` | 35% | 3 classes: AI / Deepfake / Real |
+| `prithivMLmods/Deep-Fake-Detector-Model` | 20% | Facial deepfakes |
+
+### Forensic layers (no ML)
+
+- **EXIF** — 19 AI generator signatures detected (Gemini, DALL-E, Firefly, Midjourney, Flux, SynthID, Canva AI, Stable Diffusion...)
+- **FFT** — frequency spectrum analysis, GAN oversmoothing and periodic peak detection
+- **Texture** — local variance per 16×16 patch, unnatural uniformity in skin/background
+- **Color** — colorimetric entropy and HSV distribution, artificial saturation patterns
+
+### Fusion profiles
+
+The engine selects a profile based on EXIF results, then adjusts weights:
+
+| Profile | Trigger | EXIF weight |
+|---------|---------|-------------|
+| `EXIF_IA_DETECTE` | AI source found in metadata | 60% |
+| `EXIF_FIABLE` | Real camera identified | 32% |
+| `EXIF_ABSENT` | No metadata (stripped by social network) | 0%, FFT+texture boosted |
+| `STANDARD` | General case | 20% |
+
+### Audio (pending)
+
+`MelodyMachine/Deepfake-audio-detection-V2` (wav2vec2) — pending ONNX conversion.
+
+---
+
+## API endpoints
+
+Base URL (local): `http://localhost:8000`
+Base URL (production): `https://oyabun-dev-kamyvision.hf.space`
+
+| Method | Endpoint | Status | Description |
+|--------|----------|--------|-------------|
+| `GET` | `/health` | Stable | API and model status |
+| `POST` | `/analyze/image` | Stable | Full image analysis (3 ViT + 4 forensic layers) |
+| `POST` | `/analyze/image/fast` | Stable | Fast image analysis (2 ViT + EXIF only) |
+| `POST` | `/analyze/audio` | WIP | Synthetic voice detection |
+| `POST` | `/analyze/video` | WIP | Frame-by-frame video analysis |
+| `POST` | `/analyze/text` | WIP | AI-generated text detection |
+
+```bash
+# Health check
+curl http://localhost:8000/health
+
+# Full image analysis
+curl -X POST http://localhost:8000/analyze/image \
+  -F "file=@photo.jpg"
+
+# Fast image analysis
+curl -X POST http://localhost:8000/analyze/image/fast \
+  -F "file=@photo.jpg"
+```
+
+### Response structure
+
+```json
+{
+  "status": "success",
+  "verdict": "DEEPFAKE",
+  "fake_prob": 0.8731,
+  "real_prob": 0.1269,
+  "confidence": "high",
+  "reason": "AI source detected in EXIF metadata (Google Gemini).",
+  "fusion_profile": "EXIF_IA_DETECTE",
+  "ai_source": "Google Gemini",
+  "layer_scores": {
+    "ensemble": 0.82,
+    "exif": 0.97,
+    "fft": 0.61,
+    "texture": 0.55,
+    "color": 0.70
+  },
+  "weights_used": {
+    "ensemble": 0.20,
+    "exif": 0.60,
+    "fft": 0.08,
+    "texture": 0.07,
+    "color": 0.05
+  },
+  "models": [
+    "Ateeqq/ai-vs-human-image-detector",
+    "prithivMLmods/AI-vs-Deepfake-vs-Real",
+    "prithivMLmods/Deep-Fake-Detector-Model"
+  ]
+}
+```
+
+---
+
+## Getting started
+
+### Prerequisites
+
+| Tool | Version |
+|------|---------|
+| Python | 3.10+ |
+| Node.js | 18+ |
+| Docker | 24+ (optional) |
+
+### Backend
+
+```bash
+git clone https://github.com/oyabun-dev/deepfake_detection
+cd deepfake_detection
+
+python -m venv .venv
+source .venv/bin/activate
+
+pip install -r requirements.txt
+uvicorn app.main:app --reload --host 0.0.0.0 --port 8000
+```
+
+Models (~2–4 GB) are downloaded and cached automatically on first startup.
+
+### Frontend
+
+```bash
+cd frontend-react
+npm install
+npm run dev
+```
+
+### Docker (recommended)
+
+```bash
+docker compose up --build
+```
+
+- API: `http://localhost:8000`
+- Frontend: `http://localhost:3000`
+
+---
+
+## Project structure
+
+```
+deepfake_detection/
+├── app/
+│   ├── main.py              — FastAPI application, CORS, routers
+│   ├── core/
+│   │   ├── config.py        — Constants (formats, thresholds, max size)
+│   │   └── device.py        — Automatic CPU/GPU selection
+│   ├── routers/
+│   │   ├── image.py         — /analyze/image and /analyze/image/fast
+│   │   ├── audio.py         — /analyze/audio (WIP)
+│   │   ├── video.py         — /analyze/video (WIP)
+│   │   └── text.py          — /analyze/text (WIP)
+│   └── pipelines/
+│       └── image.py         — Full pipeline: run() and run_fast()
+├── frontend-react/          — React + Vite frontend
+├── docs/                    — React documentation site
+├── docker-compose.yml
+├── docker-compose.prod.yml
+├── Dockerfile
+└── requirements.txt
+```
+
+---
+
+## Deployment
+
+### HuggingFace Spaces (API)
+
+```bash
+pip install huggingface_hub
+huggingface-cli login
+git remote add spaces https://huggingface.co/spaces/oyabun-dev/kamyvision
+git push spaces main
+```
+
+### Vercel (frontend + docs)
+
+Both the React frontend (`frontend-react/`) and the documentation (`docs/`) are deployed on Vercel. See the [Deployment docs](https://docs.kamydev.com/deploy) for full configuration.
+
+---
+
+## Known limitations
+
+The 3 ViT models were primarily trained on GAN datasets. Performance is degraded on recent diffusion model outputs (Midjourney v6, Stable Diffusion XL, Flux.1). EXIF analysis partially compensates for images that retain their metadata.
+
+---
+
+## License
+
+MIT

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/fakenews.py

@@ -0,0 +1,97 @@
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+from deep_translator import GoogleTranslator
+
+_fn_cache = {"tokenizers": {}, "models": {}}
+
+device = torch.device("mps" if torch.backends.mps.is_available() else "cuda" if torch.cuda.is_available() else "cpu")
+
+def get_or_load_fn_model(model_key):
+    fn_models_map = {
+        "fn1": "vikram71198/distilroberta-base-finetuned-fake-news-detection",
+        "fn2": "jy46604790/Fake-News-Bert-Detect"
+    }
+    
+    if model_key not in _fn_cache["models"]:
+        print(f"📥 Chargement du modèle Fake News {model_key}...")
+        repo = fn_models_map[model_key]
+        tok = AutoTokenizer.from_pretrained(repo)
+        mod = AutoModelForSequenceClassification.from_pretrained(repo).to(device)
+        mod.eval()
+        _fn_cache["tokenizers"][model_key] = tok
+        _fn_cache["models"][model_key] = mod
+        
+    return _fn_cache["tokenizers"][model_key], _fn_cache["models"][model_key]
+
+def apply_local_context_guardrails(text: str, fake_prob: float) -> float:
+    """
+    Réduit artificiellement le score de Fake News si des entités sénégalaises
+    ou africaines fiables sont mentionnées. Empêche le biais "Out-Of-Distribution".
+    """
+    text_lower = text.lower()
+    
+    # Mots-clés de crédibilité locaux ou institutions
+    credible_keywords = [
+        "aps", "agence de presse sénégalaise", "rts", "radiodiffusion télévision sénégalaise",
+        "le soleil", "seneweb", "dakaractu", "igfm", "tfm", "walfadjri", "sud quotidien"
+    ]
+    
+    # Noms propres souvent détectés comme du bruit par un modèle américain
+    local_entities = [
+        "dakar", "sénégal", "senegal", "macky sall", "ousmane sonko", "diomaye faye",
+        "bassirou diomaye", "pastef", "apr", "assemblée nationale", "ucad"
+    ]
+    
+    credible_matches = sum(1 for kw in credible_keywords if kw in text_lower)
+    entity_matches = sum(1 for kw in local_entities if kw in text_lower)
+    
+    # Applique une réduction progressive du fake prob
+    discount = 0.0
+    if credible_matches > 0:
+        discount += 0.25 * credible_matches
+    if entity_matches > 0:
+        discount += 0.15 * entity_matches
+        
+    discount = min(discount, 0.45) # Max discount 45%
+    
+    adjusted_prob = float(max(0.01, fake_prob - discount))
+    return adjusted_prob
+
+
+def analyze_fakenews_text(text: str) -> dict:
+    # 1. TRADUCTION MULTILINGUE (Hackathon Solution)
+    # On traduit le texte peu importe sa langue (auto) vers l'anglais
+    # Cela permet d'utiliser les puissants modèles Fake News anglophones sur du Français, Wolof (si supporté), etc.
+    try:
+        translated_text = GoogleTranslator(source='auto', target='en').translate(text)
+        print("📝 Traduction en cours pour analyse FakeNews...")
+    except Exception as e:
+        print(f"⚠️ Erreur de traduction : {e}. Utilisation du texte original.")
+        translated_text = text
+
+    def _predict(model_key, txt):
+        tokenizer, model = get_or_load_fn_model(model_key)
+        inputs = tokenizer(txt, return_tensors="pt", truncation=True, max_length=512).to(device)
+        with torch.inference_mode():
+            outputs = model(**inputs)
+            probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
+            fake_prob = float(probs[0][1])
+        return fake_prob
+
+    # 2. INFERENCE SUR LE TEXTE TRADUIT (EN ANGLAIS)
+    prob1 = _predict("fn1", translated_text)
+    prob2 = _predict("fn2", translated_text)
+    weighted_fake_prob = (prob1 * 0.60) + (prob2 * 0.40)
+    
+    # 3. GARDE-FOUS CONTEXTUELS LOCAUX (SÉNÉGAL)
+    # Appliqué sur le texte *original* (pas traduit)
+    adjusted_prob = apply_local_context_guardrails(text, weighted_fake_prob)
+    
+    return {
+        "verdict": "FAKE NEWS" if adjusted_prob > 0.50 else "INFO VRAIE",
+        "fake_prob": adjusted_prob,
+        "real_prob": 1.0 - adjusted_prob,
+        "is_fake": adjusted_prob > 0.50,
+        "raw_fake_prob": weighted_fake_prob, # Pour le débug
+        "was_translated": translated_text != text
+    }

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,44 @@
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+_text_cache = {"tokenizers": {}, "models": {}}
+
+device = torch.device("mps" if torch.backends.mps.is_available() else "cuda" if torch.cuda.is_available() else "cpu")
+
+def get_or_load_ai_model(model_key):
+    text_models_map = {
+        "ai1": "fakespot-ai/roberta-base-ai-text-detection-v1",
+        "ai2": "Hello-SimpleAI/chatgpt-detector-roberta"
+    }
+    
+    if model_key not in _text_cache["models"]:
+        print(f"📥 Chargement du modèle texte {model_key}...")
+        repo = text_models_map[model_key]
+        tok = AutoTokenizer.from_pretrained(repo)
+        mod = AutoModelForSequenceClassification.from_pretrained(repo).to(device)
+        mod.eval()
+        _text_cache["tokenizers"][model_key] = tok
+        _text_cache["models"][model_key] = mod
+        
+    return _text_cache["tokenizers"][model_key], _text_cache["models"][model_key]
+
+def analyze_ai_text(text: str) -> dict:
+    def _predict(model_key, txt):
+        tokenizer, model = get_or_load_ai_model(model_key)
+        inputs = tokenizer(txt, return_tensors="pt", truncation=True, max_length=512).to(device)
+        with torch.inference_mode():
+            outputs = model(**inputs)
+            probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
+            fake_prob = float(probs[0][1])
+        return fake_prob
+
+    prob1 = _predict("ai1", text)
+    prob2 = _predict("ai2", text)
+    avg_ai_prob = (prob1 + prob2) / 2.0
+    
+    return {
+        "verdict": "TEXTE IA" if avg_ai_prob > 0.50 else "TEXTE HUMAIN",
+        "ai_prob": avg_ai_prob,
+        "human_prob": 1.0 - avg_ai_prob,
+        "is_ai": avg_ai_prob > 0.50
+    }

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,62 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from app.pipelines.text_ai import analyze_ai_text
+from app.pipelines.fakenews import analyze_fakenews_text
+
+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.")
+    res = analyze_ai_text(body.text)
+    return {
+        "status": "success",
+        "verdict": res["verdict"],
+        "ai_prob": res["ai_prob"],
+        "human_prob": res["human_prob"]
+    }
+
+@router.post("/analyze/fakenews")
+async def analyze_fakenews(body: TextRequest):
+    if not body.text or not body.text.strip():
+        raise HTTPException(status_code=400, detail="Le texte ne peut pas être vide.")
+    res = analyze_fakenews_text(body.text)
+    return {
+        "status": "success",
+        "verdict": res["verdict"],
+        "fake_prob": res["fake_prob"],
+        "real_prob": res["real_prob"]
+    }
+
+@router.post("/analyze/text/full")
+async def analyze_text_full(body: TextRequest):
+    if not body.text or not body.text.strip():
+        raise HTTPException(status_code=400, detail="Le texte ne peut pas être vide.")
+    res_ai = analyze_ai_text(body.text)
+    res_fn = analyze_fakenews_text(body.text)
+    
+    is_ai = res_ai["is_ai"]
+    is_fake = res_fn["is_fake"]
+    
+    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 {
+        "status": "success",
+        "verdict": verdict,
+        "ai_prob": res_ai["ai_prob"],
+        "fake_news_prob": res_fn["fake_prob"],
+        "is_ai_generated": is_ai,
+        "is_fake_news": is_fake
+    }

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,14 @@
+fastapi
+uvicorn[standard]
+python-multipart
+torch
+transformers
+Pillow
+pillow-heif
+librosa
+soundfile
+numpy
+mediapipe
+opencv-python-headless
+optimum[onnxruntime]
+deep-translator

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.")

scripts/train_ai_detector.py

@@ -0,0 +1,90 @@
+import os
+import torch
+import pandas as pd
+from datasets import Dataset, load_dataset
+from transformers import (
+    AutoTokenizer,
+    AutoModelForSequenceClassification,
+    TrainingArguments,
+    Trainer,
+    DataCollatorWithPadding
+)
+
+# 1. Configuration pour Colab / GPU
+MODEL_NAME = "xlm-roberta-base" # Multilingue pour supporter le Français
+OUTPUT_DIR = "./ai_results"
+SAVE_DIR = "./ai_detector_model"
+
+def train():
+    # 2. Chargement des données
+    # Sur Colab, vous pouvez charger directement depuis Hugging Face :
+    # Exemple avec HC3 (Human-ChatGPT Comparison Corpus) en Français
+    print("📥 Chargement du dataset HC3 (Français)...")
+    dataset = load_dataset("Hello-SimpleAI/HC3", "french", split="train")
+    
+    # Transformation du format HC3 en classification binaire
+    # HC3 a 'human_answers' et 'chatgpt_answers'
+    # On va créer un dataset plat : [texte, label]
+    texts = []
+    labels = []
+    for item in dataset:
+        for ans in item['human_answers']:
+            texts.append(ans)
+            labels.append(0) # Humain
+        for ans in item['chatgpt_answers']:
+            texts.append(ans)
+            labels.append(1) # AI
+            
+    df = pd.DataFrame({"text": texts, "label": labels})
+    
+    # Échantillonnage pour la démo Hackathon (rapide)
+    MAX_SAMPLES = 5000
+    if len(df) > MAX_SAMPLES:
+        df = df.sample(MAX_SAMPLES, random_state=42).reset_index(drop=True)
+    
+    print(f"✅ Dataset prêt : {len(df)} exemples.")
+    hf_dataset = Dataset.from_pandas(df)
+
+    # 3. Tokenization
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+
+    def preprocess_function(examples):
+        return tokenizer(examples["text"], truncation=True, padding=True, max_length=512)
+
+    tokenized_dataset = hf_dataset.map(preprocess_function, batched=True)
+
+    # 4. Chargement du modèle
+    model = AutoModelForSequenceClassification.from_pretrained(MODEL_NAME, num_labels=2)
+
+    # 5. Arguments d'entraînement optimisés pour Colab (GPU)
+    training_args = TrainingArguments(
+        output_dir=OUTPUT_DIR,
+        learning_rate=2e-5,
+        per_device_train_batch_size=8,
+        num_train_epochs=1,
+        weight_decay=0.01,
+        save_strategy="epoch",
+        fp16=torch.cuda.is_available(), # Active l'accélération si GPU présent
+        push_to_hub=False,
+    )
+
+    # 6. Trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=tokenized_dataset,
+        tokenizer=tokenizer,
+        data_collator=DataCollatorWithPadding(tokenizer=tokenizer),
+    )
+
+    # 7. Lancement
+    print("🚀 Début de l'entraînement sur Colab...")
+    trainer.train()
+
+    # 8. Sauvegarde
+    model.save_pretrained(SAVE_DIR)
+    tokenizer.save_pretrained(SAVE_DIR)
+    print(f"✅ Modèle sauvegardé dans {SAVE_DIR}")
+
+if __name__ == "__main__":
+    train()

scripts/train_fake_news.py

@@ -0,0 +1,88 @@
+import os
+import torch
+import pandas as pd
+from datasets import Dataset
+from transformers import (
+    AutoTokenizer,
+    AutoModelForSequenceClassification,
+    TrainingArguments,
+    Trainer,
+    DataCollatorWithPadding
+)
+
+# 1. Configuration
+# Pour le Français, on utilise un modèle multilingue (XLM-RoBERTa) ou dédié (CamemBERT)
+MODEL_NAME = "xlm-roberta-base" 
+OUTPUT_DIR = "./results"
+SAVE_DIR = "./fakenews_model_fr"
+
+def train():
+    # 2. Chargement des données (Exemple avec un CSV fictif)
+    # Assurez-vous d'avoir un CSV avec au moins 'text' et 'label' (0=Real, 1=Fake)
+    if not os.path.exists("data.csv"):
+        print("Erreur: data.csv non trouvé. Création d'un exemple factice...")
+        data = {
+            "text": [
+                "Le président a inauguré une nouvelle école ce matin à Paris.", 
+                "Des extraterrestres ont envahi la tour Eiffel hier soir !"
+            ],
+            "label": [0, 1]
+        }
+        pd.DataFrame(data).to_csv("data.csv", index=False)
+
+    df = pd.read_csv("data.csv")
+    
+    # Nettoyage des données : Supprimer les NaNs et s'assurer que 'text' est de type string
+    df = df.dropna(subset=['text', 'label'])
+    df['text'] = df['text'].astype(str)
+    df = df[df['text'].str.len() > 10]
+
+    # OPTIMISATION HACKATHON 🚀 : Échantillon aléatoire pour aller plus vite
+    MAX_SAMPLES = 2000
+    if len(df) > MAX_SAMPLES:
+        print(f"Extraction d'un échantillon aléatoire de {MAX_SAMPLES} sur {len(df)} lignes...")
+        df = df.sample(MAX_SAMPLES, random_state=42).reset_index(drop=True)
+
+    dataset = Dataset.from_pandas(df.reset_index(drop=True))
+
+    # 3. Tokenization
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+
+    def preprocess_function(examples):
+        return tokenizer(examples["text"], truncation=True, padding=True)
+
+    tokenized_dataset = dataset.map(preprocess_function, batched=True)
+
+    # 4. Chargement du modèle
+    model = AutoModelForSequenceClassification.from_pretrained(MODEL_NAME, num_labels=2)
+
+    # 5. Arguments d'entraînement
+    training_args = TrainingArguments(
+        output_dir=OUTPUT_DIR,
+        learning_rate=2e-5,
+        per_device_train_batch_size=8, # Réduit pour économiser la RAM
+        num_train_epochs=1, # 1 seule passe pour le hackathon
+        weight_decay=0.01,
+        save_strategy="epoch",
+    )
+
+    # 6. Trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=tokenized_dataset,
+        tokenizer=tokenizer,
+        data_collator=DataCollatorWithPadding(tokenizer=tokenizer),
+    )
+
+    # 7. Lancement de l'entraînement
+    print("Début de l'entraînement...")
+    trainer.train()
+
+    # 8. Sauvegarde
+    model.save_pretrained(SAVE_DIR)
+    tokenizer.save_pretrained(SAVE_DIR)
+    print(f"Modèle sauvegardé dans {SAVE_DIR}")
+
+if __name__ == "__main__":
+    train()