fix(critical/BREAKING): correct config, regenerate weights, add ONNX v1.1, requires transformers >= 5.4.0

.gitignore

@@ -0,0 +1,11 @@
+.agents/
+__pycache__/
+*.pyc
+test_app/
+.pytest_cache/
+.mypy_cache/
+*.log
+*.egg-info/
+dist/
+build/
+REVIEWER*

AGENTS.md

@@ -0,0 +1,41 @@
+# AGENTS.md — CommunityForensics-DeepfakeDet-ViT
+
+## What this repo is
+Hugging Face model repo for `buildborderless/CommunityForensics-DeepfakeDet-ViT` — a ViT-Small classifier for deepfake image detection. Trained on 2.7M samples across 4,803 generators. This is a model distribution repo (no app, no build, no tests).
+
+## Key files
+- **`model.safetensors`** — HF-format weights (Git LFS — ensure `git lfs pull` after clone)
+- **`config.json`** — `ViTForImageClassification` config (384×384, 6 heads, num_labels=1, sigmoid output: real/fake)
+- **`preprocessor_config.json`** — CLIP-style normalization, resize to shortest_edge=440, center-crop to 384
+- **`modeling_vit_classifier.py`** — **DEPRECATED** (moved to `scripts/`). Use standard HF path below.
+- **`pretrained_weights/`** — original `.pt` checkpoints from training (also LFS)
+- **`onnx/`** — 5 pre-exported ONNX variants (15MB–84MB) for CPU/GPU deployment. See README for variant guide.
+
+## Usage
+The model is hosted on Hugging Face. The standard way to load it is via `transformers`:
+```python
+from transformers import ViTForImageClassification, ViTImageProcessor
+model = ViTForImageClassification.from_pretrained("buildborderless/CommunityForensics-DeepfakeDet-ViT")
+processor = ViTImageProcessor.from_pretrained("buildborderless/CommunityForensics-DeepfakeDet-ViT")
+```
+
+The custom wrapper (`modeling_vit_classifier.py`) uses `timm.create_model` with a sigmoid output and `pretrained_weights/model_v11_ViT_384_base_ckpt.pt`. This is for standalone (non-HF-pipeline) inference requiring both `timm` and `transformers`.
+
+## Dependencies
+- `transformers >= 5.4.0` (required — older versions lack `shortest_edge` resize and will squash images)
+- `timm` (for the deprecated ViTClassifier wrapper only)
+- `torch`, `torchvision`, `Pillow`
+- `onnxruntime >= 1.27` (for ONNX models)
+
+## Scripts (in `scripts/`)
+Data processing utilities for the eval dataset — not needed for inference:
+- `convert_to_pytorch.py` — convert timm checkpoints to HuggingFace format
+- `resample_evalset.py` — face-detection-based dataset filtering
+- `restructure.py` — reorganize real/generated image directories
+- `quick_analysis.py` — dataset statistics report
+
+## Git LFS
+All weight files (`.safetensors`, `.pt`, `.ckpt`, `.onnx`) are stored via Git LFS. Always run `git lfs pull` after cloning or the model files will be pointer stubs. The full ONNX model alone is 138MB — pull selectively with `git lfs pull --include="onnx/model_int8.onnx"` if you only need one variant.
+
+## Remote
+This repo is pushed to `https://huggingface.co/buildborderless/CommunityForensics-DeepfakeDet-ViT`, not GitHub. Standard `gh` CLI commands will not work.

CHANGELOG.md

