AI Image Analyzer — weights (alpha, v0.2)
Two small EfficientNet-B0 models used by the AI Image Analyzer library:
| File | What it does | Size |
|---|---|---|
detector_v2.onnx (+ .json, .pt) | real vs AI-generated, plus a 6×6 evidence map (exact per-region contribution to the decision) | 15 MB |
attribution_v1.onnx (+ .json, .pt) | which of 11 generators made an AI image (abstains below 0.80 confidence) | 15 MB |
Alpha release — not a reliable detector for arbitrary images. It is right ~84% of the time on unseen images from generators it was trained on, ~71% on a different benchmark with new generators, and flags some real photos as AI (13.5% of RAISE camera raws). Do not use a single score to make decisions about a person or an image's origin. Full analysis: REPORT.md.
Use with the library (recommended)
pip install git+https://github.com/Dadhichi-Sarker-Shayon/AI-Generated-Image-Analyzer.git # weights are bundled
from ai_image_analyzer import AIImageAnalyzer
report = AIImageAnalyzer(use_clip=False).analyze("photo.jpg")
print(report.verdict, report.ai_probability, report.attribution.specific_model)
Use the ONNX file directly
Preprocessing must match training: center-crop square → 256 px (Lanczos) → JPEG quality 95 → resize 192 px → ImageNet normalization.
import io, json, numpy as np, onnxruntime as ort
from PIL import Image
meta = json.load(open("detector_v2.json"))
def preprocess(path):
im = Image.open(path).convert("RGB")
w, h = im.size; s = min(w, h); left, top = (w - s) // 2, (h - s) // 2
im = im.crop((left, top, left + s, top + s)).resize((256, 256), Image.LANCZOS)
buf = io.BytesIO(); im.save(buf, "JPEG", quality=95)
im = Image.open(buf).convert("RGB").resize((meta["input_size"], meta["input_size"]), Image.BILINEAR)
x = (np.asarray(im, np.float32) / 255 - np.array(meta["mean"], np.float32)) / np.array(meta["std"], np.float32)
return x.transpose(2, 0, 1)[None].astype(np.float32)
sess = ort.InferenceSession("detector_v2.onnx", providers=["CPUExecutionProvider"])
probs, evidence = sess.run(None, {"pixel_values": preprocess("photo.jpg")})
print("P(AI) =", float(probs[0, 1])) # probs = [P(real), P(AI)]
# evidence: (1, 6, 6); sum(evidence) + meta["evidence_bias"] == logit_AI - logit_real (exact)
attribution_v1.onnx takes the same input and returns 11 probabilities in the order of classes in attribution_v1.json
(adm, biggan, dalle3, glide, midjourney, sd15, sd21, sd3, sdxl, vqdm, wukong). Treat the answer as "unknown" if the top probability is below min_confidence (0.80).
Training
- Architecture:
efficientnet_b0(timm), ImageNet-pretrained, 192×192 input, 2-class head (detector) / 11-class head (attribution). - Data: 70,000 training images — Defactify (COCO real vs SD 2.1, SDXL, SD3, DALL-E 3, Midjourney v6; 42,000) + Tiny-GenImage (ImageNet real vs ADM, BigGAN, GLIDE, Midjourney, SD 1.x, VQDM, Wukong; 28,000). 21,000 real / 49,000 AI. Every image: center-crop → 256 px → JPEG q95 (removes file-format/resolution shortcuts).
- Recipe: AdamW lr 1e-4, batch 32 (16×2 accumulation), label smoothing 0.1, class-balanced sampling, horizontal flip + color jitter, fp16, early stopping on validation AUC (detector: 15 epochs of 28k samples, best epoch 11; attribution: 6 epochs, best epoch 5).
- Hardware: one GTX 1650 (4 GB); ~2 h for the detector.
Evaluation (threshold 0.5; 95% CIs in the report)
| Benchmark | Images | AUC | Accuracy | Real kept real | AI caught |
|---|---|---|---|---|---|
| Validation (used to select the epoch — optimistic) | 16,000 | 0.983 | 94.5% | 94.6% | 94.5% |
| Defactify test (unseen images; 5 generators vs COCO) | 11,250 | 0.974 | 83.9% | 97.8% | 81.1% |
| Synthbuster-plus test (unseen; 13 generators incl. FLUX, Imagen 3, Firefly; real = RAISE raws) | 2,800 | 0.856 | 70.6% | 86.5% | 69.3% |
At a 1% false-positive rate the detector catches 70% (Defactify) and only 9% (Synthbuster-plus) of AI images. Synthbuster-plus detection by generator: DALL-E 3 98%, GLIDE 96%, SDXL 91%, FLUX.1-schnell 83%, Midjourney v5 81%, SD 1.x 66–69%, FLUX.1-dev 68%, SD3-medium 60%, Firefly 53%, SD 2 52%, Imagen 3 46%, DALL-E 2 42%.
Attribution: 78% correct on unseen images of the training pipeline, 47.5% on a different benchmark. At the shipped 0.80 threshold it answers ~26% of images with 87% precision, and names ~12% of images from generators it never saw (e.g. FLUX) with a wrong label.
Intended use and limitations
Intended: research, education, building explainable-forensics prototypes, one weak signal among several. Out of scope: verifying the authenticity of a specific image for legal, journalistic, academic-integrity or moderation decisions; detecting edited (inpainted) real photos; adversarial settings.
- Generalization to new generators and pipelines is limited (see above); newer high-fidelity generators (Imagen 3, Firefly) are mostly missed.
- False positives occur on real photos, especially raw-camera images (13.5% on RAISE).
- Scores change with re-encoding (same photo: JPEG 0.20, WebP 0.27, grayscale 0.16); robustness to compression/resizing/screenshots was not systematically tested.
- The probability is not calibrated. The input is reduced to 192 px, discarding fine pixel-level artifacts.
- Real and AI images in the training data come from different content distributions (COCO/ImageNet vs prompt-driven images), so content or style may contribute to the signal.
- The evidence map shows where the network's evidence lies (typically spread over the whole image); it is not proof of generation.
License
CC BY-NC-SA 4.0 — non-commercial, attribution, share-alike. The weights inherit this from the most restrictive training dataset (Tiny-GenImage, CC BY-NC-SA 4.0); two other datasets declare no license. This is the authors' conservative reading, not legal advice; see LICENSE-WEIGHTS.md. The library code is MIT.
Acknowledgements
Datasets: GenImage / Tiny-GenImage, Defactify (arXiv:2601.00553), Synthbuster, MS COCO, RAISE. Models/libraries: EfficientNet (Tan & Le 2019), timm, ONNX Runtime. Details in NOTICE.md.