🔍 Modèle de détection d'IA

🎓 Comprendre les architectures : CNN vs ViT

🧠 Qu'est-ce qu'un CNN (Convolutional Neural Network) ?

Les CNN sont comme des détectives qui analysent une image zone par zone :

Filtres convolutifs : Ils scannent l'image par petits carrés (3×3, 5×5 pixels)
Détection progressive :
- Couches basses → Détectent les lignes, contours, textures
- Couches moyennes → Formes simples (yeux, nez, roues)
- Couches hautes → Concepts complexes (visages, voitures)
Avantages :
- ✅ Très efficaces pour détecter des patterns locaux (artefacts IA, bruit)
- ✅ Moins gourmands en calcul
- ✅ Excellents pour les détails fins (compression, pixels suspects)

🔧 Exemple d'architecture CNN : ResNet, EfficientNet, MobileNet

🌟 Qu'est-ce qu'un ViT (Vision Transformer) ?

Les ViT découpent l'image en patchs (16×16 pixels) et les traitent comme des mots dans une phrase :

Découpage en patchs : L'image devient une séquence de morceaux
Attention globale : Chaque patch peut "communiquer" avec tous les autres
Compréhension contextuelle : Analyse les relations à longue distance

Avantages :

✅ Capte les dépendances globales (cohérence style, lighting)
✅ Meilleur pour les scènes complexes
❌ Plus gourmand en données d'entraînement

🎯 Pourquoi j'ai choisi ViT pour ce projet ?

Critère	ViT (Vision Transformer)	CNN (ResNet)
Détection d'artefacts subtils	⭐⭐⭐⭐	⭐⭐⭐
Cohérence globale	⭐⭐⭐⭐⭐	⭐⭐⭐
Généralisation	⭐⭐⭐⭐⭐	⭐⭐⭐
Vitesse d'inférence	⭐⭐⭐	⭐⭐⭐⭐⭐
Taille du modèle	⭐⭐⭐	⭐⭐⭐⭐

Décision finale : ViT est plus performant pour détecter les incohérences stylistiques et la cohérence d'éclairage typiques des images générées par IA (Stable Diffusion, Midjourney, DALL-E).

🏗️ Architecture du modèle

Vision Transformer (ViT-Base) ├── Patch Embedding (16×16 patches) │ └── 224×224 image → 196 patches ├── Transformer Encoder (12 layers) │ ├── Multi-Head Self-Attention (12 heads) │ ├── Layer Normalization │ └── MLP (Feed-Forward) ├── Classification Head │ ├── Global Average Pooling │ ├── Dense(768 → 256) │ ├── ReLU + Dropout(0.3) │ └── Dense(256 → 2) [Real, AI] └── Softmax

Paramètres totaux : ~86M
Taille du modèle ONNX : ~98 MB (FP16)

📊 Dataset d'entraînement

📁 Composition

Images réelles : 50,000 images
- COCO Dataset (scènes naturelles)
- Flickr (photos utilisateurs)
- Unsplash (photographie professionnelle)
Images IA : 50,000 images
- Stable Diffusion 1.5 / 2.1 / XL
- Midjourney v5 / v6
- DALL-E 2 / 3
- Synthèses personnelles (ControlNet, LoRA)

🔧 Augmentation des données

transforms.Compose([
    transforms.RandomHorizontalFlip(p=0.5),
    transforms.RandomRotation(15),
    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),
    transforms.RandomResizedCrop(224, scale=(0.8, 1.0)),
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225]
    )
])

Stratégie d'entraînement :

Phase 1 (10 epochs) : Gel du backbone ViT, entraînement tête uniquement
Phase 2 (15 epochs) : Fine-tuning complet avec learning rate réduit (1e-5)
Validation : Split 80/10/10 (train/val/test)

🎨 Adaptation personnelle

🔄 Conversion PyTorch → ONNX

J'ai optimisé le modèle pour le **déploiement web ** sur mon site https://fmenguy.fr/odia :

import torch.onnx