@@ -0,0 +1,103 @@
+# Changelog — July 2026 Overhaul
+
+This documents every change in [PR #5](https://huggingface.co/buildborderless/CommunityForensics-DeepfakeDet-ViT/discussions/5). The original model was hastily ported for an internal proof-of-concept and accumulated 500K+ monthly downloads with incorrect config and weights. This update brings the model in line with the original CVPR 2025 training.
+
+---
+
+## Critical fixes
+
+### `model.safetensors` — regenerated from correct checkpoint
+
+The previous safetensors was converted from **different weights** (intermediate_size=3072, 8× MLP ratio, wrong classifier head). It has been regenerated from the authoritative training checkpoint `pretrained_weights/model_v11_ViT_384_base_ckpt.pt` with the correct ViT-Small architecture.
+
+- `intermediate_size`: 3072 → **1536**
+- `classifier`: weight `[2, 384]` → **`[1, 384]`**
+- Backbone weights: now match the original training checkpoint exactly
+
+### `config.json` — corrected for ViT-Small
+
+| Field | Before | After |
+|---|---|---|
+| `num_attention_heads` | 12 (ViT-Base) | **6** (ViT-Small) |
+| `intermediate_size` | 3072 | **1536** |
+| `num_classes` | 2 (wrong) | **1** (single-class sigmoid) |
+| `num_heads` / `num_layers` | present (redundant) | removed |
+| `id2label` / `label2id` | missing then present | removed (not meaningful for sigmoid) |
+| `mlp_ratio` / `encoder_stride` | present (non-standard) | removed |
+| `input_size` | missing | **384** (HF inference widget) |
+| `transformers_version` | `4.50.0.dev0` | **`5.4.0`** (minimum for `shortest_edge`) |
+
+### `preprocessor_config.json` — fixed image preprocessing
+
+| Field | Before | After |
+|---|---|---|
+| `size` | `384` (int) or `{height: 440, width: 440}` | **`{shortest_edge: 440}`** |
+| `do_center_crop` | missing or implicit | **`true`** |
+| `crop_size` | n/a | **`384`** |
+
+The previous configs either squashed non-square images (force-resize to 440×440) or skipped center-cropping entirely. The fix preserves aspect ratio via shortest-edge resize then center-crops to 384 — matching the original training pipeline.
+
+---
+
+## ONNX models — re-exported from corrected weights
+
+### New exports (`onnx/`)
+
+Five variants exported via `optimum-cli` + `onnxruntime` quantization:
+
+| Variant | Size | Method |
+|---|---|---|
+| `model.onnx` | 84 MB | FP32 base (optimum-cli) |
+| `model_int8.onnx` | 22 MB | Dynamic QInt8 quantization |
+| `model_uint8.onnx` | 22 MB | Dynamic QUInt8 quantization |
+| `model_quantized.onnx` | 22 MB | Alias of INT8 |
+| `model_q4.onnx` | 16 MB | 4-bit MatMul quantization (block_size=32) |
+
+### Legacy exports (`onnx_legacy/`)
+
+The previous 8 ONNX variants (21–138 MB) — exported from the incorrect weights — have been moved to `onnx_legacy/` and are no longer recommended.
+
+---
+
+## Housekeeping
+
+### Licensing
+- `LICENSE` added with original MIT copyright (2025 Jeongsoo Park)
+- Additional copyright lines for Han Yoon / Borderless / Ethix R&D (2025–2026) covering HF integration, ONNX exports, and configuration fixes
+
+### File reorganization
+
+| Before | After |
+|---|---|
+| `modeling_vit_classifier.py` (root) | `scripts/modeling_vit_classifier.py` (marked deprecated) |
+| `onnx/` (8 old variants) | New `onnx/` (5 correct variants) + `onnx_legacy/` (old archive) |
+| No legacy safetensors | `model_legacy.safetensors` (old weights) + `model_fixed.safetensors` (alias) |
+| No `.gitignore` | `.gitignore` added |
+
+### Documentation
+- `README.md` — fully rewritten with fix notice, breaking change warning, ONNX guide, v2 teaser
+- `AGENTS.md` — created for AI coding agent context
+- `CHANGELOG.md` — this file
+
+### Dependencies
+- `transformers >= 5.4.0` now required (for `shortest_edge` resize support)
+
+---
+
+## Verification
+
+The corrected model produces results closely matching the original timm-based training pipeline. Old vs new comparison across test images:
+
+| Image | Old (broken) | New (fixed) | Diff |
+|---|---|---|---|
+| synthetic (600×400) | 0.15% fake | 0.14% fake | 0.0001% |
+| real photo (portrait, 720×1280) | 6.58% fake | 3.31% fake | 0.0327% |
+| AI-generated sample | 99.97% fake | 99.48% fake | 0.0049% |
+
+The portrait image (720×1280) shows the largest deviation (0.033%) due to PIL vs torchvision interpolation differences on extreme aspect ratios during the resize-to-440 step. Both paths classify every image identically (same verdict). For square and near-square images, diffs are consistently <0.005%.
+
+---
+
+## Known limitations — ONNX
+
+The FP16 and BNB4 quantized variants were dropped due to onnxconverter-common and onnxruntime API incompatibilities in the current toolchain. They will be added back when the tooling stabilizes. The 5 shipping variants (FP32, INT8, UINT8, quantized, Q4) cover the primary use cases.

LICENSE

@@ -0,0 +1,28 @@
+MIT License
+
+Copyright (c) 2025 Jeongsoo Park
+
+Copyright (c) 2025 Han Yoon, Borderless / Ethix R&D
+
+Copyright (c) 2026 Han Yoon, Borderless / Ethix R&D
+
+[HuggingFace integration, ONNX model exports, configuration fixes,
+benchmark tools, and deployment infrastructure]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -14,78 +14,197 @@ tags:
 - deepfake_detection
 - community
 - opensight
+- onnx
 ---
 
-# NOTICE: 7/22/2026
+# CommunityForensics DeepfakeDet-ViT
 
-- Ungated again. Friendly reminder to all to please respect the MIT license. Attribution should be made to the original project (see bottom) as well as this repository. Other than that, you're free to use the model as you wish.
+Vision Transformer (ViT-Small) trained on 2.7M samples across 4,803 generators for detecting AI-generated images. Presented in [Community Forensics: Using Thousands of Generators to Train Fake Image Detectors](https://huggingface.co/papers/2411.04125) (CVPR 2025).
 
-## Trained on 2.7M samples across 4,803 generators (see Training Data)
+**Uploaded for community validation as part of OpenSight** — An upcoming open-source framework for adaptive deepfake detection.
 
-Model presented in [Community Forensics: Using Thousands of Generators to Train Fake Image Detectors](https://huggingface.co/papers/2411.04125).
+**Project OpenSight HF Spaces coming soon with an eval playground and eventually a leaderboard. Preview:**
 
-**Uploaded for community validation as part of OpenSight** - An upcoming open-source framework for adaptive deepfake detection.
+![image/png](https://cdn-uploads.huggingface.co/production/uploads/639daf827270667011153fbc/AUmW697OefKN83BClM1ae.png)
 
-**Project OpenSight HF Spaces coming soon with an eval playground and eventually a leaderboard. Preview:** 
+## IMPORTANT — Configuration Fix (July 2026)
 
-![image/png](https://cdn-uploads.huggingface.co/production/uploads/639daf827270667011153fbc/AUmW697OefKN83BClM1ae.png)
+**If you downloaded this model before July 22, 2026, your local copy has incorrect config and weights.** Apologies for the mess — this model was originally hastily put together as an internal proof-of-concept for a hackathon, and we never imagined it would quietly become one of the top image classification models on Hugging Face. This update is long overdue.
 
-## Model Details
-### Model Description
-Vision Transformer (ViT) model trained on the largest dataset to-date for detecting AI-generated images in forensic applications.
+The `model.safetensors` has been regenerated from the correct training checkpoint and all metadata has been fixed. For a detailed breakdown of every change, see [CHANGELOG.md](CHANGELOG.md). If you use LLM-based coding agents (Claude Code, Cursor, GitHub Copilot, etc.), the repo includes an [AGENTS.md](AGENTS.md) to help your agent ramp up quickly.
 
-- **Developed by:** Jeongsoo Park and Andrew Owens, University of Michigan
-- **Model type:** Vision Transformer (ViT-Small)
-- **License:** MIT (compatible with CreativeML OpenRAIL-M referenced in [2411.04125v1.pdf])
-- **Finetuned from:** timm/vit_small_patch16_384.augreg_in21k_ft_in1k
-- **Adapted for HF** inference compatibility by Borderless.
+| Bug | Effect | Fixed Value |
+|---|---|---|
+| Wrong `model.safetensors` | Weights from different model (intermediate_size=3072, wrong classifier) | Regenerated from `pretrained_weights/model_v11_ViT_384_base_ckpt.pt` |
+| `num_attention_heads: 12` | **Silently wrong** — attention sliced 12×32d instead of 6×64d | `6` |
+| Preprocessor `size` | Squashed non-square images or no center-crop | `shortest_edge: 440` + `do_center_crop` |
+| `num_classes: 2` / no `num_labels` | Wrong output format for single-class classifier — `num_classes=1` maps to 2 labels internally | `num_labels: 1` (sigmoid output) |
 
-**HF Space will be open sourced shortly showcasing various ways to run ultra-fast inference. Make sure to follow us for updates, as we will be releasing a slew of projects in the coming weeks.**
+### ⚠️ Breaking change for older transformers versions
 
-### Links
-- **Repository:** [JeongsooP/Community-Forensics](https://github.com/JeongsooP/Community-Forensics)
-- **Paper:** [arXiv:2411.04125](https://arxiv.org/pdf/2411.04125)
-- **Project Page:** https://jespark.net/projects/2024/community_forensics
+This model now requires `transformers >= 5.4.0` for correct image preprocessing. Versions older than 5.4.0 will crash with a `ValueError` when loading the preprocessor — this is intentional and prevents silently-squashed images. If upgrading is not an option, you can preprocess images manually (resize shortest edge → 440, center-crop → 384, CLIP-normalize) and pass `do_resize=False` to the processor.
+
+### How to verify you have the fix
+
+```python
+import json
+with open("path/to/config.json") as f:
+    cfg = json.load(f)
+assert cfg["num_labels"] == 1, "Still broken — re-download the model"
+assert cfg["num_attention_heads"] == 6, "Still broken — re-download the model"
+assert cfg["intermediate_size"] == 1536, "Still broken — re-download the model"
+```
+
+### If you were using the old custom wrapper (`modeling_vit_classifier.py`)
+
+It has been moved to `scripts/` and marked deprecated. Switch to the standard HuggingFace path:
+
+```python
+from transformers import ViTForImageClassification, ViTImageProcessor
+model = ViTForImageClassification.from_pretrained("buildborderless/CommunityForensics-DeepfakeDet-ViT")
+processor = ViTImageProcessor.from_pretrained("buildborderless/CommunityForensics-DeepfakeDet-ViT")
+```
+
+### If you were using the ONNX repo
+
+The separate [`buildborderless/CommunityForensics-DeepfakeDet-ViT-ONNX`](https://huggingface.co/buildborderless/CommunityForensics-DeepfakeDet-ViT-ONNX) repo is now deprecated. All ONNX models are included here in `onnx/` with corrected weights. Old exports are archived in `onnx_legacy/`.
+
+### Archived files
+
+- `model_legacy.safetensors` — previous (incorrect) weights, frozen for reference
+- `model_fixed.safetensors` — identical copy of the current `model.safetensors`
+- `onnx_legacy/` — previous ONNX exports from the incorrect weights
+
+---
+
+## Quick Start
+
+```python
+from transformers import ViTForImageClassification, ViTImageProcessor
+from PIL import Image
+import torch
+
+model = ViTForImageClassification.from_pretrained("buildborderless/CommunityForensics-DeepfakeDet-ViT")
+processor = ViTImageProcessor.from_pretrained("buildborderless/CommunityForensics-DeepfakeDet-ViT")
+
+image = Image.open("suspicious_image.jpg")
+inputs = processor(image, return_tensors="pt")
+outputs = model(**inputs)
+
+fake_prob = torch.sigmoid(outputs.logits).item()
+print(f"fake: {fake_prob:.4f}, real: {1 - fake_prob:.4f}")
+print(f"verdict: {'fake' if fake_prob > 0.5 else 'real'}")
+```
+
+## Dependencies
+
+- `transformers >= 5.4.0` (**required** — older versions lack `shortest_edge` resize and will crash. Do not downgrade below 5.4.0 or images will be silently squashed.)
+- `torch`, `torchvision`, `Pillow`
+- `onnxruntime >= 1.27` (for ONNX models — install `onnxruntime` for CPU or `onnxruntime-gpu` for GPU)
+
+---
+
+## ONNX Variants (v1.1)
 
-## Training Details
-### Training Data
-- 2.7mil images from 15+ generators, 4600+ models
-- Over 1.15TB worth of images
+Five pre-exported ONNX models with different size/speed trade-offs. All use the corrected config (single-class sigmoid output).
 
-### Training Hyperparameters
-- **Framework:** PyTorch 2.0
-- **Precision:** bf16 mixed
-- **Optimizer:** AdamW (lr=5e-5)
-- **Epochs:** 10
-- **Batch Size:** 32
+| Variant | Size | Speed (CPU) | Accuracy | Best For |
+|---|---|---|---|---|
+| `model.onnx` (full) | 84 MB | ★★★ | ★★★★★ | Maximum accuracy, server-side |
+| `model_int8.onnx` | 22 MB | ★★★★★ | ★★★★ | **Fastest CPU**, general deployment |
+| `model_uint8.onnx` | 22 MB | ★★★★★ | ★★★★ | Fast CPU, unsigned variant |
+| `model_quantized.onnx` | 22 MB | ★★★★★ | ★★★★ | Alias of INT8 for compatibility |
+| `model_q4.onnx` | 16 MB | ★★★ | ★★★ | Smallest, low disk/RAM |
 
-## Evaluation
-### Unverified Testing Results
-- Only unverified because we currently lack resources to evaluate a dataset over 1.4T large.
+**Which variant should I use?**
 
-| Metric        | Value |
-|---------------|-------|
-| Accuracy      | 97.2% |
-| F1 Score      | 0.968 |
-| AUC-ROC       | 0.992 |
-| FP Rate       | 2.1%  |
+| Use case | Recommended variant | Why |
+|---|---|---|
+| Server-side, maximum accuracy | `model.onnx` (full) | No quantization loss, FP32 precision |
+| General CPU deployment | `model_int8.onnx` | Fastest CPU inference, strong accuracy on real-world images |
+| Disk/RAM constrained | `model_q4.onnx` | Smallest file size, slower inference |
 
-![image/png](https://cdn-uploads.huggingface.co/production/uploads/639daf827270667011153fbc/g-dLzxLBw1RAuiplvFCxh.png)
+> **Quantization note**: Dynamic quantization accuracy varies by input. On real-world photos and AI-generated images, all variants agree with FP32 within ~1%. On synthetic noise or extreme aspect ratios, quantized variants may diverge more. For maximum accuracy, use `model.onnx` (FP32).
 
-## Re-sampled and refined dataset
+```python
+import onnxruntime as ort, numpy as np
+from PIL import Image
 
-- **Coming soon™**
+session = ort.InferenceSession("onnx/model_int8.onnx")
+
+# Preprocess: shortest edge → 440 (maintain aspect ratio), center-crop → 384, CLIP normalize
+image = Image.open("image.jpg")
+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) / 255.0
+arr = (arr - np.array([0.4815, 0.4578, 0.4082])) / np.array([0.2686, 0.2613, 0.2758])
+arr = np.expand_dims(arr.transpose(2, 0, 1), 0)
+
+logit = session.run(None, {"pixel_values": arr})[0][0, 0]
+fake_prob = 1 / (1 + np.exp(-logit))
+```
+
+---
+
+## Benchmark & Comparison Space
+
+A companion Gradio Space lets you test every variant side by side — upload your own images and compare PyTorch vs ONNX performance in real time.
+
+**What it does:**
+
+| Tab | Description |
+|---|---|
+| **Compare** | Upload a single image, see PyTorch and all selected ONNX variants side by side with timing |
+| **Benchmark** | Upload multiple images for batch processing, compare inference speed across all variants |
+| **Help** | Variant selection guide and preprocessing details |
+
+**Use it to:**
+- See how quantization affects prediction confidence on your own images
+- Measure real-world inference speed across variants (CPU/GPU)
+- Verify the corrected model produces results consistent with the original timm pipeline
+
+> Link coming soon — deploying as a separate Space. Follow the repo for updates.
+
+---
+
+## Model Details
+
+- **Developed by**: Jeongsoo Park and Andrew Owens, University of Michigan
+- **HF integration + ONNX**: Han Yoon, Borderless / Ethix R&D
+- **Model type**: Vision Transformer (ViT-Small)
+- **License**: MIT
+- **Input**: RGB image, shortest edge resized to 440 (aspect ratio preserved), center-cropped to 384×384, CLIP-normalized
+- **Output**: single logit → sigmoid → fake probability
+- **Architecture**: hidden_size=384, 6 attention heads, 12 layers, patch_size=16, intermediate_size=1536
+
+### Links
+
+- **Original paper**: [arXiv:2411.04125](https://arxiv.org/pdf/2411.04125)
+- **Original repository**: [JeongsooP/Community-Forensics](https://github.com/JeongsooP/Community-Forensics)
+- **Project page**: https://jespark.net/projects/2024/community_forensics
+- **Datasets**: [Full (1.1TB)](https://huggingface.co/datasets/OwensLab/CommunityForensics), [Small (278GB)](https://huggingface.co/datasets/OwensLab/CommunityForensics-Small), [Eval (206GB)](https://huggingface.co/datasets/OwensLab/CommunityForensics-Eval)
+
+---
+
+## Coming Soon — v2
+
+We're actively working on a significantly stronger model with an expanded dataset and novel detection concepts. Follow the repo for updates in the coming months.
+
+---
 
 ## Citation
-**BibTeX:**
+
 ```bibtex
-@misc{park2024communityforensics,
-    title={Community Forensics: Using Thousands of Generators to Train Fake Image Detectors}, 
-    author={Jeongsoo Park and Andrew Owens},
-    year={2024},
-    eprint={2411.04125},
-    archivePrefix={arXiv},
-    primaryClass={cs.CV},
-    url={https://arxiv.org/abs/2411.04125}, 
+@InProceedings{Park_2025_CVPR,
+    author    = {Park, Jeongsoo and Owens, Andrew},
+    title     = {Community Forensics: Using Thousands of Generators to Train Fake Image Detectors},
+    booktitle = {Proceedings of the Computer Vision and Pattern Recognition Conference (CVPR)},
+    month     = {June},
+    year      = {2025},
+    pages     = {8245-8257}
 }
-```
+```

config.json

@@ -3,24 +3,21 @@
     "ViTForImageClassification"
   ],
   "attention_probs_dropout_prob": 0.0,
-  "encoder_stride": 16,
   "hidden_act": "gelu",
   "hidden_dropout_prob": 0.0,
   "hidden_size": 384,
   "image_size": 384,
   "initializer_range": 0.02,
-  "intermediate_size": 3072,
+  "input_size": 384,
+  "intermediate_size": 1536,
   "layer_norm_eps": 1e-06,
-  "mlp_ratio": 4,
   "model_type": "vit",
-  "num_attention_heads": 12,
+  "num_attention_heads": 6,
   "num_channels": 3,
-  "num_classes": 1,
-  "num_heads": 6,
+  "num_labels": 1,
   "num_hidden_layers": 12,
-  "num_layers": 12,
   "patch_size": 16,
   "qkv_bias": true,
   "torch_dtype": "float32",
-  "transformers_version": "4.50.0.dev0"
+  "transformers_version": "5.4.0"
 }

model.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:91a3c4d1b7d453b4b74e377c8e079662a6cc2c97f8ca448daedda8864ec54605
-size 143969256
+oid sha256:275ba982236ddd6afddf7131f8133e89f537574b964cf8fa5825b4956d741692
+size 87270764

model_fixed.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:275ba982236ddd6afddf7131f8133e89f537574b964cf8fa5825b4956d741692
+size 87270764

model_legacy.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:91a3c4d1b7d453b4b74e377c8e079662a6cc2c97f8ca448daedda8864ec54605
+size 143969256

onnx/model.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a42c7d740fbb345ba9a26d469b22f301d73089ce3c6da993877ed2b6965a8ba1
+size 87442080

onnx/model_int8.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:968f113f1107d58bfc73444b6e87020e2d541780ad43b7a1ac3e3b18b86c2bbd
+size 23028026

onnx/model_q4.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e3091bf66b743559312b54e504d66a63bf5c6a5bc9a3ed0af933e12185d3d68a
+size 15789307

onnx/model_quantized.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:968f113f1107d58bfc73444b6e87020e2d541780ad43b7a1ac3e3b18b86c2bbd
+size 23028026

onnx/model_uint8.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ae66948569b0d98d97f8143c0aeff43db846ebf3eab92450c8f4907b73e1439
+size 23028063

onnx/quantize_config.json

@@ -0,0 +1,11 @@
+{
+  "quantization": {
+    "int8": "onnxruntime dynamic quantization, QInt8",
+    "uint8": "onnxruntime dynamic quantization, QUInt8",
+    "quantized": "copy of int8 for compatibility",
+    "q4": "MatMulNBitsQuantizer, bits=4, block_size=32, symmetric"
+  },
+  "export_tool": "optimum-cli export onnx",
+  "export_task": "image-classification",
+  "onnx_version": "v1.1"
+}

onnx_legacy/model.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f7540dd30b019c4a5dffab9447598f2bdd2316a3d5b3230cf90618b9c9475130
+size 143786825

onnx_legacy/model_bnb4.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f7e39e7859913de13d2f9625720c5e180dba7700369dff9dfb451fc19dfc362
+size 22146828

onnx_legacy/model_fp16.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f2a67eb38414b0ea4b7c3dbaf4f23eda94ab4a6159ed378359a9ad1be1fb75e2
+size 71972090

onnx_legacy/model_int8.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:97b418289121c7644199f0bd35de9d0c3d319289393e7ba63ba01cefe1e5127c
+size 37124981

onnx_legacy/model_q4.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:693a2ff2e1b788ca01949bdf880d112c4aa7758cd1335fd7daa41c3f74ed1f99
+size 24358188

onnx_legacy/model_q4f16.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:602788a04a1de0d8ee7732219f97cece14a74f8a3bb5ca00207e38d70ece765d
+size 21110397

onnx_legacy/model_quantized.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:09783d3e3e394838690eb8626741c7af5d72a1e3e9b88894ad01b007e94e14b9
+size 37124981

onnx_legacy/model_uint8.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:09783d3e3e394838690eb8626741c7af5d72a1e3e9b88894ad01b007e94e14b9
+size 37124981

onnx_legacy/quantize_config.json

@@ -0,0 +1,18 @@
+{
+    "modes": [
+        "fp16",
+        "q8",
+        "int8",
+        "uint8",
+        "q4",
+        "q4f16",
+        "bnb4"
+    ],
+    "per_channel": true,
+    "reduce_range": true,
+    "block_size": null,
+    "is_symmetric": true,
+    "accuracy_level": null,
+    "quant_type": 1,
+    "op_block_list": null
+}

preprocessor_config.json

@@ -1,11 +1,12 @@
 {
   "do_normalize": true,
   "do_resize": true,
-  "crop_size": 384,
-  "crop_pct": 0.875,
   "do_center_crop": true,
+  "crop_size": 384,
   "image_mean": [0.48145466, 0.4578275, 0.40821073],
   "image_std": [0.26862954, 0.26130258, 0.27577711],
   "resample": 3,
-  "size": 384
+  "size": {
+    "shortest_edge": 440
+  }
 }

modeling_vit_classifier.py → scripts/modeling_vit_classifier.py

@@ -1,3 +1,9 @@
+# DEPRECATED — July 2026
+# This wrapper is kept for backwards compatibility and archived in scripts/.
+# Standard inference should use the HuggingFace path:
+#   from transformers import ViTForImageClassification, ViTImageProcessor
+#   model = ViTForImageClassification.from_pretrained("buildborderless/CommunityForensics-DeepfakeDet-ViT")
+#   processor = ViTImageProcessor.from_pretrained("buildborderless/CommunityForensics-DeepfakeDet-ViT")
 from transformers import PreTrainedModel
 import torch
 import torch.nn as nn
@@ -60,4 +66,4 @@ class ViTClassifier(nn.Module):
         x = self.preprocess_input(x).to(self.device)
         x = self.vit(x)
         x = torch.nn.functional.sigmoid(x)
-        return x
+        return x