Minosse

AI-generated image detection — no ML model, just signal processing.

pip install minosse

That's it — only numpy, pillow, and scipy come along. No GPU, no model weights, no network calls.

Minosse looks for tell-tale traces that diffusion models and neural upsamplers leave behind: ringing halos around text, noise in flat regions that shouldn't have any, and a synthetic signature in the high-frequency spectrum.

An image is flagged if any signal fires; the fired signals are reported along with the raw feature values.

# Analyse a single image
minosse path/to/image.png

# Analyse multiple images with visual proof sheets
minosse --proof results/ image1.png image2.jpg

from minosse import analyze, analyze_path, Result

# From a file path
r = analyze_path("image.png")
print(r.verdict)       # "likely AI-generated/edited" or "likely clean"
print(r.reasons)       # e.g. ["ringing", "synthetic-noise"]
print(r.decay)         # ringing feature value
print(r.vhf_mf)        # spectral ratio feature value
print(r.flat_noise)    # flat-region noise feature value
print(r.resid_std)     # overall residual noise

# From a PIL Image
from PIL import Image
img = Image.open("image.png")
r = analyze(img)

from minosse import analyze, evidence
from PIL import Image

img = Image.open("image.png")
r = analyze(img)
sheet = evidence.render(img, r)
sheet.save("proof.png")

The --proof flag writes <name>_proof.png: a side-by-side sheet with the original image next to one panel per fired signal, with the artifact evidence burned in as a red heatmap.

Heat is scaled absolutely (calibrated to the detection thresholds), so clean images render dark — the glow itself is the proof. For ringing, the map only shows oscillation in regions that should be smooth (8–40 px from strong edges, locally flat at coarse scale), so legitimate texture doesn't light up.

git clone https://github.com/cesp99/Minosse.git
cd Minosse
python -m venv .venv
.venv/bin/pip install -r requirements.txt

.venv/bin/python -m minosse path/to/image.png
.venv/bin/python -m minosse --proof results/ image1.png image2.jpg

minosse/
├── minosse/
│   ├── __init__.py      # Public API: analyze, analyze_path, Result
│   ├── __main__.py      # python -m minosse entry point
│   ├── cli.py           # Argument parsing and CLI loop
│   ├── detector.py      # Feature extraction + threshold logic
│   └── evidence.py      # Visual proof sheet renderer
├── results/             # Default --proof output directory
├── requirements.txt     # numpy, pillow, scipy
└── README.md

1. Preprocessing — the image is converted to RGB and downscaled if its longest edge exceeds 1600 px.
2. Feature extraction (detector._features()) — three independent signal-processing pipelines compute scalar features from the grayscale luminance.
3. Thresholding — each feature is compared against a tuned threshold; if it exceeds the threshold the corresponding signal is flagged.
4. Verdict — if any signal fires, the image is marked likely AI-generated/edited; otherwise it's likely clean.

For a deeper explanation of each signal, see docs/signals.md.

The thresholds are calibrated on a small set of examples and should be re-validated as more AI samples are added. See docs/tuning.md for instructions on re-tuning.

• 📦 PyPI: https://pypi.org/project/minosse/
• 🐙 Source: https://github.com/cesp99/Minosse
• 🐛 Issues: https://github.com/cesp99/Minosse/issues
• 📊 Download stats: https://pypistats.org/packages/minosse

MIT