Upload 6 files

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,10 @@
+.env
+*goat.py
+.vscode
+*onnx.py
+./models/*
+forensics/__pycache__/*
+*.cpython-311.pyc
+*.cpython-312.pyc
+test.ipynb
+models/*

README.md

@@ -1,12 +1,20 @@
----
-title: Deepfake
-emoji: 👀
-colorFrom: indigo
-colorTo: purple
-sdk: gradio
-sdk_version: 5.35.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: MCP Toolkit - Re-Thinking Deepfake Detection & Forensics
+description: MCP Server for Project OpenSight's Deepfake Detection & Digital Forensics Tools
+emoji: 🚑
+colorFrom: yellow
+colorTo: yellow
+sdk: gradio
+sdk_version: 5.33.0
+app_file: app_mcp.py
+pinned: true
+models:
+- aiwithoutborders-xyz/OpenSight-CommunityForensics-Deepfake-ViT
+- Heem2/AI-vs-Real-Image-Detection
+- haywoodsloan/ai-image-detector-deploy
+- cmckinle/sdxl-flux-detector
+- Organika/sdxl-detector
+license: mit
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.backup.py

@@ -0,0 +1,364 @@
+import os
+from typing import Literal
+import spaces
+import gradio as gr
+import modelscope_studio.components.antd as antd
+import modelscope_studio.components.antdx as antdx
+import modelscope_studio.components.base as ms
+from transformers import pipeline, AutoImageProcessor, SwinForImageClassification, Swinv2ForImageClassification, AutoFeatureExtractor, AutoModelForImageClassification
+from torchvision import transforms
+import torch
+from PIL import Image
+import numpy as np
+import io
+import logging
+from utils.utils import softmax, augment_image, convert_pil_to_bytes
+from utils.gradient import gradient_processing
+from utils.minmax import preprocess as minmax_preprocess
+from utils.ela import genELA as ELA
+from utils.wavelet import wavelet_blocking_noise_estimation
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+# Ensure using GPU if available
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+header_style = {
+    "textAlign": 'center',
+    "color": '#fff',
+    "height": 64,
+    "paddingInline": 48,
+    "lineHeight": '64px',
+    "backgroundColor": '#4096ff',
+}
+
+content_style = {
+    "textAlign": 'center',
+    "minHeight": 120,
+    "lineHeight": '120px',
+    "color": '#fff',
+    "backgroundColor": '#0958d9',
+}
+
+sider_style = {
+    "textAlign": 'center',
+    "lineHeight": '120px',
+    "color": '#fff',
+    "backgroundColor": '#1677ff',
+}
+
+footer_style = {
+    "textAlign": 'center',
+    "color": '#fff',
+    "backgroundColor": '#4096ff',
+}
+
+layout_style = {
+    "borderRadius": 8,
+    "overflow": 'hidden',
+    "width": 'calc(100% - 8px)',
+    "maxWidth": 'calc(100% - 8px)',
+}
+# Model paths and class names
+MODEL_PATHS = {
+    "model_1": "haywoodsloan/ai-image-detector-deploy",
+    "model_2": "Heem2/AI-vs-Real-Image-Detection",
+    "model_3": "Organika/sdxl-detector",
+    "model_4": "cmckinle/sdxl-flux-detector_v1.1",
+    "model_5": "prithivMLmods/Deep-Fake-Detector-v2-Model",
+    "model_5b": "prithivMLmods/Deepfake-Detection-Exp-02-22",
+    "model_6": "ideepankarsharma2003/AI_ImageClassification_MidjourneyV6_SDXL",
+    "model_7": "date3k2/vit-real-fake-classification-v4"
+}
+
+CLASS_NAMES = {
+    "model_1": ['artificial', 'real'],
+    "model_2": ['AI Image', 'Real Image'],
+    "model_3": ['AI', 'Real'],
+    "model_4": ['AI', 'Real'],
+    "model_5": ['Realism', 'Deepfake'],
+    "model_5b": ['Real', 'Deepfake'],
+    "model_6": ['ai_gen', 'human'],
+    "model_7": ['Fake', 'Real'],
+
+}
+
+# Load models and processors
+def load_models():
+    image_processor_1 = AutoImageProcessor.from_pretrained(MODEL_PATHS["model_1"], use_fast=True)
+    model_1 = Swinv2ForImageClassification.from_pretrained(MODEL_PATHS["model_1"])
+    model_1 = model_1.to(device)
+    clf_1 = pipeline(model=model_1, task="image-classification", image_processor=image_processor_1, device=device)
+
+    clf_2 = pipeline("image-classification", model=MODEL_PATHS["model_2"], device=device)
+
+    feature_extractor_3 = AutoFeatureExtractor.from_pretrained(MODEL_PATHS["model_3"], device=device)
+    model_3 = AutoModelForImageClassification.from_pretrained(MODEL_PATHS["model_3"]).to(device)
+
+    feature_extractor_4 = AutoFeatureExtractor.from_pretrained(MODEL_PATHS["model_4"], device=device)
+    model_4 = AutoModelForImageClassification.from_pretrained(MODEL_PATHS["model_4"]).to(device)
+
+    clf_5 = pipeline("image-classification", model=MODEL_PATHS["model_5"], device=device)
+    clf_5b = pipeline("image-classification", model=MODEL_PATHS["model_5b"], device=device)
+
+    image_processor_6 = AutoImageProcessor.from_pretrained(MODEL_PATHS["model_6"], use_fast=True)
+    model_6 = SwinForImageClassification.from_pretrained(MODEL_PATHS["model_6"]).to(device)
+    clf_6 = pipeline(model=model_6, task="image-classification", image_processor=image_processor_6, device=device)
+
+    image_processor_7 = AutoImageProcessor.from_pretrained(MODEL_PATHS["model_7"], use_fast=True)
+    model_7 = AutoModelForImageClassification.from_pretrained(MODEL_PATHS["model_7"]).to(device)
+    clf_7 = pipeline(model=model_7, task="image-classification", image_processor=image_processor_7, device=device)
+
+    return clf_1, clf_2, feature_extractor_3, model_3, feature_extractor_4, model_4, clf_5, clf_5b, clf_6, model_7, clf_7
+
+clf_1, clf_2, feature_extractor_3, model_3, feature_extractor_4, model_4, clf_5, clf_5b, clf_6, model_7, clf_7 = load_models()
+
+@spaces.GPU(duration=10)
+def predict_with_model(img_pil, clf, class_names, confidence_threshold, model_name, model_id, feature_extractor=None):
+    try:
+        if feature_extractor:
+            inputs = feature_extractor(img_pil, return_tensors="pt").to(device)
+            with torch.no_grad():
+                outputs = clf(**inputs)
+            logits = outputs.logits
+            probabilities = softmax(logits.cpu().numpy()[0])
+            result = {class_names[i]: probabilities[i] for i in range(len(class_names))}
+        else:
+            prediction = clf(img_pil)
+            result = {pred['label']: pred['score'] for pred in prediction}
+
+        result_output = [model_id, model_name, result.get(class_names[1], 0.0), result.get(class_names[0], 0.0)]
+        logger.info(result_output)
+        for class_name in class_names:
+            if class_name not in result:
+                result[class_name] = 0.0
+        if result[class_names[0]] >= confidence_threshold:
+            label = f"AI, Confidence: {result[class_names[0]]:.4f}"
+            result_output.append('AI')
+        elif result[class_names[1]] >= confidence_threshold:
+            label = f"Real, Confidence: {result[class_names[1]]:.4f}"
+            result_output.append('REAL')
+        else:
+            label = "Uncertain Classification"
+            result_output.append('UNCERTAIN')
+    except Exception as e:
+        label = f"Error: {str(e)}"
+        result_output = [model_id, model_name, 0.0, 0.0, 'ERROR']  # Ensure result_output is assigned in case of error
+    return label, result_output
+
+@spaces.GPU(duration=10)
+def predict_image(img, confidence_threshold):
+    if not isinstance(img, Image.Image):
+        raise ValueError(f"Expected a PIL Image, but got {type(img)}")
+    if img.mode != 'RGB':
+        img_pil = img.convert('RGB')
+    else:
+        img_pil = img
+    img_pil = transforms.Resize((256, 256))(img_pil)
+    img_pilvits = transforms.Resize((224, 224))(img_pil)
+
+    label_1, result_1output = predict_with_model(img_pil, clf_1, CLASS_NAMES["model_1"], confidence_threshold, "SwinV2-base", 1)
+    label_2, result_2output = predict_with_model(img_pilvits, clf_2, CLASS_NAMES["model_2"], confidence_threshold, "ViT-base Classifier", 2)
+    label_3, result_3output = predict_with_model(img_pil, model_3, CLASS_NAMES["model_3"], confidence_threshold, "SDXL-Trained", 3, feature_extractor_3)
+    label_4, result_4output = predict_with_model(img_pil, model_4, CLASS_NAMES["model_4"], confidence_threshold, "SDXL + FLUX", 4, feature_extractor_4)
+    label_5, result_5output = predict_with_model(img_pilvits, clf_5, CLASS_NAMES["model_5"], confidence_threshold, "ViT-base Newcomer", 5)
+    label_5b, result_5boutput = predict_with_model(img_pilvits, clf_5b, CLASS_NAMES["model_5b"], confidence_threshold, "ViT-base Newcomer", 6)
+    label_6, result_6output = predict_with_model(img_pilvits, clf_6, CLASS_NAMES["model_6"], confidence_threshold, "Swin Midjourney/SDXL", 7)
+    label_7, result_7output = predict_with_model(img_pilvits, clf_7, CLASS_NAMES["model_7"], confidence_threshold, "Vit", 7)
+
+    combined_results = {
+        "SwinV2/detect": label_1,
+        "ViT/AI-vs-Real": label_2,
+        "Swin/SDXL": label_3,
+        "Swin/SDXL-FLUX": label_4,
+        "prithivMLmods": label_5,
+        "prithivMLmods-2-22": label_5b,
+        "SwinMidSDXL": label_6,
+        "Vit": label_7
+    }
+    print(combined_results)
+
+    combined_outputs = [result_1output, result_2output, result_3output, result_4output, result_5output, result_5boutput, result_6output, result_7output]
+    return img_pil, combined_outputs
+# Define a function to generate the HTML content
+
+def generate_results_html(results):
+    def get_header_color(label):
+        if label == 'AI':
+            return 'bg-red-500 text-red-700', 'bg-red-400', 'bg-red-100', 'bg-red-700 text-red-700', 'bg-red-200'
+        elif label == 'REAL':
+            return 'bg-green-500 text-green-700', 'bg-green-400', 'bg-green-100', 'bg-green-700 text-green-700', 'bg-green-200'
+        elif label == 'UNCERTAIN':
+            return 'bg-yellow-500 text-yellow-700 bg-yellow-100', 'bg-yellow-400', 'bg-yellow-100', 'bg-yellow-700 text-yellow-700', 'bg-yellow-200'
+        elif label == 'MAINTENANCE':
+            return 'bg-blue-500 text-blue-700', 'bg-blue-400', 'bg-blue-100', 'bg-blue-700 text-blue-700', 'bg-blue-200'
+        else:
+            return 'bg-gray-300 text-gray-700', 'bg-gray-400', 'bg-gray-100', 'bg-gray-700 text-gray-700', 'bg-gray-200'
+
+    def generate_tile_html(index, result, model_name, contributor, model_path):
+        label = result[-1]
+        header_colors = get_header_color(label)
+        real_conf = result[2]
+        ai_conf = result[3]
+        return f"""
+        <div
+            class="flex flex-col bg-gray-800 rounded-sm p-4 m-1 border border-gray-800 shadow-xs transition hover:shadow-lg dark:shadow-gray-700/25">
+            <div
+                class="-m-4 h-24 {header_colors[0]} rounded-sm rounded-b-none transition border group-hover:border-gray-100 group-hover:shadow-lg group-hover:{header_colors[4]}">
+                <span class="text-gray-300 font-mono tracking-widest p-4 pb-3 block text-xs text-center">MODEL {index + 1}:</span>
+                <span
+                    class="flex w-30 mx-auto tracking-wide items-center justify-center rounded-full {header_colors[2]} px-1 py-0.5 {header_colors[3]}"
+                >
+                    <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="3" stroke="currentColor" class="w-4 h-4 mr-2 -ml-3 group-hover:animate group-hover:animate-pulse">
+                        {'<path stroke-linecap="round" stroke-linejoin="round" d="M9 12.75 11.25 15 15 9.75M21 12a9 9 0 1 1-18 0 9 9 0 0 1 18 0Z" />' if label == 'REAL' else '<path stroke-linecap="round" stroke-linejoin="round" d="m9.75 9.75 4.5 4.5m0-4.5-4.5 4.5M21 12a9 9 0 1 1-18 0 9 9 0 0 1 18 0Z" />'}
+                    </svg>
+                    <p class="text-base whitespace-nowrap  leading-normal font-bold text-center self-center align-middle py-px">{label}</p>
+                </span>
+            </div>
+            <div>
+                <div class="mt-4 relative -mx-4 bg-gray-800">
+                    <div class="w-full bg-gray-400 rounded-none h-8">
+                        <div class="inline-flex whitespace-nowrap bg-green-400 h-full rounded-none" style="width: {real_conf * 100:.2f}%;">
+                            <p class="p-2 px-4 text-xs self-center align-middle">Conf:
+                                <span class="ml-1 font-medium font-mono">{real_conf:.4f}</span>
+                            </p>
+                        </div>
+                    </div>
+                </div>
+                <div class="relative -mx-4 bg-gray-800">
+                    <div class="w-full bg-gray-400 rounded-none h-8">
+                        <div class="inline-flex whitespace-nowrap bg-red-400 h-full rounded-none" style="width: {ai_conf * 100:.2f}%;">
+                            <p class="p-2 px-4 text-xs self-center align-middle">Conf:
+                                <span class="ml-1 font-medium font-mono">{ai_conf:.4f}</span>
+                            </p>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            <div class="flex flex-col items-start">
+                <h4 class="mt-4 text-sm font-semibold tracking-wide">{model_name}</h4>
+                <div class="text-xs font-mono">Real: {real_conf:.4f}, AI: {ai_conf:.4f}</div>
+                <div class="card-footer">
+                <a href="https://huggingface.co/{model_path}" target="_blank" class="mt-2 text-xs text-nowrap nowrap" style="font-size:0.66rem !important;">by @{contributor}</a>
+                </div>
+            </div>
+        </div>
+        """
+
+    html_content = f"""
+    <link href="https://unpkg.com/[email protected]/dist/tailwind.min.css" rel="stylesheet">
+    <div class="container mx-auto">
+        <div class="grid xl:grid-cols-4 md:grid-cols-4 grid-cols-1 gap-1">
+            {generate_tile_html(0, results[0], "SwinV2 Based", "haywoodsloan", MODEL_PATHS["model_1"])}
+            {generate_tile_html(1, results[1], "ViT Based", "Heem2", MODEL_PATHS["model_2"])}
+            {generate_tile_html(2, results[2], "SDXL Dataset", "Organika", MODEL_PATHS["model_3"])}
+            {generate_tile_html(3, results[3], "SDXL + FLUX", "cmckinle", MODEL_PATHS["model_4"])}
+            {generate_tile_html(4, results[4], "Vit Based", "prithivMLmods", MODEL_PATHS["model_5"])}
+            {generate_tile_html(5, results[5], "Vit Based, Newer Dataset", "prithivMLmods", MODEL_PATHS["model_5b"])}
+            {generate_tile_html(6, results[6], "Swin, Midj + SDXL", "ideepankarsharma2003", MODEL_PATHS["model_6"])}
+            {generate_tile_html(7, results[7], "ViT", "temp", MODEL_PATHS["model_7"])}
+        </div>
+    </div>
+    """
+    return html_content
+
+
+def predict_image_with_html(img, confidence_threshold, augment_methods, rotate_degrees, noise_level, sharpen_strength):
+    if augment_methods:
+        img_pil, _ = augment_image(img, augment_methods, rotate_degrees, noise_level, sharpen_strength)
+    else:
+        img_pil = img
+    img_pil, results = predict_image(img_pil, confidence_threshold)
+    img_np = np.array(img_pil)  # Convert PIL Image to NumPy array
+    img_np_og = np.array(img)  # Convert PIL Image to NumPy array
+
+    gradient_image = gradient_processing(img_np)  # Added gradient processing
+    minmax_image = minmax_preprocess(img_np)  # Added MinMax processing
+
+    # First pass - standard analysis
+    ela1 = ELA(img_np_og, quality=75, scale=50, contrast=20, linear=False, grayscale=True)
+
+    # Second pass - enhanced visibility
+    ela2 = ELA(img_np_og, quality=75, scale=75, contrast=25, linear=False, grayscale=True)
+    ela3 = ELA(img_np_og, quality=75, scale=75, contrast=25, linear=False, grayscale=False)
+    
+    forensics_images = [img_pil, ela1, ela2, ela3, gradient_image, minmax_image]
+    
+    html_content = generate_results_html(results)
+    return img_pil, forensics_images, html_content
+
+with gr.Blocks(css="#post-gallery { overflow: hidden !important;} .grid-wrap{ overflow-y: hidden !important;} .ms-gr-ant-welcome-icon{ height:unset !important;} .tabs{margin-top:10px;}") as iface:
+    with ms.Application() as app:
+        with antd.ConfigProvider():
+            antdx.Welcome(
+                icon=
+                "https://cdn-avatars.huggingface.co/v1/production/uploads/639daf827270667011153fbc/WpeSFhuB81DY-1TjNUmV_.png",
+                title="Welcome to Project OpenSight",
+                description=
+                "The OpenSight aims to be an open-source SOTA generated image detection model. This HF Space is not only an introduction but a educational playground for the public to evaluate and challenge current open source models.  **Space will be upgraded shortly; inference on all 6 models should take about 1.2~ seconds.** "
+            )
+            with gr.Tab("👀 Detection Models Eval / Playground"):
+                gr.Markdown("# Open Source Detection Models Found on the Hub\n\n - **Space will be upgraded shortly;** inference on all 6 models should take about 1.2~ seconds once we're back on CUDA.\n - The **Community Forensics** mother of all detection models is now available for inference, head to the middle tab above this.\n - Lots of exciting things coming up, stay tuned!")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        image_input = gr.Image(label="Upload Image to Analyze", sources=['upload', 'webcam'], type='pil')
+                        with gr.Accordion("Settings (Optional)", open=False, elem_id="settings_accordion"):
+                            augment_checkboxgroup = gr.CheckboxGroup(["rotate", "add_noise", "sharpen"], label="Augmentation Methods")
+                            rotate_slider = gr.Slider(0, 45, value=2, step=1, label="Rotate Degrees", visible=False)
+                            noise_slider = gr.Slider(0, 50, value=4, step=1, label="Noise Level", visible=False)
+                            sharpen_slider = gr.Slider(0, 50, value=11, step=1, label="Sharpen Strength", visible=False)
+                            confidence_slider = gr.Slider(0.0, 1.0, value=0.75, step=0.05, label="Confidence Threshold")
+                        inputs = [image_input, confidence_slider, augment_checkboxgroup, rotate_slider, noise_slider, sharpen_slider]
+                        predict_button = gr.Button("Predict")
+                        augment_button = gr.Button("Augment & Predict")
+                        image_output = gr.Image(label="Processed Image", visible=False)
+
+
+                    with gr.Column(scale=2):
+                        # Custom HTML component to display results in 5 columns
+                        results_html = gr.HTML(label="Model Predictions")
+                        forensics_gallery = gr.Gallery(label="Post Processed Images", visible=True, columns=[4], rows=[2], container=False, height="auto", object_fit="contain", elem_id="post-gallery")
+
+                        outputs = [image_output, forensics_gallery, results_html]
+                
+                # Show/hide rotate slider based on selected augmentation method
+                augment_checkboxgroup.change(lambda methods: gr.update(visible="rotate" in methods), inputs=[augment_checkboxgroup], outputs=[rotate_slider])
+                augment_checkboxgroup.change(lambda methods: gr.update(visible="add_noise" in methods), inputs=[augment_checkboxgroup], outputs=[noise_slider])
+                augment_checkboxgroup.change(lambda methods: gr.update(visible="sharpen" in methods), inputs=[augment_checkboxgroup], outputs=[sharpen_slider])
+                
+                predict_button.click(
+                    fn=predict_image_with_html, 
+                    inputs=inputs, 
+                    outputs=outputs
+                )
+                augment_button.click(  # Connect Augment button to the function
+                    fn=predict_image_with_html, 
+                    inputs=[
+                        image_input, 
+                        confidence_slider, 
+                        gr.CheckboxGroup(["rotate", "add_noise", "sharpen"], value=["rotate", "add_noise", "sharpen"], visible=False),  # Default values
+                        rotate_slider, 
+                        noise_slider, 
+                        sharpen_slider
+                    ], 
+                    outputs=outputs
+                )
+                predict_button.click(
+                    fn=None, 
+                    js="() => {document.getElementById('project_accordion').open = false;}",  # Close the project accordion
+                    inputs=[], 
+                    outputs=[]
+                )
+            with gr.Tab("👑 Community Forensics Preview"):
+                temp_space = gr.load("aiwithoutborders-xyz/OpenSight-Community-Forensics-Preview", src="spaces")
+                # preview # no idea if this will work
+            with gr.Tab("🥇 Leaderboard"):
+                gr.Markdown("# AI Generated / Deepfake Detection Models Leaderboard: Soon™")
+                
+
+# Launch the interface
+iface.launch()

app_mcp.py

@@ -0,0 +1,614 @@
+import os
+import time
+from typing import Literal
+import spaces
+import gradio as gr
+import modelscope_studio.components.antd as antd
+import modelscope_studio.components.antdx as antdx
+import modelscope_studio.components.base as ms
+from transformers import pipeline, AutoImageProcessor, SwinForImageClassification, Swinv2ForImageClassification, AutoFeatureExtractor, AutoModelForImageClassification
+from torchvision import transforms
+import torch
+from PIL import Image
+import numpy as np
+import io
+import logging
+from utils.utils import softmax, augment_image, convert_pil_to_bytes
+from utils.gradient import gradient_processing
+from utils.minmax import preprocess as minmax_preprocess
+from utils.ela import genELA as ELA
+from utils.wavelet import wavelet_blocking_noise_estimation
+from utils.bitplane import bit_plane_extractor
+from utils.hf_logger import log_inference_data
+from utils.text_content import QUICK_INTRO, IMPLEMENTATION
+from agents.monitoring_agents import EnsembleMonitorAgent, WeightOptimizationAgent, SystemHealthAgent
+from agents.smart_agents import ContextualIntelligenceAgent, ForensicAnomalyDetectionAgent
+
+from forensics.registry import register_model, MODEL_REGISTRY, ModelEntry
+from agents.weight_management import ModelWeightManager
+from dotenv import load_dotenv
+import json
+from huggingface_hub import CommitScheduler
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+os.environ['HF_HUB_CACHE'] = './models'
+
+LOCAL_LOG_DIR = "./hf_inference_logs"
+HF_DATASET_NAME="degentic_rd0"
+load_dotenv()
+# print(os.getenv("HF_HUB_CACHE"))
+
+# Custom JSON Encoder to handle numpy types
+class NumpyEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, np.float32):
+            return float(obj)
+        return json.JSONEncoder.default(self, obj)
+
+# Ensure using GPU if available
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+header_style = {
+    "textAlign": 'center',
+    "color": '#fff',
+    "height": 64,
+    "paddingInline": 48,
+    "lineHeight": '64px',
+    "backgroundColor": '#4096ff',
+}
+
+content_style = {
+    "textAlign": 'center',
+    "minHeight": 120,
+    "lineHeight": '120px',
+    "color": '#fff',
+    "backgroundColor": '#0958d9',
+}
+
+sider_style = {
+    "textAlign": 'center',
+    "lineHeight": '120px',
+    "color": '#fff',
+    "backgroundColor": '#1677ff',
+}
+
+footer_style = {
+    "textAlign": 'center',
+    "color": '#fff',
+    "backgroundColor": '#4096ff',
+}
+
+layout_style = {
+    "borderRadius": 8,
+    "overflow": 'hidden',
+    "width": 'calc(100% - 8px)',
+    "maxWidth": 'calc(100% - 8px)',
+}
+# Model paths and class names
+MODEL_PATHS = {
+    "model_1": "haywoodsloan/ai-image-detector-deploy",
+    "model_2": "Heem2/AI-vs-Real-Image-Detection",
+    "model_3": "Organika/sdxl-detector",
+    "model_4": "cmckinle/sdxl-flux-detector_v1.1",
+    "model_5": "prithivMLmods/Deep-Fake-Detector-v2-Model",
+    "model_5b": "prithivMLmods/Deepfake-Detection-Exp-02-22",
+    "model_6": "ideepankarsharma2003/AI_ImageClassification_MidjourneyV6_SDXL",
+    "model_7": "date3k2/vit-real-fake-classification-v4"
+}
+
+CLASS_NAMES = {
+    "model_1": ['artificial', 'real'],
+    "model_2": ['AI Image', 'Real Image'],
+    "model_3": ['AI', 'Real'],
+    "model_4": ['AI', 'Real'],
+    "model_5": ['Realism', 'Deepfake'],
+    "model_5b": ['Real', 'Deepfake'],
+    "model_6": ['ai_gen', 'human'],
+    "model_7": ['Fake', 'Real'],
+
+}
+
+def preprocess_resize_256(image):
+    if image.mode != 'RGB':
+        image = image.convert('RGB')
+    return transforms.Resize((256, 256))(image)
+
+def preprocess_resize_224(image):
+    if image.mode != 'RGB':
+        image = image.convert('RGB')
+    return transforms.Resize((224, 224))(image)
+
+def postprocess_pipeline(prediction, class_names):
+    # Assumes HuggingFace pipeline output
+    return {pred['label']: pred['score'] for pred in prediction}
+
+def postprocess_logits(outputs, class_names):
+    # Assumes model output with logits
+    logits = outputs.logits.cpu().numpy()[0]
+    probabilities = softmax(logits)
+    return {class_names[i]: probabilities[i] for i in range(len(class_names))}
+
+# Expand ModelEntry to include metadata
+# (Assume ModelEntry is updated in registry.py to accept display_name, contributor, model_path)
+# If not, we will update registry.py accordingly after this.
+
+def register_model_with_metadata(model_id, model, preprocess, postprocess, class_names, display_name, contributor, model_path):
+    entry = ModelEntry(model, preprocess, postprocess, class_names)
+    entry.display_name = display_name
+    entry.contributor = contributor
+    entry.model_path = model_path
+    MODEL_REGISTRY[model_id] = entry
+
+# Load and register models (example for two models)
+image_processor_1 = AutoImageProcessor.from_pretrained(MODEL_PATHS["model_1"], use_fast=True)
+model_1 = Swinv2ForImageClassification.from_pretrained(MODEL_PATHS["model_1"]).to(device)
+clf_1 = pipeline(model=model_1, task="image-classification", image_processor=image_processor_1, device=device)
+register_model_with_metadata(
+    "model_1", clf_1, preprocess_resize_256, postprocess_pipeline, CLASS_NAMES["model_1"],
+    display_name="SwinV2 Based", contributor="haywoodsloan", model_path=MODEL_PATHS["model_1"]
+)
+
+clf_2 = pipeline("image-classification", model=MODEL_PATHS["model_2"], device=device)
+register_model_with_metadata(
+    "model_2", clf_2, preprocess_resize_224, postprocess_pipeline, CLASS_NAMES["model_2"],
+    display_name="ViT Based", contributor="Heem2", model_path=MODEL_PATHS["model_2"]
+)
+
+# Register remaining models
+feature_extractor_3 = AutoFeatureExtractor.from_pretrained(MODEL_PATHS["model_3"], device=device)
+model_3 = AutoModelForImageClassification.from_pretrained(MODEL_PATHS["model_3"]).to(device)
+def preprocess_256(image):
+    if image.mode != 'RGB':
+        image = image.convert('RGB')
+    return transforms.Resize((256, 256))(image)
+def postprocess_logits_model3(outputs, class_names):
+    logits = outputs.logits.cpu().numpy()[0]
+    probabilities = softmax(logits)
+    return {class_names[i]: probabilities[i] for i in range(len(class_names))}
+def model3_infer(image):
+    inputs = feature_extractor_3(image, return_tensors="pt").to(device)
+    with torch.no_grad():
+        outputs = model_3(**inputs)
+    return outputs
+register_model_with_metadata(
+    "model_3", model3_infer, preprocess_256, postprocess_logits_model3, CLASS_NAMES["model_3"],
+    display_name="SDXL Dataset", contributor="Organika", model_path=MODEL_PATHS["model_3"]
+)
+
+feature_extractor_4 = AutoFeatureExtractor.from_pretrained(MODEL_PATHS["model_4"], device=device)
+model_4 = AutoModelForImageClassification.from_pretrained(MODEL_PATHS["model_4"]).to(device)
+def model4_infer(image):
+    inputs = feature_extractor_4(image, return_tensors="pt").to(device)
+    with torch.no_grad():
+        outputs = model_4(**inputs)
+    return outputs
+def postprocess_logits_model4(outputs, class_names):
+    logits = outputs.logits.cpu().numpy()[0]
+    probabilities = softmax(logits)
+    return {class_names[i]: probabilities[i] for i in range(len(class_names))}
+register_model_with_metadata(
+    "model_4", model4_infer, preprocess_256, postprocess_logits_model4, CLASS_NAMES["model_4"],
+    display_name="SDXL + FLUX", contributor="cmckinle", model_path=MODEL_PATHS["model_4"]
+)
+
+clf_5 = pipeline("image-classification", model=MODEL_PATHS["model_5"], device=device)
+register_model_with_metadata(
+    "model_5", clf_5, preprocess_resize_224, postprocess_pipeline, CLASS_NAMES["model_5"],
+    display_name="Vit Based", contributor="prithivMLmods", model_path=MODEL_PATHS["model_5"]
+)
+
+clf_5b = pipeline("image-classification", model=MODEL_PATHS["model_5b"], device=device)
+register_model_with_metadata(
+    "model_5b", clf_5b, preprocess_resize_224, postprocess_pipeline, CLASS_NAMES["model_5b"],
+    display_name="Vit Based, Newer Dataset", contributor="prithivMLmods", model_path=MODEL_PATHS["model_5b"]
+)
+
+image_processor_6 = AutoImageProcessor.from_pretrained(MODEL_PATHS["model_6"], use_fast=True)
+model_6 = SwinForImageClassification.from_pretrained(MODEL_PATHS["model_6"]).to(device)
+clf_6 = pipeline(model=model_6, task="image-classification", image_processor=image_processor_6, device=device)
+register_model_with_metadata(
+    "model_6", clf_6, preprocess_resize_224, postprocess_pipeline, CLASS_NAMES["model_6"],
+    display_name="Swin, Midj + SDXL", contributor="ideepankarsharma2003", model_path=MODEL_PATHS["model_6"]
+)
+
+image_processor_7 = AutoImageProcessor.from_pretrained(MODEL_PATHS["model_7"], use_fast=True)
+model_7 = AutoModelForImageClassification.from_pretrained(MODEL_PATHS["model_7"]).to(device)
+clf_7 = pipeline(model=model_7, task="image-classification", image_processor=image_processor_7, device=device)
+register_model_with_metadata(
+    "model_7", clf_7, preprocess_resize_224, postprocess_pipeline, CLASS_NAMES["model_7"],
+    display_name="ViT", contributor="temp", model_path=MODEL_PATHS["model_7"]
+)
+
+# Generic inference function
+
+def infer(image: Image.Image, model_id: str, confidence_threshold: float = 0.75) -> dict:
+    entry = MODEL_REGISTRY[model_id]
+    img = entry.preprocess(image)
+    try:
+        result = entry.model(img)
+        scores = entry.postprocess(result, entry.class_names)
+        # Flatten output for Dataframe: include metadata and both class scores
+        ai_score = float(scores.get(entry.class_names[0], 0.0))
+        real_score = float(scores.get(entry.class_names[1], 0.0))
+        label = "AI" if ai_score >= confidence_threshold else ("REAL" if real_score >= confidence_threshold else "UNCERTAIN")
+        return {
+            "Model": entry.display_name,
+            "Contributor": entry.contributor,
+            "HF Model Path": entry.model_path,
+            "AI Score": ai_score,
+            "Real Score": real_score,
+            "Label": label
+        }
+    except Exception as e:
+        return {
+            "Model": entry.display_name,
+            "Contributor": entry.contributor,
+            "HF Model Path": entry.model_path,
+            "AI Score": 0.0,  # Ensure it's a float even on error
+            "Real Score": 0.0, # Ensure it's a float even on error
+            "Label": f"Error: {str(e)}"
+        }
+
+# Update predict_image to use all registered models in order
+
+def predict_image(img, confidence_threshold):
+    model_ids = [
+        "model_1", "model_2", "model_3", "model_4", "model_5", "model_5b", "model_6", "model_7"
+    ]
+    results = [infer(img, model_id, confidence_threshold) for model_id in model_ids]
+    return img, results
+
+def get_consensus_label(results):
+    labels = [r[4] for r in results if len(r) > 4]
+    if not labels:
+        return "No results"
+    consensus = max(set(labels), key=labels.count)
+    color = {"AI": "red", "REAL": "green", "UNCERTAIN": "orange"}.get(consensus, "gray")
+    return f"<b><span style='color:{color}'>{consensus}</span></b>"
+
+# Update predict_image_with_json to return consensus label
+
+def predict_image_with_json(img, confidence_threshold, augment_methods, rotate_degrees, noise_level, sharpen_strength):
+    # Ensure img is a PIL Image (if it's not already)
+    if not isinstance(img, Image.Image):
+        try:
+            # If it's a numpy array, convert it
+            img = Image.fromarray(img)
+        except Exception as e:
+            logger.error(f"Error converting input image to PIL: {e}")
+            # If conversion fails, it's a critical error for the whole process
+            raise ValueError("Input image could not be converted to PIL Image.")
+
+    # Initialize agents
+    monitor_agent = EnsembleMonitorAgent()
+    weight_manager = ModelWeightManager()
+    optimization_agent = WeightOptimizationAgent(weight_manager)
+    health_agent = SystemHealthAgent()
+    # New smart agents
+    context_agent = ContextualIntelligenceAgent()
+    anomaly_agent = ForensicAnomalyDetectionAgent()
+    
+    # Monitor system health
+    health_agent.monitor_system_health()
+
+    if augment_methods:
+        img_pil, _ = augment_image(img, augment_methods, rotate_degrees, noise_level, sharpen_strength)
+    else:
+        img_pil = img
+    img_np_og = np.array(img)  # Convert PIL Image to NumPy array
+
+    # 1. Get initial predictions from all models
+    model_predictions_raw = {}
+    confidence_scores = {}
+    results = [] # To store the results for the DataFrame
+
+    for model_id in MODEL_REGISTRY:
+        model_start = time.time()
+        result = infer(img_pil, model_id, confidence_threshold)
+        model_end = time.time()
+        
+        # Monitor individual model performance
+        monitor_agent.monitor_prediction(
+            model_id,
+            result["Label"],
+            max(result.get("AI Score", 0.0), result.get("Real Score", 0.0)),
+            model_end - model_start
+        )
+        
+        model_predictions_raw[model_id] = result # Store the full result dictionary
+        confidence_scores[model_id] = max(result.get("AI Score", 0.0), result.get("Real Score", 0.0))
+        results.append(result) # Add individual model result to the list
+    
+    # 2. Infer context tags using ContextualIntelligenceAgent
+    image_data_for_context = {
+        "width": img.width,
+        "height": img.height,
+        "mode": img.mode,
+        # Add more features like EXIF data if exif_full_dump is used
+    }
+    detected_context_tags = context_agent.infer_context_tags(image_data_for_context, model_predictions_raw)
+    logger.info(f"Detected context tags: {detected_context_tags}")
+
+    # 3. Get adjusted weights, passing context tags
+    adjusted_weights = weight_manager.adjust_weights(model_predictions_raw, confidence_scores, context_tags=detected_context_tags)
+    
+    # 4. Optimize weights if needed
+    # `final_prediction_label` is determined AFTER weighted consensus, so analyze_performance will be called later
+
+    # 5. Calculate weighted consensus
+    weighted_predictions = {
+        "AI": 0.0,
+        "REAL": 0.0,
+        "UNCERTAIN": 0.0
+    }
+    
+    for model_id, prediction in model_predictions_raw.items(): # Use raw predictions for weighting
+        # Ensure the prediction label is valid for weighted_predictions
+        prediction_label = prediction.get("Label") # Extract the label
+        if prediction_label in weighted_predictions:
+            weighted_predictions[prediction_label] += adjusted_weights[model_id]
+        else:
+            # Handle cases where prediction might be an error or unexpected label
+            logger.warning(f"Unexpected prediction label '{prediction_label}' from model '{model_id}'. Skipping its weight in consensus.")
+
+    final_prediction_label = "UNCERTAIN"
+    if weighted_predictions["AI"] > weighted_predictions["REAL"] and weighted_predictions["AI"] > weighted_predictions["UNCERTAIN"]:
+        final_prediction_label = "AI"
+    elif weighted_predictions["REAL"] > weighted_predictions["AI"] and weighted_predictions["REAL"] > weighted_predictions["UNCERTAIN"]:
+        final_prediction_label = "REAL"
+
+    # Call analyze_performance after final_prediction_label is known
+    optimization_agent.analyze_performance(final_prediction_label, None)
+    
+    # 6. Perform forensic processing
+    gradient_image = gradient_processing(img_np_og)  # Added gradient processing
+    minmax_image = minmax_preprocess(img_np_og)  # Added MinMax processing
+
+    # First pass - standard analysis
+    ela1 = ELA(img_np_og, quality=75, scale=50, contrast=20, linear=False, grayscale=True)
+
+    # Second pass - enhanced visibility
+    ela2 = ELA(img_np_og, quality=75, scale=75, contrast=25, linear=False, grayscale=True)
+    ela3 = ELA(img_np_og, quality=75, scale=75, contrast=25, linear=False, grayscale=False)
+    
+    forensics_images = [img_pil, ela1, ela2, ela3, gradient_image, minmax_image]
+
+    # 7. Generate boilerplate descriptions for forensic outputs for anomaly agent
+    forensic_output_descriptions = [
+        f"Original augmented image (PIL): {img_pil.width}x{img_pil.height}",
+        "ELA analysis (Pass 1): Grayscale error map, quality 75.",
+        "ELA analysis (Pass 2): Grayscale error map, quality 75, enhanced contrast.",
+        "ELA analysis (Pass 3): Color error map, quality 75, enhanced contrast.",
+        "Gradient processing: Highlights edges and transitions.",
+        "MinMax processing: Deviations in local pixel values."
+    ]
+    # You could also add descriptions for Wavelet and Bit Plane if they were dynamic outputs
+    # For instance, if wavelet_blocking_noise_estimation had parameters that changed and you wanted to describe them.
+
+    # 8. Analyze forensic outputs for anomalies using ForensicAnomalyDetectionAgent
+    anomaly_detection_results = anomaly_agent.analyze_forensic_outputs(forensic_output_descriptions)
+    logger.info(f"Forensic anomaly detection: {anomaly_detection_results['summary']}")
+
+
+    # Prepare table rows for Dataframe (exclude model path)
+    table_rows = [[
+        r.get("Model", ""),
+        r.get("Contributor", ""),
+        r.get("AI Score", 0.0) if r.get("AI Score") is not None else 0.0,
+        r.get("Real Score", 0.0) if r.get("Real Score") is not None else 0.0,
+        r.get("Label", "Error")
+    ] for r in results]
+    
+    logger.info(f"Type of table_rows: {type(table_rows)}")
+    for i, row in enumerate(table_rows):
+        logger.info(f"Row {i} types: {[type(item) for item in row]}")
+
+    # The get_consensus_label function is now replaced by final_prediction_label from weighted consensus
+    consensus_html = f"<b><span style='color:{'red' if final_prediction_label == 'AI' else ('green' if final_prediction_label == 'REAL' else 'orange')}'>{final_prediction_label}</span></b>"
+
+    # Prepare data for logging to Hugging Face dataset
+    inference_params = {
+        "confidence_threshold": confidence_threshold,
+        "augment_methods": augment_methods,
+        "rotate_degrees": rotate_degrees,
+        "noise_level": noise_level,
+        "sharpen_strength": sharpen_strength,
+        "detected_context_tags": detected_context_tags
+    }
+
+    ensemble_output_data = {
+        "final_prediction_label": final_prediction_label,
+        "weighted_predictions": weighted_predictions,
+        "adjusted_weights": adjusted_weights
+    }
+
+    # Collect agent monitoring data
+    agent_monitoring_data_log = {
+        "ensemble_monitor": {
+            "alerts": monitor_agent.alerts,
+            "performance_metrics": monitor_agent.performance_metrics
+        },
+        "weight_optimization": {
+            "prediction_history_length": len(optimization_agent.prediction_history),
+            # You might add a summary of recent accuracy here if _calculate_accuracy is exposed
+        },
+        "system_health": {
+            "memory_usage": health_agent.health_metrics["memory_usage"],
+            "gpu_utilization": health_agent.health_metrics["gpu_utilization"]
+        },
+        "context_intelligence": {
+            "detected_context_tags": detected_context_tags
+        },
+        "forensic_anomaly_detection": anomaly_detection_results
+    }
+
+    # Log the inference data
+    log_inference_data(
+        original_image=img, # Use the original uploaded image
+        inference_params=inference_params,
+        model_predictions=results, # This already contains detailed results for each model
+        ensemble_output=ensemble_output_data,
+        forensic_images=forensics_images, # This is the list of PIL images generated by forensic tools
+        agent_monitoring_data=agent_monitoring_data_log,
+        human_feedback=None # This can be populated later with human review data
+    )
+
+    # Final type safety check for forensic_images before returning
+    cleaned_forensics_images = []
+    for f_img in forensics_images:
+        if isinstance(f_img, Image.Image):
+            cleaned_forensics_images.append(f_img)
+        elif isinstance(f_img, np.ndarray):
+            try:
+                cleaned_forensics_images.append(Image.fromarray(f_img))
+            except Exception as e:
+                logger.warning(f"Could not convert numpy array to PIL Image for gallery: {e}")
+                # Optionally, append a placeholder or skip
+        else:
+            logger.warning(f"Unexpected type in forensic_images: {type(f_img)}. Skipping.")
+
+    logger.info(f"Cleaned forensic images types: {[type(img) for img in cleaned_forensics_images]}")
+
+    # Ensure numerical values in results are standard Python floats before JSON serialization
+    for i, res_dict in enumerate(results):
+        for key in ["AI Score", "Real Score"]:
+            value = res_dict.get(key)
+            if isinstance(value, np.float32):
+                res_dict[key] = float(value)
+                logger.info(f"Converted {key} for result {i} from numpy.float32 to float.")
+
+    # Return raw model results as JSON string for debug_json component
+    json_results = json.dumps(results, cls=NumpyEncoder)
+
+    return img_pil, cleaned_forensics_images, table_rows, json_results, consensus_html
+
+with gr.Blocks(css="#post-gallery { overflow: hidden !important;} .grid-wrap{ overflow-y: hidden !important;} .ms-gr-ant-welcome-icon{ height:unset !important;} .tabs{margin-top:10px;}") as demo:
+    with ms.Application() as app:
+        with antd.ConfigProvider():
+            antdx.Welcome(
+                icon="https://cdn-avatars.huggingface.co/v1/production/uploads/639daf827270667011153fbc/WpeSFhuB81DY-1TjNUmV_.png",
+                title="Welcome to Project OpenSight",
+                description="The OpenSight aims to be an open-source SOTA generated image detection model. This HF Space is not only an introduction but a educational playground for the public to evaluate and challenge current open source models.  **Space will be upgraded shortly; inference on all 6 models should take about 1.2~ seconds.** "
+            )
+            with gr.Tab("👀 Rethinking Detection Models: Multi-Model, Multi-Strategy Ensemble Team and Agentic Pipelines"):
+                gr.Markdown("# Open Source Detection Models Found on the Hub\n\n - **IMPORTANT UPDATE REGARDING YOUR DATA AND PRIVACY: [PLEASE REFER TO THE MCP SERVER HACKATHON SUBMISSION FOR CRUCIAL DETAILS](https://huggingface.co/spaces/Agents-MCP-Hackathon/mcp-deepfake-forensics).** ")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        image_input = gr.Image(label="Upload Image to Analyze", sources=['upload', 'webcam'], type='pil')
+                        with gr.Accordion("Settings (Optional)", open=False, elem_id="settings_accordion"):
+                            augment_checkboxgroup = gr.CheckboxGroup(["rotate", "add_noise", "sharpen"], label="Augmentation Methods")
+                            rotate_slider = gr.Slider(0, 45, value=2, step=1, label="Rotate Degrees", visible=False)
+                            noise_slider = gr.Slider(0, 50, value=4, step=1, label="Noise Level", visible=False)
+                            sharpen_slider = gr.Slider(0, 50, value=11, step=1, label="Sharpen Strength", visible=False)
+                            confidence_slider = gr.Slider(0.0, 1.0, value=0.75, step=0.05, label="Confidence Threshold")
+                        inputs = [image_input, confidence_slider, augment_checkboxgroup, rotate_slider, noise_slider, sharpen_slider]
+                        predict_button = gr.Button("Predict")
+                        augment_button = gr.Button("Augment & Predict")
+                        image_output = gr.Image(label="Processed Image", visible=False)
+
+
+                    with gr.Column(scale=2):
+                        # Use Gradio-native Dataframe to display results with headers
+                        results_table = gr.Dataframe(
+                            label="Model Predictions",
+                            headers=["Model", "Contributor", "AI Score", "Real Score", "Label"],
+                            datatype=["str", "str", "number", "number", "str"]
+                        )
+                        forensics_gallery = gr.Gallery(label="Post Processed Images", visible=True, columns=[4], rows=[2], container=False, height="auto", object_fit="contain", elem_id="post-gallery")
+                        with gr.Accordion("Debug Output (Raw JSON)", open=False):
+                            debug_json = gr.JSON(label="Raw Model Results")
+                        consensus_md = gr.Markdown(label="Consensus", value="")
+
+                        outputs = [image_output, forensics_gallery, results_table, debug_json, consensus_md]
+                
+                # Show/hide rotate slider based on selected augmentation method
+                augment_checkboxgroup.change(lambda methods: gr.update(visible="rotate" in methods), inputs=[augment_checkboxgroup], outputs=[rotate_slider])
+                augment_checkboxgroup.change(lambda methods: gr.update(visible="add_noise" in methods), inputs=[augment_checkboxgroup], outputs=[noise_slider])
+                augment_checkboxgroup.change(lambda methods: gr.update(visible="sharpen" in methods), inputs=[augment_checkboxgroup], outputs=[sharpen_slider])
+                
+                predict_button.click(
+                    fn=predict_image_with_json, 
+                    inputs=inputs, 
+                    outputs=outputs,
+                    api_name="/predict"
+                )
+                augment_button.click(  # Connect Augment button to the function
+                    fn=predict_image_with_json, 
+                    inputs=[
+                        image_input, 
+                        confidence_slider, 
+                        gr.CheckboxGroup(["rotate", "add_noise", "sharpen"], value=["rotate", "add_noise", "sharpen"], visible=False),  # Default values
+                        rotate_slider, 
+                        noise_slider, 
+                        sharpen_slider
+                    ], 
+                    outputs=outputs,
+                    api_name="/augment"
+                )
+            with gr.Tab("🙈 Project Introduction"):
+                gr.Markdown(QUICK_INTRO)
+                
+            with gr.Tab("👑 Community Forensics Preview"):
+                # temp_space = gr.load("aiwithoutborders-xyz/OpenSight-Community-Forensics-Preview", src="spaces")
+                gr.Markdown("Community Forensics Preview coming soon!") # Placeholder for now
+            with gr.Tab("🥇 Leaderboard"):
+                gr.Markdown("# AI Generated / Deepfake Detection Models Leaderboard: Soon™")
+                
+            with gr.Tab("Wavelet Blocking Noise Estimation", visible=False):
+                gr.Interface(
+                    fn=wavelet_blocking_noise_estimation,
+                    inputs=[gr.Image(type="pil"), gr.Slider(1, 32, value=8, step=1, label="Block Size")],
+                    outputs=gr.Image(type="pil"),
+                    title="Wavelet-Based Noise Analysis",
+                    description="Analyzes image noise patterns using wavelet decomposition. This tool helps detect compression artifacts and artificial noise patterns that may indicate image manipulation. Higher noise levels in specific regions can reveal areas of potential tampering.",
+                    api_name="/tool_waveletnoise"
+                )
+
+
+            with gr.Tab("Bit Plane Values", visible=False):
+                """Forensics Tool: Bit Plane Extractor
+
+                Args:
+                    image: PIL Image to analyze
+                    channel: Color channel to extract bit plane from ("Luminance", "Red", "Green", "Blue", "RGB Norm")
+                    bit_plane: Bit plane index to extract (0-7)
+                    filter_type: Filter to apply ("Disabled", "Median", "Gaussian")
+                """
+                gr.Interface(
+
+                    fn=bit_plane_extractor,
+                    inputs=[
+                        gr.Image(type="pil"),
+                        gr.Dropdown(["Luminance", "Red", "Green", "Blue", "RGB Norm"], label="Channel", value="Luminance"),
+                        gr.Slider(0, 7, value=0, step=1, label="Bit Plane"),
+                        gr.Dropdown(["Disabled", "Median", "Gaussian"], label="Filter", value="Disabled")
+                    ],
+                    outputs=gr.Image(type="pil"),
+                    title="Bit Plane Analysis",
+                    description="Extracts and visualizes individual bit planes from different color channels. This forensic tool helps identify hidden patterns and artifacts in image data that may indicate manipulation. Different bit planes can reveal inconsistencies in image processing or editing.",
+                    api_name="/tool_bitplane"
+                )
+            # with gr.Tab("EXIF Full Dump"):
+            #     gr.Interface(
+            #         fn=exif_full_dump,
+            #         inputs=gr.Image(type="pil"),
+            #         outputs=gr.JSON(),
+            #         description="Extract all EXIF metadata from the uploaded image."
+            #     )
+
+# --- MCP-Ready Launch ---
+if __name__ == "__main__":
+    # Initialize CommitScheduler
+    # The scheduler will monitor LOCAL_LOG_DIR and push changes to HF_DATASET_NAME
+    with CommitScheduler(
+        repo_id=HF_DATASET_NAME, # Your Hugging Face dataset repository ID
+        repo_type="dataset",
+        folder_path=LOCAL_LOG_DIR,
+        every=5, # Commit every 5 minutes
+        private=False, # Keep your dataset private
+        token=os.getenv("HF_TOKEN") # Uncomment and set if token is not saved globally
+    ) as scheduler:
+        demo.launch(mcp_server=True)

requirements.txt

@@ -0,0 +1,18 @@
+gradio[mcp]
+gradio_leaderboard
+transformers
+huggingface_hub[hf_xet]
+torchvision
+torch
+spaces
+# pillow
+opencv-python
+modelscope_studio
+pydantic==2.10.6
+tf-keras
+PyWavelets
+pyexiftool
+psutil
+datasets
+Pillow
+python-dotenv