update ALL

app.py

@@ -6,6 +6,9 @@ import json
 import argparse
 from types import SimpleNamespace
 from PIL import Image
+import matplotlib.pyplot as plt
+import io
+import numpy as np
 
 # Try to import detector - if this fails, we'll show an error in the UI
 try:
@@ -29,7 +32,7 @@ if os.environ.get("SPACE_ID"):
         print(f"Warning: Could not download weights: {e}")
 
 # Available detectors based on launcher.py
-DETECTORS = ['R50_TF', 'R50_nodown', 'CLIP-D', 'P2G', 'NPR']
+DETECTORS = ['ALL', 'R50_TF', 'R50_nodown', 'CLIP-D', 'P2G', 'NPR']
 
 def process_image(image_path):
     """
@@ -67,6 +70,38 @@ def process_image(image_path):
         print(f"Error processing image: {e}")
         return image_path
 
+def run_single_detection(image_path, detector_name):
+    output_path = f"temp_result_{detector_name}.json"
+    # Mock args object
+    args = SimpleNamespace(
+        image=image_path,
+        detector=detector_name,
+        config_dir='configs',
+        output=output_path,
+        weights='pretrained', # Use default/pretrained
+        device='cpu', # Force CPU
+        dry_run=False,
+        verbose=False
+    )
+    
+    try:
+        run_detect(args)
+        
+        if os.path.exists(output_path):
+            with open(output_path, 'r') as f:
+                result = json.load(f)
+            os.remove(output_path)
+            return result
+        return None
+    except Exception as e:
+        if os.path.exists(output_path):
+            try:
+                os.remove(output_path)
+            except:
+                pass
+        print(f"Error running {detector_name}: {e}")
+        return None
+
 def predict(image_path, detector_name):
     # Check if detector is available
     if not DETECTOR_AVAILABLE:
@@ -74,10 +109,10 @@ def predict(image_path, detector_name):
             "error": "Detector module not available",
             "details": IMPORT_ERROR,
             "message": "The detection system could not be initialized. Please check the logs."
-        }, indent=2)
+        }, indent=2), None
     
     if not image_path:
-        return json.dumps({"error": "Please upload an image."}, indent=2)
+        return json.dumps({"error": "Please upload an image."}, indent=2), None
     
     # Process image (central crop if too large)
     processed_path = image_path
@@ -87,64 +122,117 @@ def predict(image_path, detector_name):
         print(f"Warning: Image processing failed: {e}")
         # Continue with original image if processing fails
     
-    # Create a temporary output file path
-    output_path = "temp_result.json"
-    
-    # Mock args object
-    args = SimpleNamespace(
-        image=processed_path,
-        detector=detector_name,
-        config_dir='configs',
-        output=output_path,
-        weights='pretrained', # Use default/pretrained
-        device='cpu', # Force CPU
-        dry_run=False,
-        verbose=False
-    )
-    
     try:
-        # Run detection
-        # We need to capture stdout/stderr or just trust the function
-        # run_detect might raise FileNotFoundError if weights are missing
-        run_detect(args)
-        
-        # Read results
-        if os.path.exists(output_path):
-            with open(output_path, 'r') as f:
-                result = json.load(f)
+        if detector_name == 'ALL':
+            results = []
+            # Filter out 'ALL' from detectors list
+            real_detectors = [d for d in DETECTORS if d != 'ALL']
+            
+            for det in real_detectors:
+                res = run_single_detection(processed_path, det)
+                if res:
+                    results.append((det, res))
+            
+            if not results:
+                return "Error: No results obtained from detectors.", None
+            
+            votes_real = 0
+            votes_fake = 0
+            confidences = []
+            labels = []
+            colors = []
+            total_conf = 0
+            
+            for det, res in results:
+                pred = res.get('prediction', 'Unknown')
+                raw_conf = res.get('confidence', 0.0)
+                
+                # Calculate display confidence (confidence of the prediction)
+                if pred == 'fake':
+                    score = raw_conf
+                    color = 'red'
+                else:
+                    score = 1 - raw_conf
+                    color = 'green'
+                
+                labels.append(det)
+                confidences.append(score)
+                colors.append(color)
+                total_conf += score
+                
+                # Voting logic
+                if score > 0.6:
+                    if pred == 'fake':
+                        votes_fake += 1
+                    elif pred == 'real':
+                        votes_real += 1
             
-            # Format output
-            prediction = result.get('prediction', 'Unknown')
-            confidence = result.get('confidence', 0.0)
-            elapsed_time = result.get('elapsed_time', 0.0)
-            if prediction == 'fake':  
-                output = {
-                    "Prediction": prediction,
-                    "Confidence": f"{confidence:.4f}",
-                    "Elapsed Time": f"{elapsed_time:.3f}s"
-                }
+            # Majority Voting
+            if votes_real > votes_fake:
+                verdict = "REAL"
+            elif votes_fake > votes_real:
+                verdict = "FAKE"
             else:
-                output = {
-                    "Prediction": prediction,
-                    "Confidence": f"{1-confidence:.4f}",
-                    "Elapsed Time": f"{elapsed_time:.3f}s"
-                }
-            return json.dumps(output, indent=2)
+                verdict = "UNCERTAIN"
+            
+            avg_conf = total_conf / len(results) if results else 0
+            
+            # Explanation
+            if verdict == "REAL":
+                explanation = f"Considering the results obtained by all models, the analyzed image results, with an average confidence of {avg_conf:.4f}, not produced by a generative AI."
+            elif verdict == "FAKE":
+                explanation = f"Considering the results obtained by all models, the analyzed image results, with an average confidence of {avg_conf:.4f}, produced by a generative AI."
+            else:
+                explanation = f"The result is uncertain. The detectors produced unconsistent results. The average confidence is {avg_conf:.4f}."
+            
+            # Plotting
+            fig, ax = plt.subplots(figsize=(10, 5))
+            bars = ax.bar(labels, confidences, color=colors)
+            ax.set_ylim(0, 1.05)
+            ax.set_ylabel('Confidence')
+            ax.set_title('Detector Confidence Scores')
+            ax.axhline(y=0.6, color='gray', linestyle='--', alpha=0.5, label='Vote Threshold (0.6)')
+            ax.legend()
+            
+            # Add value labels
+            for bar in bars:
+                height = bar.get_height()
+                ax.text(bar.get_x() + bar.get_width()/2., height,
+                        f'{height:.2f}',
+                        ha='center', va='bottom')
+            
+            plt.tight_layout()
+            return explanation, fig
+            
         else:
-            return json.dumps({"error": "No result file generated. Check console logs for details."}, indent=2)
+            # Single Detector
+            res = run_single_detection(processed_path, detector_name)
             
-    except FileNotFoundError as e:
-        return json.dumps({
-            "error": str(e), 
-            "message": f"Please ensure you have downloaded the weights for {detector_name}."
-        }, indent=2)
+            if res:
+                prediction = res.get('prediction', 'Unknown')
+                confidence = res.get('confidence', 0.0)
+                elapsed_time = res.get('elapsed_time', 0.0)
+                
+                if prediction == 'fake':  
+                    output = {
+                        "Prediction": prediction,
+                        "Confidence": f"{confidence:.4f}",
+                        "Elapsed Time": f"{elapsed_time:.3f}s"
+                    }
+                else:
+                    output = {
+                        "Prediction": prediction,
+                        "Confidence": f"{1-confidence:.4f}",
+                        "Elapsed Time": f"{elapsed_time:.3f}s"
+                    }
+                return json.dumps(output, indent=2), None
+            else:
+                return json.dumps({"error": "Detection failed"}), None
+
     except Exception as e:
-        return json.dumps({"error": str(e)}, indent=2)
-    finally:
-        # Cleanup
-        if os.path.exists(output_path):
-            os.remove(output_path)
+        return json.dumps({"error": str(e)}), None
         
+    finally:
         # Cleanup cropped image if it's different from original
         if processed_path != image_path and os.path.exists(processed_path):
             try:
@@ -193,6 +281,7 @@ with demo:
                 max_lines=20,
                 show_copy_button=True
             )
+            plot_output = gr.Plot(label="Confidence Scores")
     
     with gr.Accordion("📚 Model Details", open=False):
         gr.Markdown("""
