Case study

QBioForge - Quantum Deepfake Forensics

QBioForge takes the physiological forensic approach and packages it as a self-contained, demo-ready application. A Gradio interface accepts video, image, or audio, runs the analysis pipeline, and returns a REAL / DEEPFAKE verdict with a confidence score and supporting metrics. The whole thing builds into a container so it can be run and shared without a Python environment being set up by hand.

Open the live demo All projects

The live demo is served from a local host through a temporary Cloudflare tunnel, so it is only reachable while that host is running. The link lives on the homepage project card.

Overview and objective

The earlier unified detector proved out the forensics but shipped as a developer-facing Flask tool with loose scripts. The objective here was a single, portable artifact: one Gradio app, one requirements file, and one Docker image that behaves the same on a laptop, in a container, or on a hosted Space.

QBioForge inspects three input types - video, image, and audio - and reports a verdict with forensic metrics. The project is explicitly framed as a research prototype: results are not treated as definitive evidence, and it is not a medical, clinical, or forensic-grade instrument.

Scope note

PennyLane is used here for classical numerical simulation of quantum dynamics (state evolution, purity, entropy). No quantum hardware is accessed and no quantum advantage is claimed.

System architecture

A thin Gradio shell around a self-contained forensic core. The core is organised so the packaged modules can be imported and tested without the UI.

Component map of the QBioForge application A four-stage stack: the Gradio web app feeds the forensic core packages, which produce a simulated quantum state, which feeds a deterministic rule-based detector. Gradio web app (app.py) video, image and audio tabs Docker: python:3.11-slim, port 7860 Forensic core (qbioforge/) preprocessing, quantum, model, experiments modules Quantum-state simulation PennyLane default.mixed on CPU state evolution, purity, entropy Deterministic detector rule-based, no learned video weights calibrated thresholds; 2+ violations
Component map. The preprocessing package provides face detection, rPPG, optical flow, micro-expression extraction, and normalisation; the model package holds the detectors, bundled audio classifier, and calibrated thresholds. Model assets are loaded by project-relative paths so the image works regardless of the working directory.

How data moves through the system

  1. Submit media

    An operator uploads a clip, still image, or audio file through the Gradio interface, which routes it to the matching analysis path.

    Implemented
  2. Face detection and sample gating

    Video analysis requires a sufficiently visible face. Shots with very small, distant, occluded, or extreme-profile faces may yield zero usable frames and end with an explicit error rather than a fabricated verdict.

    Implemented
  3. Biological feature extraction

    rPPG, optical-flow, and micro-expression signals are extracted and normalised. The rPPG path needs enough face-detected samples for bandpass filtering; shorter clips are reported honestly as insufficient.

    Implemented
  4. Quantum-state simulation

    Features are encoded into a simulated quantum state and evolved; observables such as purity and entropy are measured as a complexity signal.

    Simulated
  5. Rule-based detector

    Rather than learning from data, the detector enforces biological plausibility: measured metrics are compared against calibrated boundaries and a verdict is issued.

    Implemented
  6. Verdict surfaced in the UI

    The real/deepfake result, a confidence score, and the supporting metrics are returned to the Gradio interface.

    Implemented

Verified technology stack

  • InterfaceGradio (app.py as the Space entry point)
  • LanguagePython 3.11
  • Vision and signalsOpenCV, MediaPipe, NumPy, SciPy
  • Audio MLlibrosa, scikit-learn, joblib
  • Quantum simulationPennyLane (classical numerical simulation)
  • PackagingDockerfile built on python:3.11-slim, binds 0.0.0.0, reads PORT (default 7860)
  • Bundled assetsmodel/audio_classifier.pkl, model/scaler.pkl, model/calibrated_thresholds.json

Key technical decisions and trade-offs

Enforce physiology instead of learning it

The detector is deliberately rule-based. It does not train on labelled fakes; it checks whether the extracted signals remain biologically plausible. This keeps the reasoning legible and avoids a training-set dependency, but inherits the fragility of fixed boundaries.

Project-relative asset loading

Model files and thresholds are resolved relative to the project rather than the working directory, so the container, a local run, and a hosted Space all load the same bundled assets without path configuration.

CPU-only, no GPU models required

Nothing in the runtime requires a GPU or external credentials, which keeps the image portable and the demo cheap to host.

One Gradio app over a bespoke Flask UI

Replacing the earlier Flask interface with Gradio reduced interface code and made the project directly runnable as a Space, trading some UI customisation for portability.

Challenges and limitations

  • Prototype, not evidence. Results should not be treated as definitive proof of manipulation or authenticity, and the system is not a forensic-grade instrument.
  • Input sensitivity. Video needs a clearly visible face with enough frames for filtering; unsuitable clips are rejected rather than guessed at.
  • CPU processing. Long clips can take noticeable time because all analysis runs on the CPU.
  • Ephemeral demo hosting. The public demo runs through a temporary tunnel from a local host and is offline whenever that host is not running.
  • No accuracy figures. The repository states no validated accuracy metrics, so none are asserted on this page.
  • Deployment not finished. The Cloud Run container path exists but the application has not been deployed there, and a permanent tunnel is not yet set up.

Reproducing and exploring it

Run it directly from a virtual environment:

python -m venv .venv
.venv\Scripts\activate
pip install -r requirements.txt
python app.py

Or build and run the container:

docker build -t qbioforge .
docker run -p 7860:7860 -e PORT=7860 qbioforge

The app then serves the Gradio interface on port 7860. There is no public source repository for this project; it is documented here and through its local deployment files.

Future engineering work

Future work - not implemented
  • Stand up a permanent named tunnel so the public demo no longer depends on an ephemeral URL.
  • Evaluate the detector on public deepfake datasets to substantiate its behaviour.
  • Deploy the existing container to a managed platform such as Cloud Run.

QBioForge packages the forensic approach first explored in the unified detector, and shares its edge-sensing spirit with the spectrometer project.

Unified Deepfake Detection Microplastic Detection Back to all projects