Clean deployment for Hugging Face

.gitattributes

@@ -0,0 +1 @@
+*.pth filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,210 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+datasets/CIFAKE/
+.idea/

Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3.11-slim
+WORKDIR /app
+COPY requirements.txt /app/
+RUN pip install --no-cache-dir -r requirements.txt gunicorn
+COPY . .
+EXPOSE 7860
+RUN useradd -m -u 1000 user
+RUN chown -R user:user /app
+USER user
+CMD ["gunicorn", "-b", "0.0.0.0:7860", "app:app", "--timeout", "120"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rishit Baitule
+
+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

@@ -0,0 +1,253 @@
+# 🧠 AI Detector — Real-Time Deepfake Detection Extension
+
+<div align="center">
+
+**Bringing trust back to the internet — one image at a time.**
+
+[![Status](https://img.shields.io/badge/Status-Working-success?style=for-the-badge)](https://github.com/How2Invade/extension-deepfake)
+[![Model](https://img.shields.io/badge/Model-OpenCLIP2-black?style=for-the-badge)](https://github.com/How2Invade/extension-deepfake)
+[![Backend](https://img.shields.io/badge/Backend-Flask-blue?style=for-the-badge)](https://flask.palletsprojects.com/)
+[![Platform](https://img.shields.io/badge/Platform-Chrome-green?style=for-the-badge)](https://chrome.google.com/)
+[![PyTorch](https://img.shields.io/badge/PyTorch-EE4C2C?style=for-the-badge&logo=pytorch&logoColor=white)](https://pytorch.org/)
+[![Python](https://img.shields.io/badge/Python-3776AB?style=for-the-badge&logo=python&logoColor=white)](https://python.org/)
+
+[Report Bug](https://github.com/How2Invade/extension-deepfake/issues) • [Request Feature](https://github.com/How2Invade/extension-deepfake/issues) • [View Demo](#-output)
+
+**Built for Prakalp 4.0**
+
+</div>
+
+---
+
+## ✨ What is AI Detector?
+
+With the explosion of generative AI tools like **Stable Diffusion**, **Midjourney**, and **DALL·E**, distinguishing real images from synthetic ones has become nearly impossible for the human eye.
+
+**AI Detector** is a real-time deepfake detection Chrome extension that scans every image on any webpage and classifies it as:
+
+- 🧠 **AI Generated** — flagged with a red border and confidence score
+- 📷 **Real** — confirmed with a green border and confidence score
+
+It doesn't just stop there. It calculates a **full page-level risk score** so you can instantly understand how much synthetic content you're being served — on any website, at any time.
+
+> In a world where AI can generate anything — this system helps you understand what is real.
+
+---
+
+## 🚀 Features
+
+### 🔍 Real-Time Image Scanning
+- Detects all visible images on any webpage
+- Works on Google Images, blogs, news sites, social media — anywhere
+- Ignores hidden or non-visible DOM elements for accurate results
+
+### 🎯 AI vs Real Classification
+- Powered by **OpenCLIP (ViT-L-14)** deep vision model
+- Transfer learning with a custom binary classification head
+- Outputs a clean probability score per image
+
+### 🎨 Visual Highlighting
+- 🔴 **Red border** → AI Generated
+- 🟢 **Green border** → Real
+- Hover over any image to see its label + confidence score
+
+### 📊 Page Risk Analysis
+Calculates an overall AI content percentage for the entire page:
+
+| Risk Level | Range | Meaning |
+|------------|-------|---------|
+| 🟢 Low Risk | 0–30% | Mostly real content |
+| 🟡 Moderate Risk | 30–70% | Mixed content |
+| 🔴 High Risk | 70–100% | Mostly AI-generated |
+
+### ⚡ Clean UI/UX
+- Minimal, Apple-inspired design
+- Fast and non-intrusive
+- Confidence scores displayed inline
+
+---
+
+## ⚙️ How It Works
+
+### Step 1 — Image Extraction
+The extension scans the webpage DOM and collects all visible `<img>` elements, extracting their `src` URLs for backend processing.
+
+### Step 2 — URL-Based Backend Processing
+Image URLs are sent directly to the Flask backend — no screenshots, no compression artifacts. This ensures maximum accuracy and faster processing.
+
+### Step 3 — Feature Extraction via OpenCLIP
+The backend uses a frozen **OpenCLIP (ViT-L-14)** backbone pretrained on `datacomp_xl_s13b_b90k` to convert each image into rich deep feature embeddings.
+
+### Step 4 — Custom Classification Head
+A lightweight neural network processes those embeddings:
+
+```
+Linear → ReLU → Dropout → Linear → Sigmoid
+```
+
+Output: A probability score indicating how likely the image is AI-generated.
+
+### Step 5 — UI Rendering
+Results are pushed back to the extension, which:
+- Highlights each image directly on the page
+- Overlays confidence labels on hover
+- Updates the popup with page-level risk analysis
+
+---
+
+## 🧪 Model Details
+
+| Property | Value |
+|----------|-------|
+| **Backbone** | OpenCLIP (ViT-L-14) |
+| **Pretrained On** | datacomp_xl_s13b_b90k |
+| **Approach** | Transfer Learning |
+| **Encoder** | Frozen |
+| **Head** | Custom Binary Classifier |
+| **Output** | AI / Real + Probability |
+
+### 📂 Training Dataset
+
+**AI Images:** Stable Diffusion, Midjourney, DALL·E, Flux
+
+**Real Images:** Unsplash dataset
+
+---
+
+## 🏗 Project Structure
+
+```
+extension-deepfake/
+│
+├── app.py                        # Flask backend — model inference & API
+├── OpenCLIP_forensic_head.pth      # Trained model weights
+├── train.py                      # Training script (reference only)
+│
+└── extension/
+    ├── manifest.json             # Chrome extension configuration
+    ├── popup.html                # Extension UI layout
+    ├── popup.js                  # Button logic & UI state updates
+    └── content.js                # DOM scanning & image highlighting
+```
+
+---
+
+## ⚙️ Setup & Installation
+
+### Prerequisites
+
+- Python 3.8+
+- pip
+- Google Chrome browser
+
+---
+
+### 1. Clone the Repository
+
+```bash
+git clone https://github.com/How2Invade/extension-deepfake.git
+cd extension-deepfake
+```
+
+---
+
+### 2. Install Backend Dependencies
+
+```bash
+pip install torch torchvision flask pillow open_clip_torch
+```
+
+---
+
+### 3. Run the Flask Backend
+
+```bash
+python app.py
+```
+
+The server will start at:
+
+```
+http://127.0.0.1:5000
+```
+
+> Keep this terminal running while using the extension.
+
+---
+
+### 4. Load the Chrome Extension
+
+1. Open Chrome and navigate to `chrome://extensions/`
+2. Toggle **Developer Mode** (top right)
+3. Click **Load Unpacked**
+4. Select the `extension/` folder from the cloned repo
+
+---
+
+### 5. Start Detecting
+
+1. Open any webpage (try Google Images)
+2. Click the **AI Detector** extension icon
+3. Hit **Scan Images**
+
+Every image on the page will be analyzed and highlighted instantly.
+
+---
+
+## 🎯 Output
+
+Each scanned image receives:
+- A **colored border** (Red = AI, Green = Real)
+- A **confidence label** on hover (e.g., `AI — 78%` or `Real — 64%`)
+
+The popup displays:
+- Overall **risk percentage**
+- Page-level **verdict** (Low / Moderate / High Risk)
+
+---
+
+## 🔮 Future Scope
+
+- 🎥 **Video deepfake detection** — frame-by-frame analysis
+- 🎙️ **Audio deepfake detection** — voice synthesis identification
+- ☁️ **Cloud deployment** — remove the local backend requirement
+- 📊 **Advanced analytics dashboard** — historical scan data & trends
+- ⚡ **Batch inference optimization** — faster multi-image processing
+
+---
+
+## ⚠️ Limitations
+
+- Accuracy depends on training data coverage
+- Some false positives may occur on heavily stylized images
+- Backend must be running locally for the extension to work
+
+---
+
+## 🏆 Impact
+
+AI Detector directly addresses one of the most pressing issues of the AI era:
+
+- ✅ Detecting fake and synthetic content at scale
+- ✅ Reducing the spread of AI-powered misinformation
+- ✅ Empowering users to verify what they see online
+- ✅ Assisting journalists, researchers, and media professionals
+
+---
+
+## 🙏 Acknowledgments
+
+- [OpenCLIP](https://github.com/mlfoundations/open_clip) for the OpenCLIP vision model
+- [PyTorch](https://pytorch.org/) ecosystem for model training and inference
+- [Chrome Extensions API](https://developer.chrome.com/docs/extensions/) for browser integration
+- [Unsplash](https://unsplash.com/) for real image training data
+
+---
+
+<div align="center">
+
+### 💡 Built to bring trust in an AI-generated world
+
+[⭐ Star on GitHub](https://github.com/How2Invade/extension-deepfake) • [🐛 Report an Issue](https://github.com/How2Invade/extension-deepfake/issues)
+
+</div>

app.py

@@ -0,0 +1,269 @@
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+import torch
+import torch.nn as nn
+import open_clip
+from PIL import Image, ImageFilter
+from torchvision import transforms, models
+from io import BytesIO
+import requests
+import base64
+import numpy as np
+
+app = Flask(__name__)
+CORS(app)
+
+DEVICE = torch.device("mps") if torch.backends.mps.is_available() else torch.device("cpu")
+
+
+class ForensicHead(nn.Module):
+    def __init__(self, input_dim=768):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(input_dim, 512),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(512, 1),
+            nn.Sigmoid()
+        )
+
+    def forward(self, x):
+        return self.net(x)
+
+
+print("Loading Models...")
+
+model, _, preprocess = open_clip.create_model_and_transforms(
+    "ViT-L-14",
+    pretrained="datacomp_xl_s13b_b90k"
+)
+model = model.to(DEVICE)
+model.eval()
+
+tokenizer = open_clip.get_tokenizer("ViT-L-14")
+
+AI_FLAWS = [
+    "plastic skin, overly smooth textures, and lack of realistic pores",
+    "distorted anatomical shapes like strange hands, limbs, or face",
+    "inconsistent lighting, impossible shadows, or unnatural highlights",
+    "garbled, blurred, or nonsensical background details and text",
+    "asymmetrical facial features or floating elements",
+    "blending errors where subjects melt unnaturally into the background"
+]
+
+REAL_TRAITS = [
+    "natural texture with visible realistic imperfections",
+    "physically consistent lighting, shadows, and reflections",
+    "natural anatomical proportions and distinct physical boundaries",
+    "sharp, coherent background elements and depth of field",
+    "authentic noise and realistic color balance"
+]
+
+print("Encoding explainability vectors...")
+ai_tokens = tokenizer(AI_FLAWS).to(DEVICE)
+real_tokens = tokenizer(REAL_TRAITS).to(DEVICE)
+
+with torch.no_grad():
+    ai_text_features = model.encode_text(ai_tokens)
+    ai_text_features /= ai_text_features.norm(dim=-1, keepdim=True)
+    
+    real_text_features = model.encode_text(real_tokens)
+    real_text_features /= real_text_features.norm(dim=-1, keepdim=True)
+
+head = ForensicHead(input_dim=768)
+head.load_state_dict(torch.load("models/openclip_forensic_head.pth", map_location=DEVICE))
+head = head.to(DEVICE)
+head.eval()
+
+cn_backbone = models.convnext_base(weights=None)
+cn_backbone.to(DEVICE)
+cn_backbone.eval()
+
+class ConvNextHead(nn.Module):
+    def __init__(self, input_dim=1024):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(input_dim, 512),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(512, 1)
+        )
+    def forward(self, x): return self.net(x)
+
+cn_head = ConvNextHead(input_dim=1024).to(DEVICE)
+cn_head.load_state_dict(torch.load('models/convnext_forensic_head.pth', map_location=DEVICE))
+cn_head.eval()
+
+cn_preprocess = transforms.Compose([
+    transforms.Resize(256),
+    transforms.CenterCrop(224),
+    transforms.ToTensor(),
+    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+])
+
+print("Models loaded")
+
+
+def load_image_from_url(url: str) -> Image.Image:
+    headers = {
+        "User-Agent": "Mozilla/5.0"
+    }
+    response = requests.get(url, headers=headers, timeout=8)
+    response.raise_for_status()
+    return Image.open(BytesIO(response.content)).convert("RGB")
+
+
+def load_image_from_data_url(data_url: str) -> Image.Image:
+    if "," not in data_url:
+        raise ValueError("Invalid data URL")
+
+    _, encoded = data_url.split(",", 1)
+    raw = base64.b64decode(encoded)
+    return Image.open(BytesIO(raw)).convert("RGB")
+
+
+def load_any_image(payload: dict) -> Image.Image:
+    if "image_url" in payload and payload["image_url"]:
+        src = payload["image_url"]
+        if src.startswith("data:"):
+            return load_image_from_data_url(src)
+        return load_image_from_url(src)
+
+    if "image" in payload and payload["image"]:
+        return load_image_from_data_url(payload["image"])
+
+    raise ValueError("No image data provided")
+
+
+def get_explanation(label: str, img_feat_tensor: torch.Tensor, heuristics: dict, confidence: float) -> str:
+    """Combines Zero-Shot CLIP semantic extraction with raw OpenCV Image Processing."""
+    noise = heuristics.get('noise_level', 0)
+    edges = heuristics.get('edge_density', 0)
+    
+    if label == "AI":
+        # find the closest semantic flaw using dot product similarity
+        similarity = (100.0 * img_feat_tensor @ ai_text_features.T).softmax(dim=-1)
+        top_idx = similarity.argmax().item()
+        semantic_reason = AI_FLAWS[top_idx]
+        
+        technical_reason = []
+        if noise < 0.025:
+            technical_reason.append(f"an unnatural lack of sensor noise ({noise:.3f})")
+        if edges < 0.1:
+            technical_reason.append("abnormally soft structural contours")
+            
+        tech_str = (" coupled directly with " + " and ".join(technical_reason)) if technical_reason else ""
+        return f"The model detected {semantic_reason}{tech_str}.<br/><br/><strong>Assessed as Synthetic ({confidence*100:.1f}% confidence)</strong>"
+    else:
+        # Feature Extraction: Find closest authentic trait
+        similarity = (100.0 * img_feat_tensor @ real_text_features.T).softmax(dim=-1)
+        top_idx = similarity.argmax().item()
+        semantic_reason = REAL_TRAITS[top_idx]
+        
+        technical_reason = []
+        if noise > 0.04:
+            technical_reason.append(f"expected natural grain matrix ({noise:.3f})")
+        if edges >= 0.1:
+            technical_reason.append("well-defined structural boundaries")
+            
+        tech_str = (" supported by " + " and ".join(technical_reason)) if technical_reason else ""
+        return f"The model identified {semantic_reason}{tech_str}.<br/><br/><strong>Assessed as Authentic</strong>"
+
+
+def extract_simple_features(img: Image.Image):
+    """Extract image characteristics WITHOUT ML"""
+    img_rgb = img.convert('RGB')
+    img_array = np.array(img_rgb) / 255.0
+
+    # Edge density (real photos have more natural edges, less uniform)
+    edges = np.abs(np.diff(np.mean(img_array, axis=2), axis=0)).mean() + \
+            np.abs(np.diff(np.mean(img_array, axis=2), axis=1)).mean()
+
+    # Noise level (real photos have noise, AI images are smoother)
+    img_smooth = np.array(img_rgb.filter(ImageFilter.GaussianBlur(2))) / 255.0
+    noise = np.mean((img_array - img_smooth) ** 2) * 1000  # scale for visibility
+
+    # Color balance (product photos often have strong color gradients)
+    hsv = img.convert('HSV')
+    hsv_array = np.array(hsv) / 255.0
+    color_variance = np.var(hsv_array[:, :, 0])  # hue variance
+
+    return {
+        'edge_density': edges,
+        'noise_level': noise,
+        'color_variance': color_variance,
+        'is_too_clean': (noise < 0.02 and edges < 0.1),  # product photo signature
+    }
+
+
+def calibrate_output(img: Image.Image, raw_confidence: float):
+    """Adjust model confidence based on image characteristics"""
+    features = extract_simple_features(img)
+
+    if features['is_too_clean']:
+        adjusted_confidence = raw_confidence * 0.67
+    else:
+        adjusted_confidence = raw_confidence
+    adjusted_confidence = min(adjusted_confidence, 0.90)
+
+    return adjusted_confidence, features
+
+
+@app.route("/predict", methods=["POST"])
+def predict():
+    try:
+        data = request.get_json(force=True, silent=False)
+        image = load_any_image(data)
+
+        openclip_weight = 0.95
+        convnext_weight = 0.05
+
+        # openclip inference
+        img_openclip = preprocess(image).unsqueeze(0).to(DEVICE)
+        with torch.no_grad():
+            features = model.encode_image(img_openclip)
+            features = features / features.norm(dim=-1, keepdim=True)
+            prob_openclip = float(head(features).item())
+            
+            global_image_features = features.squeeze(0).clone()
+
+        # convnext inference
+        img_cn = cn_preprocess(image).unsqueeze(0).to(DEVICE)
+        with torch.no_grad():
+            cn_feat = cn_backbone.features(img_cn)
+            cn_feat = cn_backbone.avgpool(cn_feat)
+            cn_feat = torch.flatten(cn_feat, 1)
+            cn_logit = cn_head(cn_feat)
+            prob_cn = torch.sigmoid(cn_logit).item()
+            
+        total_ml_weight = openclip_weight + convnext_weight
+        if total_ml_weight > 0:
+            raw_ensemble_score = (prob_openclip * openclip_weight + prob_cn * convnext_weight) / total_ml_weight
+        else:
+            raw_ensemble_score = (prob_openclip + prob_cn) / 2.0
+
+        prob, img_features = calibrate_output(image, raw_ensemble_score)
+
+        label = "AI" if prob >= 0.75 else "Real"
+        confidence = prob if label == "AI" else 1 - prob
+
+        return jsonify({
+            "label": label,
+            "confidence": confidence,
+            "explanation": get_explanation(label, global_image_features, img_features, confidence),
+            "scores": {
+                "openclip": prob_openclip,
+                "convnext": prob_cn,
+                "ensemble_raw": raw_ensemble_score,
+                "calibrated_final": prob
+            }
+        })
+
+    except Exception as e:
+        return jsonify({
+            "error": str(e)
+        }), 500
+
+
+if __name__ == "__main__":
+    app.run(debug=True)

extension/background.js

@@ -0,0 +1,114 @@
+// ── AI Detector · background.js (service worker) ─────────────────────────
+//
+// Responsibilities:
+//   1. Keep a canonical scan-result cache (in-memory + storage)
+//   2. Handle OPEN_SIDE_PANEL messages from popup
+//   3. Relay GET_SCAN_RESULT / CLEAR_SCAN_RESULT messages to side panel
+// ── Init side panel on action click ───────────────────────────────────────
+chrome.runtime.onInstalled.addListener(() => {
+  chrome.sidePanel.setPanelBehavior({ openPanelOnActionClick: true }).catch((error) => console.error(error));
+});
+
+// ── In-memory result cache ────────────────────────────────────────────────
+// Survives for the lifetime of the service worker (typically a few minutes
+// of inactivity). chrome.storage.local is the durable fallback.
+let cachedResult = null;
+
+const activeScans = new Set();
+
+chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
+
+  // Orchestrate scan logic globally to avoid duplication and sync state
+  if (msg.type === "START_SCAN") {
+    const tabId = msg.tabId;
+    if (activeScans.has(tabId)) {
+      sendResponse({ ok: false });
+      return false;
+    }
+    activeScans.add(tabId);
+    console.log("SCAN_STARTED");
+
+    cachedResult = { status: "scanning", tabId, timestamp: Date.now() };
+    chrome.storage.local.set({ scanResult: cachedResult, lastScreenshot: msg.screenshot }).catch(()=>{});
+
+    chrome.scripting.executeScript({
+      target: { tabId },
+      files: ["content.js"]
+    }).then(() => {
+      const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Scan timed out after 90 seconds")), 90000));
+      const scanPromise = new Promise((resolve, reject) => {
+        chrome.tabs.sendMessage(tabId, { type: "SCAN_IMAGES", screenshot: msg.screenshot }, (resp) => {
+          if (chrome.runtime.lastError) reject(new Error(chrome.runtime.lastError.message));
+          else resolve(resp);
+        });
+      });
+      return Promise.race([scanPromise, timeoutPromise]);
+    }).then((response) => {
+      if (!response) throw new Error("No response from content script");
+      
+      let finalResult;
+      if (response.stopped) {
+        finalResult = { status: "stopped", risk: 0, count: 0, explanation: null, tabId, timestamp: Date.now() };
+      } else if (response.done) {
+        const risk = typeof response.risk === "number" ? response.risk : 0;
+        const count = typeof response.count === "number" ? response.count : 0;
+        const explanation = response.explanation || null;
+        const rawConfidence = typeof response.rawConfidence === "number" ? response.rawConfidence : risk / 100;
+        finalResult = { status: "done", risk, count, explanation, rawConfidence, tabId, timestamp: Date.now() };
+      } else {
+        throw new Error(response.error || "Unexpected response");
+      }
+      
+      console.log("SCAN_COMPLETED");
+      cachedResult = finalResult;
+      chrome.storage.local.set({ scanResult: finalResult }).catch(()=>{});
+    }).catch(err => {
+      console.warn("SCAN_ERROR:", err.message);
+      const errResult = { status: "error", error: err.message, tabId, timestamp: Date.now() };
+      cachedResult = errResult;
+      chrome.storage.local.set({ scanResult: errResult }).catch(()=>{});
+    }).finally(() => {
+      activeScans.delete(tabId);
+    });
+
+    sendResponse({ ok: true });
+    return false;
+  }
+
+  if (msg.type === "STOP_SCAN") {
+    console.log("SCAN_STOPPED");
+    chrome.tabs.sendMessage(msg.tabId, { type: "STOP_SCAN" }, () => {
+      void chrome.runtime.lastError;
+    });
+    sendResponse({ ok: true });
+    return false;
+  }
+
+  // Side panel → background: retrieve latest scan result
+  if (msg.type === "GET_SCAN_RESULT") {
+    if (cachedResult) {
+      sendResponse({ result: cachedResult });
+      return false;
+    }
+    // Fall back to storage (service worker may have been restarted)
+    chrome.storage.local.get("scanResult", (data) => {
+      if (chrome.runtime.lastError) {
+        console.warn("[BG] storage read error:", chrome.runtime.lastError.message);
+        sendResponse({ result: null });
+        return;
+      }
+      cachedResult = data.scanResult || null;
+      sendResponse({ result: cachedResult });
+    });
+    return true; // async response
+  }
+
+
+  // Popup or side panel: clear stored result
+  if (msg.type === "CLEAR_SCAN_RESULT") {
+    cachedResult = null;
+    chrome.storage.local.remove("scanResult");
+    sendResponse({ ok: true });
+    return false;
+  }
+});

extension/content.js

@@ -0,0 +1,404 @@
+if (!window.__AI_DETECTOR_LOADED__) {
+  window.__AI_DETECTOR_LOADED__ = true;
+
+  const OVERLAY_ATTR = "data-ai-detector-overlay";
+  const TIP_ATTR = "data-ai-detector-tip";
+  let activeOverlays = [];
+
+  // ── Stop-scan flag ──────────────────────────────────────────────────────
+  // Reset on every new SCAN_IMAGES request; set to true by STOP_SCAN.
+  let stopRequested = false;
+
+  /* ── Inject shared tooltip styles once ── */
+  if (!document.getElementById("__ai_detector_styles__")) {
+    const link = document.createElement("link");
+    link.rel = "stylesheet";
+    link.href = "https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@400;500&family=Inter:wght@400;500;600;700&display=swap";
+    document.head.appendChild(link);
+
+    const style = document.createElement("style");
+    style.id = "__ai_detector_styles__";
+    style.textContent = `
+      [${TIP_ATTR}="1"] {
+        --radai-mono: "IBM Plex Mono", monospace, sans-serif;
+        --radai-sans: "Inter", -apple-system, system-ui, sans-serif;
+        position: fixed;
+        pointer-events: none;
+        z-index: 2147483647;
+        background: #ffffff;
+        border: 1px solid #d4d4d4;
+        border-radius: 4px;
+        padding: 14px;
+        box-shadow: 0 4px 12px rgba(0,0,0,0.1);
+        font-family: var(--radai-sans);
+        color: #111111;
+        min-width: 200px;
+        max-width: 320px;
+        opacity: 0;
+        transform: translateY(4px);
+        transition: opacity 0.2s ease, transform 0.2s ease;
+        line-height: 1.5;
+      }
+
+      [${TIP_ATTR}="1"].visible {
+        opacity: 1;
+        transform: translateY(0);
+      }
+
+      [${TIP_ATTR}="1"] .tip-header {
+        display: flex;
+        align-items: flex-start;
+        justify-content: space-between;
+        margin-bottom: 10px;
+        gap: 12px;
+      }
+
+      [${TIP_ATTR}="1"] .tip-label {
+        font-size: 18px;
+        font-weight: 700;
+        letter-spacing: -0.5px;
+        line-height: 1;
+      }
+
+      [${TIP_ATTR}="1"] .tip-badge {
+        font-size: 18px;
+        font-weight: 700;
+        font-family: var(--radai-mono);
+        letter-spacing: -0.5px;
+        line-height: 1;
+      }
+
+      [${TIP_ATTR}="1"] .tip-divider {
+        height: 1px;
+        background: #e5e5e5;
+        margin-bottom: 10px;
+      }
+
+      [${TIP_ATTR}="1"] .tip-text {
+        font-size: 12px;
+        color: #525252;
+        font-weight: 400;
+        line-height: 1.5;
+      }
+    `;
+    document.head.appendChild(style);
+  }
+
+  /* ── Clear all overlays ── */
+  function clearBoxes() {
+    activeOverlays.forEach(o => o.box.remove());
+    activeOverlays = [];
+    document.querySelectorAll(`[${TIP_ATTR}="1"]`).forEach(el => el.remove());
+  }
+
+  /* ── Get a muted color per label ── */
+  function labelColor(label) {
+    return label === "AI" ? "#e53e3e" : "#38a169";
+  }
+
+  /* ── Strip HTML ── */
+  function stripHtml(htmlStr) {
+    if (!htmlStr) return "Analysis complete.";
+    const tmp = document.createElement("div");
+    tmp.innerHTML = htmlStr;
+    return tmp.textContent || tmp.innerText || "";
+  }
+
+  /* ── Build the tooltip element ── */
+  function buildTooltip(data) {
+    const rawExp = data.explanation || "";
+    const fullExp = stripHtml(rawExp);
+    const color = labelColor(data.label);
+    const pct = Math.round(data.confidence * 100);
+
+    const tip = document.createElement("div");
+    tip.setAttribute(TIP_ATTR, "1");
+
+    tip.innerHTML = `
+      <div class="tip-header">
+        <span class="tip-label" style="color:${color}">${data.label === "AI" ? "AI Generated" : "Likely Real"}</span>
+        <span class="tip-badge" style="color:${color};">${pct}%</span>
+      </div>
+      <div class="tip-divider"></div>
+      <div class="tip-text">${fullExp}</div>
+    `;
+
+    return tip;
+  }
+
+  /* ── Position tooltip near image, keeping it in viewport ── */
+  function positionTooltip(tip, rect) {
+    const TIP_W = 172;
+    const TIP_H = 118;
+    const PAD = 10;
+
+    let left = rect.left;
+    let top = rect.top - TIP_H - 10;
+
+    // Flip below if not enough room above
+    if (top < PAD) top = rect.bottom + 10;
+
+    // Clamp horizontally
+    if (left + TIP_W > window.innerWidth - PAD) {
+      left = window.innerWidth - TIP_W - PAD;
+    }
+    if (left < PAD) left = PAD;
+
+    tip.style.left = `${left}px`;
+    tip.style.top = `${top}px`;
+  }
+
+  /* ── Draw border box + attach hover tooltip ── */
+  function drawBox(img, data) {
+    const rect = img.getBoundingClientRect();
+    const color = labelColor(data.label);
+
+    // Border overlay box
+    const box = document.createElement("div");
+    box.setAttribute(OVERLAY_ATTR, "1");
+    box.style.cssText = `
+      position: absolute;
+      left: ${rect.left + window.scrollX}px;
+      top: ${rect.top + window.scrollY}px;
+      width: ${rect.width}px;
+      height: ${rect.height}px;
+      border: 3px solid ${color};
+      border-radius: 10px;
+      pointer-events: none;
+      z-index: 999998;
+      opacity: 0;
+      transition: opacity 0.25s ease;
+      box-shadow: 0 0 0 1px rgba(255,255,255,0.15), 0 4px 20px ${color}33;
+    `;
+
+    // Small inline label tag
+    const tag = document.createElement("div");
+    tag.style.cssText = `
+      position: absolute;
+      top: -1px;
+      left: -1px;
+      padding: 3px 8px;
+      font-size: 11px;
+      font-weight: 600;
+      font-family: -apple-system, BlinkMacSystemFont, "Inter", sans-serif;
+      color: #ffffff;
+      background: ${color};
+      border-radius: 9px 0 9px 0;
+      letter-spacing: 0.2px;
+      line-height: 1.6;
+    `;
+    tag.textContent = `${data.label} · ${Math.round(data.confidence * 100)}%`;
+
+    box.appendChild(tag);
+    document.body.appendChild(box);
+    activeOverlays.push({ img, box });
+
+    // Fade in
+    requestAnimationFrame(() => { box.style.opacity = "1"; });
+
+    // Hover tooltip (attached to the img element)
+    if (!img.dataset.aiDetectorBound) {
+      img.dataset.aiDetectorBound = "1";
+
+      let activeTip = null;
+
+      img.addEventListener("mouseenter", () => {
+        // Remove any existing tip
+        document.querySelectorAll(`[${TIP_ATTR}="1"]`).forEach(el => el.remove());
+
+        const r = img.getBoundingClientRect();
+        const tip = buildTooltip(data);
+        document.body.appendChild(tip);
+
+        positionTooltip(tip, r);
+        activeTip = tip;
+
+        // Trigger fade-in on next frame
+        requestAnimationFrame(() => { tip.classList.add("visible"); });
+      });
+
+      img.addEventListener("mouseleave", () => {
+        if (activeTip) {
+          activeTip.classList.remove("visible");
+          const dying = activeTip;
+          activeTip = null;
+          setTimeout(() => dying.remove(), 220);
+        }
+      });
+
+      // Re-position if user scrolls while hovering
+      window.addEventListener("scroll", () => {
+        if (activeTip) {
+          const r = img.getBoundingClientRect();
+          positionTooltip(activeTip, r);
+        }
+      }, { passive: true });
+    }
+  }
+
+  /* ── Recalculate Box Positions on Resize ── */
+  let resizeTimeout;
+  window.addEventListener("resize", () => {
+    clearTimeout(resizeTimeout);
+    resizeTimeout = setTimeout(() => {
+      activeOverlays.forEach(({ img, box }) => {
+        if (!img.isConnected) {
+          box.style.display = "none";
+          return;
+        }
+
+        const rect = img.getBoundingClientRect();
+
+        // Hide box if image becomes invisible or too small
+        if (rect.width === 0 || rect.height === 0) {
+          box.style.display = "none";
+          return;
+        }
+
+        box.style.display = "block";
+        box.style.left = `${rect.left + window.scrollX}px`;
+        box.style.top = `${rect.top + window.scrollY}px`;
+        box.style.width = `${rect.width}px`;
+        box.style.height = `${rect.height}px`;
+      });
+    }, 150); // slight debounce ensures sidebar finishes dragging/animating
+  }, { passive: true });
+
+  /* ── Helpers ── */
+  function loadImage(src) {
+    return new Promise((resolve, reject) => {
+      const image = new Image();
+      image.onload = () => resolve(image);
+      image.onerror = reject;
+      image.src = src;
+    });
+  }
+
+  async function cropVisibleImageFromScreenshot(screenshotDataUrl, rect) {
+    const shot = await loadImage(screenshotDataUrl);
+
+    const scaleX = shot.width / window.innerWidth;
+    const scaleY = shot.height / window.innerHeight;
+
+    const sx = Math.max(0, rect.left * scaleX);
+    const sy = Math.max(0, rect.top * scaleY);
+    const sw = Math.max(1, rect.width * scaleX);
+    const sh = Math.max(1, rect.height * scaleY);
+
+    const canvas = document.createElement("canvas");
+    canvas.width = Math.max(1, Math.round(sw));
+    canvas.height = Math.max(1, Math.round(sh));
+
+    const ctx = canvas.getContext("2d");
+    ctx.drawImage(shot, sx, sy, sw, sh, 0, 0, canvas.width, canvas.height);
+
+    return canvas.toDataURL("image/png");
+  }
+
+  async function predictWithUrlOrFallback(img, screenshotDataUrl) {
+    const url = img.currentSrc || img.src;
+
+    if (url && !url.startsWith("blob:")) {
+      try {
+        const res = await fetch("http://127.0.0.1:5000/predict", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ image_url: url })
+        });
+        if (res.ok) return await res.json();
+      } catch (err) {
+        console.log("URL path failed, falling back to screenshot crop:", err);
+      }
+    }
+
+    const rect = img.getBoundingClientRect();
+    const cropDataUrl = await cropVisibleImageFromScreenshot(screenshotDataUrl, rect);
+
+    const res = await fetch("http://127.0.0.1:5000/predict", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ image: cropDataUrl })
+    });
+
+    if (!res.ok) throw new Error(`Prediction failed with status ${res.status}`);
+    return await res.json();
+  }
+
+  async function scanImages(screenshotDataUrl) {
+    clearBoxes();
+    stopRequested = false;
+
+    const images = Array.from(document.querySelectorAll("img")).filter(img => {
+      const rect = img.getBoundingClientRect();
+      return (
+        img.complete &&
+        img.naturalWidth > 0 &&
+        rect.width >= 80 &&
+        rect.height >= 80
+      );
+    });
+
+    let count = 0;
+    let aiCount = 0;
+    let lastExplanation = null;
+
+    for (const img of images) {
+      // Check stop flag before processing each image
+      if (stopRequested) {
+        return { count, aiCount, risk: count > 0 ? Math.round((aiCount / count) * 100) : 0, explanation: lastExplanation, stopped: true, total: images.length };
+      }
+
+      try {
+        const data = await predictWithUrlOrFallback(img, screenshotDataUrl);
+
+        if (stopRequested) {
+          return { count, aiCount, risk: count > 0 ? Math.round((aiCount / count) * 100) : 0, explanation: lastExplanation, stopped: true, total: images.length };
+        }
+
+        if (data.label === "AI") {
+          aiCount++;
+        }
+        // Save the last explanation regardless of label to provide some feedback
+        if (data.explanation) lastExplanation = data.explanation;
+
+        drawBox(img, data);
+        count++;
+      } catch (err) {
+        console.log("Skipping image:", err);
+      }
+    }
+
+    const risk = count > 0 ? Math.round((aiCount / count) * 100) : 0;
+    return { count, risk, explanation: lastExplanation, stopped: false };
+  }
+
+  chrome.runtime.onMessage.addListener((req, sender, sendResponse) => {
+    if (req.action === "SCAN_IMAGES") {
+      scanImages(req.screenshot)
+        .then(result => {
+          if (result.stopped) {
+            sendResponse({ done: false, stopped: true, count: result.count, aiCount: result.aiCount, total: result.total, risk: result.risk, explanation: result.explanation });
+          } else {
+            sendResponse({
+              done: true,
+              count: result.count,
+              risk: result.risk,
+              explanation: result.explanation
+            });
+          }
+        })
+        .catch(err => {
+          console.error(err);
+          sendResponse({ done: false, error: String(err) });
+        });
+
+      return true; // keep message channel open
+    }
+
+    if (req.action === "STOP_SCAN") {
+      stopRequested = true;
+      // No sendResponse needed; popup will receive the stopped flag via SCAN_IMAGES response
+      return false;
+    }
+  });
+}

extension/manifest.json

@@ -0,0 +1,29 @@
+{
+  "manifest_version": 3,
+  "name": "RADAI",
+  "version": "2.0",
+  "description": "Detect AI-generated images on webpages.",
+  "permissions": [
+    "activeTab",
+    "tabs",
+    "scripting",
+    "storage",
+    "sidePanel"
+  ],
+  "host_permissions": [
+    "http://127.0.0.1:5000/*"
+  ],
+  "action": {},
+  "side_panel": {
+    "default_path": "sidepanel.html"
+  },
+  "background": {
+    "service_worker": "background.js"
+  },
+  "content_scripts": [
+    {
+      "matches": ["<all_urls>"],
+      "js": ["content.js"]
+    }
+  ]
+}

extension/sidepanel.html

@@ -0,0 +1,635 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>RADAI / Analysis</title>
+  <link rel="preconnect" href="https://fonts.googleapis.com" />
+  <link
+    href="https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@400;500&family=Inter:wght@400;500;600;700&display=swap"
+    rel="stylesheet" />
+  <style>
+    /* ─────────────────────────────────────────────────────────────
+       DESIGN SYSTEM — forensic tool aesthetic
+       Palette: near-white bg, near-black text, grey structure,
+                muted red (#b91c1c) for danger, amber for warnings.
+       No gradients. No box-shadows beyond hairlines. No rounding > 6px.
+    ───────────────────────────────────────────────────────────── */
+    :root {
+      --bg: #f4f4f4;
+      --surface: #ffffff;
+      --border: #d4d4d4;
+      --border-lg: #e5e5e5;
+      --text: #111111;
+      --text2: #525252;
+      --text3: #737373;
+      --danger: #b91c1c;
+      --danger-dim: rgba(185, 28, 28, 0.07);
+      --warn: #92400e;
+      --warn-dim: rgba(146, 64, 14, 0.07);
+      --ok: #14532d;
+      --ok-dim: rgba(20, 83, 45, 0.07);
+      --mono: 'IBM Plex Mono', monospace;
+      --sans: 'Inter', system-ui, sans-serif;
+    }
+
+    [data-theme="dark"] {
+      --bg: #0f0f0f;
+      --surface: #1a1a1a;
+      --border: #303030;
+      --border-lg: #242424;
+      --text: #e5e5e5;
+      --text2: #a3a3a3;
+      --text3: #737373;
+      --danger: #ef4444;
+      --danger-dim: rgba(239, 68, 68, 0.08);
+      --warn: #f59e0b;
+      --warn-dim: rgba(245, 158, 11, 0.08);
+      --ok: #22c55e;
+      --ok-dim: rgba(34, 197, 94, 0.08);
+    }
+
+    *,
+    *::before,
+    *::after {
+      box-sizing: border-box;
+      margin: 0;
+      padding: 0;
+    }
+
+    html,
+    body {
+      height: 100%;
+    }
+
+    body {
+      font-family: var(--sans);
+      background: var(--bg);
+      color: var(--text);
+      font-size: 13px;
+      line-height: 1.5;
+      -webkit-font-smoothing: antialiased;
+      overflow: hidden;
+    }
+
+    /* ── Panel ── */
+    .panel {
+      height: 100vh;
+      display: flex;
+      flex-direction: column;
+      overflow-y: auto;
+      overflow-x: hidden;
+      scrollbar-width: thin;
+      scrollbar-color: var(--border) transparent;
+    }
+
+    .panel::-webkit-scrollbar {
+      width: 4px;
+    }
+
+    .panel::-webkit-scrollbar-thumb {
+      background: var(--border);
+    }
+
+    /* ── Top bar ── */
+    .topbar {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      padding: 10px 14px;
+      background: var(--surface);
+      border-bottom: 1px solid var(--border);
+      flex-shrink: 0;
+      position: sticky;
+      top: 0;
+      z-index: 100;
+    }
+
+    .brand {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+    }
+
+    .brand-mark {
+      width: 20px;
+      height: 20px;
+      display: grid;
+      place-items: center;
+      color: var(--text);
+    }
+
+    .brand-mark svg {
+      width: 18px;
+      height: 18px;
+    }
+
+    .brand-name {
+      font-size: 12px;
+      font-weight: 700;
+      letter-spacing: 0.5px;
+      text-transform: uppercase;
+      color: var(--text);
+    }
+
+    .brand-sep {
+      width: 1px;
+      height: 12px;
+      background: var(--border);
+    }
+
+    .brand-sub {
+      font-size: 10px;
+      color: var(--text3);
+      font-family: var(--mono);
+      letter-spacing: 0.5px;
+    }
+
+    .topbar-right {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+    }
+
+    .topbar-chip {
+      font-size: 10px;
+      font-family: var(--mono);
+      font-weight: 500;
+      color: var(--text3);
+      border: 1px solid var(--border);
+      padding: 2px 8px;
+      border-radius: 2px;
+      white-space: nowrap;
+    }
+
+    .theme-toggle {
+      font-size: 10px;
+      font-family: var(--mono);
+      font-weight: 500;
+      color: var(--text2);
+      background: none;
+      border: 1px solid var(--border);
+      padding: 2px 8px;
+      border-radius: 2px;
+      cursor: pointer;
+      transition: color 0.1s, border-color 0.1s;
+    }
+
+    .theme-toggle:hover {
+      color: var(--text);
+      border-color: var(--text2);
+    }
+
+    /* ── Content area ── */
+    .content {
+      flex: 1;
+      padding: 14px;
+      display: flex;
+      flex-direction: column;
+      gap: 12px;
+    }
+
+    /* ── Empty state ── */
+    .empty {
+      flex: 1;
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      gap: 8px;
+      text-align: center;
+      padding: 40px 24px;
+    }
+
+    .empty-icon {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      width: 48px;
+      height: 48px;
+      border: 1px solid var(--border);
+      border-radius: 4px;
+      color: var(--text3);
+      margin-bottom: 6px;
+    }
+
+    .empty-icon svg {
+      width: 22px;
+      height: 22px;
+    }
+
+    .empty-title {
+      font-size: 14px;
+      font-weight: 600;
+      color: var(--text);
+    }
+
+    .empty-desc {
+      font-size: 12px;
+      color: var(--text3);
+      line-height: 1.55;
+      max-width: 220px;
+    }
+
+    /* ── Section label ── */
+    .section-label {
+      font-size: 10px;
+      font-family: var(--mono);
+      font-weight: 500;
+      letter-spacing: 0.8px;
+      text-transform: uppercase;
+      color: var(--text3);
+      margin-bottom: 6px;
+    }
+
+    /* ── Verdict card ── */
+    .verdict-card {
+      background: var(--surface);
+      border: 1px solid var(--border);
+      border-radius: 4px;
+      padding: 14px;
+    }
+
+    .verdict-top {
+      display: flex;
+      align-items: flex-start;
+      justify-content: space-between;
+      gap: 12px;
+    }
+
+    .verdict-label {
+      font-size: 28px;
+      font-weight: 700;
+      letter-spacing: -1px;
+      line-height: 1;
+      color: var(--text);
+    }
+
+    .verdict-meta {
+      display: flex;
+      flex-direction: column;
+      align-items: flex-end;
+      gap: 4px;
+      flex-shrink: 0;
+    }
+
+    .confidence-value {
+      font-size: 28px;
+      font-weight: 700;
+      letter-spacing: -1px;
+      line-height: 1;
+      font-family: var(--mono);
+      color: var(--text);
+    }
+
+    .confidence-label {
+      font-size: 10px;
+      font-family: var(--mono);
+      color: var(--text3);
+      letter-spacing: 0.5px;
+    }
+
+    .verdict-desc {
+      font-size: 12px;
+      color: var(--text2);
+      margin-top: 8px;
+      line-height: 1.5;
+    }
+
+    /* ── Status bar ── */
+    .status-bar {
+      margin-top: 12px;
+      padding-top: 10px;
+      border-top: 1px solid var(--border-lg);
+      display: flex;
+      align-items: center;
+      gap: 6px;
+    }
+
+    .status-dot {
+      width: 6px;
+      height: 6px;
+      border-radius: 50%;
+      flex-shrink: 0;
+    }
+
+    .status-text {
+      font-size: 11px;
+      font-family: var(--mono);
+      color: var(--text2);
+    }
+
+    /* ── Risk bar ── */
+    .risk-bar-wrap {
+      margin-top: 12px;
+    }
+
+    .risk-bar-header {
+      display: flex;
+      justify-content: space-between;
+      font-size: 10px;
+      font-family: var(--mono);
+      color: var(--text3);
+      margin-bottom: 5px;
+    }
+
+    .risk-bar-track {
+      height: 3px;
+      background: var(--border);
+      border-radius: 2px;
+      overflow: hidden;
+    }
+
+    .risk-bar-fill {
+      height: 100%;
+      width: 0%;
+      border-radius: 2px;
+      transition: width 0.6s ease;
+    }
+
+    /* ── How it works ── */
+    .how-it-works-card {
+      background: var(--surface);
+      border: 1px solid var(--border);
+      border-radius: 4px;
+      overflow: hidden;
+    }
+
+    .hiw-header {
+      padding: 10px 14px;
+      border-bottom: 1px solid var(--border-lg);
+    }
+
+    .hiw-body {
+      padding: 12px 14px;
+    }
+
+    .hiw-text {
+      font-size: 12px;
+      color: var(--text2);
+      line-height: 1.6;
+      margin-bottom: 8px;
+    }
+
+    .hiw-list {
+      list-style-type: disc;
+      padding-left: 20px;
+      margin-bottom: 0px;
+    }
+
+    .hiw-list li {
+      font-size: 12px;
+      color: var(--text2);
+      line-height: 1.6;
+      margin-bottom: 4px;
+    }
+
+
+    /* ── Footer ── */
+    .panel-footer {
+      padding: 8px 14px;
+      border-top: 1px solid var(--border);
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      flex-shrink: 0;
+      background: var(--surface);
+    }
+
+    .footer-left {
+      font-size: 10px;
+      font-family: var(--mono);
+      color: var(--text3);
+    }
+
+    .footer-right {
+      font-size: 10px;
+      font-family: var(--mono);
+      color: var(--text3);
+    }
+
+    /* ── Loading state ── */
+    .loading-bar {
+      height: 2px;
+      background: var(--border);
+      position: relative;
+      overflow: hidden;
+    }
+
+    .loading-bar::after {
+      content: '';
+      position: absolute;
+      left: -40%;
+      top: 0;
+      width: 40%;
+      height: 100%;
+      background: var(--text3);
+      animation: loading-slide 1.2s ease-in-out infinite;
+    }
+
+    @keyframes loading-slide {
+      0% {
+        left: -40%;
+      }
+
+      100% {
+        left: 110%;
+      }
+    }
+
+    /* ── Data container toggle ── */
+    #dataContainer {
+      display: none;
+    }
+
+    #dataContainer.visible {
+      display: contents;
+    }
+
+    #emptyState {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      flex: 1;
+    }
+
+    #emptyState.hidden {
+      display: none;
+    }
+
+    /* ── Stopped state ── */
+    .stopped-banner {
+      background: var(--warn-dim);
+      border: 1px solid currentColor;
+      color: var(--warn);
+      border-radius: 3px;
+      padding: 9px 12px;
+      font-size: 11px;
+      font-family: var(--mono);
+      margin-bottom: 12px;
+    }
+
+    /* ── Action buttons ── */
+    .btn-row {
+      display: grid;
+      grid-template-columns: 1fr auto;
+      gap: 6px;
+      margin-bottom: 2px;
+      flex-shrink: 0;
+    }
+
+    .btn {
+      border: 1px solid var(--border);
+      border-radius: 3px;
+      padding: 8px 12px;
+      background: var(--surface);
+      color: var(--text);
+      font-family: var(--mono);
+      font-size: 11px;
+      font-weight: 500;
+      cursor: pointer;
+      letter-spacing: 0.3px;
+      transition: background 0.1s, border-color 0.1s;
+    }
+
+    .btn:hover:not(:disabled) {
+      background: var(--border-lg);
+    }
+
+    .btn:disabled {
+      opacity: 0.35;
+      cursor: default;
+    }
+
+    .btn-danger {
+      color: var(--danger);
+      border-color: var(--danger);
+    }
+
+    .btn-danger:hover:not(:disabled) {
+      background: var(--danger-dim);
+    }
+  </style>
+</head>
+
+<body data-theme="light">
+
+  <div class="panel" id="panel">
+
+    <!-- Sticky topbar -->
+    <div class="topbar">
+      <div class="brand">
+        <div class="brand-mark">
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"
+            stroke-linejoin="round">
+            <polygon
+              points="12 2 15.09 8.26 22 9.27 17 14.14 18.18 21.02 12 17.77 5.82 21.02 7 14.14 2 9.27 8.91 8.26 12 2" />
+          </svg>
+        </div>
+        <span class="brand-name">RADAI</span>
+        <div class="brand-sep"></div>
+        <span class="brand-sub">FORENSIC ANALYSIS</span>
+      </div>
+      <div class="topbar-right">
+        <div class="topbar-chip" id="statusChip">IDLE</div>
+        <button class="theme-toggle" id="themeBtn">DARK</button>
+      </div>
+    </div>
+
+    <!-- Loading bar (hidden by default, shown during initial load) -->
+    <div class="loading-bar" id="loadingBar" style="display:none"></div>
+
+    <!-- Main content -->
+    <div class="content">
+
+      <!-- Action buttons -->
+      <div class="btn-row">
+        <button class="btn" id="scanBtn">SCAN IMAGES</button>
+        <button class="btn btn-danger" id="stopBtn" disabled>STOP</button>
+      </div>
+
+      <!-- Empty state -->
+      <div id="emptyState">
+        <div class="empty">
+          <div class="empty-icon">
+            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5">
+              <circle cx="11" cy="11" r="8" />
+              <line x1="21" y1="21" x2="16.65" y2="16.65" />
+            </svg>
+          </div>
+          <div class="empty-title">No scan data</div>
+          <div class="empty-desc">Click "SCAN IMAGES" to analyze the current webpage for AI-generated content.</div>
+        </div>
+      </div>
+
+      <!-- Data sections -->
+      <div id="dataContainer">
+
+        <!-- Stopped banner (shown only when scan was stopped) -->
+        <div class="stopped-banner" id="stoppedBanner" style="display:none">
+          SCAN INTERRUPTED — incomplete data. Run a full scan for complete results.
+        </div>
+
+        <!-- Verdict -->
+        <div class="verdict-card">
+          <div class="verdict-top">
+            <div>
+              <div class="verdict-label" id="verdictLabel">—</div>
+              <div class="verdict-desc" id="verdictDesc" style="white-space: pre-line;">—</div>
+            </div>
+          </div>
+
+          <div class="risk-bar-wrap">
+            <div class="risk-bar-header">
+              <span>Risk score</span>
+              <span id="riskBarLabel">—</span>
+            </div>
+            <div class="risk-bar-track">
+              <div class="risk-bar-fill" id="riskBarFill"></div>
+            </div>
+          </div>
+
+          <div class="status-bar">
+            <div class="status-dot" id="statusDot"></div>
+            <div class="status-text" id="statusText">—</div>
+          </div>
+        </div>
+
+        <!-- How it works -->
+        <div class="how-it-works-card" id="howItWorks">
+          <div class="hiw-header">
+            <div class="section-label">How detection works</div>
+          </div>
+          <div class="hiw-body">
+            <div class="hiw-text">
+              Our system utilizes a dual-model ensemble to assess images for forensic anomalies:
+            </div>
+            <ul class="hiw-list">
+              <li><strong>Vision-Language Model</strong> (OpenCLIP) for broad semantic and texture analysis</li>
+              <li><strong>Secondary CNN Model</strong> (ConvNeXt) for deep feature pattern matching</li>
+            </ul>
+            <div class="hiw-text" style="margin-top: 10px;">
+              The algorithms flag synthetic origins by detecting subtle, generated inconsistencies in: <strong>texture
+                frequencies, lighting coherence, and spatial composition.</strong>
+            </div>
+          </div>
+        </div>
+
+      </div><!-- /dataContainer -->
+
+    </div><!-- /content -->
+
+    <!-- Footer -->
+    <div class="panel-footer">
+      <div class="footer-left" id="footerLeft">RADAI v2.0</div>
+      <div class="footer-right" id="footerRight">—</div>
+    </div>
+
+  </div><!-- /panel -->
+
+  <script src="sidepanel.js"></script>
+</body>
+
+</html>

extension/sidepanel.js

@@ -0,0 +1,268 @@
+// ── RADAI · sidepanel.js ──────────────────────────────────────────────
+//
+// Architecture:
+//   • Loads latest scan result from background via GET_SCAN_RESULT message
+//   • Also reads the stored screenshot from chrome.storage.local for heatmap
+//   • Heatmap: patch-based pixel analysis (frequency variance, luminance
+//     deviation, edge density per cell) rendered to a <canvas> element
+//   • Re-loads on window focus (user ran a new scan)
+//   • No state held in globals that could stale; every render call is fresh
+//
+// Bug fixes vs. previous version:
+//   • Background GET_SCAN_RESULT now has a 5s timeout guard
+//   • Canvas is cleared before each render (no ghost overlays)
+//   • All DOM refs validated before use
+//   • rAF used for canvas draw to avoid blocking the main thread
+// ─────────────────────────────────────────────────────────────────────────
+
+"use strict";
+
+// ── DOM refs ──────────────────────────────────────────────────────────────
+const $  = (id) => document.getElementById(id);
+
+const statusChip       = $("statusChip");
+const loadingBar       = $("loadingBar");
+const emptyState       = $("emptyState");
+const dataContainer    = $("dataContainer");
+const stoppedBanner    = $("stoppedBanner");
+
+const verdictLabel     = $("verdictLabel");
+const verdictDesc      = $("verdictDesc");
+const riskBarFill      = $("riskBarFill");
+const riskBarLabel     = $("riskBarLabel");
+const statusDot        = $("statusDot");
+const statusText       = $("statusText");
+
+const footerLeft       = $("footerLeft");
+const footerRight      = $("footerRight");
+const themeBtn         = $("themeBtn");
+const scanBtn          = $("scanBtn");
+const stopBtn          = $("stopBtn");
+
+
+
+// ── UI state functions ────────────────────────────────────────────────────
+
+function showLoading() {
+  loadingBar.style.display = "block";
+  statusChip.textContent   = "LOADING";
+  statusChip.style.color   = "";
+}
+
+function hideLoading() {
+  loadingBar.style.display = "none";
+}
+
+function showEmpty() {
+  hideLoading();
+  emptyState.classList.remove("hidden");
+  dataContainer.classList.remove("visible");
+  statusChip.textContent = "READY";
+  statusChip.style.color = "";
+}
+
+function showStopped(result = {}) {
+  hideLoading();
+  emptyState.classList.add("hidden");
+  dataContainer.classList.add("visible");
+  stoppedBanner.style.display = "block";
+
+  statusChip.textContent = "STOPPED";
+  statusChip.style.color = "var(--warn)";
+
+  const scanned = result.count || 0;
+  const total = result.total || 0;
+  const flagged = result.aiCount || 0;
+  const risk = result.risk || 0;
+
+  verdictLabel.textContent    = "Stopped (incomplete scan)";
+  verdictLabel.style.color    = "var(--warn)";
+  
+  verdictDesc.textContent     = `${scanned} / ${total} images scanned\n${flagged} flagged as AI\n~${risk}% of scanned images appear AI-generated`;
+  
+  riskBarFill.style.width     = `${risk}%`;
+  riskBarFill.style.background = "var(--warn)";
+  riskBarLabel.textContent     = `${risk}%`;
+
+  statusDot.style.background  = "var(--warn)";
+  statusText.textContent       = "SCAN STOPPED BY USER";
+
+  footerRight.textContent = "Partial scan";
+}
+
+function showResult(result) {
+  hideLoading();
+  emptyState.classList.add("hidden");
+  dataContainer.classList.add("visible");
+  stoppedBanner.style.display = "none";
+
+  const risk        = typeof result.risk  === "number" ? result.risk  : 0;
+  const count       = typeof result.count === "number" ? result.count : 0;
+  const confidence = result.rawConfidence || (risk / 100);
+  const timestamp  = result.timestamp;
+
+  // Colour swatch for risk
+  const riskColor =
+    risk > 60 ? "var(--danger)" :
+    risk > 30 ? "var(--warn)"   : "var(--ok)";
+
+  // Status chip
+  statusChip.textContent = risk > 60 ? "HIGH RISK" : risk > 30 ? "MODERATE" : "CLEAN";
+  statusChip.style.color = riskColor;
+
+  if (count === 0) {
+    verdictLabel.textContent = "No Images";
+    verdictLabel.style.color = riskColor;
+    verdictDesc.textContent  = "No images found on this page.";
+  } else {
+    // Verdict
+    verdictLabel.textContent = risk > 60 ? "AI-Generated" : risk > 30 ? "Suspicious"  : "Likely Real";
+    verdictLabel.style.color = riskColor;
+    const flagged = Math.round((risk / 100) * count);
+    verdictDesc.textContent  = `${count} images scanned • ${flagged} flagged as AI\n${risk}% of images appear AI-generated`;
+  }
+
+  // Risk bar
+  riskBarFill.style.width      = `${risk}%`;
+  riskBarFill.style.background = riskColor;
+  riskBarLabel.textContent     = `${risk}%`;
+
+  // Status row
+  statusDot.style.background = riskColor;
+  statusText.textContent =
+    risk > 60 ? `HIGH CONFIDENCE AI · ${count} image${count !== 1 ? "s" : ""} processed` :
+    risk > 30 ? `MODERATE SIGNAL · ${count} image${count !== 1 ? "s" : ""} processed` :
+                `CLEAN · ${count} image${count !== 1 ? "s" : ""} processed`;
+
+  // Footer
+  if (timestamp) {
+    const d = new Date(timestamp);
+    footerRight.textContent =
+      `Scanned at ${d.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })}`;
+  } else {
+    footerRight.textContent = `${count} image${count !== 1 ? "s" : ""} analysed`;
+  }
+}
+
+// ── Load data (now just initialized on empty) ──────────────────────────────
+async function loadResult() {
+  showEmpty();
+}
+
+// ── Re-load on focus ──────────────────────────────────────────────────────
+window.addEventListener("focus", () => {
+  loadResult();
+});
+
+// ── Theme ─────────────────────────────────────────────────────────────────
+function applyTheme(theme) {
+  document.documentElement.setAttribute("data-theme", theme);
+  themeBtn.textContent = theme === "dark" ? "LIGHT" : "DARK";
+}
+
+function initTheme() {
+  try {
+    chrome.storage.local.get("theme", (res) => {
+      void chrome.runtime.lastError;
+      const t = res?.theme ||
+        (window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light");
+      applyTheme(t);
+    });
+  } catch {
+    applyTheme(window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light");
+  }
+}
+
+themeBtn.addEventListener("click", () => {
+  const cur  = document.documentElement.getAttribute("data-theme") || "light";
+  const next = cur === "dark" ? "light" : "dark";
+  applyTheme(next);
+  try { chrome.storage.local.set({ theme: next }); } catch { /* ignore */ }
+});
+
+// ── Global scan coordination ────────────────────────────────────────────────
+let isScanRunning = false;
+function setScanButtons(scanning) {
+  if (!scanBtn) return;
+  scanBtn.disabled    = scanning;
+  scanBtn.textContent = scanning ? "SCANNING..." : "SCAN IMAGES";
+  stopBtn.disabled    = !scanning;
+}
+
+async function startScan() {
+  if (isScanRunning) return;
+
+  console.log("SCAN CLICKED");
+
+  const tabs = await chrome.tabs.query({ active: true, currentWindow: true });
+  const tab = tabs[0];
+  if (!tab) return;
+  if (!tab.url || tab.url.startsWith("chrome://") || tab.url.startsWith("chrome-extension://")) {
+    showEmpty(); // Not allowed
+    return;
+  }
+
+  isScanRunning = true;
+  setScanButtons(true);
+  
+  // Reset UI before scan
+  showLoading();
+  statusChip.textContent = "SCANNING...";
+  verdictLabel.textContent = "—";
+  verdictLabel.style.color = "inherit";
+  verdictDesc.textContent = "—";
+  riskBarFill.style.width = "0%";
+  riskBarLabel.textContent = "—";
+  statusText.textContent = "—";
+
+  let screenshot = null;
+  try {
+    screenshot = await chrome.tabs.captureVisibleTab(null, { format: "png" });
+  } catch (e) {
+    console.log("Screenshot failed (could be context limit)", e);
+  }
+
+  console.log("Sending action: SCAN_IMAGES to content.js on tab:", tab.id);
+
+  chrome.tabs.sendMessage(tab.id, { action: "SCAN_IMAGES", screenshot }, (response) => {
+    isScanRunning = false;
+    setScanButtons(false);
+
+    if (chrome.runtime.lastError) {
+      console.warn("No response from content script. Error:", chrome.runtime.lastError.message);
+      showStopped();
+      return;
+    }
+
+    if (response) {
+      console.log("Response:", response);
+      if (response.stopped) {
+        showStopped();
+      } else if (response.done) {
+        showResult(response);
+      } else {
+        showEmpty();
+      }
+    } else {
+      showEmpty();
+    }
+  });
+}
+
+async function stopScan() {
+  console.log("STOP CLICKED");
+  const tabs = await chrome.tabs.query({ active: true, currentWindow: true });
+  const tab = tabs[0];
+  if (tab) {
+    chrome.tabs.sendMessage(tab.id, { action: "STOP_SCAN" });
+  }
+}
+
+if (scanBtn) scanBtn.addEventListener("click", startScan);
+if (stopBtn) stopBtn.addEventListener("click", stopScan);
+
+
+
+// ── Boot ──────────────────────────────────────────────────────────────────
+initTheme();
+loadResult();

models/convnext_forensic_head.pth

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

models/convnext_training_log.csv

@@ -0,0 +1,6 @@
+epoch,val_acc,train_loss
+1,0.9625,0.36604552464166157
+2,0.9783333333333334,0.11480749809476132
+3,0.9866666666666667,0.06741061826791842
+4,0.99,0.04732492169531438
+5,0.9883333333333333,0.03646433481972822

models/openclip_forensic_head.pth

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

models/training_log.csv

@@ -0,0 +1,11 @@
+epoch,train_loss,train_acc,val_loss,val_acc
+1,0.18460586362296855,0.9287869704236611,0.11360406280606986,0.95745
+2,0.12776405832496807,0.9513489208633094,0.1104536650210619,0.95815
+3,0.10373234867592893,0.9604216626698641,0.09013852900639176,0.96635
+4,0.08993887702157051,0.9658772981614708,0.0889575471073389,0.9681
+5,0.07703082630736217,0.9714128697042366,0.09260836776420474,0.96485
+6,0.06759887119140172,0.9743605115907275,0.09099651588853448,0.9658
+7,0.05909571438406855,0.977847721822542,0.08872529532201588,0.96795
+8,0.051992759698007616,0.9802458033573141,0.07628220746666194,0.9712
+9,0.04654393878499227,0.9828836930455636,0.09181491279350594,0.96745
+10,0.040898888357765555,0.9844524380495604,0.0927946492746938,0.96735

requirements.txt

@@ -0,0 +1,64 @@
+annotated-doc==0.0.4
+anyio==4.13.0
+blinker==1.9.0
+certifi==2026.2.25
+charset-normalizer==3.4.7
+click==8.3.2
+contourpy==1.3.3
+cycler==0.12.1
+dotenv==0.9.9
+filelock==3.25.2
+Flask==3.1.3
+flask-cors==6.0.2
+fonttools==4.62.1
+fsspec==2026.3.0
+ftfy==6.3.1
+h11==0.16.0
+hf-xet==1.4.3
+httpcore==1.0.9
+httpx==0.28.1
+huggingface_hub==1.10.1
+idna==3.11
+itsdangerous==2.2.0
+Jinja2==3.1.6
+joblib==1.5.3
+kiwisolver==1.5.0
+markdown-it-py==4.0.0
+MarkupSafe==3.0.3
+matplotlib==3.10.8
+mdurl==0.1.2
+mpmath==1.3.0
+networkx==3.6.1
+numpy==2.4.4
+open_clip_torch==3.3.0
+packaging==26.0
+pandas==3.0.2
+pillow==12.2.0
+Pygments==2.20.0
+pyparsing==3.3.2
+python-dateutil==2.9.0.post0
+python-dotenv==1.2.2
+PyYAML==6.0.3
+regex==2026.4.4
+requests==2.33.1
+rich==14.3.3
+safetensors==0.7.0
+scikit-learn==1.8.0
+scipy==1.17.1
+seaborn==0.13.2
+setuptools==81.0.0
+shellingham==1.5.4
+six==1.17.0
+sympy==1.14.0
+threadpoolctl==3.6.0
+timm==1.0.26
+tokenizers==0.22.2
+torch==2.11.0
+torchvision==0.26.0
+tqdm==4.67.3
+transformers==5.5.4
+typer==0.24.1
+typing_extensions==4.15.0
+urllib3==2.6.3
+wcwidth==0.6.0
+Werkzeug==3.1.8

test.py

@@ -0,0 +1,144 @@
+import torch
+import torch.nn as nn
+from torchvision import transforms, models
+import open_clip
+from PIL import Image, ImageFilter
+import numpy as np
+import os
+
+# --- 1. SETUP & DEVICE ---
+DEVICE = torch.device("mps") if torch.backends.mps.is_available() else torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(f"Using device: {DEVICE}")
+
+# --- 2. LOAD MODELS ---
+
+# A. Load openclip (ViT-L-14)
+print("Loading openclip...")
+openclip_model, _, openclip_preprocess = open_clip.create_model_and_transforms(
+    'ViT-L-14', pretrained='datacomp_xl_s13b_b90k'
+)
+openclip_model.to(DEVICE)
+
+# Define your openclip Forensic Head Architecture (matches your training)
+class openclipHead(nn.Module):
+    def __init__(self, input_dim):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(input_dim, 512),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(512, 1)
+        )
+    def forward(self, x): return self.net(x)
+
+# Load openclip Weights
+openclip_head = openclipHead(input_dim=768).to(DEVICE)
+openclip_head.load_state_dict(torch.load('models/openclip_forensic_head.pth', map_location=DEVICE))
+openclip_head.eval()
+
+# B. Load ConvNeXt-Base
+print("Loading ConvNeXt...")
+cn_backbone = models.convnext_base(weights=None) # Architecture only
+cn_backbone.to(DEVICE)
+cn_backbone.eval()
+
+class ConvNextHead(nn.Module):
+    def __init__(self, input_dim):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(input_dim, 512),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(512, 1)
+        )
+    def forward(self, x): return self.net(x)
+
+cn_head = ConvNextHead(input_dim=1024).to(DEVICE)
+cn_head.load_state_dict(torch.load('models/convnext_forensic_head.pth', map_location=DEVICE))
+cn_head.eval()
+
+# ConvNext Preprocessing (Standard ImageNet)
+cn_preprocess = transforms.Compose([
+    transforms.Resize(256),
+    transforms.CenterCrop(224),
+    transforms.ToTensor(),
+    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+])
+
+# --- 3. FEATURE EXTRACTION (Heuristics) ---
+
+def extract_simple_features(image_path):
+    img = Image.open(image_path).convert('RGB')
+    img_array = np.array(img) / 255.0
+    
+    edges = np.abs(np.diff(np.mean(img_array, axis=2), axis=0)).mean() + \
+            np.abs(np.diff(np.mean(img_array, axis=2), axis=1)).mean()
+    
+    img_smooth = np.array(img.filter(ImageFilter.GaussianBlur(2))) / 255.0
+    noise = np.mean((img_array - img_smooth) ** 2) * 1000
+    
+    return {
+        'noise_level': noise,
+        'edge_density': edges,
+        'is_too_clean': (noise < 0.05 and edges < 0.12) # Adjusted thresholds
+    }
+
+# --- 4. THE ENSEMBLE INFERENCE ---
+
+def run_ensemble(image_path):
+    img = Image.open(image_path).convert('RGB')
+    
+    # openclip Score
+    img_openclip = openclip_preprocess(img).unsqueeze(0).to(DEVICE)
+    with torch.no_grad():
+        sig_feat = openclip_model.encode_image(img_openclip)
+        sig_feat /= sig_feat.norm(dim=-1, keepdim=True)
+        sig_logit = openclip_head(sig_feat)
+        prob_openclip = torch.sigmoid(sig_logit).item()
+    
+    # ConvNeXt Score
+    img_cn = cn_preprocess(img).unsqueeze(0).to(DEVICE)
+    with torch.no_grad():
+        feat = cn_backbone.features(img_cn)
+        feat = cn_backbone.avgpool(feat)
+        feat = torch.flatten(feat, 1)
+        cn_logit = cn_head(feat)
+        prob_cn = torch.sigmoid(cn_logit).item()
+    
+    # Average the two for the "Raw Ensemble Score"
+    raw_ensemble_score = (prob_openclip + prob_cn) / 2
+    
+    # Calibration
+    features = extract_simple_features(image_path)
+    if features['is_too_clean']:
+        calibrated_score = raw_ensemble_score * 0.55 # 45% discount for product shots
+        reason = "Clean product-shot detected. Reducing probability."
+    else:
+        calibrated_score = raw_ensemble_score
+        reason = "Standard analysis applied."
+    
+    return {
+        'openclip_score': prob_openclip,
+        'convnext_score': prob_cn,
+        'raw_ensemble': raw_ensemble_score,
+        'calibrated': min(calibrated_score, 0.95),
+        'reason': reason,
+        'features': features
+    }
+
+# --- 5. TEST IT ---
+test_image = "/Users/rishitbaitule/Downloads/b.jpg" # Update this path!
+
+if os.path.exists(test_image):
+    results = run_ensemble(test_image)
+    
+    print("-" * 30)
+    print(f"Individual openclip: {results['openclip_score']:.2%}")
+    print(f"Individual ConvNeXt: {results['convnext_score']:.2%}")
+    print("-" * 30)
+    print(f"ENSEMBLE RAW SCORE: {results['raw_ensemble']:.2%}")
+    print(f"CALIBRATED SCORE:   {results['calibrated']:.2%}")
+    print(f"REASON: {results['reason']}")
+    print("-" * 30)
+else:
+    print("Image not found. Please check test_image path.")

train_convnext.py

@@ -0,0 +1,168 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import DataLoader
+from torchvision import transforms, models
+from datasets import load_dataset
+from huggingface_hub import login
+from kaggle_secrets import UserSecretsClient
+from PIL import Image
+import os
+import random
+import pandas as pd
+from tqdm.auto import tqdm
+
+# config
+user_secrets = UserSecretsClient()
+try:
+    hf_token = user_secrets.get_secret("HF_TOKEN")
+    login(token=hf_token)
+except:
+    print("HF_TOKEN not found in Secrets. Ensure you added it!")
+
+KAGLE_REAL_PATH = "/kaggle/input/datasets/matthewjansen/unsplash-lite-5k-colorization/train/color"
+HF_AI_DATASET = "Rapidata/Flux_SD3_MJ_Dalle_Human_Alignment_Dataset"
+TARGET_SHARDS = ["train_0001", "train_0002", "train_0003", "train_0004"]
+SAVE_PATH = "/kaggle/working/convnext_forensic_head.pth"
+LOG_PATH = "/kaggle/working/convnext_training_log.csv"
+
+# training params
+BATCH_SIZE = 32
+EPOCHS = 5
+LR = 1e-4
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+IMG_SIZE = (224, 224)
+
+final_data = []
+print(f"Streaming AI shards: {TARGET_SHARDS}")
+for shard in TARGET_SHARDS:
+    shard_stream = load_dataset(HF_AI_DATASET, split=shard, streaming=True)
+    for item in tqdm(shard_stream, total=1000, desc=f"AI Shard {shard}"):
+        img = item["image1"].convert("RGB").resize(IMG_SIZE)
+        final_data.append({"image": img, "label": 1})
+
+real_files = [os.path.join(KAGLE_REAL_PATH, f) for f in os.listdir(KAGLE_REAL_PATH) 
+              if f.lower().endswith(('.jpg', '.png', '.jpeg'))]
+random.shuffle(real_files)
+
+print(f"Balancing with {len(final_data)} Real images")
+for i in tqdm(range(min(len(final_data), len(real_files))), desc="Processing Real"):
+    try:
+        img = Image.open(real_files[i]).convert("RGB").resize(IMG_SIZE)
+        final_data.append({"image": img, "label": 0})
+    except: continue
+
+random.shuffle(final_data)
+split_idx = int(len(final_data) * 0.85)
+train_list, val_list = final_data[:split_idx], final_data[split_idx:]
+
+# model details
+backbone = models.convnext_base(weights='IMAGENET1K_V1')
+backbone = backbone.to(DEVICE)
+for param in backbone.parameters():
+    param.requires_grad = False
+backbone.eval() 
+
+class ForensicHead(nn.Module):
+    def __init__(self, input_dim):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(input_dim, 512),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(512, 1)
+        )
+    def forward(self, x): return self.net(x)
+
+feature_dim = backbone.classifier[2].in_features 
+head = ForensicHead(input_dim=feature_dim).to(DEVICE)
+
+if torch.cuda.device_count() > 1:
+    print(f"Activating Dual-GPU Mode with {torch.cuda.device_count()} T4s")
+    head = nn.DataParallel(head)
+    backbone = nn.DataParallel(backbone)
+
+# preprocessing
+preprocess = transforms.Compose([
+    transforms.ToTensor(),
+    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+])
+
+def collate_fn(batch):
+    imgs = torch.stack([preprocess(item['image']) for item in batch])
+    lbls = torch.tensor([item['label'] for item in batch]).float().view(-1, 1)
+    return imgs, lbls
+
+train_loader = DataLoader(train_list, batch_size=BATCH_SIZE, shuffle=True, collate_fn=collate_fn)
+val_loader = DataLoader(val_list, batch_size=BATCH_SIZE, collate_fn=collate_fn)
+
+# training loop
+optimizer = optim.Adam(head.parameters(), lr=LR)
+criterion = nn.BCEWithLogitsLoss() 
+scaler = torch.amp.GradScaler('cuda') 
+
+best_acc, history = 0.0, []
+
+for epoch in range(EPOCHS):
+    head.train()
+    train_loss = 0
+    pbar = tqdm(train_loader, desc=f"Epoch {epoch+1}/{EPOCHS}")
+    
+    for imgs, lbls in pbar:
+        imgs, lbls = imgs.to(DEVICE), lbls.to(DEVICE)
+        optimizer.zero_grad()
+
+        with torch.amp.autocast('cuda'):
+            with torch.no_grad():
+                # Extract features handling DataParallel wrapper
+                if isinstance(backbone, nn.DataParallel):
+                    feat = backbone.module.features(imgs)
+                    feat = backbone.module.avgpool(feat)
+                else:
+                    feat = backbone.features(imgs)
+                    feat = backbone.avgpool(feat)
+                feat = torch.flatten(feat, 1)
+            
+            logits = head(feat)
+            loss = criterion(logits, lbls)
+
+        scaler.scale(loss).backward()
+        scaler.step(optimizer)
+        scaler.update()
+        train_loss += loss.item()
+        pbar.set_postfix(loss=f"{loss.item():.4f}")
+
+    # validation
+    head.eval()
+    val_correct = 0
+    with torch.no_grad():
+        for imgs, lbls in val_loader:
+            imgs, lbls = imgs.to(DEVICE), lbls.to(DEVICE)
+            with torch.amp.autocast('cuda'):
+                if isinstance(backbone, nn.DataParallel):
+                    feat = backbone.module.features(imgs)
+                    feat = backbone.module.avgpool(feat)
+                else:
+                    feat = backbone.features(imgs)
+                    feat = backbone.avgpool(feat)
+                feat = torch.flatten(feat, 1)
+                
+                logits = head(feat)
+                preds = (torch.sigmoid(logits) > 0.5).float()
+                
+            val_correct += (preds == lbls).sum().item()
+
+    val_acc = val_correct / len(val_list)
+    avg_loss = train_loss / len(train_loader)
+    print(f"Epoch {epoch+1} | Loss: {avg_loss:.4f} | Val Acc: {val_acc:.4f}")
+    
+    history.append({'epoch': epoch+1, 'val_acc': val_acc, 'train_loss': avg_loss})
+    pd.DataFrame(history).to_csv(LOG_PATH, index=False)
+
+    if val_acc > best_acc:
+        best_acc = val_acc
+        save_state = head.module.state_dict() if isinstance(head, nn.DataParallel) else head.state_dict()
+        torch.save(save_state, SAVE_PATH)
+        print("--> Best Model Saved!")
+
+print(f"Training Complete. File saved: {SAVE_PATH}")

train_openclip.py

@@ -0,0 +1,178 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import DataLoader
+from datasets import load_dataset
+import open_clip
+from tqdm.auto import tqdm
+import os
+import random
+from PIL import Image
+from huggingface_hub import login
+from kaggle_secrets import UserSecretsClient
+
+try:
+    user_secrets = UserSecretsClient()
+    hf_token = user_secrets.get_secret("HF_TOKEN")
+    login(token=hf_token)
+    print("Successfully logged into Hugging Face")
+except Exception as e:
+    print("Warning: Could not find HF_TOKEN in Kaggle Secrets. Proceeding anonymously")
+
+# config
+KAGLE_REAL_PATH = "/kaggle/input/datasets/matthewjansen/unsplash-lite-5k-colorization/train/color"
+HF_AI_DATASET = "Rapidata/Flux_SD3_MJ_Dalle_Human_Alignment_Dataset"
+SAVE_PATH = "/kaggle/working/openclip_forensic_head.pth"
+TARGET_SHARDS = ["train_0001", "train_0002", "train_0003", "train_0004"]
+
+# params
+BATCH_SIZE = 16
+EPOCHS = 5
+LR = 1e-4
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+IMG_SIZE = (224, 224)
+
+# data loading with streaming
+print(f"Streaming {len(TARGET_SHARDS)} shards from Hugging Face")
+final_data = []
+
+for shard in TARGET_SHARDS:
+    print(f"Opening stream for {shard}")
+    shard_stream = load_dataset(HF_AI_DATASET, split=shard, streaming=True)
+
+    for item in tqdm(shard_stream, total=1000, desc=f"Streaming {shard}"):
+        # Resize immediately to keep RAM usage low
+        img = item["image1"].convert("RGB").resize(IMG_SIZE)
+        final_data.append({
+            "image": img,
+            "label": 1
+        })
+
+num_ai_images = len(final_data)
+print(f"Total AI images collected: {num_ai_images}")
+
+print("Loading Real Images from Kaggle")
+real_images_list = [os.path.join(KAGLE_REAL_PATH, f) for f in os.listdir(KAGLE_REAL_PATH) if
+                    f.endswith(('.jpg', '.jpeg', '.png'))]
+random.shuffle(real_images_list)
+
+print(f"Balancing dataset with {num_ai_images} Real images")
+for i in tqdm(range(min(num_ai_images, len(real_images_list))), desc="Processing Real Images"):
+    path = real_images_list[i]
+    try:
+        img = Image.open(path).convert("RGB").resize(IMG_SIZE)
+        final_data.append({
+            "image": img,
+            "label": 0
+        })
+    except Exception as e:
+        continue
+
+# shuffle split
+random.seed(42)
+random.shuffle(final_data)
+
+split_idx = int(len(final_data) * 0.85)
+train_list = final_data[:split_idx]
+val_list = final_data[split_idx:]
+
+print(f"Dataset prepared: Train size = {len(train_list)}, Val size = {len(val_list)}")
+
+# model init
+print(f"Initializing ViT-L-14 on {DEVICE}")
+model, _, preprocess_val = open_clip.create_model_and_transforms(
+    'ViT-L-14',
+    pretrained='datacomp_xl_s13b_b90k'
+)
+model = model.to(DEVICE)
+
+# freeze backbone
+for param in model.parameters():
+    param.requires_grad = False
+
+print("Detecting feature dimensions...")
+with torch.no_grad():
+    dummy_input = torch.randn(1, 3, 224, 224).to(DEVICE)
+    dummy_feature = model.encode_image(dummy_input)
+    detected_dim = dummy_feature.shape[1]
+    print(f"Backbone output dimension: {detected_dim}")
+
+
+class ForensicHead(nn.Module):
+    def __init__(self, input_dim):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(input_dim, 512),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(512, 1),
+            nn.Sigmoid()
+        )
+
+    def forward(self, x):
+        return self.net(x)
+
+
+# Initialize head with detected dimension (768 for DataComp ViT-L-14)
+head = ForensicHead(input_dim=detected_dim).to(DEVICE)
+
+
+def collate_fn(batch):
+    images = [preprocess_val(item['image']) for item in batch]
+    labels = [item['label'] for item in batch]
+    return torch.stack(images), torch.tensor(labels).float().view(-1, 1)
+
+
+train_loader = DataLoader(train_list, batch_size=BATCH_SIZE, shuffle=True, collate_fn=collate_fn)
+val_loader = DataLoader(val_list, batch_size=BATCH_SIZE, collate_fn=collate_fn)
+
+# training loop
+optimizer = optim.Adam(head.parameters(), lr=LR)
+criterion = nn.BCELoss()
+best_acc = 0.0
+
+print(f"Starting training on {len(train_list)} images")
+
+for epoch in range(EPOCHS):
+    head.train()
+    train_pbar = tqdm(train_loader, desc=f"Epoch {epoch + 1}/{EPOCHS} [Train]")
+
+    epoch_loss = 0
+    for imgs, lbls in train_pbar:
+        imgs, lbls = imgs.to(DEVICE), lbls.to(DEVICE)
+
+        with torch.no_grad():
+            features = model.encode_image(imgs)
+            features /= features.norm(dim=-1, keepdim=True)
+
+        optimizer.zero_grad()
+        outputs = head(features)
+        loss = criterion(outputs, lbls)
+        loss.backward()
+        optimizer.step()
+
+        epoch_loss += loss.item()
+        train_pbar.set_postfix(loss=f"{loss.item():.4f}")
+
+    # validation
+    head.eval()
+    val_correct = 0
+    val_pbar = tqdm(val_loader, desc=f"Epoch {epoch + 1}/{EPOCHS} [Val]")
+
+    with torch.no_grad():
+        for imgs, lbls in val_pbar:
+            imgs, lbls = imgs.to(DEVICE), lbls.to(DEVICE)
+            feat = model.encode_image(imgs)
+            feat /= feat.norm(dim=-1, keepdim=True)
+            preds = (head(feat) > 0.5).float()
+            val_correct += (preds == lbls).sum().item()
+
+    val_acc = val_correct / len(val_list)
+    print(f"Epoch {epoch + 1} Results | Loss: {epoch_loss / len(train_loader):.4f} | Val Acc: {val_acc:.4f}")
+
+    if val_acc > best_acc:
+        best_acc = val_acc
+        torch.save(head.state_dict(), SAVE_PATH)
+        print(f"New best model saved with {val_acc:.4f} accuracy")
+
+print(f"Training complete. Model saved in: {SAVE_PATH}")

visualise.py

@@ -0,0 +1,59 @@
+import torch
+from PIL import Image
+from transformers import AutoProcessor, openclipVisionModel
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Load your model
+processor = AutoProcessor.from_pretrained("google/openclip-so400m-patch14-384")
+model = openclipVisionModel.from_pretrained("google/openclip-so400m-patch14-384")
+model.load_state_dict(torch.load("your_finetuned_openclip.pt"))
+
+# Set up to get attention maps
+model.eval()
+model.vision_model.encoder.config.output_attentions = True
+
+# Load image
+img = Image.open("car_product_photo.jpg")
+inputs = processor(images=img, return_tensors="pt")
+
+# Forward pass WITH attention
+with torch.no_grad():
+    outputs = model.vision_model(**inputs, output_attentions=True)
+
+    # Get attention weights from last layer
+    # Shape: (batch, num_heads, seq_len, seq_len)
+    attention_weights = outputs.attentions[-1]
+
+    # Average across heads and batch
+    attention_map = attention_weights[0].mean(dim=0)  # (seq_len, seq_len)
+
+    # Reshape back to image space
+    # openclip uses patch embedding, so we need to reshape
+    H, W = 384, 384  # input image size
+    patch_size = 14
+    num_patches_h = H // patch_size  # 27
+    num_patches_w = W // patch_size  # 27
+
+    # Take the attention to the [CLS] token (first token)
+    cls_attention = attention_map[0, 1:]  # Ignore self-attention to CLS
+    cls_attention = cls_attention.reshape(num_patches_h, num_patches_w)
+
+    # Upsample to image size
+    cls_attention_upsampled = torch.nn.functional.interpolate(
+        cls_attention.unsqueeze(0).unsqueeze(0),
+        size=(H, W),
+        mode='bilinear'
+    ).squeeze()
+
+    # Normalize to 0-1
+    cls_attention_upsampled = (cls_attention_upsampled - cls_attention_upsampled.min()) / \
+                              (cls_attention_upsampled.max() - cls_attention_upsampled.min())
+
+    return cls_attention_upsampled.numpy()
+
+# Visualize
+heatmap = get_attention_heatmap(img)
+plt.imshow(img)
+plt.imshow(heatmap, alpha=0.4, cmap='jet')
+plt.show()