chore: exclude test_app from repo (deploy as separate HF Space)

.gitignore

@@ -1,3 +1,4 @@
 .agents/
 __pycache__/
 *.pyc
+test_app/

test_app/.gitignore

@@ -1 +0,0 @@
-__pycache__/

test_app/app.py

@@ -1,347 +0,0 @@
-"""
-Local test app — 3 tabs: PyTorch vs ONNX comparison, benchmarks, help.
-Auto-detects GPU, falls back to CPU.
-"""
-import os
-import time
-import gradio as gr
-import numpy as np
-import torch
-from PIL import Image
-from transformers import ViTForImageClassification, ViTImageProcessor
-
-BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-ONNX_DIR = os.path.join(BASE_DIR, "onnx")
-IMAGES_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "images")
-
-ONNX_VARIANTS = {
-    "full   (84 MB)":  "model.onnx",
-    "int8   (22 MB)":  "model_int8.onnx",
-    "uint8  (22 MB)":  "model_uint8.onnx",
-    "qntzd  (22 MB)":  "model_quantized.onnx",
-    "q4     (16 MB)":  "model_q4.onnx",
-}
-
-# ── Device detection ──────────────────────────────────────────────────
-
-pt_device = "cuda" if torch.cuda.is_available() else "cpu"
-print(f"[PyTorch] device={pt_device}")
-
-import onnxruntime as ort
-_onnx_providers = ort.get_available_providers()
-onnx_device = "GPU" if any("CUDA" in p or "TensorRT" in p for p in _onnx_providers) else "CPU"
-print(f"[ONNX]    providers={_onnx_providers} -> {onnx_device}")
-
-# ── PyTorch ───────────────────────────────────────────────────────────
-
-pt_model = ViTForImageClassification.from_pretrained(BASE_DIR, local_files_only=True)
-pt_model.to(pt_device).eval()
-pt_processor = ViTImageProcessor.from_pretrained(BASE_DIR, local_files_only=True)
-print(f"[PyTorch]  heads={pt_model.config.num_attention_heads}  "
-      f"classes={pt_model.config.num_classes}  "
-      f"hidden={pt_model.config.hidden_size}")
-
-# ── Old timm-based model (deprecated path) ────────────────────────────
-
-import sys
-SCRIPTS_DIR = os.path.join(BASE_DIR, "scripts")
-if SCRIPTS_DIR not in sys.path:
-    sys.path.insert(0, SCRIPTS_DIR)
-from modeling_vit_classifier import ViTClassifier as OldViTClassifier
-
-def _load_old_model():
-    old_cfg = json.load(open(os.path.join(os.path.dirname(__file__), "old_config.json")))
-    device = old_cfg["device"]
-    if not torch.cuda.is_available():
-        device = "cpu"
-    # Resolve checkpoint path relative to repo root (one level up from test_app/)
-    ckpt_rel = old_cfg["checkpoint_path"]
-    ckpt_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), ckpt_rel)
-    if not os.path.exists(ckpt_path):
-        raise FileNotFoundError(f"Checkpoint not found: {ckpt_path}")
-    model = OldViTClassifier(old_cfg, device=device)
-    ckpt = torch.load(ckpt_path, map_location=device, weights_only=False)
-    model.load_state_dict(ckpt["model"])
-    return model.to(device).eval()
-
-import json
-_old_model = None
-_old_device = None
-
-def _get_old_model():
-    global _old_model, _old_device
-    if _old_model is None:
-        _old_device = "cuda" if torch.cuda.is_available() else "cpu"
-        _old_model = _load_old_model()
-    return _old_model, _old_device
-
-_onnx_sessions = {}
-def _get_onnx(variant):
-    if variant not in _onnx_sessions:
-        path = os.path.join(ONNX_DIR, ONNX_VARIANTS[variant])
-        _onnx_sessions[variant] = ort.InferenceSession(path, providers=_onnx_providers)
-    return _onnx_sessions[variant]
-
-def _onnx_preprocess(image):
-    w, h = image.size
-    scale = 440 / min(w, h)
-    img = image.resize((int(w * scale), int(h * scale)))
-    left = (img.size[0] - 384) // 2
-    top = (img.size[1] - 384) // 2
-    img = img.crop((left, top, left + 384, top + 384))
-    arr = np.array(img, dtype=np.float32)
-    arr *= np.float32(1.0 / 255.0)
-    mean = np.array([0.48145466, 0.4578275, 0.40821073], dtype=np.float32)
-    std  = np.array([0.26862954, 0.26130258, 0.27577711], dtype=np.float32)
-    arr = (arr - mean) / std
-    return np.expand_dims(arr.transpose(2, 0, 1), 0)
-
-
-# ── Tab 1: PyTorch vs ONNX comparison ─────────────────────────────────
-
-def compare(image, onnx_variants):
-    if image is None or not onnx_variants:
-        return (None, None)
-
-    t0 = time.perf_counter()
-    inputs = pt_processor(image, return_tensors="pt")
-    inputs = {k: v.to(pt_device) for k, v in inputs.items()}
-    with torch.no_grad():
-        logits = pt_model(**inputs).logits[0].cpu()
-        if pt_model.config.num_classes == 1:
-            fake_prob = torch.sigmoid(logits).item()
-            pt_pred = "fake" if fake_prob > 0.5 else "real"
-            pt_probs = [1.0 - fake_prob, fake_prob]
-        else:
-            pt_probs_arr = torch.softmax(logits, dim=-1)
-            pt_pred = pt_model.config.id2label[torch.argmax(pt_probs_arr).item()]
-            pt_probs = [pt_probs_arr[0].item(), pt_probs_arr[1].item()]
-    pt_ms = (time.perf_counter() - t0) * 1000
-
-    pt = {
-        "device": pt_device.upper(),
-        "prediction": pt_pred,
-        "real": round(pt_probs[0], 4),
-        "fake": round(pt_probs[1], 4),
-        "time_ms": round(pt_ms, 1),
-    }
-
-    onx = {}
-    for variant in onnx_variants:
-        session = _get_onnx(variant)
-        arr = _onnx_preprocess(image)
-        use_f16 = session.get_inputs()[0].type == "tensor(float16)"
-        t0 = time.perf_counter()
-        inp = arr.astype(np.float16) if use_f16 else arr
-        onx_logits = session.run(None, {"pixel_values": inp})[0]
-        if len(onx_logits.shape) > 1 and onx_logits.shape[-1] > 1:
-            onx_probs = np.exp(onx_logits - onx_logits.max()) / np.exp(onx_logits - onx_logits.max()).sum()
-            fake_prob = float(onx_probs[0, 1])
-            onx_probs_np = [float(onx_probs[0, 0]), float(onx_probs[0, 1])]
-        else:
-            fake_prob = float(1 / (1 + np.exp(-onx_logits[0, 0])))
-            onx_probs_np = [1.0 - fake_prob, fake_prob]
-        onx_pred = "fake" if fake_prob > 0.5 else "real"
-        onx_ms = (time.perf_counter() - t0) * 1000
-
-        onx[variant] = {
-            "device": onnx_device,
-            "prediction": onx_pred,
-            "real": round(float(onx_probs_np[0]), 4),
-            "fake": round(float(onx_probs_np[1]), 4),
-            "time_ms": round(onx_ms, 1),
-        }
-
-    return (pt, onx)
-
-
-# ── Tab 2: Benchmark all variants ─────────────────────────────────────
-
-def _find_test_images():
-    if not os.path.isdir(IMAGES_DIR):
-        return []
-    exts = {".jpg", ".jpeg", ".png", ".bmp", ".webp", ".gif"}
-    images = []
-    for f in sorted(os.listdir(IMAGES_DIR)):
-        if os.path.splitext(f)[1].lower() in exts:
-            images.append((f, os.path.join(IMAGES_DIR, f)))
-    return images
-
-def benchmark():
-    images = _find_test_images()
-    if not images:
-        return (gr.update(value="## No images found\n\n"
-                       f"Place test images in `{IMAGES_DIR}` and click Run Benchmark."),
-                None)
-
-    variants = list(ONNX_VARIANTS.keys())
-    rows = [["Image"] + variants]
-    total_ms = {v: 0.0 for v in variants}
-
-    for name, path in images:
-        img = Image.open(path).convert("RGB")
-        row = [name]
-
-        for variant in variants:
-            session = _get_onnx(variant)
-            use_f16 = session.get_inputs()[0].type == "tensor(float16)"
-
-            t0 = time.perf_counter()
-            for _ in range(10):  # warmup
-                arr = _onnx_preprocess(img)
-                _ = session.run(None, {"pixel_values": arr.astype(np.float16) if use_f16 else arr})
-
-            t0 = time.perf_counter()
-            for _ in range(50):
-                arr = _onnx_preprocess(img)
-                _ = session.run(None, {"pixel_values": arr.astype(np.float16) if use_f16 else arr})
-            elapsed = (time.perf_counter() - t0) / 50 * 1000
-            total_ms[variant] += elapsed
-
-            logits = session.run(None, {"pixel_values": arr.astype(np.float16) if use_f16 else arr})[0]
-            if len(logits.shape) > 1 and logits.shape[-1] > 1:
-                probs = np.exp(logits - logits.max()) / np.exp(logits - logits.max()).sum()
-                fake_prob = float(probs[0, 1])
-                pred = "R" if fake_prob < 0.5 else "F"
-                row.append(f"{pred} {probs[0,0]:.3f}/{probs[0,1]:.3f}")
-            else:
-                fake_prob = float(1 / (1 + np.exp(-logits[0, 0])))
-                pred = "R" if fake_prob < 0.5 else "F"
-                row.append(f"{pred} {1-fake_prob:.3f}/{fake_prob:.3f}")
-
-        rows.append(row)
-
-    # Averages row
-    avg_row = ["**Avg ms**"] + [f"**{total_ms[v]/len(images):.1f}**" for v in variants]
-    rows.append(avg_row)
-
-    col_widths = [max(len(r[i]) for r in rows) + 3 for i in range(len(rows[0]))]
-
-    markdown = "## Benchmark Results\n\n"
-    markdown += f"Device: {onnx_device} | Images: {len(images)} | "
-    markdown += "50 runs per image (10 warmup)\n\n"
-
-    for i, row in enumerate(rows):
-        if i == 0 or i == len(rows) - 1:
-            markdown += f"| {' | '.join(r.ljust(w) for r, w in zip(row, col_widths))} |\n"
-            if i == 0:
-                markdown += f"|{'|'.join('-' * (w + 2) for w in col_widths)}|\n"
-        else:
-            markdown += f"| {' | '.join(r.ljust(w) for r, w in zip(row, col_widths))} |\n"
-
-    # Variant guide
-    guide = (
-        "**ONNX variant guide**\n\n"
-        f"• **{variants[0]}** — Best accuracy, largest file, slowest CPU inference\n"
-        f"• **{variants[1]}** — Near-lossless, good for GPU inference\n"
-        f"• **{variants[2]} / {variants[3]} / {variants[4]}** — Sweet spot for CPU, fastest inference\n"
-        f"• **{variants[5]} / {variants[6]} / {variants[7]}** — Smallest files, higher latency (dequantization overhead)"
-    )
-
-    return (gr.update(value=markdown), guide)
-
-
-# ── Tab 3: Old vs New ──────────────────────────────���─────────────────
-
-def compare_old_new(image):
-    if image is None:
-        return (None, None)
-
-    # ── New (HF ViTForImageClassification, fixed config) ──
-    t0 = time.perf_counter()
-    inputs = pt_processor(image, return_tensors="pt")
-    inputs = {k: v.to(pt_device) for k, v in inputs.items()}
-    with torch.no_grad():
-        logits = pt_model(**inputs).logits[0].cpu()
-        fake_prob = torch.sigmoid(logits).item()
-        new_pred = "fake" if fake_prob > 0.5 else "real"
-    new_ms = (time.perf_counter() - t0) * 1000
-
-    new_result = {
-        "backend": "ViTForImageClassification (fixed, July 2026)",
-        "prediction": new_pred,
-        "real": round(1.0 - fake_prob, 4),
-        "fake": round(fake_prob, 4),
-        "time_ms": round(new_ms, 1),
-    }
-
-    # ── Old (timm ViTClassifier, deprecated) ──
-    old_model, old_dev = _get_old_model()
-    t0 = time.perf_counter()
-    with torch.no_grad():
-        fake_prob = old_model.forward(image).item()
-    old_ms = (time.perf_counter() - t0) * 1000
-    old_pred = "fake" if fake_prob > 0.5 else "real"
-
-    old_result = {
-        "backend": "ViTClassifier (timm wrapper, deprecated)",
-        "prediction": old_pred,
-        "real": round(1.0 - fake_prob, 4),
-        "fake": round(fake_prob, 4),
-        "time_ms": round(old_ms, 1),
-        "note": "sigmoid single-class output",
-    }
-
-    return (old_result, new_result)
-
-
-# ── UI ────────────────────────────────────────────────────────────────
-
-with gr.Blocks(title="DeepfakeDet-ViT") as demo:
-    gr.Markdown("## CommunityForensics DeepfakeDet-ViT — Test App")
-
-    with gr.Tabs():
-        with gr.TabItem("Compare"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    img_in = gr.Image(type="pil", label="Upload Image")
-                with gr.Column(scale=1):
-                    variant = gr.CheckboxGroup(
-                        choices=list(ONNX_VARIANTS.keys()),
-                        value=[list(ONNX_VARIANTS.keys())[2]],
-                        label="ONNX Variants (select 1+)",
-                    )
-                    pt_out = gr.JSON(label="PyTorch")
-                    onx_out = gr.JSON(label="ONNX")
-            img_in.change(fn=compare, inputs=[img_in, variant], outputs=[pt_out, onx_out])
-            variant.change(fn=compare, inputs=[img_in, variant], outputs=[pt_out, onx_out])
-
-        with gr.TabItem("Benchmark"):
-            gr.Markdown(f"Place test images in `{IMAGES_DIR}` (create if needed) and click Run Benchmark.")
-            run_btn = gr.Button("Run Benchmark", variant="primary")
-            bench_md = gr.Markdown("")
-            guide = gr.Markdown("")
-            run_btn.click(fn=benchmark, inputs=[], outputs=[bench_md, guide])
-
-        with gr.TabItem("Old vs New"):
-            gr.Markdown("Compare the **deprecated timm wrapper** against the **fixed HF pipeline**. Same weights, different loading paths.")
-            with gr.Row():
-                with gr.Column(scale=1):
-                    cmp_img = gr.Image(type="pil", label="Upload Image")
-                with gr.Column(scale=1):
-                    old_out = gr.JSON(label="Old (timm, deprecated)")
-                    new_out = gr.JSON(label="New (HF, fixed)")
-            cmp_img.change(fn=compare_old_new, inputs=[cmp_img], outputs=[old_out, new_out])
-
-        with gr.TabItem("Help"):
-            gr.Markdown("""
-            **About this app**
-
-            This is a local test tool for the CommunityForensics DeepfakeDet-ViT model.
-
-            - **Compare tab**: Upload an image to see PyTorch and ONNX predictions side by side with timing.
-            - **Benchmark tab**: Runs all 8 ONNX variants against all images in the `test_app/images/` directory. Shows predictions and average inference time per variant.
-            - **Old vs New tab**: Compares the deprecated timm wrapper against the fixed HF pipeline — proves the fix is correct.
-
-            **Adding test images**
-
-            Create a `test_app/images/` directory next to `app.py` and drop your JPEG/PNG images in it. The benchmark tab will automatically find them.
-
-            **Interpreting the ONNX variant guide**
-
-            On CPU, the 36 MB INT8 variants are usually fastest (optimized kernels). Smaller 4-bit models trade disk space for slower inference due to dequantization overhead. The full 138 MB model is only recommended for maximum accuracy on server deployments.
-            """)
-
-if __name__ == "__main__":
-    os.makedirs(IMAGES_DIR, exist_ok=True)
-    demo.launch(show_error=True)

test_app/old_config.json

@@ -1,29 +0,0 @@
-{
-  "model": {
-    "variant": "vit_small_patch16_384.augreg_in21k_ft_in1k",
-    "input_size": 384,
-    "patch_size": 16,
-    "freeze_backbone": false,
-    "hidden_dropout_prob": 0.0,
-    "hidden_size": 384,
-    "num_attention_heads": 6,
-    "num_hidden_layers": 12,
-    "attention_probs_dropout_prob": 0.0,
-    "layer_norm_eps": 1e-6,
-    "num_classes": 1,
-    "head": {
-      "in_features": 384,
-      "out_features": 1,
-      "bias": true
-    }
-  },
-  "preprocessing": {
-    "norm_mean": [0.48145466, 0.4578275, 0.40821073],
-    "norm_std": [0.26862954, 0.26130258, 0.27577711],
-    "resize_size": 440,
-    "crop_size": 384
-  },
-  "device": "cuda",
-  "dtype": "float32",
-  "checkpoint_path": "pretrained_weights/model_v11_ViT_384_base_ckpt.pt"
-}

test_app/requirements.txt

@@ -1,7 +0,0 @@
-gradio
-torch
-transformers
-timm
-pillow
-onnxruntime
-numpy