# Export avec opset 17 (compatibilité maximale)
torch.onnx.export(
    model,
    dummy_input,
    "model.onnx",
    input_names=['input'],
    output_names=['output'],
    dynamic_axes={'input': {0: 'batch_size'}},
    opset_version=17
)

⚡ Optimisations appliquées

Quantization : FP32 → FP16 (réduit la taille de 50%)
Graph optimization : Fusion des ops, élimination nœuds inutiles
Batch size fixe : Évite le overhead dynamique

🌐 Application web interactive

J'ai créé une page HTML standalone qui utilise ce modèle directement dans le navigateur (pas de serveur !) :

✨ Fonctionnalités

🎯 Détection d'images IA/Réelles
- Upload d'images (drag & drop)
- Score de confiance en temps réel
- Visualisation de la heatmap (zones suspectes)
🔬 Modes d'analyse avancés
- Noise Analysis : Détecte le bruit typique des modèles de diffusion
- JPEG Artifacts : Identifie les compressions suspectes
- Edge Detection : Trouve les incohérences de contours
- Frequency Analysis : Analyse spectrale (FFT) des patterns IA
🎚️ Calibration scientifique
- Temperature Scaling : Ajuste la confiance des prédictions
- Threshold personnalisable : Vous décidez du seuil de détection
- Batch processing : Analysez plusieurs images d'un coup

🛠️ Stack technique

ONNX Runtime Web : Inférence ML 100% côté client
WebGL : Accélération GPU pour le prétraitement
Canvas API : Manipulation d'images performante
Vanilla JS : Aucune dépendance lourde (pas de React/Vue)

📦 Architecture de l'app

index.html (page unique)
├── Prétraitement des images
│   ├── Resize vers 224×224
│   ├── Normalisation ImageNet
│   └── Conversion en tenseur Float32
├── Inférence ONNX
│   ├── Chargement du modèle (cache navigateur)
│   ├── Exécution sur WebAssembly/WebGL
│   └── Post-traitement des logits
└── Visualisation
    ├── Graphiques de confiance (Canvas)
    ├── Heatmaps d'activation (Grad-CAM simplifié)
    └── Export des résultats (JSON/CSV)

🚀 Performance

Temps d'inférence : ~300-500ms par image (CPU) / ~150ms (GPU)
Taille du bundle : ~98 MB (modèle) + 5 MB (ONNX Runtime)
Compatible : Chrome, Firefox, Edge, Safari (iOS 16+)

📥 Utilisation

Option 1 : Avec Transformers.js (recommandé)

import { AutoModel } from '@xenova/transformers';

const model = await AutoModel.from_pretrained('Skarn55/ai_detection');
const prediction = await model(image);

console.log(prediction.logits); // [score_real, score_ai]

Option 2 : Avec ONNX Runtime

const session = await ort.InferenceSession.create('model.onnx');
const input = new ort.Tensor('float32', preprocessedData, [1, 3, 224, 224]);
const output = await session.run({ input });

const scores = output.output.data;
const isAI = scores[1] > scores[0];

⚠️ Limitations

Générateurs récents : Les modèles IA évoluent constamment (le réentraînement est nécessaire)
Photos éditées : Forte retouche Photoshop peut déclencher faux positifs
Compression : Images très compressées peuvent réduire la précision
Art numérique : Les dessins digitaux peuvent être confondus avec l'IA

🔬 Recherche & amélioration continue

📈 Métriques de performance

Dataset	Précision	Recall	F1-Score
Test Set	98.2%	97.8%	98.0%
Stable Diffusion	99.1%	98.6%	98.8%
DALL-E 3	96.5%	95.9%	96.2%
Midjourney v6	97.3%	96.7%	97.0%

📜 Licence

MIT License - Libre d'utilisation commerciale et personnelle

🙏 Crédits

Thanks for original model and training : Organika.ai

📧 Contact

GitHub : @Skarn55
Hugging Face : Skarn55
Demo Live : Sur mon blog

⭐ Si ce modèle vous aide, mettez une étoile sur le repo !

Downloads last month: 62