@@ -235,7 +324,7 @@ with demo:
     submit_btn.click(
         fn=predict,
         inputs=[image_input, detector_input],
-        outputs=output_display
+        outputs=[output_display, plot_output]
     )
 
 if __name__ == "__main__":

requirements.txt

@@ -13,6 +13,7 @@ pandas==2.2.3
 scikit-image==0.22.0
 scikit-learn==1.5.2
 numpy<2.0
+matplotlib
 
 # MLOps & Infrastructure
 wandb==0.16.6

verify_all_option.py

@@ -0,0 +1,93 @@
+import os
+from PIL import Image
+import matplotlib.pyplot as plt
+import json
+import sys
+from unittest.mock import patch
+
+# Add current directory to path
+sys.path.append(os.getcwd())
+
+import app
+from app import predict, DETECTORS
+
+def create_dummy_image(path):
+    img = Image.new('RGB', (512, 512), color = 'red')
+    img.save(path)
+    return path
+
+def mock_run_single_detection(image_path, detector_name):
+    # Mock results
+    results = {
+        'R50_TF': {'prediction': 'fake', 'confidence': 0.9, 'elapsed_time': 0.1},
+        'R50_nodown': {'prediction': 'real', 'confidence': 0.2, 'elapsed_time': 0.1}, # Score 0.8 (Real)
+        'CLIP-D': {'prediction': 'fake', 'confidence': 0.8, 'elapsed_time': 0.1},
+        'P2G': {'prediction': 'real', 'confidence': 0.45, 'elapsed_time': 0.1}, # Score 0.55 (Real) - Invalid Vote
+        'NPR': {'prediction': 'fake', 'confidence': 0.95, 'elapsed_time': 0.1}
+    }
+    return results.get(detector_name)
+
+def test_all_option():
+    print("Testing 'ALL' option with MOCKED results...")
+    img_path = create_dummy_image("test_image.jpg")
+    
+    with patch('app.run_single_detection', side_effect=mock_run_single_detection):
+        try:
+            # Run predict with 'ALL'
+            text, fig = predict(img_path, 'ALL')
+            
+            print(f"Output type: {type(text)}, {type(fig)}")
+            print(f"Text output: {text}")
+            
+            if isinstance(fig, plt.Figure):
+                print("Figure created successfully.")
+                # Optional: check plot content if needed
+            else:
+                print("Figure creation failed or None returned.")
+                
+            expected_verdict = "produced by a generative AI" # Majority Fake
+            if expected_verdict in text:
+                 print("Verdict seems correct (Fake majority).")
+            else:
+                 print(f"Unexpected verdict. Expected '{expected_verdict}' in text.")
+
+        except Exception as e:
+            print(f"Test failed with exception: {e}")
+        finally:
+            if os.path.exists(img_path):
+                os.remove(img_path)
+
+def test_single_option():
+    print("\nTesting 'R50_TF' option with MOCKED results...")
+    img_path = create_dummy_image("test_image_single.jpg")
+    
+    with patch('app.run_single_detection', side_effect=mock_run_single_detection):
+        try:
+            # Run predict with single detector
+            text, fig = predict(img_path, 'R50_TF')
+            
+            print(f"Output type: {type(text)}, {type(fig)}")
+            print(f"Text output: {text}")
+            
+            if fig is None:
+                print("Figure is None as expected.")
+            else:
+                print("Figure should be None for single detector.")
+                
+            try:
+                json_out = json.loads(text)
+                print("JSON output parsed successfully.")
+                if json_out.get("Prediction") == "fake":
+                    print("JSON content seems correct.")
+            except:
+                print("Failed to parse JSON output.")
+
+        except Exception as e:
+            print(f"Test failed with exception: {e}")
+        finally:
+            if os.path.exists(img_path):
+                os.remove(img_path)
+
+if __name__ == "__main__":
+    test_all_option()
+    test_single_option()