Merge commit '999d6757e80ee17842c6e2195c3a12eeb59ff329' into pr/2

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* 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
+preview/1.png filter=lfs diff=lfs merge=lfs -text
+preview/127.0.0.1_7860__.png filter=lfs diff=lfs merge=lfs -text
+preview/2.png filter=lfs diff=lfs merge=lfs -text
+preview/3.png filter=lfs diff=lfs merge=lfs -text
+preview/4.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -7,4 +7,9 @@ forensics/__pycache__/*
 *.cpython-311.pyc
 *.cpython-312.pyc
 test.ipynb
-models/*
+models/*
+*.cpython-310.pyc
+*/inference_logs/*
+hf_inference_logs/*.json
+hf_inference_logs/*
+.gradio/flagged/*

FLOW.gv

@@ -0,0 +1,66 @@
+digraph ImagePredictionFlow {
+    graph [fontname="Arial", fontsize="10", rankdir="TB"]; // Top-to-Bottom, Reduced Width
+    node [shape="rect", style="rounded,filled", fontname="Arial", fontsize="10", fillcolor="lightblue", gradientangle="90"];
+    edge [fontname="Arial", fontsize="8"];
+
+    A [label="User Upload,\nPredict", fillcolor="lightgreen"]; //Shorter Label
+    B [label="Img Pre-proc,\nAgent Init", fillcolor="lightyellow"];
+
+    subgraph cluster_models {
+        label = "Model Ensemble";
+        style = "dashed";
+
+        ImageIn [shape=point, label="", width=0, height=0];
+        Model1 [label="Model1", fillcolor="lightcoral"];   //Shorter Labels
+        Model2 [label="Model2", fillcolor="lightcoral"];
+        Model3 [label="Model3", fillcolor="lightcoral"];
+        Model4 [label="Model4", fillcolor="lightcoral"];
+        Model5 [label="Model5", fillcolor="lightcoral"];
+        Model6 [label="Model6", fillcolor="lightcoral"];
+        Model7 [label="Model7", fillcolor="lightcoral"];
+        WeightedConsensusInput [label="Model Results", fillcolor="lightyellow"];  //Shorter Label
+
+        ImageIn -> Model1;  ImageIn -> Model2;  ImageIn -> Model3;  ImageIn -> Model4;  ImageIn -> Model5;  ImageIn -> Model6;  ImageIn -> Model7;
+        Model1 -> WeightedConsensusInput;  Model2 -> WeightedConsensusInput; Model3 -> WeightedConsensusInput; Model4 -> WeightedConsensusInput; Model5 -> WeightedConsensusInput; Model6 -> WeightedConsensusInput; Model7 -> WeightedConsensusInput;
+    }
+
+    ContextualIntelligenceAgent [label="Contextual\nIntelligence Agent", fillcolor="lightcyan"]; //Shorter Label
+    BaggingAgent [label="BaggingAgent", fillcolor="lightcyan"];        //Shorter Label
+    DeepEnsembleAgent [label="DeepEnsemble\nAgent", fillcolor="lightcyan"];        //Shorter Label
+    EvolutionEnsembleAgent [label="EvolutionEnsemble\nAgent", fillcolor="lightcyan"];       //Shorter Label
+
+    WeightManager [label="Weight\nManager", fillcolor="lightcyan"];    //Shorter Label
+    WeightedConsensus [label="Weighted\nConsensus", fillcolor="lightgreen"];
+    OptimizeAgent [label="Weight\nOpt Agent", fillcolor="lightcyan"];        //Shorter Label
+
+
+    subgraph cluster_forensics {
+        label = "Forensic Analysis";
+        style = "dashed";
+
+        ForensicIn [shape=point, label="", width=0, height=0];
+        GradientProcessing [label="Gradient\nProcessing", fillcolor="lightpink"];      //Shorter Labels
+        MinMaxProcessing [label="MinMax\nProcessing", fillcolor="lightpink"];
+        ELAPorcessing [label="ELAPorcessing", fillcolor="lightpink"];
+        BitPlaneExtraction [label="BitPlane\nExtraction", fillcolor="lightpink"];
+        WaveletBasedNoiseAnalysis [label="Wavelet\nNoise Analysis", fillcolor="lightpink"];
+        AnomalyAgent [label="Anomaly\nDetection", fillcolor="lightcyan"];        //Shorter Label
+
+        ForensicIn -> GradientProcessing;  ForensicIn -> MinMaxProcessing;  ForensicIn -> ELAPorcessing;  ForensicIn -> BitPlaneExtraction;  ForensicIn -> WaveletBasedNoiseAnalysis;
+        GradientProcessing -> AnomalyAgent;  MinMaxProcessing -> AnomalyAgent;  ELAPorcessing -> AnomalyAgent;  BitPlaneExtraction -> AnomalyAgent;  WaveletBasedNoiseAnalysis -> AnomalyAgent;
+    }
+
+    DataLoggingAndOutput [label="Data Logging\nOutput", fillcolor="lightsalmon"];//Shorter Label
+    ResultsDisplay [label="Results", fillcolor="lightgreen"];    //Shorter Label
+
+    // Connections
+    A -> B;
+    B -> ImageIn;
+
+    WeightedConsensusInput -> ContextualIntelligenceAgent;  WeightedConsensusInput -> BaggingAgent;  WeightedConsensusInput -> DeepEnsembleAgent;  WeightedConsensusInput -> EvolutionEnsembleAgent;  // Connect agents
+    ContextualIntelligenceAgent -> WeightManager;  BaggingAgent -> WeightManager;  DeepEnsembleAgent -> WeightManager;  EvolutionEnsembleAgent -> WeightManager;      //  Agents to WM
+    WeightManager -> WeightedConsensus;
+    WeightedConsensus -> OptimizeAgent;  OptimizeAgent -> WeightManager;
+    WeightedConsensus -> ForensicIn;  AnomalyAgent -> DataLoggingAndOutput;
+    DataLoggingAndOutput -> ResultsDisplay;
+}

README.md

@@ -6,15 +6,401 @@ colorFrom: yellow
 colorTo: yellow
 sdk: gradio
 sdk_version: 5.33.0
-app_file: app_mcp.py
+app_file: app_optimized.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
+tags:
+  - mcp-server-track
+  - ai-agents
+  - leaderboards
+  - incentivized-contests
+  - Agents-MCP-Hackathon
+
+---
+
+**6/18/25: YES, we are aware that updates to the submission will likely result in a disqualification.** It was never about the cash prize for us in the first place 😉 Good luck to all hackers! 
+
+# The Detection Dilemma: The Degentic Games
+
+![image/png](https://cdn-uploads.huggingface.co/production/uploads/639daf827270667011153fbc/_1wlvHrYhfKyn-7lMQhsN.png)
+
+The cat-and-mouse game between digital forgery and detection reached a tipping point early last year after years of escalating concern and anxiety. The most ambitious, expensive, and resource-intensive detection model was launched with actually impressive results. Impressive… for an embarassing two to three weeks. 
+
+Then came the knockout punches. New SOTA models emerging every few weeks, in every imaginageable domain -- image, audio, video, music. Generated images are now at a level of realism that to an untrained eye, its unable to discern if its real or fake. [TO-DO: Add Citation to the study] 
+
+And let's be honest: we saw this coming. When has humanity ever resisted accelerating technology that promises... *interesting* applications? As the ancients wisely tweeted: 🔞 drives innovation. 
+
+It's time for a reset. Quit crying and get ready. Didn't you hear? The long awaited Degentic Games is starting soon, and your model sucks.
+
+## Re-Thinking Detection
+
+### 1. **Shift away from the belief that more data leads to better results. Rather, focus on insight-driven and "quality over quantity" datasets in training.**
+* **Move Away from Terabyte-Scale Datasets**: Focus on **quality over quantity** by curating a smaller, highly diverse, and **labeled dataset** emphasizing edge cases and the latest AI generations.
+* **Active Learning**: Implement active learning techniques to iteratively select the most informative samples for human labeling, reducing dataset size while maintaining effectiveness.
+
+### 2. **Efficient Model Architectures**
+* **Adopt Lightweight, State-of-the-Art Models**: Explore models designed for efficiency like MobileNet, EfficientNet, or recent advancements in vision transformers (ViTs) tailored for forensic analysis.
+* **Transfer Learning with Fine-Tuning**: Leverage pre-trained models fine-tuned on your curated dataset to leverage general knowledge while adapting to specific AI image detection tasks.
+
+### 3. **Multi-Modal and Hybrid Approaches**
+* **Combine Image Forensics with Metadata Analysis**: Integrate insights from image processing with metadata (e.g., EXIF, XMP) for a more robust detection framework.
+* **Incorporate Knowledge Graphs for AI Model Identification**: If feasible, build or utilize knowledge graphs mapping known AI models to their generation signatures for targeted detection.
+
+### 4. **Continuous Learning and Update Mechanism**
+* **Online Learning or Incremental Training**: Implement a system that can incrementally update the model with new, strategically selected samples, adapting to new AI generation techniques.
+* **Community-Driven Updates**: Establish a feedback loop with users/community to report undetected AI images, fueling model updates.
+
+### 5. **Evaluation and Validation**
+* **Robust Validation Protocols**: Regularly test against unseen, diverse datasets including novel AI generations not present during training.
+* **Benchmark Against State-of-the-Art**: Periodically compare performance with newly published detection models or techniques.
+
+
+### Core Roadmap
+
+[x] Project Introduction
+[ ] Agents Released into Wild
+[ ] Whitepaper / Arxiv Release
+[ ] Public Participation
+
+
+
+## Functions Available for LLM Calls via MCP
+
+This document outlines the functions available for programmatic invocation by LLMs through the MCP (Multi-Cloud Platform) server, as defined in `mcp-deepfake-forensics/app.py`.
+
+## 1. `full_prediction`
+
+### Description
+This function processes an uploaded image to predict whether it is AI-generated or real, utilizing an ensemble of deepfake detection models and advanced forensic analysis techniques. It also incorporates intelligent agents for context inference, weight management, and anomaly detection.
+
+### API Names
+- `predict`
+
+### Parameters
+- `img` (str): The input image to be analyzed, provided as a file path.
+- `confidence_threshold` (float): A value between 0.0 and 1.0 (default: 0.7) that determines the confidence level required for a model to label an image as "AI" or "REAL". If neither score meets this threshold, the label will be "UNCERTAIN".
+- `rotate_degrees` (float): The maximum degree by which to rotate the image (default: 0). If greater than 0, "rotate" augmentation is applied.
+- `noise_level` (float): The level of noise to add to the image (default: 0). If greater than 0, "add_noise" augmentation is applied.
+- `sharpen_strength` (float): The strength of the sharpening effect to apply (default: 0). If greater than 0, "sharpen" augmentation is applied.
+
+### Returns
+- `img_pil` (PIL Image): The processed image (original or augmented).
+- `cleaned_forensics_images` (list of PIL Image): A list of images generated by various forensic analysis techniques (ELA, gradient, minmax, bitplane). These include:
+    - Original augmented image
+    - ELA analysis (multiple passes)
+    - Gradient processing (multiple variations)
+    - MinMax processing (multiple variations)
+    - Bit Plane extraction
+- `table_rows` (list of lists): A list of lists representing the model predictions, suitable for display in a Gradio Dataframe. Each inner list contains: Model Name, Contributor, AI Score, Real Score, and Label.
+- `json_results` (str): A JSON string containing the raw model prediction results for debugging purposes.
+- `consensus_html` (str): An HTML string representing the final consensus label ("AI", "REAL", or "UNCERTAIN"), styled with color.
+
+## 2. `noise_estimation`
+
+### 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`
+
+### Parameters
+- `image` (PIL Image): The input image to analyze.
+- `block_size` (int): The size of the blocks for wavelet analysis (default: 8, range: 1-32).
+
+### Returns
+- `output_image` (PIL Image): An image visualizing the noise patterns.
+
+## 3. `bit_plane_extractor`
+
+### 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`
+
+### Parameters
+- `image` (PIL Image): The input image to analyze.
+- `channel` (str): The color channel to extract the bit plane from. Possible values: "Luminance", "Red", "Green", "Blue", "RGB Norm" (default: "Luminance").
+- `bit_plane` (int): The bit plane index to extract (0-7, default: 0).
+- `filter_type` (str): A filter to apply to the extracted bit plane. Possible values: "Disabled", "Median", "Gaussian" (default: "Disabled").
+
+### Returns
+- `output_image` (PIL Image): An image visualizing the extracted bit plane.
+
+## 4. `ELA`
+
+### Description
+Performs Error Level Analysis to detect re-saved JPEG images, which can indicate tampering. ELA highlights areas of an image that have different compression levels.
+
+### API Name
+- `tool_ela`
+
+### Parameters
+- `img` (PIL Image): Input image to analyze.
+- `quality` (int): JPEG compression quality (1-100, default: 75).
+- `scale` (int): Output multiplicative gain (1-100, default: 50).
+- `contrast` (int): Output tonality compression (0-100, default: 20).
+- `linear` (bool): Whether to use linear difference (default: False).
+- `grayscale` (bool): Whether to output grayscale image (default: False).
+
+### Returns
+- `processed_ela_image` (PIL Image): The processed ELA image.
+
+## 5. `gradient_processing`
+
+### Description
+Applies gradient filters to an image to enhance edges and transitions, which can reveal inconsistencies due to manipulation.
+
+### API Name
+- `tool_gradient_processing`
+
+### Parameters
+- `image` (PIL Image): The input image to analyze.
+- `intensity` (int): Intensity of the gradient effect (0-100, default: 90).
+- `blue_mode` (str): Mode for the blue channel. Possible values: "Abs", "None", "Flat", "Norm" (default: "Abs").
+- `invert` (bool): Whether to invert the gradients (default: False).
+- `equalize` (bool): Whether to equalize the histogram (default: False).
+
+### Returns
+- `gradient_image` (PIL Image): The image with gradient processing applied.
+
+## 6. `minmax_process`
+
+### Description
+Analyzes local pixel value deviations to detect subtle changes in image data, often indicative of digital forgeries.
+
+### API Name
+- `tool_minmax_processing`
+
+### Parameters
+- `image` (PIL Image): The input image to analyze.
+- `channel` (int): The color channel to process. Possible values: 0 (Grayscale), 1 (Blue), 2 (Green), 3 (Red), 4 (RGB Norm) (default: 4).
+- `radius` (int): The radius for local pixel analysis (0-10, default: 2).
+
+### Returns
+- `minmax_image` (PIL Image): The image with minmax processing applied.
+
+## 7. `augment_image_interface`
+
+### Description
+Applies various augmentation techniques to an image.
+
+### API Name
+- `augment_image`
+
+### Parameters
+- `img` (PIL Image): The input image to augment.
+- `augment_methods` (list of str): A list of augmentation methods to apply. Possible values: "rotate", "add_noise", "sharpen".
+- `rotate_degrees` (float): The degrees to rotate the image (0-360).
+- `noise_level` (float): The level of noise to add (0-100).
+- `sharpen_strength` (float): The strength of the sharpening effect (0-200).
+
+### Returns
+- `augmented_img` (PIL Image): The augmented image.
+
+## 8. `community_forensics_preview`
+
+### Description
+Provides a quick and simple prediction using our strongest model.
+
+### API Name
+- `quick_predict`
+
+### Parameters
+- `img` (str): The input image to analyze, provided as a file path.
+
+### Returns
+- (HTML): An HTML output from the loaded Gradio Space.
+
+---
+
+# Behind the Scenes: Image Prediction Flow
+
+When you upload an image for analysis and click the "Predict" button, the following steps occur:
+
+### 1. Image Pre-processing and Agent Initialization
+
+*   **Image Conversion**: The input image is first ensured to be a PIL (Pillow) Image object. If it's a file path, it's loaded and converted to PIL. If it's a NumPy array, it's converted. The image is then ensured to be in RGB format.
+*   **Agent Setup**: Several intelligent agents are initialized to assist in the process:
+    *   `EnsembleMonitorAgent`: Monitors the performance of individual models.
+    *   `ModelWeightManager`: Manages and adjusts the weights of different models.
+    *   `WeightOptimizationAgent`: Optimizes model weights based on performance.
+    *   `SystemHealthAgent`: Monitors the system's resource usage (e.g., memory, GPU).
+    *   `ContextualIntelligenceAgent`: Infers context tags from the image to aid in weight adjustment.
+    *   `ForensicAnomalyDetectionAgent`: Analyzes forensic outputs for signs of manipulation.
+*   **System Health Monitoring**: The `SystemHealthAgent` performs an initial check of system resources.
+*   **Image Augmentation (Optional)**: If `rotate_degrees`, `noise_level`, or `sharpen_strength` are provided, the image is augmented accordingly using "rotate", "add_noise", and "sharpen" methods internally. Otherwise, the original image is used.
+
+### 2. Initial Model Predictions
+
+*   **Individual Model Inference**: The augmented (or original) image is passed through each of the registered deepfake detection models (`model_1` through `model_7`).
+*   **Performance Monitoring**: For each model, the `EnsembleMonitorAgent` tracks its prediction label, confidence score, and inference time.
+*   **Result Collection**: The raw prediction results (AI Score, Real Score, predicted Label) from each model are stored.
+
+### 3. Smart Agent Processing and Weighted Consensus
+
+*   **Contextual Intelligence**: The `ContextualIntelligenceAgent` analyzes the image's metadata (width, height, mode) and the raw model predictions to infer relevant context tags (e.g., "generated by Midjourney", "likely real photo"). This helps in making more informed decisions about model reliability.
+*   **Dynamic Weight Adjustment**: The `ModelWeightManager` adjusts the influence (weights) of each individual model's prediction. This adjustment takes into account the initial model predictions, their confidence scores, and the detected context tags. Note that `simple_prediction` (Community Forensics model) is given a significantly higher base weight.
+*   **Weighted Consensus Calculation**: A final prediction label ("AI", "REAL", or "UNCERTAIN") is determined by combining the individual model predictions using their adjusted weights. Models with higher confidence and relevance to the detected context contribute more to the final decision.
+*   **Performance Analysis (for Optimization)**: The `WeightOptimizationAgent` analyzes the final consensus label to continually improve the weight adjustment strategy for future predictions.
+
+### 4. Forensic Processing
+
+*   **Multiple Forensic Techniques**: The original image is subjected to various forensic analysis techniques to reveal hidden artifacts that might indicate manipulation:
+    *   **Gradient Processing**: Highlights edges and transitions in the image.
+    *   **MinMax Processing**: Reveals deviations in local pixel values.
+    *   **ELA (Error Level Analysis)**: Performed in multiple passes (grayscale and color, with varying contrast) to detect areas of different compression levels, which can suggest tampering.
+    *   **Bit Plane Extraction**: Extracts and visualizes individual bit planes.
+    *   **Wavelet-Based Noise Analysis**: Analyzes noise patterns using wavelet decomposition.
+*   **Forensic Anomaly Detection**: The `ForensicAnomalyDetectionAgent` analyzes the outputs of these forensic tools and their descriptions to identify potential anomalies or inconsistencies that could indicate image manipulation.
+
+### 5. Data Logging and Output Generation
+
+*   **Inference Data Logging**: All relevant data from the current prediction, including original image, inference parameters, individual model predictions, ensemble output, forensic images, and agent monitoring data, is logged to a Hugging Face dataset for continuous improvement and analysis.
+*   **Output Preparation**: The results are formatted for display in the Gradio interface:
+    *   The processed image (augmented or original) is prepared.
+    *   The forensic analysis images are collected for display in a gallery.
+    *   A table summarizing each model's prediction (Model, Contributor, AI Score, Real Score, Label) is generated.
+    *   The raw JSON output of model results is prepared for debugging.
+    *   The final consensus label is prepared with appropriate styling.
+*   **Data Type Conversion**: Numerical values (like AI Score, Real Score) are converted to standard Python floats to ensure proper JSON serialization.
+
+---
+## Flow-Chart
+
+<img src="graph_alt.svg">
+
+
+## Roadmap & Features
+
+### In Progress & Pending Tasks
+
+| Task | Status | Priority | Notes |
+|------|--------|----------|-------|
+| [x] Set up basic ensemble model architecture | ✅ Completed | High | Core framework established |
+| [x] Implement initial forensic analysis tools | ✅ Completed | High | ELA, Gradient, MinMax processing |
+| [x] Create intelligent agent system | ✅ Completed | High | All monitoring agents implemented |
+| [x] Refactor Gradio interface for MCP | ✅ Completed | Medium | User-friendly web interface |
+| [x] Integrate multiple deepfake detection models | ✅ Completed | High | 7 models successfully integrated |
+| [x] Implement weighted consensus algorithm | ✅ Completed | High | Dynamic weight adjustment working |
+| [x] Add image augmentation capabilities | ✅ Completed | Medium | Rotation, noise, sharpening features |
+| [x] Set up data logging to Hugging Face | ✅ Completed | Medium | Continuous improvement pipeline |
+| [x] Create system health monitoring | ✅ Completed | Medium | Resource usage tracking |
+| [x] Implement contextual intelligence analysis | ✅ Completed | Medium | Context tag inference system |
+| [x] Expose `augment_image` as a Gradio interface | ✅ Completed | Medium | New "Image Augmentation" tab added |
+| [ ] Implement real-time model performance monitoring | 🔷 In Progress | High | Add live metrics dashboard |
+| [ ] Add support for video deepfake detection | Pending | Medium | Extend current image-based system |
+| [ ] Optimize forensic analysis processing speed | 🔷 In Progress | High | Current ELA processing is slow |
+| [ ] Implement batch processing for multiple images | 🔷 In Progress | Medium | Improve throughput for bulk analysis |
+| [ ] Add model confidence threshold configuration | Pending | Low | Allow users to adjust sensitivity |
+| [ ] Create test suite | Pending | High | Unit tests for all agents and models |
+| [ ] Implement model versioning and rollback | Pending | Medium | Track model performance over time |
+| [ ] Add export functionality for analysis reports | Pending | Low | PDF/CSV export options |
+| [ ] Optimize memory usage for large images | 🔷 In Progress | High | Handle 4K+ resolution images |
+| [ ] Add support for additional forensic techniques | 🔷 In Progress | Medium | Consider adding noise analysis |
+| [ ] Implement user authentication system | Pending | Low | For enterprise deployment |
+| [ ] Create API documentation | 🔷 In Progress | Medium | OpenAPI/Swagger specs |
+| [ ] Add model ensemble validation metrics | Pending | High | Cross-validation for weight optimization |
+| [ ] Implement caching for repeated analyses | Pending | Medium | Reduce redundant processing |
+| [ ] Add support for custom model integration | Pending | Low | Plugin architecture for new models |
+
+### Legend
+- **Priority**: High (Critical), Medium (Important), Low (Nice to have)
+- **Status**: Pending, 🔷 In Progress, ✅ Completed, 🔻 Blocked
+
+---
+
+Digital Forensics Implementation
+
+
+Here's the updated table with an additional column providing **instructions on how to use these tools with vision LLMs** (e.g., CLIP, Vision Transformers, or CNNs) for effective AI content detection:
+
+---
+
+### **Top 20 Tools for AI Content Detection (with Vision LLM Integration Guidance)**
+
+| Status | Rank | Tool/Algorithm                         | Reason                                                                                                                                                 | **Agent Guidance / Instructions**                                                                                               |
+|--------|------|----------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------|
+| ✅     | 1    | Noise Separation                       | Detect synthetic noise patterns absent in natural images.                                                                                              | Train the LLM on noise-separated image patches to recognize AI-specific noise textures (e.g., overly smooth or missing thermal noise).                  |
+| 🔷     | 2    | EXIF Full Dump                         | AI-generated images lack valid metadata (e.g., camera model, geolocation).                                                                             | Input the image *and its metadata as text* to a **multimodal LLM** (e.g., image + metadata caption). Flag inconsistencies (e.g., missing GPS, invalid timestamps). |
+| ✅     | 3    | Error Level Analysis (ELA)             | Reveals compression artifacts unique to AI-generated images.                                                                                           | Preprocess images via ELA before input to the LLM. Train the model to detect high-error regions indicative of synthetic content.                          |
+| 🔷     | 4    | JPEG Ghost Maps                        | Identifies compression history anomalies.                                                                                                              | Use ghost maps as a separate input channel (e.g., overlay ELA results on the RGB image) to train the LLM on synthetic vs. natural compression traces.          |
+| 🔷     | 5    | Copy-Move Forgery                      | AI models often clone/reuse elements.                                                                                                                  | Train the LLM to detect duplicated regions via frequency analysis or gradient-based saliency maps (e.g., using a Siamese network to compare image segments). |
+| ✅     | 6    | Channel Histograms                       | Skewed color distributions in AI-generated images.                                                                                                     | Feed the **histogram plots** as additional input (e.g., as a grayscale image) to highlight unnatural color profiles in the LLM.                             |
+| 🔷     | 7    | Pixel Statistics                         | Unnatural RGB value deviations in AI-generated images.                                                                                                 | Train the LLM on datasets with metadata tags indicating mean/max/min RGB values, using these stats as part of the training signal.                          |
+| 🔷     | 8    | JPEG Quality Estimation                  | AI-generated content may have atypical JPEG quality settings.                                                                                          | Preprocess the image to expose JPEG quality artifacts (e.g., blockiness) and train the LLM to identify these patterns via loss functions tuned to compression. |
+| 🔷     | 9    | Resampling Detection                     | AI tools may upscale/rotate images, leaving subpixel-level artifacts.                                                                                  | Use **frequency analysis** modules in the LLM (e.g., Fourier-transformed images) to detect Moiré patterns or grid distortions from resampling.               |
+| ✅     | 10   | PCA Projection                           | Highlights synthetic color distributions.                                                                                                              | Apply PCA to reduce color dimensions and input the 2D/3D projection to the LLM as a simplified feature space.                                               |
+| ✅     | 11   | Bit Planes Values                        | Detect synthetic noise patterns absent in natural images.                                                                                              | Analyze individual bit planes (e.g., bit plane 1–8) and feed the binary images to the LLM to train on AI-specific bit-plane anomalies.                      |
+| 🔷     | 12   | Median Filtering Traces                  | AI pre/post-processing steps mimic median filtering.                                                                                                   | Train the LLM on synthetically filtered images to recognize AI-applied diffusion artifacts.                                                                     |
+| ✅     | 13   | Wavelet Threshold                        | Identifies AI-generated texture inconsistencies.                                                                                                       | Use wavelet-decomposed images as input channels to the LLM to isolate synthetic textures vs. natural textures.                                             |
+| ✅     | 14   | Frequency Split                          | AI may generate unnatural gradients or sharpness.                                                                                                      | Separate high/low frequencies and train the LLM to detect missing high-frequency content in AI-generated regions (e.g., over-smoothed edges).               |
+| 🔷     | 15   | PRNU Identification                      | Absence of sensor-specific noise in AI-generated images.                                                                                               | Train the LLM on PRNU-noise databases to detect the absence or mismatch of sensor-specific noise in unlabeled images.                                    |
+| 🔷     | 16   | EXIF Tampering Detection                 | AI may falsify metadata.                                                                                                                               | Flag images with inconsistent Exif hashes (e.g., mismatched EXIF/visual content) and use metadata tags as training labels.                                |
+| 🔷     | 17   | Composite Splicing                       | AI-generated images often stitch elements with inconsistencies.                                                                                        | Use **edge-aware models** (e.g., CRFL-like architectures) to detect lighting/shadow mismatches in spliced regions.                                          |
+| 🔷     | 18   | RGB/HSV Plots                            | AI-generated images have unnatural color distributions.                                                                                                | Input RGB/HSV channel plots as 1D signals to the LLM's classifier head, along with the original image.                                                          |
+| 🔷     | 19   | Dead/Hot Pixel Analysis                | Absence of sensor-level imperfections in AI-generated images.                                                                                          | Use pre-trained sensor noise databases to train the LLM to flag images missing dead/hot pixels.                                                             |
+| 🔷     | 20   | File Digest (Hashing)                  | Compare to known AI-generated image hashes for rapid detection.                                                                                       | Use hash values as binary tags in a training dataset (e.g., "hash matches known AI model" → label as synthetic).                                           |
+
+### Legend
+- **Priority**: High (Critical), Medium (Important), Low (Nice to have)
+- **Status**: 🔷 In-Progress, ✅ Completed, 🔻 Blocked
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+### **Hybrid Input Table for AI Content Detection (Planned)**
+
+| **Strategy #** | **Description**                                                                 | **Input Components**                                                                 | **Agent Guidance / Instructions**                                                                                                              |
+|----------------|----------------------------------------------------------------------------------|--------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------|
+| 1              | Combine ELA (Error Level Analysis) with RGB images for texture discrimination.     | ELA-processed image + original RGB image (stacked as 4D tensor).                     | Use a **multi-input CNN** to process ELA maps and RGB images in parallel, or concatenate them into a 6-channel input (3 RGB + 3 ELA). |
+| 2              | Use metadata (Exif) and visual content as a **multimodal pair**.                   | Visual image + Exif metadata (as text caption).                                      | Feed the image and metadata text into a **multimodal LLM** (e.g., CLIP or MMBT). Use a cross-attention module to align metadata with visual features. |
+| 3              | Add **histogram plots** as a 1D auxiliary input for color distribution analysis.   | Image (3D input) + histogram plots (1D vector or 2D grayscale image).                | Train a **dual-stream model** (CNN for image + LSTM/Transformer for histogram data) to learn the relationship between visual and statistical features. |
+| 4              | Combine **frequency split images** (high/low) with RGB for texture detection.      | High-frequency image + low-frequency image + RGB image (as 3+3+3 input channels).    | Use a **frequency-aware CNN** to process each frequency band with separate filters, then merge features for classification.             |
+| 5              | Train a model on **bit planes values** alongside the original image.               | Bit plane images (binary black-and-white layers) + original RGB image.               | Stack or concatenate bit plane images with RGB channels before inputting to the LLM. For example, combine 3 bit planes with 3 RGB channels. |
+| 6              | Use **PRNU noise maps** and visual features to detect synthetic content.            | PRNU-noise map (grayscale) + RGB image (3D input).                                   | Train a **Siamese network** to compare PRNU maps with real-world noise databases. If PRNU is absent or mismatched, flag the image as synthetic. |
+| 7              | Stack **hex-editor-derived metadata** (e.g., file header signatures) as a channel. | Hex-derived binary patterns (encoded as 1D or 2D data) + RGB image.                  | Use a **transformer with 1D hex embeddings** as a metadata input, cross-attending with a ViT (Vision Transformer) for RGB analysis.     |
+| 8              | Add **dead/hot pixel detection maps** as a mask to highlight sensor artifacts.     | Dead/hot pixel mask (binary 2D map) + RGB image.                                     | Concatenate the mask with the RGB image as a 4th channel. Train a U-Net-style model to detect synthetic regions where the mask lacks sensor patterns. |
+| 9              | Use **PCA-reduced color projections** as a simplified input for LLMs.              | PCA-transformed color embeddings (2D/3D projection) + original image.                | Train a **transformer** to learn how PCA-projected color distributions differ between natural and synthetic images.                 |
+| 10             | Integrate **wavelet-decomposed subbands** with RGB for texture discrimination.     | Wavelet subbands (LL, LH, HL, HH) + RGB image (stacked as 7D input).                 | Design a **wavelet-aware CNN** to process each subband separately before global pooling and classification.                          |
+
+---
+
+### **Key Integration Tips for Hybrid Inputs**
+1. **Multimodal Models**  
+   - Use models like **CLIP**, **BLIP**, or **MBT** to align metadata (text) with visual features (images).  
+   - For example: Combine a **ViT** (for image processing) with a **Transformer** (for Exif metadata or histograms).
+
+2. **Feature Fusion Techniques**  
+   - **Early fusion**: Concatenate inputs (e.g., ELA + RGB) before the first layer.  
+   - **Late fusion**: Process inputs separately and merge features before final classification.  
+   - **Cross-modal attention**: Use cross-attention to align metadata with visual features (e.g., Exif text and PRNU noise maps).
+
+3. **Preprocessing for Hybrid Inputs**  
+   - Normalize metadata and image data to the same scale (e.g., 0–1).  
+   - Convert 1D histogram data into 2D images (e.g., heatmap-like plots) for consistent input formats.
+
+4. **Loss Functions for Hybrid Tasks**  
+   - Use **multi-task loss** (e.g., classification + regression) if metadata is involved.  
+   - For consistency checks (e.g., metadata vs. visual content), use **triplet loss** or **contrastive loss**.
+
+---
+### **Overview of Multi-Model Consensus Methods in ML**
+| **Method**               | **Category**               | **Description**                                  | **Key Advantages**                                | **Key Limitations**                                          | **Weaknesses**                          | **Strengths**                                                                 |
+|--------------------------|----------------------------|--------------------------------------------------|---------------------------------------------------|--------------------------------------------------------------|----------------------------------------|--------------------------------------------------------------------------------|
+| **Bagging (e.g., Random Forest)** | **Traditional Ensembles**  | Trains multiple models on bootstrapped data subsets, aggregating predictions | Reduces overfitting (~variance reduction)           | Computationally costly for large datasets; models can be correlated | Not robust to adversarial attacks      | Simple to implement; robust to noisy data; handles high-dimensional data well     |
+| **Boosting (e.g., XGBoost, LightGBM)** | **Traditional Ensembles**  | Iteratively corrects errors using weighted models | High accuracy on structured/tabular data           | Risk of overfitting; sensitive to noisy data                   | Computationally intensive              | Dominates in competitions (e.g., Kaggle); scalable for medium datasets           |
+| **Stacking**             | **Traditional Ensembles**  | Combines predictions via a meta-learner          | Can outperform individual models; flexible          | Increased complexity and data leakage risk                   | Requires careful hyperparameter tuning | Excels in combining diverse models (e.g., trees + SVMs + linear models)            |
+| **Deep Ensembles**       | **Deep Learning Ensembles**| Multiple independently trained neural networks   | Uncertainty estimation; robust to data shifts        | High computational cost; memory-heavy                        | Model coordination challenges          | State-of-the-art in safety-critical domains (e.g., medical imaging, autonomous vehicles) |
+| **Snapshot Ensembles**   | **Deep Learning Ensembles**| Saves models at different optimization stages    | Efficient (only one training run)                   | Limited diversity (same architecture/init)                   | Requires careful checkpoint selection  | Lightweight for tasks like on-device deployment                                  |
+| **Monte Carlo Dropout**  | **Approximate Ensembles**  | Applies dropout at inference to simulate many models | Free ensemble (during testing)                      | Approximates uncertainty poorly compared to deep ensembles    | Limited diversity                     | Cheap and simple; useful for quick uncertainty estimates                         |
+| **Mixture of Experts (MoE)** | **Scalable Ensembles**  | Specialized sub-models (experts) with a gating mechanism | Efficient scaling (only activate sub-models)        | Training instability; uneven expert utilization              | Requires expert/gate orchestration     | Dominates large-scale applications like Switch Transformers and Hyper-Cloud systems |
+| **Bayesian Neural Networks (BNNs)** | **Probabilistic Ensembles** | Models weights as probability distributions      | Built-in uncertainty quantification                 | Intractable to train exactly; approximations needed            | Difficult optimization                | Essential for risk-averse applications (robotics, finance)                       |
+| **Ensemble Knowledge Distillation** | **Model Compression**   | Trains a single model to mimic an ensemble       | Reduces compute/memory demands                   | Loses some ensemble benefits (diversity, uncertainty)         | Relies on a high-quality teacher ensemble | Enables deployment of ensemble-like performance in compact models (edge devices) |
+| **Noisy Student Training** | **Semi-Supervised Ensembles** | Iterative self-training with teacher-student loops | Uses unlabeled data effectively; improves robustness| Needs large unlabeled data and computational resources         | Vulnerable to error propagation         | State-of-the-art in semi-supervised settings (e.g., NLP)                         |
+| **Evolutionary Ensembles** | **Dynamic Ensembles**    | Uses genetic algorithms to evolve model populations | Adaptive diversity generation                      | High time/cost for evolution; niche use cases                 | Hard to interpret                     | Useful for non-stationary environments/on datasets with drift                  |
+| **Consensus Networks**   | **NLP/Serverless Ensembles** | Distributes models across clients/aggregates votes | Decentralized privacy-preserving predictions     | Communication overhead; non-i.i.d. data conflicts       | Requires synchronized coordination    | Fed into federated learning systems (e.g., healthcare, finance)                 |
+| **Hybrid Systems**       | **Cross-Architecture Ensembles** | Combines models (e.g., CNNs, GNNs, transformers) | Captures multi-modal or heterogeneous patterns     | Integration complexity; delayed inference               | Model conflicts                       | Dominates in tasks requiring domain-specific reasoning (e.g., drug discovery)  |
+| **Self-Supervised Ensembles** | **Vision/NLP**          | Uses contrastive learning with multiple models (e.g., MoCo, SimCLR) | Data-efficient; strong performance on downstream tasks | Training is resource-heavy; requires pre-training at scale | Low interpretability                  | Foundations for modern vision/NLP architectures (e.g., resists data scarcity)   |
+---

agents/ensemble_team.py

@@ -0,0 +1,131 @@
+import logging
+import time
+import torch
+import psutil # Ensure psutil is imported here as well
+import GPUtil
+from datetime import datetime, timedelta
+import gc # Import garbage collector
+
+logger = logging.getLogger(__name__)
+
+class EnsembleMonitorAgent:
+    def __init__(self):
+        logger.info("Initializing EnsembleMonitorAgent.")
+        self.performance_metrics = {}
+        self.alerts = []
+    
+    def monitor_prediction(self, model_id, prediction_label, confidence_score, inference_time):
+        logger.info(f"Monitoring prediction for model '{model_id}'. Label: {prediction_label}, Confidence: {confidence_score:.2f}, Time: {inference_time:.4f}s")
+        if model_id not in self.performance_metrics:
+            self.performance_metrics[model_id] = {
+                "total_predictions": 0,
+                "correct_predictions": 0,  # This would require ground truth, which we don't have here.
+                "total_confidence": 0.0,
+                "total_inference_time": 0.0
+            }
+        
+        metrics = self.performance_metrics[model_id]
+        metrics["total_predictions"] += 1
+        metrics["total_confidence"] += confidence_score
+        metrics["total_inference_time"] += inference_time
+        
+        # Example alert: model taking too long
+        if inference_time > 5.0: # Threshold for slow inference
+            alert_msg = f"ALERT: Model '{model_id}' inference time exceeded 5.0s: {inference_time:.4f}s"
+            self.alerts.append(alert_msg)
+            logger.warning(alert_msg)
+        
+        # Example alert: low confidence
+        if confidence_score < 0.5: # Threshold for low confidence
+            alert_msg = f"ALERT: Model '{model_id}' returned low confidence: {confidence_score:.2f}"
+            self.alerts.append(alert_msg)
+            logger.warning(alert_msg)
+            
+        logger.info(f"Updated metrics for '{model_id}': {metrics}")
+    
+    def get_performance_summary(self):
+        logger.info("Generating performance summary for all models.")
+        summary = {}
+        for model_id, metrics in self.performance_metrics.items():
+            avg_confidence = metrics["total_confidence"] / metrics["total_predictions"] if metrics["total_predictions"] > 0 else 0
+            avg_inference_time = metrics["total_inference_time"] / metrics["total_predictions"] if metrics["total_predictions"] > 0 else 0
+            summary[model_id] = {
+                "avg_confidence": avg_confidence,
+                "avg_inference_time": avg_inference_time,
+                "total_predictions": metrics["total_predictions"]
+            }
+        logger.info(f"Performance summary: {summary}")
+        return summary
+
+class WeightOptimizationAgent:
+    def __init__(self, weight_manager):
+        logger.info("Initializing WeightOptimizationAgent.")
+        self.weight_manager = weight_manager
+        self.prediction_history = []
+        self.performance_window = timedelta(hours=24) # Evaluate performance over last 24 hours
+    
+    def analyze_performance(self, final_prediction, ground_truth=None):
+        logger.info(f"Analyzing performance. Final prediction: {final_prediction}, Ground truth: {ground_truth}")
+        timestamp = datetime.now()
+        self.prediction_history.append({
+            "timestamp": timestamp,
+            "final_prediction": final_prediction,
+            "ground_truth": ground_truth # Ground truth is often not available in real-time
+        })
+        
+        # Keep history windowed
+        self.prediction_history = [p for p in self.prediction_history if timestamp - p["timestamp"] < self.performance_window]
+        logger.info(f"Prediction history length: {len(self.prediction_history)}")
+
+        # In a real scenario, this would involve a more complex optimization logic
+        # For now, it just logs the history length.
+
+class SystemHealthAgent:
+    def __init__(self):
+        logger.info("Initializing SystemHealthAgent.")
+        self.health_metrics = {
+            "cpu_percent": 0,
+            "memory_usage": {"total": 0, "available": 0, "percent": 0},
+            "gpu_utilization": []
+        }
+    
+    def monitor_system_health(self):
+        logger.info("Monitoring system health...")
+        self.health_metrics["cpu_percent"] = psutil.cpu_percent(interval=1)
+        mem = psutil.virtual_memory()
+        self.health_metrics["memory_usage"] = {
+            "total": mem.total,
+            "available": mem.available,
+            "percent": mem.percent
+        }
+
+        # Holy moly, been at 99% for hours whoops
+        if mem.percent > 90: 
+            logger.warning(f"CRITICAL: System memory usage is at {mem.percent}%. Attempting to clear memory cache...")
+            gc.collect() 
+            logger.info("Garbage collection triggered. Re-checking memory usage...")
+            mem_after_gc = psutil.virtual_memory()
+            self.health_metrics["memory_usage_after_gc"] = {
+                "total": mem_after_gc.total,
+                "available": mem_after_gc.available,
+                "percent": mem_after_gc.percent
+            }
+            logger.info(f"Memory usage after GC: {mem_after_gc.percent}%")
+
+        gpu_info = []
+        try:
+            gpus = GPUtil.getGPUs()
+            for gpu in gpus:
+                gpu_info.append({
+                    "id": gpu.id,
+                    "name": gpu.name,
+                    "load": gpu.load,
+                    "memoryUtil": gpu.memoryUtil,
+                    "memoryTotal": gpu.memoryTotal,
+                    "memoryUsed": gpu.memoryUsed
+                })
+        except Exception as e:
+            logger.warning(f"Could not retrieve GPU information: {e}")
+            gpu_info.append({"error": str(e)})
+        self.health_metrics["gpu_utilization"] = gpu_info
+        logger.info(f"System health metrics: CPU: {self.health_metrics['cpu_percent']}%, Memory: {self.health_metrics['memory_usage']['percent']}%, GPU: {gpu_info}") 

agents/{weight_management.py → ensemble_weights.py}

@@ -1,10 +1,12 @@
 import logging
 import torch
+from utils.registry import MODEL_REGISTRY # Import MODEL_REGISTRY
 
 logger = logging.getLogger(__name__)
 
 class ContextualWeightOverrideAgent:
     def __init__(self):
+        logger.info("Initializing ContextualWeightOverrideAgent.")
         self.context_overrides = {
             # Example: when image is outdoor, model_X is penalized, model_Y is boosted
             "outdoor": {
@@ -23,7 +25,7 @@ class ContextualWeightOverrideAgent:
         }
 
     def get_overrides(self, context_tags: list[str]) -> dict:
-        """Returns combined weight overrides for given context tags."""
+        logger.info(f"Getting weight overrides for context tags: {context_tags}")
         combined_overrides = {}
         for tag in context_tags:
             if tag in self.context_overrides:
@@ -31,21 +33,37 @@ class ContextualWeightOverrideAgent:
                     # If a model appears in multiple contexts, we can decide how to combine (e.g., multiply, average, take max)
                     # For now, let's just take the last one if there are conflicts, or multiply for simple cumulative effect.
                     combined_overrides[model_id] = combined_overrides.get(model_id, 1.0) * multiplier
+        logger.info(f"Combined context overrides: {combined_overrides}")
         return combined_overrides
 
 
 class ModelWeightManager:
-    def __init__(self):
-        self.base_weights = {
-            "model_1": 0.15,  # SwinV2 Based
-            "model_2": 0.15,  # ViT Based
-            "model_3": 0.15,  # SDXL Dataset
-            "model_4": 0.15,  # SDXL + FLUX
-            "model_5": 0.15,  # ViT Based
-            "model_5b": 0.10, # ViT Based, Newer Dataset
-            "model_6": 0.10,  # Swin, Midj + SDXL
-            "model_7": 0.05   # ViT
-        }
+    def __init__(self, strongest_model_id: str = None):
+        logger.info(f"Initializing ModelWeightManager with strongest_model_id: {strongest_model_id}")
+        # Dynamically initialize base_weights from MODEL_REGISTRY
+        num_models = len(MODEL_REGISTRY)
+        if num_models > 0:
+            if strongest_model_id and strongest_model_id in MODEL_REGISTRY:
+                logger.info(f"Designating '{strongest_model_id}' as the strongest model.")
+                # Assign a high weight to the strongest model (e.g., 50%)
+                strongest_weight_share = 0.5
+                self.base_weights = {strongest_model_id: strongest_weight_share}
+                remaining_models = [mid for mid in MODEL_REGISTRY.keys() if mid != strongest_model_id]
+                if remaining_models:
+                    other_models_weight_share = (1.0 - strongest_weight_share) / len(remaining_models)
+                    for model_id in remaining_models:
+                        self.base_weights[model_id] = other_models_weight_share
+                else: # Only one model, which is the strongest
+                    self.base_weights[strongest_model_id] = 1.0
+            else:
+                if strongest_model_id and strongest_model_id not in MODEL_REGISTRY:
+                    logger.warning(f"Strongest model ID '{strongest_model_id}' not found in MODEL_REGISTRY. Distributing weights equally.")
+                initial_weight = 1.0 / num_models
+                self.base_weights = {model_id: initial_weight for model_id in MODEL_REGISTRY.keys()}
+        else:
+            self.base_weights = {} # Handle case with no registered models
+        logger.info(f"Base weights initialized: {self.base_weights}")
+        
         self.situation_weights = {
             "high_confidence": 1.2,    # Boost weights for high confidence predictions
             "low_confidence": 0.8,     # Reduce weights for low confidence
@@ -56,52 +74,80 @@ class ModelWeightManager:
     
     def adjust_weights(self, predictions, confidence_scores, context_tags: list[str] = None):
         """Dynamically adjust weights based on prediction patterns and optional context."""
+        logger.info("Adjusting model weights.")
         adjusted_weights = self.base_weights.copy()
+        logger.info(f"Initial adjusted weights (copy of base): {adjusted_weights}")
 
         # 1. Apply contextual overrides first
         if context_tags:
+            logger.info(f"Applying contextual overrides for tags: {context_tags}")
             overrides = self.context_override_agent.get_overrides(context_tags)
             for model_id, multiplier in overrides.items():
                 adjusted_weights[model_id] = adjusted_weights.get(model_id, 0.0) * multiplier
+            logger.info(f"Adjusted weights after context overrides: {adjusted_weights}")
         
         # 2. Apply situation-based adjustments (consensus, conflict, confidence)
         # Check for consensus
-        if self._has_consensus(predictions):
+        has_consensus = self._has_consensus(predictions)
+        if has_consensus:
+            logger.info("Consensus detected. Boosting weights for consensus.")
             for model in adjusted_weights:
                 adjusted_weights[model] *= self.situation_weights["consensus"]
+            logger.info(f"Adjusted weights after consensus boost: {adjusted_weights}")
         
         # Check for conflicts
-        if self._has_conflicts(predictions):
+        has_conflicts = self._has_conflicts(predictions)
+        if has_conflicts:
+            logger.info("Conflicts detected. Reducing weights for conflict.")
             for model in adjusted_weights:
                 adjusted_weights[model] *= self.situation_weights["conflict"]
+            logger.info(f"Adjusted weights after conflict reduction: {adjusted_weights}")
         
         # Adjust based on confidence
+        logger.info("Adjusting weights based on model confidence scores.")
         for model, confidence in confidence_scores.items():
             if confidence > 0.8:
                 adjusted_weights[model] *= self.situation_weights["high_confidence"]
+                logger.info(f"Model '{model}' has high confidence ({confidence:.2f}). Weight boosted.")
             elif confidence < 0.5:
                 adjusted_weights[model] *= self.situation_weights["low_confidence"]
+                logger.info(f"Model '{model}' has low confidence ({confidence:.2f}). Weight reduced.")
+        logger.info(f"Adjusted weights before normalization: {adjusted_weights}")
         
-        return self._normalize_weights(adjusted_weights)
+        normalized_weights = self._normalize_weights(adjusted_weights)
+        logger.info(f"Final normalized adjusted weights: {normalized_weights}")
+        return normalized_weights
     
     def _has_consensus(self, predictions):
         """Check if models agree on prediction"""
-        # Ensure all predictions are not None before checking for consensus
+        logger.info("Checking for consensus among model predictions.")
         non_none_predictions = [p.get("Label") for p in predictions.values() if p is not None and isinstance(p, dict) and p.get("Label") is not None and p.get("Label") != "Error"]
-        return len(non_none_predictions) > 0 and len(set(non_none_predictions)) == 1
+        logger.debug(f"Non-none predictions for consensus check: {non_none_predictions}")
+        result = len(non_none_predictions) > 0 and len(set(non_none_predictions)) == 1
+        logger.info(f"Consensus detected: {result}")
+        return result
     
     def _has_conflicts(self, predictions):
         """Check if models have conflicting predictions"""
-        # Ensure all predictions are not None before checking for conflicts
+        logger.info("Checking for conflicts among model predictions.")
         non_none_predictions = [p.get("Label") for p in predictions.values() if p is not None and isinstance(p, dict) and p.get("Label") is not None and p.get("Label") != "Error"]
-        return len(non_none_predictions) > 1 and len(set(non_none_predictions)) > 1
+        logger.debug(f"Non-none predictions for conflict check: {non_none_predictions}")
+        result = len(non_none_predictions) > 1 and len(set(non_none_predictions)) > 1
+        logger.info(f"Conflicts detected: {result}")
+        return result
     
     def _normalize_weights(self, weights):
         """Normalize weights to sum to 1"""
+        logger.info("Normalizing weights.")
         total = sum(weights.values())
         if total == 0:
-            # Handle case where all weights became zero due to aggressive multipliers
-            # This could assign equal weights or revert to base weights
-            logger.warning("All weights became zero after adjustments. Reverting to base weights.")
-            return {k: 1.0/len(self.base_weights) for k in self.base_weights}
-        return {k: v/total for k, v in weights.items()} 
+            logger.warning("All weights became zero after adjustments. Reverting to equal base weights for registered models.")
+            # Revert to equal weights for all *registered* models if total becomes zero
+            num_registered_models = len(MODEL_REGISTRY)
+            if num_registered_models > 0:
+                return {k: 1.0/num_registered_models for k in MODEL_REGISTRY.keys()}
+            else:
+                return {} # No models registered
+        normalized = {k: v/total for k, v in weights.items()}
+        logger.info(f"Weights normalized. Total sum: {sum(normalized.values()):.2f}")
+        return normalized 

agents/monitoring_agents.py

@@ -1,135 +0,0 @@
-import logging
-import time
-import torch
-import psutil # Ensure psutil is imported here as well
-
-logger = logging.getLogger(__name__)
-
-class EnsembleMonitorAgent:
-    def __init__(self):
-        self.performance_metrics = {
-            "model_accuracy": {},
-            "response_times": {},
-            "confidence_distribution": {},
-            "consensus_rate": 0.0
-        }
-        self.alerts = []
-    
-    def monitor_prediction(self, model_id, prediction, confidence, response_time):
-        """Monitor individual model performance"""
-        if model_id not in self.performance_metrics["model_accuracy"]:
-            self.performance_metrics["model_accuracy"][model_id] = []
-            self.performance_metrics["response_times"][model_id] = []
-            self.performance_metrics["confidence_distribution"][model_id] = []
-        
-        self.performance_metrics["response_times"][model_id].append(response_time)
-        self.performance_metrics["confidence_distribution"][model_id].append(confidence)
-        
-        # Check for performance issues
-        self._check_performance_issues(model_id)
-    
-    def _check_performance_issues(self, model_id):
-        """Check for any performance anomalies"""
-        response_times = self.performance_metrics["response_times"][model_id]
-        if len(response_times) > 10:
-            avg_time = sum(response_times[-10:]) / 10
-            if avg_time > 2.0:  # More than 2 seconds
-                self.alerts.append(f"High latency detected for {model_id}: {avg_time:.2f}s")
-
-class WeightOptimizationAgent:
-    def __init__(self, weight_manager):
-        self.weight_manager = weight_manager
-        self.prediction_history = []  # Stores (ensemble_prediction_label, assumed_actual_label)
-        self.optimization_threshold = 0.05  # 5% change in accuracy triggers optimization
-        self.min_history_for_optimization = 20 # Minimum samples before optimizing
-    
-    def analyze_performance(self, ensemble_prediction_label, actual_label=None):
-        """Analyze ensemble performance and record for optimization"""
-        # If actual_label is not provided, assume ensemble is correct if not UNCERTAIN
-        assumed_actual_label = actual_label
-        if assumed_actual_label is None and ensemble_prediction_label != "UNCERTAIN":
-            assumed_actual_label = ensemble_prediction_label
-        
-        self.prediction_history.append((ensemble_prediction_label, assumed_actual_label))
-        
-        if len(self.prediction_history) >= self.min_history_for_optimization and self._should_optimize():
-            self._optimize_weights()
-    
-    def _calculate_accuracy(self, history_subset):
-        """Calculates accuracy based on history where actual_label is known."""
-        correct_predictions = 0
-        total_known = 0
-        for ensemble_pred, actual_label in history_subset:
-            if actual_label is not None:
-                total_known += 1
-                if ensemble_pred == actual_label:
-                    correct_predictions += 1
-        return correct_predictions / total_known if total_known > 0 else 0.0
-
-    def _should_optimize(self):
-        """Determine if weights should be optimized based on recent performance change."""
-        if len(self.prediction_history) < self.min_history_for_optimization * 2: # Need enough history for comparison
-            return False
-        
-        # Compare accuracy of recent batch with previous batch
-        recent_batch = self.prediction_history[-self.min_history_for_optimization:]
-        previous_batch = self.prediction_history[-self.min_history_for_optimization*2:-self.min_history_for_optimization]
-        
-        recent_accuracy = self._calculate_accuracy(recent_batch)
-        previous_accuracy = self._calculate_accuracy(previous_batch)
-        
-        # Trigger optimization if there's a significant drop in accuracy
-        if previous_accuracy > 0 and (previous_accuracy - recent_accuracy) / previous_accuracy > self.optimization_threshold:
-            logger.warning(f"Performance degradation detected (from {previous_accuracy:.2f} to {recent_accuracy:.2f}). Triggering weight optimization.")
-            return True
-        return False
-    
-    def _optimize_weights(self):
-        """Optimize model weights based on performance."""
-        logger.info("Optimizing model weights based on recent performance.")
-        # Placeholder for sophisticated optimization logic.
-        # This is where you would adjust self.weight_manager.base_weights
-        # based on which models contributed more to correct predictions or errors.
-        # For now, it's just a log message.
-
-
-class SystemHealthAgent:
-    def __init__(self):
-        self.health_metrics = {
-            "memory_usage": [],
-            "gpu_utilization": [],
-            "model_load_times": {},
-            "error_rates": {}
-        }
-    
-    def monitor_system_health(self):
-        """Monitor overall system health"""
-        self._check_memory_usage()
-        self._check_gpu_utilization()
-        # You might add _check_model_health() here later
-    
-    def _check_memory_usage(self):
-        """Monitor memory usage"""
-        try:
-            import psutil
-            memory = psutil.virtual_memory()
-            self.health_metrics["memory_usage"].append(memory.percent)
-            
-            if memory.percent > 90:
-                logger.warning(f"High memory usage detected: {memory.percent}%")
-        except ImportError:
-            logger.warning("psutil not installed. Cannot monitor memory usage.")
-    
-    def _check_gpu_utilization(self):
-        """Monitor GPU utilization if available"""
-        if torch.cuda.is_available():
-            try:
-                gpu_util = torch.cuda.memory_allocated() / torch.cuda.max_memory_allocated()
-                self.health_metrics["gpu_utilization"].append(gpu_util)
-                
-                if gpu_util > 0.9:
-                    logger.warning(f"High GPU utilization detected: {gpu_util*100:.2f}%")
-            except Exception as e:
-                logger.warning(f"Error monitoring GPU utilization: {e}")
-        else:
-            logger.info("CUDA not available. Skipping GPU utilization monitoring.") 

agents/smart_agents.py

@@ -1,54 +1,126 @@
 import logging
-from PIL import Image
+import torch
+import numpy as np
+from PIL import Image # For image processing context
+# import smolagents # Removed unused import
 
 logger = logging.getLogger(__name__)
 
 class ContextualIntelligenceAgent:
     def __init__(self):
-        # In a real scenario, this would involve an LLM call or a sophisticated rule engine
-        pass
+        logger.info("Initializing ContextualIntelligenceAgent.")
+        # This would be a more sophisticated model in a real scenario
+        self.context_rules = {
+            "high_resolution": {"min_width": 1920, "min_height": 1080, "tag": "high_resolution_image"},
+            "low_resolution": {"max_width": 640, "max_height": 480, "tag": "low_resolution_image"},
+            "grayscale": {"mode": "L", "tag": "grayscale_image"},
+            "potentially_natural_scene": {"keywords": ["Real"], "threshold": 0.7, "tag": "potentially_natural_scene"},
+            "potentially_ai_generated": {"keywords": ["AI", "Fake", "Deepfake"], "threshold": 0.7, "tag": "potentially_ai_generated"},
+            "outdoor": {"model_tags": ["sunny", "sky", "trees"], "tag": "outdoor"},
+            "indoor": {"model_tags": ["room", "furniture"], "tag": "indoor"},
+            "sunny": {"rgb_avg_min": [200, 200, 100], "tag": "sunny"},
+            "dark": {"rgb_avg_max": [50, 50, 50], "tag": "dark"},
+        }
 
-    def infer_context_tags(self, image_data: dict, initial_predictions: dict) -> list[str]:
-        """Simulates an LLM inferring context tags based on image data and predictions."""
-        context_tags = []
+    def infer_context_tags(self, image_metadata: dict, model_predictions: dict) -> list[str]:
+        logger.info("Inferring context tags from image metadata and model predictions.")
+        detected_tags = []
+
+        # Analyze image metadata
+        width = image_metadata.get("width", 0)
+        height = image_metadata.get("height", 0)
+        mode = image_metadata.get("mode", "RGB")
+
+        if width >= self.context_rules["high_resolution"]["min_width"] and \
+           height >= self.context_rules["high_resolution"]["min_height"]:
+            detected_tags.append(self.context_rules["high_resolution"]["tag"])
+            logger.debug(f"Detected tag: {self.context_rules['high_resolution']['tag']}")
+
+        if width <= self.context_rules["low_resolution"]["max_width"] and \
+           height <= self.context_rules["low_resolution"]["max_height"]:
+            detected_tags.append(self.context_rules["low_resolution"]["tag"])
+            logger.debug(f"Detected tag: {self.context_rules['low_resolution']['tag']}")
+
+        if mode == self.context_rules["grayscale"]["mode"]:
+            detected_tags.append(self.context_rules["grayscale"]["tag"])
+            logger.debug(f"Detected tag: {self.context_rules['grayscale']['tag']}")
+
+        # Analyze model predictions for general context
+        for model_id, prediction in model_predictions.items():
+            label = prediction.get("Label")
+            ai_score = prediction.get("AI Score", 0.0)
+            real_score = prediction.get("Real Score", 0.0)
+
+            if label and "potentially_natural_scene" not in detected_tags:
+                for keyword in self.context_rules["potentially_natural_scene"]["keywords"]:
+                    if keyword in label and real_score >= self.context_rules["potentially_natural_scene"]["threshold"]:
+                        detected_tags.append(self.context_rules["potentially_natural_scene"]["tag"])
+                        logger.debug(f"Detected tag: {self.context_rules['potentially_natural_scene']['tag']}")
+                        break # Only add once
+            
+            if label and "potentially_ai_generated" not in detected_tags:
+                for keyword in self.context_rules["potentially_ai_generated"]["keywords"]:
+                    if keyword in label and ai_score >= self.context_rules["potentially_ai_generated"]["threshold"]:
+                        detected_tags.append(self.context_rules["potentially_ai_generated"]["tag"])
+                        logger.debug(f"Detected tag: {self.context_rules['potentially_ai_generated']['tag']}")
+                        break # Only add once
         
-        # Boilerplate logic: infer tags based on simple cues
-        if image_data.get("width", 0) > 1000 and image_data.get("height", 0) > 1000:
-            context_tags.append("high_resolution")
+        # Simulate simple scene detection based on general consensus if available
+        # This is a very basic simulation; a real system would use a separate scene classification model
+        if "potentially_natural_scene" in detected_tags and "potentially_ai_generated" not in detected_tags:
+            # Simulate outdoor/sunny detection based on presence of a real image tag
+            # In a real scenario, this would involve analyzing image features
+            if real_score > 0.8: # Placeholder for actual image feature analysis
+                detected_tags.append(self.context_rules["outdoor"]["tag"])
+                detected_tags.append(self.context_rules["sunny"]["tag"])
+                logger.debug(f"Simulated tags: {self.context_rules['outdoor']['tag']},{self.context_rules['sunny']['tag']}")
         
-        # Example based on initial broad prediction (e.g., if any model strongly predicts 'real')
-        if any(v.get("Real Score", 0) > 0.9 for v in initial_predictions.values()):
-            context_tags.append("potentially_natural_scene")
+        logger.info(f"Inferred context tags: {detected_tags}")
+        return detected_tags
 
-        # Mock external detection (e.g., from a simpler scene classification model or EXIF data)
-        # For demonstration, we'll hardcode some possible tags here.
-        # In a real system, you'd feed actual image features or metadata to an LLM.
-        mock_tags = ["outdoor", "sunny"] # These could be returned by an actual LLM based on input
-        for tag in mock_tags:
-            if tag not in context_tags:
-                context_tags.append(tag)
-
-        return context_tags
 
 class ForensicAnomalyDetectionAgent:
     def __init__(self):
-        # In a real scenario, this would involve an LLM call to analyze textual descriptions
-        pass
+        logger.info("Initializing ForensicAnomalyDetectionAgent.")
+        self.anomaly_thresholds = {
+            "ELA": {"min_anomalies": 3, "max_error_std": 20}, # Example thresholds
+            "gradient": {"min_sharp_edges": 500},
+            "minmax": {"min_local_deviation": 0.1}
+        }
 
     def analyze_forensic_outputs(self, forensic_output_descriptions: list[str]) -> dict:
-        """Simulates an LLM analyzing descriptions of forensic images for anomalies."""
-        anomalies = {"summary": "No significant anomalies detected.", "details": []}
-
-        # Boilerplate logic: look for keywords in descriptions
-        for desc in forensic_output_descriptions:
-            if "strong edges" in desc.lower() and "ela" in desc.lower():
-                anomalies["summary"] = "Potential manipulation indicated by ELA."
-                anomalies["details"].append("ELA: Unusually strong edges detected, suggesting image compositing.")
-            if "unexpected patterns" in desc.lower() and "bit plane" in desc.lower():
-                anomalies["summary"] = "Anomalies detected in bit plane data."
-                anomalies["details"].append("Bit Plane: Irregular patterns found, possibly indicating hidden data or processing.")
-
-        if len(anomalies["details"]) > 0:
-            anomalies["summary"] = "Multiple anomalies detected across forensic outputs."
+        logger.info("Analyzing forensic outputs for anomalies.")
+        anomalies_detected = []
+        summary_message = "No significant anomalies detected."
+
+        # Example: Check for ELA anomalies (simplified)
+        ela_anomalies = [desc for desc in forensic_output_descriptions if "ELA analysis" in desc and "enhanced contrast" in desc]
+        if len(ela_anomalies) > self.anomaly_thresholds["ELA"]["min_anomalies"]:
+            anomalies_detected.append("Multiple ELA passes indicate potential inconsistencies.")
+            logger.warning("Detected multiple ELA passes indicating potential inconsistencies.")
+
+        # Example: Check for gradient anomalies (simplified)
+        gradient_anomalies = [desc for desc in forensic_output_descriptions if "Gradient processing" in desc]
+        if len(gradient_anomalies) > 1 and "Highlights edges and transitions" in gradient_anomalies[0]:
+            # This is a placeholder for actual image analysis, e.g., checking standard deviation of gradients
+            anomalies_detected.append("Gradient analysis shows unusual edge patterns.")
+            logger.warning("Detected unusual edge patterns from gradient analysis.")
+
+        # Example: Check for MinMax anomalies (simplified)
+        minmax_anomalies = [desc for desc in forensic_output_descriptions if "MinMax processing" in desc]
+        if len(minmax_anomalies) > 1 and "Deviations in local pixel values" in minmax_anomalies[0]:
+            # Placeholder for actual analysis of minmax output, e.g., deviation variance
+            anomalies_detected.append("MinMax processing reveals subtle pixel deviations.")
+            logger.warning("Detected subtle pixel deviations from MinMax processing.")
             
-        return anomalies 
+        if "Bit Plane extractor" in str(forensic_output_descriptions):
+            anomalies_detected.append("Bit Plane extraction performed.")
+            logger.info("Bit Plane extraction performed.")
+
+        if anomalies_detected:
+            summary_message = "Potential anomalies detected: " + "; ".join(anomalies_detected)
+            logger.warning(f"Forensic anomaly detection summary: {summary_message}")
+        else:
+            logger.info(f"Forensic anomaly detection summary: {summary_message}")
+
+        return {"anomalies": anomalies_detected, "summary": summary_message}

app.backup.py

@@ -13,10 +13,10 @@ 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 forensics.gradient import gradient_processing
+from forensics.minmax import minmax_process
+from forensics.ela import ELA
+from forensics.wavelet import wavelet_blocking_noise_estimation
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -276,7 +276,7 @@ def predict_image_with_html(img, confidence_threshold, augment_methods, rotate_d
     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
+    minmax_image = minmax_process(img_np)  # Added MinMax processing
 
     # First pass - standard analysis
     ela1 = ELA(img_np_og, quality=75, scale=50, contrast=20, linear=False, grayscale=True)

app.py

@@ -0,0 +1,728 @@
+import gradio as gr
+from gradio_client import Client, handle_file
+from PIL import Image, ImageFilter
+import numpy as np
+import os
+import time
+import logging
+import io
+import collections
+import onnxruntime
+
+from utils.utils import softmax, augment_image
+from forensics.gradient import gradient_processing
+from forensics.minmax import minmax_process
+from forensics.ela import ELA
+from forensics.wavelet import noise_estimation
+from forensics.bitplane import bit_plane_extractor
+from utils.hf_logger import log_inference_data
+from utils.load import load_image
+from agents.ensemble_team import EnsembleMonitorAgent, WeightOptimizationAgent, SystemHealthAgent
+from agents.smart_agents import ContextualIntelligenceAgent, ForensicAnomalyDetectionAgent
+from utils.registry import register_model, MODEL_REGISTRY, ModelEntry
+from agents.ensemble_weights import ModelWeightManager
+from transformers import pipeline, AutoImageProcessor, SwinForImageClassification, Swinv2ForImageClassification, AutoFeatureExtractor, AutoModelForImageClassification
+from torchvision import transforms
+import torch
+import json
+from huggingface_hub import CommitScheduler
+from dotenv import load_dotenv
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+os.environ['HF_HUB_CACHE'] = './models'
+
+# --- Gradio Log Handler ---
+class GradioLogHandler(logging.Handler):
+    def __init__(self, log_queue):
+        super().__init__()
+        self.log_queue = log_queue
+        self.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
+
+    def emit(self, record):
+        self.log_queue.append(self.format(record))
+
+log_queue = collections.deque(maxlen=1000) # Store last 1000 log messages
+gradio_handler = GradioLogHandler(log_queue)
+
+# Set root logger level to DEBUG to capture all messages from agents
+logging.getLogger().setLevel(logging.INFO)
+logging.getLogger().addHandler(gradio_handler)
+# --- End Gradio Log Handler ---
+
+LOCAL_LOG_DIR = "./hf_inference_logs"
+HF_DATASET_NAME="aiwithoutborders-xyz/degentic_rd0"
+load_dotenv()
+
+# 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')
+
+# Model paths and class names (copied from app_mcp.py)
+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_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_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))}
+
+def register_model_with_metadata(model_id, model, preprocess, postprocess, class_names, display_name, contributor, model_path, architecture=None, dataset=None):
+    entry = ModelEntry(model, preprocess, postprocess, class_names, display_name=display_name, contributor=contributor, model_path=model_path, architecture=architecture, dataset=dataset)
+    MODEL_REGISTRY[model_id] = entry
+
+# Load and register models (copied from app_mcp.py)
+# 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="SWIN1", contributor="haywoodsloan", model_path=MODEL_PATHS["model_1"],
+#     architecture="SwinV2", dataset="TBA"
+# )
+
+# --- ONNX Quantized Model Example ---
+ONNX_QUANTIZED_MODEL_PATH = "./models/model_1_quantized.onnx"
+
+def preprocess_onnx_input(image: Image.Image):
+    # Preprocess image for ONNX model (e.g., for SwinV2, usually 256x256, normalized)
+    if image.mode != 'RGB':
+        image = image.convert('RGB')
+    
+    transform = transforms.Compose([
+        transforms.Resize((256, 256)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485,0.456,0.406], std=[0.229,0.224,0.225]), # ImageNet normalization
+    ])
+    input_tensor = transform(image)
+    # ONNX expects numpy array with batch dimension (1, C, H, W)
+    return input_tensor.unsqueeze(0).cpu().numpy()
+
+def infer_onnx_model(preprocessed_image_np):
+    try:
+        # Ensure the ONNX model exists before trying to load it
+        if not os.path.exists(ONNX_QUANTIZED_MODEL_PATH):
+            logger.error(f"ONNX quantized model not found at: {ONNX_QUANTIZED_MODEL_PATH}")
+            raise FileNotFoundError(f"ONNX quantized model not found at: {ONNX_QUANTIZED_MODEL_PATH}")
+
+        ort_session = onnxruntime.InferenceSession(ONNX_QUANTIZED_MODEL_PATH)
+        ort_inputs = {ort_session.get_inputs()[0].name: preprocessed_image_np}
+        ort_outputs = ort_session.run(None, ort_inputs)
+        
+        # Assuming the output is logits, apply softmax to get probabilities
+        logits = ort_outputs[0]
+        probabilities = softmax(logits[0]) # Remove batch dim, apply softmax
+        return {"logits": logits, "probabilities": probabilities}
+
+    except Exception as e:
+        logger.error(f"Error during ONNX inference: {e}")
+        # Return a structure consistent with other model errors
+        return {"logits": np.array([]), "probabilities": np.array([])}
+
+def postprocess_onnx_output(onnx_output, class_names):
+    probabilities = onnx_output.get("probabilities")
+    if probabilities is not None and len(probabilities) == len(class_names):
+        return {class_names[i]: probabilities[i] for i in range(len(class_names))}
+    else:
+        logger.warning("ONNX post-processing failed or class names mismatch.")
+        return {name: 0.0 for name in class_names}
+
+# Register the ONNX quantized model
+register_model_with_metadata(
+    "model_1_onnx_quantized", 
+    infer_onnx_model, 
+    preprocess_onnx_input, 
+    postprocess_onnx_output, 
+    CLASS_NAMES["model_1"], # Assuming it uses the same class names as model_1
+    display_name="SWIN1", 
+    contributor="haywoodsloan", 
+    model_path=ONNX_QUANTIZED_MODEL_PATH,
+    architecture="SwinV2", 
+    dataset="TBA"
+)
+# --- End ONNX Quantized Model Example ---
+
+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="VIT2", contributor="Heem2", model_path=MODEL_PATHS["model_2"],
+    architecture="ViT", dataset="TBA"
+)
+
+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="SDXL3", contributor="Organika", model_path=MODEL_PATHS["model_3"],
+    architecture="VIT", dataset="SDXL"
+)
+
+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="XLFLUX4", contributor="cmckinle", model_path=MODEL_PATHS["model_4"],
+    architecture="VIT", dataset="SDXL, FLUX"
+)
+
+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="VIT5", contributor="prithivMLmods", model_path=MODEL_PATHS["model_5"],
+    architecture="VIT", dataset="TBA"
+)
+
+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="SWIN6", contributor="ideepankarsharma2003", model_path=MODEL_PATHS["model_6"],
+    architecture="SWINv1", dataset="SDXL, Midjourney"
+)
+
+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="VIT7", contributor="date3k2", model_path=MODEL_PATHS["model_7"],
+    architecture="VIT", dataset="TBA"
+)
+
+# def postprocess_simple_prediction(result, class_names):
+#     scores = {name: 0.0 for name in class_names}
+#     fake_prob = result.get("Fake Probability")
+#     if fake_prob is not None:
+#         # Assume class_names = ["AI", "REAL"]
+#         scores["AI"] = float(fake_prob)
+#         scores["REAL"] = 1.0 - float(fake_prob)
+#     return scores
+
+# def simple_prediction(img):
+#     client = Client("aiwithoutborders-xyz/OpenSight-Community-Forensics-Preview")
+#     client.view_api()
+#     print(type(img))
+#     result = client.predict(
+#            handle_file(img),
+#            api_name="simple_predict"
+#     )
+#     return result
+
+
+# register_model_with_metadata(
+#     model_id="simple_prediction",
+#     model=simple_prediction,
+#     preprocess=None,
+#     postprocess=postprocess_simple_prediction,
+#     class_names=["AI", "REAL"], 
+#     display_name="Community Forensics",
+#     contributor="Jeongsoo Park",
+#     model_path="aiwithoutborders-xyz/CommunityForensics-DeepfakeDet-ViT",
+#     architecture="ViT", dataset="GOAT"
+# )
+def infer(image: Image.Image, model_id: str, confidence_threshold: float = 0.75) -> dict:
+    """Predict using a specific model.
+
+    Args:
+        image (Image.Image): The input image to classify.
+        model_id (str): The ID of the model to use for classification.
+        confidence_threshold (float, optional): The confidence threshold for classification. Defaults to 0.75.
+
+    Returns:
+        dict: A dictionary containing the model details, classification scores, and label.
+    """
+    entry = MODEL_REGISTRY[model_id]
+    img = entry.preprocess(image) if entry.preprocess else image
+    try:
+        result = entry.model(img)
+        scores = entry.postprocess(result, entry.class_names)
+        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,
+            "Real Score": 0.0,
+            "Label": f"Error: {str(e)}"
+        }
+
+def full_prediction(img, confidence_threshold, rotate_degrees, noise_level, sharpen_strength):
+    """Full prediction run, with a team of ensembles and agents.
+
+    Args:
+        img (url: str, Image.Image, np.ndarray): The input image to classify.
+        confidence_threshold (float, optional): The confidence threshold for classification. Defaults to 0.75.
+        rotate_degrees (int, optional): The degrees to rotate the image.
+        noise_level (int, optional): The noise level to use.
+        sharpen_strength (int, optional): The sharpen strength to use.
+
+    Returns:
+        dict: A dictionary containing the model details, classification scores, and label.
+    """
+    # Ensure img is a PIL Image object
+    if img is None:
+        raise gr.Error("No image provided. Please upload an image to analyze.")
+    # Handle filepath conversion if needed
+    if isinstance(img, str):
+        try:
+            img = load_image(img)
+        except Exception as e:
+            logger.error(f"Error loading image from path: {e}")
+            raise gr.Error(f"Could not load image from the provided path. Error: {str(e)}")
+        
+    if not isinstance(img, Image.Image):
+        try:
+            img = Image.fromarray(img)
+        except Exception as e:
+            logger.error(f"Error converting input image to PIL: {e}")
+            raise gr.Error("Input image could not be converted to a valid image format. Please try another image.")
+
+    # Ensure image is in RGB format for consistent processing
+    if img.mode != 'RGB':
+        img = img.convert('RGB')
+
+    monitor_agent = EnsembleMonitorAgent()
+    weight_manager = ModelWeightManager(strongest_model_id="simple_prediction")
+    optimization_agent = WeightOptimizationAgent(weight_manager)
+    health_agent = SystemHealthAgent()
+    context_agent = ContextualIntelligenceAgent()
+    anomaly_agent = ForensicAnomalyDetectionAgent()
+    health_agent.monitor_system_health()
+    if rotate_degrees or noise_level or sharpen_strength:
+        img_pil, _ = augment_image(img, ["rotate", "add_noise", "sharpen"], rotate_degrees, noise_level, sharpen_strength)
+    else:
+        img_pil = img
+    img_np_og = np.array(img)
+
+    model_predictions_raw = {}
+    confidence_scores = {}
+    results = []
+    table_rows = []
+
+    # Stream results as each model finishes
+    for model_id in MODEL_REGISTRY:
+        model_start = time.time()
+        result = infer(img_pil, model_id, confidence_threshold)
+        model_end = time.time()
+        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
+        confidence_scores[model_id] = max(result.get("AI Score", 0.0), result.get("Real Score", 0.0))
+        results.append(result)
+        table_rows.append([
+            result.get("Model", ""),
+            result.get("Contributor", ""),
+            round(result.get("AI Score", 0.0), 3) if result.get("AI Score") is not None else 0.0,
+            round(result.get("Real Score", 0.0), 3) if result.get("Real Score") is not None else 0.0,
+            result.get("Label", "Error")
+        ])
+        # Yield partial results: only update the table, others are None
+        yield None, None, table_rows, None, None
+
+    # After all models, compute the rest as before
+    image_data_for_context = {
+        "width": img.width,
+        "height": img.height,
+        "mode": img.mode,
+    }
+    detected_context_tags = context_agent.infer_context_tags(image_data_for_context, model_predictions_raw)
+    logger.info(f"Detected context tags: {detected_context_tags}")
+    adjusted_weights = weight_manager.adjust_weights(model_predictions_raw, confidence_scores, context_tags=detected_context_tags)
+    weighted_predictions = {"AI": 0.0, "REAL": 0.0, "UNCERTAIN": 0.0}
+    for model_id, prediction in model_predictions_raw.items():
+        prediction_label = prediction.get("Label")
+        if prediction_label in weighted_predictions:
+            weighted_predictions[prediction_label] += adjusted_weights[model_id]
+        else:
+            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"
+    optimization_agent.analyze_performance(final_prediction_label, None)
+    gradient_image = gradient_processing(img_np_og)
+    gradient_image2 = gradient_processing(img_np_og, intensity=45, equalize=True)
+    minmax_image = minmax_process(img_np_og)
+    minmax_image2 = minmax_process(img_np_og, radius=6)
+    # bitplane_image = bit_plane_extractor(img_pil)
+    ela1 = ELA(img_np_og, quality=75, scale=50, contrast=20, linear=False, grayscale=True)
+    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, gradient_image2, minmax_image, minmax_image2]
+    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.",
+        "Gradient processing: Int=45, Equalize=True",
+        "MinMax processing: Deviations in local pixel values.",
+        "MinMax processing (Radius=6): Deviations in local pixel values.",
+        # "Bit Plane extractor: Visualization of individual bit planes from different color channels."
+    ]
+    anomaly_detection_results = anomaly_agent.analyze_forensic_outputs(forensic_output_descriptions)
+    logger.info(f"Forensic anomaly detection: {anomaly_detection_results['summary']}")
+    consensus_html = f"<div style='font-size: 2.2em; font-weight: bold;padding: 10px;'>Consensus: <span style='color:{'red' if final_prediction_label == 'AI' else ('green' if final_prediction_label == 'REAL' else 'orange')}'>{final_prediction_label}</span></div>"
+    inference_params = {
+        "confidence_threshold": confidence_threshold,
+        "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
+    }
+    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),
+        },
+        "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_inference_data(
+        original_image=img,
+        inference_params=inference_params,
+        model_predictions=results,
+        ensemble_output=ensemble_output_data,
+        forensic_images=forensics_images,
+        agent_monitoring_data=agent_monitoring_data_log,
+        human_feedback=None
+    )
+    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}")
+        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]}")
+    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.")
+    json_results = json.dumps(results, cls=NumpyEncoder)
+    yield img_pil, cleaned_forensics_images, table_rows, json_results, consensus_html
+
+detection_model_eval_playground = gr.Interface(
+    fn=full_prediction,
+    inputs=[
+        gr.Image(label="Upload Image to Analyze", sources=['upload', 'webcam'], type='filepath'),
+        gr.Slider(0.0, 1.0, value=0.7, step=0.05, label="Confidence Threshold"),
+        gr.Slider(0, 45, value=0, step=1, label="Rotate Degrees", visible=False),
+        gr.Slider(0, 50, value=0, step=1, label="Noise Level", visible=False),
+        gr.Slider(0, 50, value=0, step=1, label="Sharpen Strength", visible=False)
+    ],
+    outputs=[
+        gr.Image(label="Processed Image", visible=False),
+        gr.Gallery(label="Post Processed Images", visible=True, columns=[4], rows=[2], container=False, height="auto", object_fit="contain", elem_id="post-gallery"),
+        gr.Dataframe(
+            label="Model Predictions",
+            headers=["Arch / Dataset", "By", "AI", "Real", "Label"],
+            datatype=["str", "str", "number", "number", "str"]
+        ),
+        gr.JSON(label="Raw Model Results", visible=False),
+        gr.Markdown(label="Consensus", value="")
+    ],
+    title="Multi-Model Ensemble + Agentic Coordinated Deepfake Detection (Paper in Progress)",
+    description="The detection of AI-generated images has entered a critical inflection point. While existing solutions struggle with outdated datasets and inflated claims, our approach prioritizes agility, community collaboration, and an offensive approach to deepfake detection.",
+    api_name="predict",
+    live=True  # Enable streaming
+)
+# def echo_headers(x, request: gr.Request):
+#     print(dict(request.headers))
+#     return str(dict(request.headers))
+
+
+def predict(img):
+    """
+    Predicts whether an image is AI-generated or real using the SOTA Community Forensics model.
+
+    Args:
+        img (str): Path to the input image file to analyze.
+
+    Returns:
+        dict: A dictionary containing:
+            - 'Fake Probability' (float): Probability score between 0 and 1 indicating likelihood of being AI-generated
+            - 'Result Description' (str): Human-readable description of the prediction result
+
+    Example:
+        >>> result = predict("path/to/image.jpg")
+        >>> print(result)
+        {'Fake Probability': 0.002, 'Result Description': 'The image is likely real.'}
+    """
+    client = Client("aiwithoutborders-xyz/OpenSight-Community-Forensics-Preview")
+    client.view_api()
+    result = client.predict(
+        handle_file(img),
+        api_name="/simple_predict"
+    )
+    return str(result)
+community_forensics_preview = gr.Interface(
+    fn=predict,
+    inputs=gr.Image(type="filepath"),
+    outputs=gr.HTML(), # or gr.Markdown() if it's just text
+    title="Quick and simple prediction by our strongest model.",
+    description="No ensemble, no context, no agents, just a quick and simple prediction by our strongest model.",
+    api_name="predict"
+)
+
+# leaderboard = gr.Interface(
+#     fn=lambda: "# AI Generated / Deepfake Detection Models Leaderboard: Soon™",
+#     inputs=None,
+#     outputs=gr.Markdown(),
+#     title="Leaderboard",
+#     api_name="leaderboard"
+# )
+def simple_prediction(img):
+    """
+    Quick and simple deepfake or real image prediction by the strongest open-source model on the hub.
+
+    Args:
+        img (str): The input image to analyze, provided as a file path.
+
+    Returns:
+        str: The prediction result stringified from dict. Example: `{'Fake Probability': 0.002, 'Result Description': 'The image is likely real.'}`
+    """    
+    client = Client("aiwithoutborders-xyz/OpenSight-Community-Forensics-Preview")
+    client.view_api()
+    client.predict(
+        handle_file(img),
+        api_name="simple_predict"
+    )
+simple_predict_interface = gr.Interface(
+    fn=simple_prediction,
+    inputs=gr.Image(type="filepath"),
+    outputs=gr.Text(),
+    title="Quick and simple prediction by our strongest model.",
+    description="No ensemble, no context, no agents, just a quick and simple prediction by our strongest model.",
+    api_name="simple_predict"
+)
+
+noise_estimation_interface = gr.Interface(
+    fn=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"
+)
+
+bit_plane_interface = 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"
+)
+
+ela_interface = gr.Interface(
+    fn=ELA,
+    inputs=[
+        gr.Image(type="pil", label="Input Image"),
+        gr.Slider(1, 100, value=75, step=1, label="JPEG Quality"),
+        gr.Slider(1, 100, value=50, step=1, label="Output Scale (Multiplicative Gain)"),
+        gr.Slider(0, 100, value=20, step=1, label="Output Contrast (Tonality Compression)"),
+        gr.Checkbox(value=False, label="Use Linear Difference"),
+        gr.Checkbox(value=False, label="Grayscale Output")
+    ],
+    outputs=gr.Image(type="pil"),
+    title="Error Level Analysis (ELA)",
+    description="Performs Error Level Analysis to detect re-saved JPEG images, which can indicate tampering. ELA highlights areas of an image that have different compression levels.",
+    api_name="tool_ela"
+)
+
+gradient_processing_interface = gr.Interface(
+    fn=gradient_processing,
+    inputs=[
+        gr.Image(type="pil", label="Input Image"),
+        gr.Slider(0, 100, value=90, step=1, label="Intensity"),
+        gr.Dropdown(["Abs", "None", "Flat", "Norm"], label="Blue Mode", value="Abs"),
+        gr.Checkbox(value=False, label="Invert Gradients"),
+        gr.Checkbox(value=False, label="Equalize Histogram")
+    ],
+    outputs=gr.Image(type="pil"),
+    title="Gradient Processing",
+    description="Applies gradient filters to an image to enhance edges and transitions, which can reveal inconsistencies due to manipulation.",
+    api_name="tool_gradient_processing"
+)
+
+minmax_processing_interface = gr.Interface(
+    fn=minmax_process,
+    inputs=[
+        gr.Image(type="pil", label="Input Image"),
+        gr.Radio([0, 1, 2, 3, 4], label="Channel (0:Grayscale, 1:Blue, 2:Green, 3:Red, 4:RGB Norm)", value=4),
+        gr.Slider(0, 10, value=2, step=1, label="Radius")
+    ],
+    outputs=gr.Image(type="pil"),
+    title="MinMax Processing",
+    description="Analyzes local pixel value deviations to detect subtle changes in image data, often indicative of digital forgeries.",
+    api_name="tool_minmax_processing"
+)
+
+# augmentation_tool_interface = gr.Interface(
+#     fn=augment_image,
+#     inputs=[
+#         gr.Image(label="Upload Image to Augment", sources=['upload', 'webcam'], type='pil'),
+#         gr.CheckboxGroup(["rotate", "add_noise", "sharpen"], label="Augmentation Methods"),
+#         gr.Slider(0, 360, value=0, step=1, label="Rotate Degrees", visible=True),
+#         gr.Slider(0, 100, value=0, step=1, label="Noise Level", visible=True),
+#         gr.Slider(0, 200, value=1, step=1, label="Sharpen Strength", visible=True)
+#     ],
+#     outputs=gr.Image(label="Augmented Image", type='pil'),
+#     title="Image Augmentation Tool",
+#     description="Apply various augmentation techniques to your image.",
+#     api_name="augment_image"
+# )
+
+# def get_captured_logs():
+#     # Retrieve all logs from the queue and clear it
+#     logs = list(log_queue)
+#     log_queue.clear() # Clear the queue after retrieving
+#     return "\n".join(logs)
+
+
+demo = gr.TabbedInterface(
+    [
+        detection_model_eval_playground,
+        community_forensics_preview,
+        noise_estimation_interface,
+        bit_plane_interface,
+        ela_interface,
+        gradient_processing_interface,
+        minmax_processing_interface,
+        # gr.Textbox(label="Agent Logs", interactive=False, lines=5, max_lines=20, autoscroll=True) # New textbox for logs
+    ],
+    [
+        "Run Ensemble Prediction",
+        "Open-Source SOTA Model",
+        "Wavelet Blocking Noise Estimation",
+        "Bit Plane Values",
+        "Error Level Analysis (ELA)",
+        "Gradient Processing",
+        "MinMax Processing",
+        # "Agent Logs" # New tab title
+    ],
+    title="Deepfake Detection & Forensics Tools",
+    theme=None,
+
+)
+footerMD = """
+### ⚠️ ENSEMBLE TEAM IN TRAINING ⚠️ \n\n
+
+1. **DISCLAIMER: METADATA AS WELL AS MEDIA SUBMITTED TO THIS SPACE MAY BE VIEWED AND SELECTED FOR FUTURE DATASETS, PLEASE DO NOT SUBMIT PERSONAL CONTENT. FOR UNTRACKED, PRIVATE USE OF THE MODELS YOU MAY STILL USE [THE ORIGINAL SPACE HERE](https://huggingface.co/spaces/aiwithoutborders-xyz/OpenSight-Deepfake-Detection-Models-Playground), SOTA MODEL INCLUDED.**
+2. **UPDATE 6-13-25**: APOLOGIES FOR THE CONFUSION, WE ARE WORKING TO REVERT THE ORIGINAL REPO BACK TO ITS NON-DATA COLLECTION STATE -- ONLY THE "SIMPLE PREDICTION" ENDPOINT IS CURRENTLY 100% PRIVATE. PLEASE STAY TUNED AS WE FIGURE OUT A SOLUTION FOR THE ENSEMBLE + AGENT TEAM ENDPOINT. IT CAN GET RESOURCE INTENSIVE TO RUN A FULL PREDICTION. ALTERNATIVELY, WE **ENCOURAGE** ANYONE TO FORK AND CONTRIBUTE TO THE PROJECT.
+3. **UPDATE 6-13-25 (cont.)**: WHILE WE HAVE NOT TAKEN A STANCE ON NSFW AND EXPLICIT CONTENT, PLEASE REFRAIN FROM ... YOUR HUMAN DESIRES UNTIL WE GET THIS PRIVACY SITUATION SORTED OUT. DO NOT BE RECKLESS PLEASE. OUR PAPER WILL BE OUT SOON ON ARXIV WHICH WILL EXPLAIN EVERYTHING WITH DATA-BACKED RESEARCH ON WHY THIS PROJECT IS NEEDED, BUT WE CANNOT DO IT WITHOUT THE HELP OF THE COMMUNITY.
+
+TO SUMMARIZE: DATASET COLLECTION WILL CONTINUE FOR OUR NOVEL ENSEMBLE-TEAM PREDICTION PIPELINE UNTIL WE CAN GET THINGS SORTED OUT. FOR THOSE THAT WISH TO OPT-OUT, WE OFFER THE SIMPLE, BUT [MOST POWERFUL DETECTION MODEL HERE.](https://huggingface.co/spaces/aiwithoutborders-xyz/OpenSight-Community-Forensics-Preview)
+
+"""
+footer = gr.Markdown("", elem_classes="footer")
+
+with gr.Blocks() as app:
+    demo.render()
+    footer.render()
+    
+
+app.queue(max_size=10, default_concurrency_limit=2).launch(mcp_server=True) 

app_mcp.py → app_mcp.old.py

@@ -3,9 +3,8 @@ 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 gradio_client import Client, handle_file
+
 from transformers import pipeline, AutoImageProcessor, SwinForImageClassification, Swinv2ForImageClassification, AutoFeatureExtractor, AutoModelForImageClassification
 from torchvision import transforms
 import torch
@@ -14,18 +13,18 @@ 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 forensics.gradient import gradient_processing
+from forensics.minmax import minmax_process
+from forensics.ela import ELA
+from forensics.wavelet import wavelet_blocking_noise_estimation
+from forensics.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.ensemble_team 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 utils.registry import register_model, MODEL_REGISTRY, ModelEntry
+from agents.ensemble_weights import ModelWeightManager
 from dotenv import load_dotenv
 import json
 from huggingface_hub import CommitScheduler
@@ -93,7 +92,6 @@ MODEL_PATHS = {
     "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"
 }
@@ -104,22 +102,19 @@ CLASS_NAMES = {
     "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 preprocess_256(image):
+    if image.mode != 'RGB':
+        image = image.convert('RGB')
+    return transforms.Resize((256, 256))(image)
 def postprocess_pipeline(prediction, class_names):
     # Assumes HuggingFace pipeline output
     return {pred['label']: pred['score'] for pred in prediction}
@@ -146,7 +141,7 @@ image_processor_1 = AutoImageProcessor.from_pretrained(MODEL_PATHS["model_1"], u
 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"],
+    "model_1", clf_1, preprocess_256, postprocess_pipeline, CLASS_NAMES["model_1"],
     display_name="SwinV2 Based", contributor="haywoodsloan", model_path=MODEL_PATHS["model_1"]
 )
 
@@ -159,10 +154,7 @@ register_model_with_metadata(
 # 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)
@@ -199,11 +191,6 @@ register_model_with_metadata(
     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)
@@ -255,7 +242,7 @@ def infer(image: Image.Image, model_id: str, confidence_threshold: float = 0.75)
 
 def predict_image(img, confidence_threshold):
     model_ids = [
-        "model_1", "model_2", "model_3", "model_4", "model_5", "model_5b", "model_6", "model_7"
+        "model_1", "model_2", "model_3", "model_4", "model_5", "model_6", "model_7"
     ]
     results = [infer(img, model_id, confidence_threshold) for model_id in model_ids]
     return img, results
@@ -268,9 +255,9 @@ def get_consensus_label(results):
     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
+# Update predict_with_ensemble to return consensus label
 
-def predict_image_with_json(img, confidence_threshold, augment_methods, rotate_degrees, noise_level, sharpen_strength):
+def predict_with_ensemble(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:
@@ -364,7 +351,12 @@ def predict_image_with_json(img, confidence_threshold, augment_methods, rotate_d
     
     # 6. Perform forensic processing
     gradient_image = gradient_processing(img_np_og)  # Added gradient processing
-    minmax_image = minmax_preprocess(img_np_og)  # Added MinMax processing
+    gradient_image2 = gradient_processing(img_np_og, intensity=45, equalize=True)  # Added gradient processing
+
+    minmax_image = minmax_process(img_np_og)  # Added MinMax processing
+    minmax_image2 = minmax_process(img_np_og, radius=6)  # Added MinMax processing
+    # bitplane_image = bit_plane_extractor(img_pil)
+    
 
     # First pass - standard analysis
     ela1 = ELA(img_np_og, quality=75, scale=50, contrast=20, linear=False, grayscale=True)
@@ -373,7 +365,7 @@ def predict_image_with_json(img, confidence_threshold, augment_methods, rotate_d
     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]
+    forensics_images = [img_pil, ela1, ela2, ela3, gradient_image, gradient_image2, minmax_image, minmax_image2]
 
     # 7. Generate boilerplate descriptions for forensic outputs for anomaly agent
     forensic_output_descriptions = [
@@ -382,7 +374,9 @@ def predict_image_with_json(img, confidence_threshold, augment_methods, rotate_d
         "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."
+        "Gradient processing: Int=45, Equalize=True",
+        "MinMax processing: Deviations in local pixel values.",
+        "MinMax processing (Radius=6): 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.
@@ -406,7 +400,7 @@ def predict_image_with_json(img, confidence_threshold, augment_methods, rotate_d
         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>"
+    consensus_html = f"<div style='display: flex; justify-content: space-between;'><div style='flex: 1;'><b>THIS IMAGE IS LIKELY <span style='color:{'red' if final_prediction_label == 'AI' else ('green' if final_prediction_label == 'REAL' else 'orange')}'>{final_prediction_label}</span></b></div><div style='flex: 1;'><b>CONSENSUS REACHED BY {len(results)} MODELS</b></div></div>"
 
     # Prepare data for logging to Hugging Face dataset
     inference_params = {
@@ -484,6 +478,13 @@ def predict_image_with_json(img, confidence_threshold, augment_methods, rotate_d
 
     return img_pil, cleaned_forensics_images, table_rows, json_results, consensus_html
 
+def simple_prediction(img):
+    client = Client("aiwithoutborders-xyz/OpenSight-Community-Forensics-Preview")
+    result = client.predict(
+            input_image=handle_file(img),
+            api_name="/simple_predict"
+    )
+    return result
 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():
@@ -567,38 +568,151 @@ with gr.Blocks(css="#post-gallery { overflow: hidden !important;} .grid-wrap{ ov
                     api_name="/tool_waveletnoise"
                 )
 
+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 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("👀 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=0, step=1, label="Rotate Degrees", visible=False)
+                    noise_slider = gr.Slider(0, 50, value=0, step=1, label="Noise Level", visible=False)
+                    sharpen_slider = gr.Slider(0, 50, value=0, step=1, label="Sharpen Strength", visible=False)
+                    confidence_slider = gr.Slider(0.0, 1.0, value=0.7, 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"]
                 )
-            # 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."
-            #     )
+                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]
+
+        predict_button.click(
+            fn=predict_with_ensemble, 
+            inputs=inputs, 
+            outputs=outputs,
+            api_name="predict"
+        )
+        augment_button.click(  # Connect Augment button to the function
+            fn=predict_with_ensemble, 
+            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_then_predict"
+        )
+    with gr.Tab("🙈 Project Introduction"):
+        gr.Markdown(QUICK_INTRO)
+        
+    with gr.Tab("👑 Community Forensics Preview"):
+        gr.load("aiwithoutborders-xyz/OpenSight-Community-Forensics-Preview", src="spaces")
+    with gr.Tab("🥇 Leaderboard"):
+        gr.Markdown("# AI Generated / Deepfake Detection Models Leaderboard: Soon™")
+    with gr.Tab("Simple Predict", visible=False):
+        gr.Interface(
+            fn=simple_prediction,
+            inputs=gr.Image(type="filepath"),
+            outputs=gr.Text(),
+            title="Simple and Fast Prediction",
+            description=""
+        )
+    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"
+        )
 
+    """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")
+    """
+    with gr.Tab("Bit Plane Values", visible=False):
+        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("Error Level Analysis (ELA)", visible=False):
+        gr.Interface(
+            fn=ELA,
+            inputs=[
+                gr.Image(type="pil", label="Input Image"),
+                gr.Slider(1, 100, value=75, step=1, label="JPEG Quality"),
+                gr.Slider(1, 100, value=50, step=1, label="Output Scale (Multiplicative Gain)"),
+                gr.Slider(0, 100, value=20, step=1, label="Output Contrast (Tonality Compression)"),
+                gr.Checkbox(value=False, label="Use Linear Difference"),
+                gr.Checkbox(value=False, label="Grayscale Output")
+            ],
+            outputs=gr.Image(type="pil"),
+            title="Error Level Analysis (ELA)",
+            description="Performs Error Level Analysis to detect re-saved JPEG images, which can indicate tampering. ELA highlights areas of an image that have different compression levels.",
+            api_name="tool_ela"
+        )
+    with gr.Tab("Gradient Processing", visible=False):
+        gr.Interface(
+            fn=gradient_processing,
+            inputs=[
+                gr.Image(type="pil", label="Input Image"),
+                gr.Slider(0, 100, value=90, step=1, label="Intensity"),
+                gr.Dropdown(["Abs", "None", "Flat", "Norm"], label="Blue Mode", value="Abs"),
+                gr.Checkbox(value=False, label="Invert Gradients"),
+                gr.Checkbox(value=False, label="Equalize Histogram")
+            ],
+            outputs=gr.Image(type="pil"),
+            title="Gradient Processing",
+            description="Applies gradient filters to an image to enhance edges and transitions, which can reveal inconsistencies due to manipulation.",
+            api_name="tool_gradient_processing"
+        )
+    with gr.Tab("MinMax Processing", visible=False):
+        gr.Interface(
+            fn=minmax_process,
+            inputs=[
+                gr.Image(type="pil", label="Input Image"),
+                gr.Radio([0, 1, 2, 3, 4], label="Channel (0:Grayscale, 1:Blue, 2:Green, 3:Red, 4:RGB Norm)", value=4),
+                gr.Slider(0, 10, value=2, step=1, label="Radius")
+            ],
+            outputs=gr.Image(type="pil"),
+            title="MinMax Processing",
+            description="Analyzes local pixel value deviations to detect subtle changes in image data, often indicative of digital forgeries.",
+            api_name="tool_minmax_processing"
+        )
 # --- MCP-Ready Launch ---
 if __name__ == "__main__":
     # Initialize CommitScheduler

app_optimized.py

@@ -0,0 +1,987 @@
+import gradio as gr
+from gradio_client import Client, handle_file
+from PIL import Image, ImageFilter
+import numpy as np
+import os
+import time
+import logging
+import io
+import collections
+import onnxruntime
+import json
+from huggingface_hub import CommitScheduler, hf_hub_download, snapshot_download
+from dotenv import load_dotenv
+import concurrent.futures
+import ast
+import torch
+
+from utils.utils import softmax, augment_image
+from forensics.gradient import gradient_processing
+from forensics.minmax import minmax_process
+from forensics.ela import ELA
+from forensics.wavelet import noise_estimation
+from forensics.bitplane import bit_plane_extractor
+from utils.hf_logger import log_inference_data
+from utils.load import load_image
+from agents.ensemble_team import EnsembleMonitorAgent, WeightOptimizationAgent, SystemHealthAgent
+from agents.smart_agents import ContextualIntelligenceAgent, ForensicAnomalyDetectionAgent
+from utils.registry import register_model, MODEL_REGISTRY, ModelEntry
+from agents.ensemble_weights import ModelWeightManager
+from transformers import pipeline, AutoImageProcessor, SwinForImageClassification, Swinv2ForImageClassification, AutoFeatureExtractor, AutoModelForImageClassification
+from torchvision import transforms
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+os.environ['HF_HUB_CACHE'] = './models'
+
+# --- Gradio Log Handler ---
+class GradioLogHandler(logging.Handler):
+    def __init__(self, log_queue):
+        super().__init__()
+        self.log_queue = log_queue
+        self.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
+
+    def emit(self, record):
+        self.log_queue.append(self.format(record))
+
+log_queue = collections.deque(maxlen=1000) # Store last 1000 log messages
+gradio_handler = GradioLogHandler(log_queue)
+
+# Set root logger level to DEBUG to capture all messages from agents
+logging.getLogger().setLevel(logging.INFO)
+logging.getLogger().addHandler(gradio_handler)
+# --- End Gradio Log Handler ---
+
+LOCAL_LOG_DIR = "./hf_inference_logs"
+HF_DATASET_NAME="aiwithoutborders-xyz/degentic_rd0"
+load_dotenv()
+
+# 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')
+
+# Model paths and class names (copied from app_mcp.py)
+MODEL_PATHS = {
+    "model_1": "LPX55/detection-model-1-ONNX",
+    "model_2": "LPX55/detection-model-2-ONNX",
+    "model_3": "LPX55/detection-model-3-ONNX",
+    "model_4": "cmckinle/sdxl-flux-detector_v1.1",
+    "model_5": "LPX55/detection-model-5-ONNX",
+    "model_6": "LPX55/detection-model-6-ONNX",
+    "model_7": "LPX55/detection-model-7-ONNX",
+    "model_8": "aiwithoutborders-xyz/CommunityForensics-DeepfakeDet-ViT"
+}
+
+CLASS_NAMES = {
+    "model_1": ['artificial', 'real'],
+    "model_2": ['AI Image', 'Real Image'],
+    "model_3": ['artificial', 'human'],
+    "model_4": ['AI', 'Real'],
+    "model_5": ['Realism', 'Deepfake'],
+    "model_6": ['ai_gen', 'human'],
+    "model_7": ['Fake', 'Real'],
+    "model_8": ['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']: float(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))}
+
+def postprocess_binary_output(output, class_names):
+    # output can be a dictionary {"probabilities": numpy_array} or directly a numpy_array
+    probabilities_array = None
+    if isinstance(output, dict) and "probabilities" in output:
+        probabilities_array = output["probabilities"]
+    elif isinstance(output, np.ndarray):
+        probabilities_array = output
+    else:
+        logger.warning(f"Unexpected output type for binary post-processing: {type(output)}. Expected dict with 'probabilities' or numpy.ndarray.")
+        return {class_names[0]: 0.0, class_names[1]: 1.0}
+
+    logger.info(f"Debug: Probabilities array entering postprocess_binary_output: {probabilities_array}, type: {type(probabilities_array)}, shape: {probabilities_array.shape}")
+
+    if probabilities_array is None:
+        logger.warning("Probabilities array is None after extracting from output. Returning default scores.")
+        return {class_names[0]: 0.0, class_names[1]: 1.0}
+
+    if probabilities_array.size == 1:
+        fake_prob = float(probabilities_array.item())
+    elif probabilities_array.size == 2:
+        fake_prob = float(probabilities_array[0])
+    else:
+        logger.warning(f"Unexpected probabilities array shape for binary post-processing: {probabilities_array.shape}. Expected size 1 or 2.")
+        return {class_names[0]: 0.0, class_names[1]: 1.0}
+
+    real_prob = 1.0 - fake_prob # Ensure Fake and Real sum to 1
+    return {class_names[0]: fake_prob, class_names[1]: real_prob}
+
+def infer_gradio_api(image_path):
+    client = Client("aiwithoutborders-xyz/OpenSight-Community-Forensics-Preview")
+    result_dict = client.predict(
+        input_image=handle_file(image_path),
+        api_name="/simple_predict"
+    )
+    logger.info(f"Debug: Raw result_dict from Gradio API (model_8): {result_dict}, type: {type(result_dict)}")
+    # result_dict is already a dictionary, no need for ast.literal_eval
+    fake_probability = result_dict.get('Fake Probability', 0.0)
+    logger.info(f"Debug: Parsed result_dict: {result_dict}, Extracted fake_probability: {fake_probability}")
+    return {"probabilities": np.array([fake_probability])} # Return as a numpy array with one element
+
+# New preprocess function for Gradio API
+def preprocess_gradio_api(image: Image.Image):
+    # The Gradio API expects a file path, so we need to save the PIL Image to a temporary file.
+    temp_file_path = "./temp_gradio_input.png"
+    image.save(temp_file_path)
+    return temp_file_path
+
+# New postprocess function for Gradio API (adapting postprocess_binary_output)
+def postprocess_gradio_api(gradio_output, class_names):
+    # gradio_output is expected to be a dictionary like {"probabilities": np.array([fake_prob])}
+    probabilities_array = None
+    if isinstance(gradio_output, dict) and "probabilities" in gradio_output:
+        probabilities_array = gradio_output["probabilities"]
+    elif isinstance(gradio_output, np.ndarray):
+        probabilities_array = gradio_output
+    else:
+        logger.warning(f"Unexpected output type for Gradio API post-processing: {type(gradio_output)}. Expected dict with 'probabilities' or numpy.ndarray.")
+        return {class_names[0]: 0.0, class_names[1]: 1.0}
+
+    logger.info(f"Debug: Probabilities array entering postprocess_gradio_api: {probabilities_array}, type: {type(probabilities_array)}, shape: {probabilities_array.shape}")
+
+    if probabilities_array is None or probabilities_array.size == 0:
+        logger.warning("Probabilities array is None or empty after extracting from Gradio API output. Returning default scores.")
+        return {class_names[0]: 0.0, class_names[1]: 1.0}
+
+    # It should always be a single element array for fake probability
+    fake_prob = float(probabilities_array.item())
+    real_prob = 1.0 - fake_prob
+
+    return {class_names[0]: fake_prob, class_names[1]: real_prob}
+
+def register_model_with_metadata(model_id, model, preprocess, postprocess, class_names, display_name, contributor, model_path, architecture=None, dataset=None):
+    entry = ModelEntry(model, preprocess, postprocess, class_names, display_name=display_name, contributor=contributor, model_path=model_path, architecture=architecture, dataset=dataset)
+    MODEL_REGISTRY[model_id] = entry
+
+
+def load_onnx_model_and_preprocessor(hf_model_id):
+    # model_dir = snapshot_download(repo_id=hf_model_id, local_dir_use_symlinks=False)
+    
+    # Create a unique local directory for each ONNX model
+    model_specific_dir = os.path.join("./models", hf_model_id.replace('/', '_'))
+    os.makedirs(model_specific_dir, exist_ok=True)
+
+    # Use hf_hub_download to get specific files into the model-specific directory
+    onnx_model_path = hf_hub_download(repo_id=hf_model_id, filename="model_quantized.onnx", subfolder="onnx", local_dir=model_specific_dir, local_dir_use_symlinks=False)
+
+    # Load preprocessor config
+    preprocessor_config = {}
+    try:
+        preprocessor_config_path = hf_hub_download(repo_id=hf_model_id, filename="preprocessor_config.json", local_dir=model_specific_dir, local_dir_use_symlinks=False)
+        with open(preprocessor_config_path, 'r') as f:
+            preprocessor_config = json.load(f)
+    except Exception as e:
+        logger.warning(f"Could not download or load preprocessor_config.json for {hf_model_id}: {e}")
+    
+    # Load model config for class names if available
+    model_config = {}
+    try:
+        model_config_path = hf_hub_download(repo_id=hf_model_id, filename="config.json", local_dir=model_specific_dir, local_dir_use_symlinks=False)
+        with open(model_config_path, 'r') as f:
+            model_config = json.load(f)
+    except Exception as e:
+        logger.warning(f"Could not download or load config.json for {hf_model_id}: {e}")
+
+    return onnxruntime.InferenceSession(onnx_model_path), preprocessor_config, model_config
+
+
+# Cache for ONNX sessions and preprocessors
+_onnx_model_cache = {}
+
+def get_onnx_model_from_cache(hf_model_id):
+    if hf_model_id not in _onnx_model_cache:
+        logger.info(f"Loading ONNX model and preprocessor for {hf_model_id}...")
+        _onnx_model_cache[hf_model_id] = load_onnx_model_and_preprocessor(hf_model_id)
+    return _onnx_model_cache[hf_model_id]
+
+def preprocess_onnx_input(image: Image.Image, preprocessor_config: dict):
+    # Preprocess image for ONNX model based on preprocessor_config
+    if image.mode != 'RGB':
+        image = image.convert('RGB')
+    
+    # Get image size and normalization values from preprocessor_config or use defaults
+    # Use 'size' for initial resize and 'crop_size' for center cropping
+    initial_resize_size = preprocessor_config.get('size', {'height': 224, 'width': 224})
+    crop_size = preprocessor_config.get('crop_size', initial_resize_size['height'])
+    mean = preprocessor_config.get('image_mean', [0.485, 0.456, 0.406])
+    std = preprocessor_config.get('image_std', [0.229, 0.224, 0.225])
+
+    transform = transforms.Compose([
+        transforms.Resize((initial_resize_size['height'], initial_resize_size['width'])),
+        transforms.CenterCrop(crop_size), # Apply center crop
+        transforms.ToTensor(),
+        transforms.Normalize(mean=mean, std=std),
+    ])
+    input_tensor = transform(image)
+    # ONNX expects numpy array with batch dimension (1, C, H, W)
+    return input_tensor.unsqueeze(0).cpu().numpy()
+
+def infer_onnx_model(hf_model_id, preprocessed_image_np, model_config: dict):
+    try:
+        ort_session, _, _ = get_onnx_model_from_cache(hf_model_id)
+        
+        # Debug: Print expected input shape from ONNX model
+        for input_meta in ort_session.get_inputs():
+            logger.info(f"Debug: ONNX model expected input name: {input_meta.name}, shape: {input_meta.shape}, type: {input_meta.type}")
+
+        logger.info(f"Debug: preprocessed_image_np shape: {preprocessed_image_np.shape}")
+        ort_inputs = {ort_session.get_inputs()[0].name: preprocessed_image_np}
+        ort_outputs = ort_session.run(None, ort_inputs)
+        
+        logits = ort_outputs[0]
+        logger.info(f"Debug: logits type: {type(logits)}, shape: {logits.shape}")
+        # If the model outputs a single logit (e.g., shape (1,)), use .item() to convert to scalar
+        # Otherwise, assume it's a batch of logits (e.g., shape (1, num_classes)) and take the first element (batch dim)
+        # The num_classes in config.json can be misleading; rely on actual output shape.
+        
+        # Apply softmax to the logits to get probabilities for the classes
+        # The softmax function in utils/utils.py now ensures a list of floats
+        probabilities = softmax(logits[0]) # Assuming logits[0] is the relevant output for a single prediction
+
+        return {"logits": logits, "probabilities": probabilities}
+
+    except Exception as e:
+        logger.error(f"Error during ONNX inference for {hf_model_id}: {e}")
+        # Return a structure consistent with other model errors
+        return {"logits": np.array([]), "probabilities": np.array([])}
+
+def postprocess_onnx_output(onnx_output, model_config):
+    # Get class names from model_config
+    # Prioritize id2label, then check num_classes, otherwise default
+    class_names_map = model_config.get('id2label')
+    if class_names_map:
+        class_names = [class_names_map[k] for k in sorted(class_names_map.keys())]
+    elif model_config.get('num_classes') == 1: # Handle models that output a single value (e.g., probability of 'Fake')
+        class_names = ['Fake', 'Real'] # Assume first class is 'Fake' and second 'Real'
+    else:
+        class_names = {0: 'Fake', 1: 'Real'} # Default to Fake/Real if not found or not 1 class
+        class_names = [class_names[i] for i in sorted(class_names.keys())]
+
+    probabilities = onnx_output.get("probabilities")
+    
+    if probabilities is not None:
+        if model_config.get('num_classes') == 1 and len(probabilities) == 2: # Special handling for single output models
+            # The single output is the probability of the 'Fake' class
+            fake_prob = float(probabilities[0])
+            real_prob = float(probabilities[1])
+            return {class_names[0]: fake_prob, class_names[1]: real_prob}
+        elif len(probabilities) == len(class_names):
+            return {class_names[i]: float(probabilities[i]) for i in range(len(class_names))}
+        else:
+            logger.warning("ONNX post-processing: Probabilities length mismatch with class names.")
+            return {name: 0.0 for name in class_names}
+    else:
+        logger.warning("ONNX post-processing failed: 'probabilities' key not found in output.")
+        return {name: 0.0 for name in class_names}
+
+# Register the ONNX quantized model
+# Dummy entry for ONNX model to be loaded dynamically
+# We will now register a 'wrapper' that handles dynamic loading
+
+class ONNXModelWrapper:
+    def __init__(self, hf_model_id):
+        self.hf_model_id = hf_model_id
+        self._session = None
+        self._preprocessor_config = None
+        self._model_config = None
+
+    def load(self):
+        if self._session is None:
+            self._session, self._preprocessor_config, self._model_config = get_onnx_model_from_cache(self.hf_model_id)
+            logger.info(f"ONNX model {self.hf_model_id} loaded into wrapper.")
+
+    def __call__(self, image_np):
+        self.load() # Ensure model is loaded on first call
+        # Pass model_config to infer_onnx_model
+        return infer_onnx_model(self.hf_model_id, image_np, self._model_config)
+
+    def preprocess(self, image: Image.Image):
+        self.load()
+        return preprocess_onnx_input(image, self._preprocessor_config)
+
+    def postprocess(self, onnx_output: dict, class_names_from_registry: list): # class_names_from_registry is ignored
+        self.load()
+        return postprocess_onnx_output(onnx_output, self._model_config)
+
+# Consolidate all model loading and registration
+for model_key, hf_model_path in MODEL_PATHS.items():
+    logger.debug(f"Attempting to register model: {model_key} with path: {hf_model_path}")
+    model_num = model_key.replace("model_", "").upper()
+    contributor = "Unknown"
+    architecture = "Unknown"
+    dataset = "TBA"
+
+    current_class_names = CLASS_NAMES.get(model_key, [])
+
+    # Logic for ONNX models (1, 2, 3, 5, 6, 7)
+    if "ONNX" in hf_model_path:
+        logger.debug(f"Model {model_key} identified as ONNX.")
+        logger.info(f"Registering ONNX model: {model_key} from {hf_model_path}")
+        onnx_wrapper_instance = ONNXModelWrapper(hf_model_path)
+
+        # Attempt to derive contributor, architecture, dataset based on model_key
+        if model_key == "model_1":
+            contributor = "haywoodsloan"
+            architecture = "SwinV2"
+            dataset = "DeepFakeDetection"
+        elif model_key == "model_2":
+            contributor = "Heem2"
+            architecture = "ViT"
+            dataset = "DeepFakeDetection"
+        elif model_key == "model_3":
+            contributor = "Organika"
+            architecture = "VIT"
+            dataset = "SDXL"
+        elif model_key == "model_5":
+            contributor = "prithivMLmods"
+            architecture = "VIT"
+        elif model_key == "model_6":
+            contributor = "ideepankarsharma2003"
+            architecture = "SWINv1"
+            dataset = "SDXL, Midjourney"
+        elif model_key == "model_7":
+            contributor = "date3k2"
+            architecture = "VIT"
+
+        display_name_parts = [model_num]
+        if architecture and architecture not in ["Unknown"]:
+            display_name_parts.append(architecture)
+        if dataset and dataset not in ["TBA"]:
+            display_name_parts.append(dataset)
+        display_name = "-".join(display_name_parts)
+        display_name += "_ONNX" # Always append _ONNX for ONNX models
+
+        register_model_with_metadata(
+            model_id=model_key,
+            model=onnx_wrapper_instance, # The callable wrapper for the ONNX model
+            preprocess=onnx_wrapper_instance.preprocess,
+            postprocess=onnx_wrapper_instance.postprocess,
+            class_names=current_class_names, # Initial class names; will be overridden by model_config if available
+            display_name=display_name,
+            contributor=contributor,
+            model_path=hf_model_path,
+            architecture=architecture,
+            dataset=dataset
+        )
+    # Logic for Gradio API model (model_8)
+    elif model_key == "model_8":
+        logger.debug(f"Model {model_key} identified as Gradio API.")
+        logger.info(f"Registering Gradio API model: {model_key} from {hf_model_path}")
+        contributor = "aiwithoutborders-xyz"
+        architecture = "ViT"
+        dataset = "DeepfakeDetection"
+
+        display_name_parts = [model_num]
+        if architecture and architecture not in ["Unknown"]:
+            display_name_parts.append(architecture)
+        if dataset and dataset not in ["TBA"]:
+            display_name_parts.append(dataset)
+        display_name = "-".join(display_name_parts)
+
+        register_model_with_metadata(
+            model_id=model_key,
+            model=infer_gradio_api,
+            preprocess=preprocess_gradio_api,
+            postprocess=postprocess_gradio_api,
+            class_names=current_class_names,
+            display_name=display_name,
+            contributor=contributor,
+            model_path=hf_model_path,
+            architecture=architecture,
+            dataset=dataset
+        )
+    # Logic for PyTorch/Hugging Face pipeline models (currently only model_4)
+    elif model_key == "model_4": # Explicitly handle model_4
+        logger.debug(f"Model {model_key} identified as PyTorch/HuggingFace pipeline.")
+        logger.info(f"Registering HuggingFace pipeline/AutoModel: {model_key} from {hf_model_path}")
+        contributor = "cmckinle"
+        architecture = "VIT"
+        dataset = "SDXL, FLUX"
+
+        display_name_parts = [model_num]
+        if architecture and architecture not in ["Unknown"]:
+            display_name_parts.append(architecture)
+        if dataset and dataset not in ["TBA"]:
+            display_name_parts.append(dataset)
+        display_name = "-".join(display_name_parts)
+
+        current_processor = AutoFeatureExtractor.from_pretrained(hf_model_path, device=device)
+        model_instance = AutoModelForImageClassification.from_pretrained(hf_model_path).to(device)
+
+        preprocess_func = preprocess_resize_256
+        postprocess_func = postprocess_logits
+
+        def custom_infer(image, processor_local=current_processor, model_local=model_instance):
+            inputs = processor_local(image, return_tensors="pt").to(device)
+            with torch.no_grad():
+                outputs = model_local(**inputs)
+            return outputs
+        model_instance = custom_infer
+
+        register_model_with_metadata(
+            model_id=model_key,
+            model=model_instance,
+            preprocess=preprocess_func,
+            postprocess=postprocess_func,
+            class_names=current_class_names,
+            display_name=display_name,
+            contributor=contributor,
+            model_path=hf_model_path,
+            architecture=architecture,
+            dataset=dataset
+        )
+    else: # Fallback for any unhandled models (shouldn't happen if MODEL_PATHS is fully covered)
+        logger.warning(f"Could not automatically load and register model: {model_key} from {hf_model_path}. No matching registration logic found.")
+
+
+def infer(image: Image.Image, model_id: str, confidence_threshold: float = 0.75) -> dict:
+    """Predict using a specific model.
+
+    Args:
+        image (Image.Image): The input image to classify.
+        model_id (str): The ID of the model to use for classification.
+        confidence_threshold (float, optional): The confidence threshold for classification. Defaults to 0.75.
+
+    Returns:
+        dict: A dictionary containing the model details, classification scores, and label.
+    """
+    entry = MODEL_REGISTRY[model_id]
+    img = entry.preprocess(image) if entry.preprocess else image
+    try:
+        result = entry.model(img)
+        scores = entry.postprocess(result, entry.class_names)
+        
+        def _to_float_scalar(value):
+            if isinstance(value, np.ndarray):
+                return float(value.item()) # Convert numpy array scalar to Python float
+            return float(value) # Already a Python scalar or convertible type
+
+        ai_score = _to_float_scalar(scores.get(entry.class_names[0], 0.0))
+        real_score = _to_float_scalar(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,
+            "Real Score": 0.0,
+            "Label": f"Error: {str(e)}"
+        }
+
+def full_prediction(img, confidence_threshold, rotate_degrees, noise_level, sharpen_strength):
+    """Full prediction run, with a team of ensembles and agents.
+
+    Args:
+        img (url: str, Image.Image, np.ndarray): The input image to classify.
+        confidence_threshold (float, optional): The confidence threshold for classification. Defaults to 0.75.
+        rotate_degrees (int, optional): The degrees to rotate the image.
+        noise_level (int, optional): The noise level to use.
+        sharpen_strength (int, optional): The sharpen strength to use.
+
+    Returns:
+        dict: A dictionary containing the model details, classification scores, and label.
+    """
+    # Ensure img is a PIL Image object
+    if img is None:
+        raise gr.Error("No image provided. Please upload an image to analyze.")
+    # Handle filepath conversion if needed
+    if isinstance(img, str):
+        try:
+            img = load_image(img)
+        except Exception as e:
+            logger.error(f"Error loading image from path: {e}")
+            raise gr.Error(f"Could not load image from the provided path. Error: {str(e)}")
+        
+    if not isinstance(img, Image.Image):
+        try:
+            img = Image.fromarray(img)
+        except Exception as e:
+            logger.error(f"Error converting input image to PIL: {e}")
+            raise gr.Error("Input image could not be converted to a valid image format. Please try another image.")
+
+    # Ensure image is in RGB format for consistent processing
+    if img.mode != 'RGB':
+        img = img.convert('RGB')
+
+    monitor_agent = EnsembleMonitorAgent()
+    weight_manager = ModelWeightManager(strongest_model_id="simple_prediction")
+    optimization_agent = WeightOptimizationAgent(weight_manager)
+    health_agent = SystemHealthAgent()
+    context_agent = ContextualIntelligenceAgent()
+    anomaly_agent = ForensicAnomalyDetectionAgent()
+    health_agent.monitor_system_health()
+    if rotate_degrees or noise_level or sharpen_strength:
+        img_pil, _ = augment_image(img, ["rotate", "add_noise", "sharpen"], rotate_degrees, noise_level, sharpen_strength)
+    else:
+        img_pil = img
+    img_np_og = np.array(img)
+
+    model_predictions_raw = {}
+    confidence_scores = {}
+    results = []
+    table_rows = []
+
+    # Initialize lists for forensic outputs, starting with the original augmented image
+    cleaned_forensics_images = []
+    forensic_output_descriptions = []
+
+    # Always add the original augmented image first for forensic display
+    if isinstance(img_pil, Image.Image):
+        cleaned_forensics_images.append(img_pil)
+        forensic_output_descriptions.append(f"Original augmented image (PIL): {img_pil.width}x{img_pil.height}")
+    elif isinstance(img_pil, np.ndarray):
+        try:
+            pil_img_from_np = Image.fromarray(img_pil)
+            cleaned_forensics_images.append(pil_img_from_np)
+            forensic_output_descriptions.append(f"Original augmented image (numpy converted to PIL): {pil_img_from_np.width}x{pil_img_from_np.height}")
+        except Exception as e:
+            logger.warning(f"Could not convert original numpy image to PIL for gallery: {e}")
+    
+    # Yield initial state with augmented image and empty model predictions
+    yield img_pil, cleaned_forensics_images, table_rows, "[]", "<div style='font-size: 2.2em; font-weight: bold;padding: 10px;'>Consensus: <span style='color:orange'>UNCERTAIN</span></div>"
+
+
+    # Stream results as each model finishes
+    for model_id in MODEL_REGISTRY:
+        model_start = time.time()
+        result = infer(img_pil, model_id, confidence_threshold)
+        model_end = time.time()
+
+        # Helper to ensure values are Python floats, handling numpy scalars
+        def _ensure_float_scalar(value):
+            if isinstance(value, np.ndarray):
+                return float(value.item()) # Convert numpy array scalar to Python float
+            return float(value) # Already a Python scalar or convertible type
+
+        ai_score_val = _ensure_float_scalar(result.get("AI Score", 0.0))
+        real_score_val = _ensure_float_val = _ensure_float_scalar(result.get("Real Score", 0.0))
+
+        monitor_agent.monitor_prediction(
+            model_id,
+            result["Label"],
+            max(ai_score_val, real_score_val),
+            model_end - model_start
+        )
+        model_predictions_raw[model_id] = result
+        confidence_scores[model_id] = max(ai_score_val, real_score_val)
+        results.append(result)
+        table_rows.append([
+            result.get("Model", ""),
+            result.get("Contributor", ""),
+            round(ai_score_val, 5),
+            round(real_score_val, 5),
+            result.get("Label", "Error")
+        ])
+        # Yield partial results: only update the table, others are None
+        yield None, cleaned_forensics_images, table_rows, None, None # Keep cleaned_forensics_images as is (only augmented image for now)
+
+    # Multi-threaded forensic processing
+    def _run_forensic_task(task_func, img_input, description, **kwargs):
+        try:
+            result_img = task_func(img_input, **kwargs)
+            return result_img, description
+        except Exception as e:
+            logger.error(f"Error processing forensic task {task_func.__name__}: {e}")
+            return None, f"Error processing {description}: {str(e)}"
+
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        future_ela1 = executor.submit(_run_forensic_task, ELA, img_np_og, "ELA analysis (Pass 1): Grayscale error map, quality 75.", quality=75, scale=50, contrast=20, linear=False, grayscale=True)
+        future_ela2 = executor.submit(_run_forensic_task, ELA, img_np_og, "ELA analysis (Pass 2): Grayscale error map, quality 75, enhanced contrast.", quality=75, scale=75, contrast=25, linear=False, grayscale=True)
+        future_ela3 = executor.submit(_run_forensic_task, ELA, img_np_og, "ELA analysis (Pass 3): Color error map, quality 75, enhanced contrast.", quality=75, scale=75, contrast=25, linear=False, grayscale=False)
+        future_gradient1 = executor.submit(_run_forensic_task, gradient_processing, img_np_og, "Gradient processing: Highlights edges and transitions.")
+        future_gradient2 = executor.submit(_run_forensic_task, gradient_processing, img_np_og, "Gradient processing: Int=45, Equalize=True", intensity=45, equalize=True)
+        future_minmax1 = executor.submit(_run_forensic_task, minmax_process, img_np_og, "MinMax processing: Deviations in local pixel values.")
+        future_minmax2 = executor.submit(_run_forensic_task, minmax_process, img_np_og, "MinMax processing (Radius=6): Deviations in local pixel values.", radius=6)
+
+        forensic_futures = [future_ela1, future_ela2, future_ela3, future_gradient1, future_gradient2, future_minmax1, future_minmax2]
+        
+        for future in concurrent.futures.as_completed(forensic_futures):
+            processed_img, description = future.result()
+            if processed_img is not None:
+                if isinstance(processed_img, Image.Image):
+                    cleaned_forensics_images.append(processed_img)
+                elif isinstance(processed_img, np.ndarray):
+                    try:
+                        cleaned_forensics_images.append(Image.fromarray(processed_img))
+                    except Exception as e:
+                        logger.warning(f"Could not convert numpy array to PIL Image for gallery: {e}")
+                else:
+                    logger.warning(f"Unexpected type in processed_img from {description}: {type(processed_img)}. Skipping.")
+                
+                forensic_output_descriptions.append(description) # Keep track of descriptions for anomaly agent
+                
+                # Yield partial results: update gallery
+                yield None, cleaned_forensics_images, table_rows, None, None
+
+    # After all models, compute the rest as before
+    image_data_for_context = {
+        "width": img.width,
+        "height": img.height,
+        "mode": img.mode,
+    }
+    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.",
+        "Gradient processing: Int=45, Equalize=True",
+        "MinMax processing: Deviations in local pixel values.",
+        "MinMax processing (Radius=6): Deviations in local pixel values.",
+        # "Bit Plane extractor: Visualization of individual bit planes from different color channels."
+    ]
+    detected_context_tags = context_agent.infer_context_tags(image_data_for_context, model_predictions_raw)
+    logger.info(f"Detected context tags: {detected_context_tags}")
+    adjusted_weights = weight_manager.adjust_weights(model_predictions_raw, confidence_scores, context_tags=detected_context_tags)
+    weighted_predictions = {"AI": 0.0, "REAL": 0.0, "UNCERTAIN": 0.0}
+    for model_id, prediction in model_predictions_raw.items():
+        prediction_label = prediction.get("Label")
+        if prediction_label in weighted_predictions:
+            weighted_predictions[prediction_label] += adjusted_weights[model_id]
+        else:
+            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"
+    optimization_agent.analyze_performance(final_prediction_label, None)
+    # gradient_image = gradient_processing(img_np_og)
+    # gradient_image2 = gradient_processing(img_np_og, intensity=45, equalize=True)
+    # minmax_image = minmax_process(img_np_og)
+    # minmax_image2 = minmax_process(img_np_og, radius=6)
+    # # bitplane_image = bit_plane_extractor(img_pil)
+    # ela1 = ELA(img_np_og, quality=75, scale=50, contrast=20, linear=False, grayscale=True)
+    # 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, gradient_image2, minmax_image, minmax_image2]
+    # 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.",
+    #     "Gradient processing: Int=45, Equalize=True",
+    #     "MinMax processing: Deviations in local pixel values.",
+    #     "MinMax processing (Radius=6): Deviations in local pixel values.",
+    #     # "Bit Plane extractor: Visualization of individual bit planes from different color channels."
+    # ]
+    anomaly_detection_results = anomaly_agent.analyze_forensic_outputs(forensic_output_descriptions)
+    logger.info(f"Forensic anomaly detection: {anomaly_detection_results['summary']}")
+    consensus_html = f"<div style='font-size: 2.2em; font-weight: bold;padding: 10px;'>Consensus: <span style='color:{'red' if final_prediction_label == 'AI' else ('green' if final_prediction_label == 'REAL' else 'orange')}'>{final_prediction_label}</span></div>"
+    inference_params = {
+        "confidence_threshold": confidence_threshold,
+        "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
+    }
+    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),
+        },
+        "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_inference_data(
+        original_image=img,
+        inference_params=inference_params,
+        model_predictions=results,
+        ensemble_output=ensemble_output_data,
+        forensic_images=cleaned_forensics_images, # Use the incrementally built list
+        agent_monitoring_data=agent_monitoring_data_log,
+        human_feedback=None
+    )
+
+    logger.info(f"Cleaned forensic images types: {[type(img) for img in cleaned_forensics_images]}")
+    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.")
+    json_results = json.dumps(results, cls=NumpyEncoder)
+    yield img_pil, cleaned_forensics_images, table_rows, json_results, consensus_html
+
+detection_model_eval_playground = gr.Interface(
+    fn=full_prediction,
+    inputs=[
+        gr.Image(label="Upload Image to Analyze", sources=['upload', 'webcam'], type='filepath'),
+        gr.Slider(0.0, 1.0, value=0.7, step=0.05, label="Confidence Threshold"),
+        gr.Slider(0, 45, value=0, step=1, label="Rotate Degrees", visible=False),
+        gr.Slider(0, 50, value=0, step=1, label="Noise Level", visible=False),
+        gr.Slider(0, 50, value=0, step=1, label="Sharpen Strength", visible=False)
+    ],
+    outputs=[
+        gr.Image(label="Processed Image", visible=False),
+        gr.Gallery(label="Post Processed Images", visible=True, columns=[4], rows=[2], container=False, height="auto", object_fit="contain", elem_id="post-gallery"),
+        gr.Dataframe(
+            label="Model Predictions",
+            headers=["Arch / Dataset", "By", "AI", "Real", "Label"],
+            datatype=["str", "str", "number", "number", "str"]
+        ),
+        gr.JSON(label="Raw Model Results", visible=False),
+        gr.Markdown(label="Consensus", value="")
+    ],
+    title="Multi-Model Ensemble + Agentic Coordinated Deepfake Detection (Paper in Progress)",
+    description="The detection of AI-generated images has entered a critical inflection point. While existing solutions struggle with outdated datasets and inflated claims, our approach prioritizes agility, community collaboration, and an offensive approach to deepfake detection.",
+    api_name="predict",
+    live=True  # Enable streaming
+)
+# def echo_headers(x, request: gr.Request):
+#     print(dict(request.headers))
+#     return str(dict(request.headers))
+
+
+def predict(img):
+    """
+    Predicts whether an image is AI-generated or real using the SOTA Community Forensics model.
+
+    Args:
+        img (str): Path to the input image file to analyze.
+
+    Returns:
+        dict: A dictionary containing:
+            - 'Fake Probability' (float): Probability score between 0 and 1 indicating likelihood of being AI-generated
+            - 'Result Description' (str): Human-readable description of the prediction result
+
+    Example:
+        >>> result = predict("path/to/image.jpg")
+        >>> print(result)
+        {'Fake Probability': 0.002, 'Result Description': 'The image is likely real.'}
+    """
+    client = Client("aiwithoutborders-xyz/OpenSight-Community-Forensics-Preview")
+    client.view_api()
+    result = client.predict(
+        handle_file(img),
+        api_name="/simple_predict"
+    )
+    return str(result)
+community_forensics_preview = gr.Interface(
+    fn=predict,
+    inputs=gr.Image(type="filepath"),
+    outputs=gr.HTML(), # or gr.Markdown() if it's just text
+    title="Quick and simple prediction by our strongest model.",
+    description="No ensemble, no context, no agents, just a quick and simple prediction by our strongest model.",
+    api_name="predict"
+)
+
+# leaderboard = gr.Interface(
+#     fn=lambda: "# AI Generated / Deepfake Detection Models Leaderboard: Soon™",
+#     inputs=None,
+#     outputs=gr.Markdown(),
+#     title="Leaderboard",
+#     api_name="leaderboard"
+# )
+def simple_prediction(img):
+    """
+    Quick and simple deepfake or real image prediction by the strongest open-source model on the hub.
+
+    Args:
+        img (str): The input image to analyze, provided as a file path.
+
+    Returns:
+        str: The prediction result stringified from dict. Example: `{'Fake Probability': 0.002, 'Result Description': 'The image is likely real.'}`
+    """    
+    client = Client("aiwithoutborders-xyz/OpenSight-Community-Forensics-Preview")
+    client.view_api()
+    client.predict(
+        handle_file(img),
+        api_name="simple_predict"
+    )
+simple_predict_interface = gr.Interface(
+    fn=simple_prediction,
+    inputs=gr.Image(type="filepath"),
+    outputs=gr.Text(),
+    title="Quick and simple prediction by our strongest model.",
+    description="No ensemble, no context, no agents, just a quick and simple prediction by our strongest model.",
+    api_name="simple_predict"
+)
+
+noise_estimation_interface = gr.Interface(
+    fn=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"
+)
+
+bit_plane_interface = 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"
+)
+
+ela_interface = gr.Interface(
+    fn=ELA,
+    inputs=[
+        gr.Image(type="pil", label="Input Image"),
+        gr.Slider(1, 100, value=75, step=1, label="JPEG Quality"),
+        gr.Slider(1, 100, value=50, step=1, label="Output Scale (Multiplicative Gain)"),
+        gr.Slider(0, 100, value=20, step=1, label="Output Contrast (Tonality Compression)"),
+        gr.Checkbox(value=False, label="Use Linear Difference"),
+        gr.Checkbox(value=False, label="Grayscale Output")
+    ],
+    outputs=gr.Image(type="pil"),
+    title="Error Level Analysis (ELA)",
+    description="Performs Error Level Analysis to detect re-saved JPEG images, which can indicate tampering. ELA highlights areas of an image that have different compression levels.",
+    api_name="tool_ela"
+)
+
+gradient_processing_interface = gr.Interface(
+    fn=gradient_processing,
+    inputs=[
+        gr.Image(type="pil", label="Input Image"),
+        gr.Slider(0, 100, value=90, step=1, label="Intensity"),
+        gr.Dropdown(["Abs", "None", "Flat", "Norm"], label="Blue Mode", value="Abs"),
+        gr.Checkbox(value=False, label="Invert Gradients"),
+        gr.Checkbox(value=False, label="Equalize Histogram")
+    ],
+    outputs=gr.Image(type="pil"),
+    title="Gradient Processing",
+    description="Applies gradient filters to an image to enhance edges and transitions, which can reveal inconsistencies due to manipulation.",
+    api_name="tool_gradient_processing"
+)
+
+minmax_processing_interface = gr.Interface(
+    fn=minmax_process,
+    inputs=[
+        gr.Image(type="pil", label="Input Image"),
+        gr.Radio([0, 1, 2, 3, 4], label="Channel (0:Grayscale, 1:Blue, 2:Green, 3:Red, 4:RGB Norm)", value=4),
+        gr.Slider(0, 10, value=2, step=1, label="Radius")
+    ],
+    outputs=gr.Image(type="pil"),
+    title="MinMax Processing",
+    description="Analyzes local pixel value deviations to detect subtle changes in image data, often indicative of digital forgeries.",
+    api_name="tool_minmax_processing"
+)
+
+# augmentation_tool_interface = gr.Interface(
+#     fn=augment_image,
+#     inputs=[
+#         gr.Image(label="Upload Image to Augment", sources=['upload', 'webcam'], type='pil'),
+#         gr.CheckboxGroup(["rotate", "add_noise", "sharpen"], label="Augmentation Methods"),
+#         gr.Slider(0, 360, value=0, step=1, label="Rotate Degrees", visible=True),
+#         gr.Slider(0, 100, value=0, step=1, label="Noise Level", visible=True),
+#         gr.Slider(0, 200, value=1, step=1, label="Sharpen Strength", visible=True)
+#     ],
+#     outputs=gr.Image(label="Augmented Image", type='pil'),
+#     title="Image Augmentation Tool",
+#     description="Apply various augmentation techniques to your image.",
+#     api_name="augment_image"
+# )
+
+# def get_captured_logs():
+#     # Retrieve all logs from the queue and clear it
+#     logs = list(log_queue)
+#     log_queue.clear() # Clear the queue after retrieving
+#     return "\n".join(logs)
+
+
+demo = gr.TabbedInterface(
+    [
+        detection_model_eval_playground,
+        community_forensics_preview,
+        noise_estimation_interface,
+        bit_plane_interface,
+        ela_interface,
+        gradient_processing_interface,
+        minmax_processing_interface,
+        # gr.Textbox(label="Agent Logs", interactive=False, lines=5, max_lines=20, autoscroll=True) # New textbox for logs
+    ],
+    [
+        "Run Ensemble Prediction",
+        "Open-Source SOTA Model",
+        "Wavelet Blocking Noise Estimation",
+        "Bit Plane Values",
+        "Error Level Analysis (ELA)",
+        "Gradient Processing",
+        "MinMax Processing",
+        # "Agent Logs" # New tab title
+    ],
+    title="Deepfake Detection & Forensics Tools",
+    theme=None,
+
+)
+footerMD = """
+## ⚠️ ENSEMBLE TEAM IN TRAINING ⚠️ \n\n
+
+1. **DISCLAIMER: METADATA AS WELL AS MEDIA SUBMITTED TO THIS SPACE MAY BE VIEWED AND SELECTED FOR FUTURE DATASETS, PLEASE DO NOT SUBMIT PERSONAL CONTENT. FOR UNTRACKED, PRIVATE USE OF THE MODELS YOU MAY STILL USE [THE ORIGINAL SPACE HERE](https://huggingface.co/spaces/aiwithoutborders-xyz/OpenSight-Deepfake-Detection-Models-Playground), SOTA MODEL INCLUDED.**
+2. **UPDATE 6-13-25**: APOLOGIES FOR THE CONFUSION, WE ARE WORKING TO REVERT THE ORIGINAL REPO BACK TO ITS NON-DATA COLLECTION STATE -- ONLY THE "SIMPLE PREDICTION" ENDPOINT IS CURRENTLY 100% PRIVATE. PLEASE STAY TUNED AS WE FIGURE OUT A SOLUTION FOR THE ENSEMBLE + AGENT TEAM ENDPOINT. IT CAN GET RESOURCE INTENSIVE TO RUN A FULL PREDICTION. ALTERNATIVELY, WE **ENCOURAGE** ANYONE TO FORK AND CONTRIBUTE TO THE PROJECT.
+3. **UPDATE 6-13-25 (cont.)**: WHILE WE HAVE NOT TAKEN A STANCE ON NSFW AND EXPLICIT CONTENT, PLEASE REFRAIN FROM ... YOUR HUMAN DESIRES UNTIL WE GET THIS PRIVACY SITUATION SORTED OUT. DO NOT BE RECKLESS PLEASE. OUR PAPER WILL BE OUT SOON ON ARXIV WHICH WILL EXPLAIN EVERYTHING WITH DATA-BACKED RESEARCH ON WHY THIS PROJECT IS NEEDED, BUT WE CANNOT DO IT WITHOUT THE HELP OF THE COMMUNITY.
+
+TO SUMMARIZE: DATASET COLLECTION WILL CONTINUE FOR OUR NOVEL ENSEMBLE-TEAM PREDICTION PIPELINE UNTIL WE CAN GET THINGS SORTED OUT. FOR THOSE THAT WISH TO OPT-OUT, WE OFFER THE SIMPLE, BUT [MOST POWERFUL DETECTION MODEL HERE.](https://huggingface.co/spaces/aiwithoutborders-xyz/OpenSight-Community-Forensics-Preview)
+
+"""
+footer = gr.Markdown(footerMD, elem_classes="footer")
+
+with gr.Blocks() as app:
+    demo.render()
+    footer.render()
+    
+
+app.queue(max_size=10, default_concurrency_limit=2).launch(mcp_server=True) 

forensics/__init__.py

@@ -0,0 +1,15 @@
+from .bitplane import bit_plane_extractor
+from .ela import ELA
+# from .exif import exif_full_dump
+from .gradient import gradient_processing
+from .minmax import minmax_process
+from .wavelet import noise_estimation
+
+__all__ = [
+    'bit_plane_extractor',
+    'ELA',
+     # 'exif_full_dump',
+    'gradient_processing',
+    'minmax_process',
+    'noise_estimation'
+] 

{utils → forensics}/bitplane.py

@@ -8,7 +8,14 @@ def bit_plane_extractor(
     bit: int = 0,
     filter_type: str = "Disabled"
 ) -> Image.Image:
-    """Extract and visualize a bit plane from a selected channel of the image."""
+    """Extract and visualize a bit plane from a selected channel of the image.
+
+    Args:
+        image (Image.Image, string: filepath): The input image to analyze.
+        channel (str, optional): The channel to extract. Defaults to "Luminance".
+        bit (int, optional): The bit to extract. Defaults to 0.
+        filter_type (str, optional): The type of filter to apply. Defaults to "Disabled".
+    """
     img = np.array(image.convert("RGB"))
     if channel == "Luminance":
         img = cv.cvtColor(img, cv.COLOR_RGB2GRAY)

{utils → forensics}/ela.py

@@ -24,7 +24,7 @@ def elapsed_time(start):
     """Calculate elapsed time since start."""
     return f"{time() - start:.3f}s"
 
-def genELA(img, quality=75, scale=50, contrast=20, linear=False, grayscale=False):
+def ELA(img, quality=75, scale=50, contrast=20, linear=False, grayscale=False):
     """
     Perform Error Level Analysis on an image.
     
@@ -61,4 +61,4 @@ def genELA(img, quality=75, scale=50, contrast=20, linear=False, grayscale=False
     if grayscale:
         ela = desaturate(ela)
     
-    return Image.fromarray(ela)
+    return Image.fromarray(ela) 

forensics/exif.py

@@ -0,0 +1,11 @@
+# import tempfile
+# import exiftool
+# from PIL import Image
+
+# def exif_full_dump(image: Image.Image) -> dict:
+#     """Extract all EXIF metadata from an image using exiftool."""
+#     with tempfile.NamedTemporaryFile(suffix='.jpg', delete=True) as tmp:
+#         image.save(tmp.name)
+#         with exiftool.ExifTool() as et:
+#             metadata = et.get_metadata(tmp.name)
+#     return metadata 

{utils → forensics}/gradient.py

@@ -19,6 +19,18 @@ def create_lut(intensity, gamma):
     return lut
 
 def gradient_processing(image, intensity=90, blue_mode="Abs", invert=False, equalize=False):
+    """Apply gradient processing to an image. 
+
+    Args:
+        image (Image.Image, string: filepath): The input image to analyze.
+        intensity (int, optional): The intensity of the gradient. Defaults to 90.
+        blue_mode (str, optional): The mode to use for the blue channel. Defaults to "Abs".
+        invert (bool, optional): Whether to invert the gradient. Defaults to False.
+        equalize (bool, optional): Whether to equalize the gradient. Defaults to False.
+
+    Returns:
+        Image.Image: A PIL image of the gradient.
+    """    
     image = np.array(image)
     dx, dy = cv.spatialGradient(cv.cvtColor(image, cv.COLOR_BGR2GRAY))
     intensity = int(intensity / 100 * 127)
@@ -47,4 +59,4 @@ def gradient_processing(image, intensity=90, blue_mode="Abs", invert=False, equa
         gradient = equalize_img(gradient)
     elif intensity > 0:
         gradient = cv.LUT(gradient, create_lut(intensity, intensity))
-    return Image.fromarray(gradient)
+    return Image.fromarray(gradient) 

{utils → forensics}/minmax.py

@@ -27,7 +27,19 @@ def blk_filter(img, radius):
             )
     return cv.normalize(result, None, 0, 127, cv.NORM_MINMAX, cv.CV_8UC1)
 
-def preprocess(image, channel=4, radius=2):
+def minmax_process(image, channel=4, radius=2):
+    """
+    Analyzes local pixel value deviations in an image to detect potential manipulation by comparing each pixel with its neighbors. This forensic technique helps identify areas where pixel values deviate significantly from their local context, which can indicate digital tampering or editing.
+    
+    Args:
+        image: Union[np.ndarray, Image.Image]: Input image to process
+        channel (int): Channel to process (0:Grayscale, 1:Blue, 2:Green, 3:Red, 4:RGB Norm)
+        radius (int): Radius for block filtering
+    Returns:
+        PIL.Image.Image: The processed image showing minmax deviations.
+    Raises:
+        ValueError: If the input image is invalid or channel/radius parameters are out of valid range.
+    """
     if not isinstance(image, np.ndarray):
         image = np.array(image)  # Ensure image is a NumPy array
     if channel == 0:
@@ -79,4 +91,4 @@ def preprocess(image, channel=4, radius=2):
         elif channel == 3:
             minmax[low] = [255, 255, 255]
             minmax[high] = [255, 255, 255]
-    return Image.fromarray(minmax)
+    return Image.fromarray(minmax) 

{utils → forensics}/wavelet.py

@@ -3,8 +3,16 @@ import pywt
 import cv2
 from PIL import Image
 
-def wavelet_blocking_noise_estimation(image: Image.Image, blocksize: int = 8) -> Image.Image:
-    """Estimate local noise using wavelet blocking. Returns a PIL image of the noise map."""
+def noise_estimation(image: Image.Image, blocksize: int = 8) -> Image.Image:
+    """Estimate local noise using wavelet blocking. Returns a PIL image of the noise map.
+
+    Args:
+        image (Image.Image, string: filepath): The input image to analyze.
+        blocksize (int): The size of the blocks to use for wavelet blocking.
+
+    Returns:
+        Image.Image: A PIL image of the noise map.
+    """    
     im = np.array(image.convert('L'))
     y = np.double(im)
     cA1, (cH, cV, cD) = pywt.dwt2(y, 'db8')

requirements.txt

@@ -1,18 +1,37 @@
-gradio[mcp]
-gradio_leaderboard
-transformers
-huggingface_hub[hf_xet]
+
+# Core ML/AI libraries
+git+https://github.com/huggingface/transformers.git
+torch 
 torchvision
-torch
-spaces
-# pillow
+torchaudio
+# Image processing
 opencv-python
-modelscope_studio
-pydantic==2.10.6
-tf-keras
-PyWavelets
-pyexiftool
-psutil
-datasets
 Pillow
-python-dotenv
+
+# Wavelet processing
+PyWavelets==1.8.0
+
+# System utilities
+psutil
+GPUtil
+python-dotenv
+onnxruntime
+# Gradio and UI
+gradio[mcp]>=5.33.1
+# gradio_leaderboard==0.0.13
+gradio_client==1.10.3
+spaces
+gradio_log
+
+# HuggingFace ecosystem
+huggingface_hub[hf_xet]>=0.31.0
+datasets>=3.5.0
+
+# Data validation and utilities
+pydantic==2.11.5
+
+# AI agents
+smolagents[toolkit,mcp,openai,transformers,vision,gradio]
+
+# Optional: EXIF metadata (if needed)
+pyexiftool

temp_model_config/config.json

@@ -0,0 +1,28 @@
+{
+  "_attn_implementation_autoset": true,
+  "_name_or_path": "aiwithoutborders-xyz/CommunityForensics-DeepfakeDet-ViT",
+  "architectures": [
+    "ViTForImageClassification"
+  ],
+  "attention_probs_dropout_prob": 0.0,
+  "encoder_stride": 16,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.0,
+  "hidden_size": 384,
+  "image_size": 384,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "layer_norm_eps": 1e-06,
+  "mlp_ratio": 4,
+  "model_type": "vit",
+  "num_attention_heads": 12,
+  "num_channels": 3,
+  "num_classes": 1,
+  "num_heads": 6,
+  "num_hidden_layers": 12,
+  "num_layers": 12,
+  "patch_size": 16,
+  "qkv_bias": true,
+  "torch_dtype": "float32",
+  "transformers_version": "4.49.0"
+}

temp_original_vit_config/config.json

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

utils/exif.py

@@ -1,11 +0,0 @@
-import tempfile
-import exiftool
-from PIL import Image
-
-def exif_full_dump(image: Image.Image) -> dict:
-    """Extract all EXIF metadata from an image using exiftool."""
-    with tempfile.NamedTemporaryFile(suffix='.jpg', delete=True) as tmp:
-        image.save(tmp.name)
-        with exiftool.ExifTool() as et:
-            metadata = et.get_metadata(tmp.name)
-    return metadata 

utils/hf_logger.py

@@ -5,13 +5,13 @@ import io
 import datetime
 from PIL import Image
 import logging
-from huggingface_hub import HfApi, CommitOperationAdd # Keep HfApi for repo creation, but remove CommitOperationAdd for direct upload
+from huggingface_hub import HfApi, CommitScheduler
 import numpy as np
 
 logger = logging.getLogger(__name__)
 
 HF_DATASET_NAME = "aiwithoutborders-xyz/degentic_rd0"
-LOCAL_LOG_DIR = "./hf_inference_logs" # Define a local directory to store logs
+LOCAL_LOG_DIR = "./hf_inference_logs"
 
 # Custom JSON Encoder to handle numpy types
 class NumpyEncoder(json.JSONEncoder):
@@ -20,18 +20,21 @@ class NumpyEncoder(json.JSONEncoder):
             return float(obj)
         return json.JSONEncoder.default(self, obj)
 
-def _pil_to_base64(image: Image.Image) -> str:
-    """Converts a PIL Image to a base64 string."""
-    # Explicitly check if the input is a PIL Image
+def _save_pil_image_to_file(image: Image.Image, directory: str, prefix: str) -> str:
+    """Saves a PIL Image to a file and returns its filename."""
     if not isinstance(image, Image.Image):
         raise TypeError(f"Expected a PIL Image, but received type: {type(image)}")
 
-    buffered = io.BytesIO()
-    # Ensure image is in RGB mode before saving as JPEG
+    os.makedirs(directory, exist_ok=True)
+    timestamp_str = datetime.datetime.now().strftime("%Y%m%d%H%M%S%f")
+    filename = f"{prefix}_{timestamp_str}.png"
+    file_path = os.path.join(directory, filename)
+
     if image.mode != 'RGB':
         image = image.convert('RGB')
-    image.save(buffered, format="JPEG", quality=85)
-    return base64.b64encode(buffered.getvalue()).decode('utf-8')
+    image.save(file_path, format="PNG")
+    logger.info(f"Saved image to: {file_path}")
+    return filename
 
 # The initialize_dataset function will change significantly or be removed/simplified
 # as we are no longer appending to a datasets.Dataset object directly in memory
@@ -59,26 +62,26 @@ def log_inference_data(
     try:
         api = initialize_dataset_repo() # Get or create the repository
 
-        original_image_b64 = _pil_to_base64(original_image)
+        original_image_filename = _save_pil_image_to_file(original_image, LOCAL_LOG_DIR, "original")
 
-        forensic_images_b64 = []
+        forensic_images_filenames = []
         for img_item in forensic_images:
             if img_item is not None:
                 if not isinstance(img_item, Image.Image):
                     try:
                         img_item = Image.fromarray(img_item)
                     except Exception as e:
-                        logger.error(f"Error converting forensic image to PIL for base64 encoding: {e}")
+                        logger.error(f"Error converting forensic image to PIL for saving: {e}")
                         continue
-                forensic_images_b64.append(_pil_to_base64(img_item))
+                forensic_images_filenames.append(_save_pil_image_to_file(img_item, LOCAL_LOG_DIR, "forensic"))
 
         new_entry = {
             "timestamp": datetime.datetime.now().isoformat(),
-            "image": original_image_b64,
+            "image": original_image_filename,
             "inference_request": inference_params,
             "model_predictions": model_predictions,
             "ensemble_output": ensemble_output,
-            "forensic_outputs": forensic_images_b64,
+            "forensic_outputs": forensic_images_filenames,
             "agent_monitoring_data": agent_monitoring_data,
             "human_feedback": human_feedback if human_feedback is not None else {}
         }
@@ -92,7 +95,18 @@ def log_inference_data(
         with open(log_file_path, 'w', encoding='utf-8') as f:
             json.dump(new_entry, f, cls=NumpyEncoder, indent=2)
         
-        logger.info(f"Inference data logged successfully to local file: {log_file_path}")
+        # Schedule commit to Hugging Face dataset repository
+        scheduler = CommitScheduler(
+            repo_id=HF_DATASET_NAME,
+            repo_type="dataset",
+            folder_path=LOCAL_LOG_DIR,
+            path_in_repo="logs",
+            token=os.getenv("HF_TOKEN"),
+            every=10  # Commit every 10 files
+        )
+        
+        with scheduler:
+            logger.info(f"Inference data logged successfully to local file: {log_file_path}")
 
     except Exception as e:
         logger.error(f"Failed to log inference data to local file: {e}") 

utils/load.py

@@ -0,0 +1,51 @@
+import os
+import tempfile
+from typing import Any, Callable, List, Optional, Tuple, Union
+from urllib.parse import unquote, urlparse
+
+import PIL.Image
+import PIL.ImageOps
+import requests
+
+def load_image(
+    image: Union[str, PIL.Image.Image], convert_method: Optional[Callable[[PIL.Image.Image], PIL.Image.Image]] = None
+) -> PIL.Image.Image:
+    """
+    Loads `image` to a PIL Image.
+
+    Args:
+        image (`str` or `PIL.Image.Image`):
+            The image to convert to the PIL Image format.
+        convert_method (Callable[[PIL.Image.Image], PIL.Image.Image], *optional*):
+            A conversion method to apply to the image after loading it. When set to `None` the image will be converted
+            "RGB".
+
+    Returns:
+        `PIL.Image.Image`:
+            A PIL Image.
+    """
+    if isinstance(image, str):
+        if image.startswith("http://") or image.startswith("https://"):
+            image = PIL.Image.open(requests.get(image, stream=True, timeout=600).raw)
+        elif os.path.isfile(image):
+            image = PIL.Image.open(image)
+        else:
+            raise ValueError(
+                f"Incorrect path or URL. URLs must start with `http://` or `https://`, and {image} is not a valid path."
+            )
+    elif isinstance(image, PIL.Image.Image):
+        image = image
+    else:
+        raise ValueError(
+            "Incorrect format used for the image. Should be a URL linking to an image, a local path, or a PIL image."
+        )
+
+    image = PIL.ImageOps.exif_transpose(image)
+
+    if convert_method is not None:
+        image = convert_method(image)
+    else:
+        image = image.convert("RGB")
+
+    return image
+

{forensics → utils}/registry.py

@@ -2,7 +2,8 @@ from typing import Callable, Dict, Any, List, Optional
 
 class ModelEntry:
     def __init__(self, model: Any, preprocess: Callable, postprocess: Callable, class_names: List[str],
-                 display_name: Optional[str] = None, contributor: Optional[str] = None, model_path: Optional[str] = None):
+                 display_name: Optional[str] = None, contributor: Optional[str] = None, model_path: Optional[str] = None,
+                 architecture: Optional[str] = None, dataset: Optional[str] = None):
         self.model = model
         self.preprocess = preprocess
         self.postprocess = postprocess
@@ -10,8 +11,10 @@ class ModelEntry:
         self.display_name = display_name
         self.contributor = contributor
         self.model_path = model_path
+        self.architecture = architecture
+        self.dataset = dataset
 
 MODEL_REGISTRY: Dict[str, ModelEntry] = {}
 
-def register_model(model_id: str, model: Any, preprocess: Callable, postprocess: Callable, class_names: List[str]):
-    MODEL_REGISTRY[model_id] = ModelEntry(model, preprocess, postprocess, class_names) 
+def register_model(model_id: str, model: Any, preprocess: Callable, postprocess: Callable, class_names: List[str], architecture: Optional[str] = None, dataset: Optional[str] = None):
+    MODEL_REGISTRY[model_id] = ModelEntry(model, preprocess, postprocess, class_names, architecture=architecture, dataset=dataset) 

utils/utils.py

@@ -5,7 +5,8 @@ from torchvision import transforms
 
 def softmax(vector):
     e = np.exp(vector - np.max(vector))  # for numerical stability
-    return e / e.sum()
+    probabilities = e / e.sum()
+    return [float(p.item()) for p in probabilities] # Convert numpy array elements to Python floats using .item()
 
 def augment_image(img_pil, methods, rotate_degrees=0, noise_level=0, sharpen_strength=1):
     for method in methods: