feat: integrate ONNX model inference and logging enhancements, add contextual intelligence and forensic anomaly detection agents

agents/ensemble_team.py

@@ -2,134 +2,116 @@ import logging
 import time
 import torch
 import psutil # Ensure psutil is imported here as well
+import GPUtil
+from datetime import datetime, timedelta
 
 logger = logging.getLogger(__name__)
 
 class EnsembleMonitorAgent:
     def __init__(self):
-        self.performance_metrics = {
-            "model_accuracy": {},
-            "response_times": {},
-            "confidence_distribution": {},
-            "consensus_rate": 0.0
-        }
+        logger.info("Initializing EnsembleMonitorAgent.")
+        self.performance_metrics = {}
         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] = []
+    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
         
-        self.performance_metrics["response_times"][model_id].append(response_time)
-        self.performance_metrics["confidence_distribution"][model_id].append(confidence)
+        # 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)
         
-        # Check for performance issues
-        self._check_performance_issues(model_id)
+        # 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.debug(f"Updated metrics for '{model_id}': {metrics}")
     
-    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")
+    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 = []  # 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
+        self.prediction_history = []
+        self.performance_window = timedelta(hours=24) # Evaluate performance over last 24 hours
     
-    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))
+    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
+        })
         
-        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.
+        # Keep history windowed
+        self.prediction_history = [p for p in self.prediction_history if timestamp - p["timestamp"] < self.performance_window]
+        logger.debug(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 = {
-            "memory_usage": [],
-            "gpu_utilization": [],
-            "model_load_times": {},
-            "error_rates": {}
+            "cpu_percent": 0,
+            "memory_usage": {"total": 0, "available": 0, "percent": 0},
+            "gpu_utilization": []
         }
     
     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"""
+        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
+        }
+
+        gpu_info = []
         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.") 
+            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/ensemble_weights.py

@@ -6,6 +6,7 @@ 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": {
@@ -24,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:
@@ -32,15 +33,18 @@ 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, 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}
@@ -52,10 +56,13 @@ class ModelWeightManager:
                 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
@@ -67,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/smart_agents.py

@@ -1,65 +1,126 @@
 import logging
-from PIL import Image
-import smolagents
+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_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']}")
 
-    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 = []
+        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")
-
-        # 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 = ["foo", "bar"] # 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)
+        logger.info(f"Inferred context tags: {detected_tags}")
+        return detected_tags
 
-        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."""
-        import random
-        
-        # 4 mock anomalies for demo purposes
-        mock_anomalies = [
-            {
-                "summary": "ELA analysis reveals potential image manipulation",
-                "details": ["ELA: Unusually strong compression artifacts detected", "ELA: Inconsistent noise patterns suggest compositing"]
-            },
-            {
-                "summary": "Bit plane analysis shows irregular patterns",
-                "details": ["Bit Plane: Unexpected data patterns in LSB", "Bit Plane: Hidden information detected in lower planes"]
-            },
-            {
-                "summary": "Gradient analysis indicates artificial boundaries",
-                "details": ["Gradient: Sharp discontinuities in color transitions", "Gradient: Unnatural edge patterns detected"]
-            },
-            {
-                "summary": "Wavelet analysis reveals processing artifacts",
-                "details": ["Wavelet: Unusual frequency distribution", "Wavelet: Compression artifacts inconsistent with natural images"]
-            }
-        ]
-        
-        # Randomly select one of the mock anomalies
-        selected_anomaly = random.choice(mock_anomalies)
-        
-        return selected_anomaly
+        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.")
+            
+        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.py

@@ -6,6 +6,8 @@ import os
 import time
 import logging
 import io
+import collections # Import collections
+import onnxruntime # Import onnxruntime
 
 # Assuming these are available from your utils and agents directories
 # You might need to adjust paths or copy these functions/classes if they are not directly importable.
@@ -28,11 +30,28 @@ import json
 from huggingface_hub import CommitScheduler
 from dotenv import load_dotenv
 
-# Configure logging
 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.DEBUG)
+logging.getLogger().addHandler(gradio_handler)
+# --- End Gradio Log Handler ---
+
 LOCAL_LOG_DIR = "./hf_inference_logs"
 HF_DATASET_NAME="aiwithoutborders-xyz/degentic_rd0"
 load_dotenv()
@@ -102,6 +121,67 @@ register_model_with_metadata(
     architecture="SwinV2", dataset="TBA"
 )
 
+# --- ONNX Quantized Model Example ---
+ONNX_QUANTIZED_MODEL_PATH = "./models/model_1_quantized.onnx" # Placeholder for your ONNX model
+
+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"],
@@ -446,14 +526,26 @@ detection_model_eval_playground = gr.Interface(
     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):
+    client = Client("aiwithoutborders-xyz/OpenSight-Community-Forensics-Preview")
+    client.view_api()
+    result = client.predict(
+        handle_file(img),
+        api_name="/simple_predict"
+    )
+    return result
 community_forensics_preview = gr.Interface(
-    fn=lambda: gr.load("aiwithoutborders-xyz/OpenSight-Community-Forensics-Preview", src="spaces"),
+    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="quick_predict"
+    api_name="predict"
 )
 
 # leaderboard = gr.Interface(
@@ -463,15 +555,30 @@ community_forensics_preview = gr.Interface(
 #     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.
 
-# 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"
-# )
+    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,
@@ -540,36 +647,27 @@ minmax_processing_interface = gr.Interface(
     api_name="tool_minmax_processing"
 )
 
-def augment_image_interface(img, augment_methods, rotate_degrees, noise_level, sharpen_strength):
-    if img is None:
-        raise gr.Error("No image provided for augmentation. Please upload an image.")
-    
-    # Ensure image is PIL Image and in RGB format
-    if not isinstance(img, Image.Image):
-        try:
-            img = Image.fromarray(img)
-        except Exception as e:
-            raise gr.Error(f"Could not convert input to PIL Image: {e}")
-    if img.mode != 'RGB':
-        img = img.convert('RGB')
+# 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"
+# )
 
-    augmented_img, _ = augment_image(img, augment_methods, rotate_degrees, noise_level, sharpen_strength)
-    return augmented_img
+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)
 
-augmentation_tool_interface = gr.Interface(
-    fn=augment_image_interface,
-    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"
-)
 
 demo = gr.TabbedInterface(
     [
@@ -580,7 +678,7 @@ demo = gr.TabbedInterface(
         ela_interface,
         gradient_processing_interface,
         minmax_processing_interface,
-        augmentation_tool_interface
+        gr.Textbox(label="Agent Logs", interactive=False, lines=5, max_lines=20, autoscroll=True) # New textbox for logs
     ],
     [
         "Run Ensemble Prediction",
@@ -590,12 +688,15 @@ demo = gr.TabbedInterface(
         "Error Level Analysis (ELA)",
         "Gradient Processing",
         "MinMax Processing",
-        "Image Augmentation"
+        "Agent Logs" # New tab title
     ],
     title="Deepfake Detection & Forensics Tools",
     theme=None,
 
 )
 
+# Add live update for the logs textbox
+demo.load(get_captured_logs, None, demo.outputs[8], every=1)
+
 if __name__ == "__main__":
     demo.launch(mcp_server=True) 

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)

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)

forensics/wavelet.py

@@ -4,7 +4,15 @@ import cv2
 from PIL import Image
 
 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."""
+    """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

@@ -13,8 +13,9 @@ PyWavelets==1.8.0
 
 # System utilities
 psutil
+GPUtil
 python-dotenv
-
+onnxruntime
 # Gradio and UI
 gradio[mcp]>=5.33.1
 # gradio_leaderboard==0.0.13