Add Git LFS configuration and update test files for Mac CPU compatibility

- Configure Git LFS to track CSV files
- Update test scripts for CPU-only inference on Mac
- Add latency measurements for model comparison
- Update result CSV files from testing

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

demo/app.py

@@ -1,6 +1,8 @@
 """
 Streamlit Demo: AI-Generated Image Detector
 Simple web interface for detecting AI-generated images using ARNIQA model.
+
+python3 -m streamlit run app.py --server.port=25000 --server.address=0.0.0.0
 """
 import streamlit as st
 from PIL import Image

functions/run_on_images_fn.py

@@ -273,9 +273,8 @@ def run_on_images(feature_extractor, classifier, config, test_real_images_paths,
 	# Global Variables: (feature_extractor)
 	global feature_extractor_module
 	feature_extractor_module = feature_extractor
-	# Use CPU for Mac compatibility (change to "cuda" if you have NVIDIA GPU)
-	device = "cpu"
-	feature_extractor_module.to(device)
+	# Detect device from feature extractor (it's already on the correct device)
+	device = next(feature_extractor_module.parameters()).device
 	feature_extractor_module.eval()
 	for params in feature_extractor_module.parameters():
 		params.requires_grad = False
@@ -287,10 +286,17 @@ def run_on_images(feature_extractor, classifier, config, test_real_images_paths,
 	Model = Model_LightningModule(classifier, config)
 
 	# PyTorch Lightning Trainer
-	# Override accelerator and devices for Mac compatibility
+	# Override accelerator based on detected device
 	trainer_config = config["trainer"].copy()
-	trainer_config["accelerator"] = "cpu"  # Use "cuda" for NVIDIA GPU, "mps" for Apple Silicon GPU
-	trainer_config["devices"] = 1  # CPU uses integer, GPU uses list like [0]
+	if device.type == "mps":
+		trainer_config["accelerator"] = "mps"
+		trainer_config["devices"] = 1
+	elif device.type == "cuda":
+		trainer_config["accelerator"] = "cuda"
+		trainer_config["devices"] = [device.index] if device.index is not None else [0]
+	else:  # cpu
+		trainer_config["accelerator"] = "cpu"
+		trainer_config["devices"] = 1
 	trainer = pl.Trainer(
 		**trainer_config,
 		callbacks=[best_checkpoint_callback, utils.LitProgressBar()],

test_all_models.py

@@ -1,169 +1,256 @@
 """
-Test all available models on the same image
+Test all available models on the same image with latency measurements
 """
 import os
 import sys
-
-# Available models - test all 5 IQA-based models
-models = ['contrique', 'hyperiqa', 'tres', 'reiqa', 'arniqa']
-
-# Test images directory
-test_images_dir = "new_images_to_test"
-
-# Get all images from the directory
-import glob
-image_extensions = ['*.jpg', '*.jpeg', '*.png', '*.JPG', '*.JPEG', '*.PNG']
-test_images = []
-for ext in image_extensions:
-    test_images.extend(glob.glob(os.path.join(test_images_dir, ext)))
-
-if not test_images:
-    print(f"Error: No images found in {test_images_dir}/")
-    sys.exit(1)
-
-print(f"Found {len(test_images)} image(s) in {test_images_dir}/")
-print("=" * 80)
-
-# Import libraries once
-sys.path.insert(0, '.')
-from yaml import safe_load
-from functions.loss_optimizers_metrics import *
-from functions.run_on_images_fn import run_on_images
-import functions.utils as utils
-import functions.networks as networks
-import defaults
-import warnings
-warnings.filterwarnings("ignore")
-
-all_results = {}
-
-# Test each model
-for model_idx, model_name in enumerate(models, 1):
-    print(f"\n{'='*80}")
-    print(f"[{model_idx}/{len(models)}] Testing model: {model_name.upper()}")
+import time
+
+if __name__ == '__main__':
+    # Available models - test all 5 IQA-based models
+    models = ['contrique','hyperiqa', 'tres', 'arniqa', 'reiqa']
+    models = ['reiqa']
+    # models = ['reiqa', 'arniqa']
+    # models = ['contrique', 'hyperiqa', 'tres', 'reiqa', 'arniqa']
+
+    """
+      ---
+  Summary Table - All Models
+
+  | Model     | Image 1 (11.14.39 PM) | Image 2 (5.50.50
+  PM)  | Verdict                     |
+  |-----------|-----------------------|--------------------
+  ---|-----------------------------|
+  | CONTRIQUE | 0.7931 (AI - 58.6%)   | 0.6332 (AI - 26.6%)
+     | ✓ Both AI-Generated         |
+  | HYPERIQA  | 0.7602 (AI - 52.0%)   | 0.8179 (AI - 63.6%)
+     | ✓ Both AI-Generated         |
+  | TRES      | ❌ Failed              | ❌ Failed
+       | Model incompatible with CPU |
+  | REIQA     | 0.3500 (Real - 30.0%) | 0.2416 (Real -
+  51.7%) | ✗ Both Real                 |
+  | ARNIQA    | 0.7133 (AI - 42.7%)   | 0.9605 (AI - 92.1%)
+     | ✓ Both AI-Generated         |
+
+  ---
+    """
+
+    # Test images directory
+    test_images_dir = "new_images_to_test"
+
+    # Get all images from the directory
+    import glob
+    image_extensions = ['*.jpg', '*.jpeg', '*.png', '*.JPG', '*.JPEG', '*.PNG']
+    test_images = []
+    for ext in image_extensions:
+        test_images.extend([os.path.abspath(p) for p in glob.glob(os.path.join(test_images_dir, ext))])
+
+    if not test_images:
+        print(f"Error: No images found in {test_images_dir}/")
+        sys.exit(1)
+
+    print(f"Found {len(test_images)} image(s) in {test_images_dir}/")
+    print("=" * 80)
+
+    # Import libraries once
+    sys.path.insert(0, '.')
+    from yaml import safe_load
+    from functions.loss_optimizers_metrics import *
+    from functions.run_on_images_fn import run_on_images
+    import functions.utils as utils
+    import functions.networks as networks
+    import defaults
+    import warnings
+    warnings.filterwarnings("ignore")
+
+    all_results = {}
+    latency_stats = {}
+
+    # Test each model
+    for model_idx, model_name in enumerate(models, 1):
+        print(f"\n{'='*80}")
+        print(f"[{model_idx}/{len(models)}] Testing model: {model_name.upper()}")
+        print("="*80)
+
+        # Start timing model loading
+        model_load_start = time.time()
+
+        try:
+            config_path = f"configs/{model_name}.yaml"
+            config = safe_load(open(config_path, "r"))
+
+            # Override settings
+            config["dataset"]["dataset_type"] = "GenImage"
+            config["checkpoints"]["resume_dirname"] = "GenImage/extensive/MarginContrastiveLoss_CrossEntropy"
+            config["checkpoints"]["resume_filename"] = "best_model.ckpt"
+            config["checkpoints"]["checkpoint_dirname"] = "extensive/MarginContrastiveLoss_CrossEntropy"
+            config["checkpoints"]["checkpoint_filename"] = "best_model.ckpt"
+
+            # Training settings (for testing)
+            config["train_settings"]["train"] = False
+            config["train_loss_fn"]["name"] = "CrossEntropy"
+            config["val_loss_fn"]["name"] = "CrossEntropy"
+
+            # Model setup - use CPU (MPS has compatibility issues)
+            device = "cpu"
+            feature_extractor = networks.get_model(model_name=model_name, device=device)
+
+            # Classifier
+            config["classifier"]["hidden_layers"] = [1024]
+            classifier = networks.Classifier_Arch2(
+                input_dim=config["classifier"]["input_dim"],
+                hidden_layers=config["classifier"]["hidden_layers"]
+            )
+
+            # Preprocessing settings
+            preprocess_settings = {
+                "model_name": model_name,
+                "selected_transforms_name": "test",
+                "probability": -1,
+                "gaussian_blur_range": None,
+                "jpeg_compression_qfs": None,
+                "input_image_dimensions": (224, 224),
+                "resize": None
+            }
+
+            model_load_time = time.time() - model_load_start
+            print(f"✓ {model_name.upper()} model loaded successfully (Load time: {model_load_time:.3f}s)\n")
+
+            results = []
+            inference_times = []
+
+            # Test each image with this model
+            for idx, test_image in enumerate(test_images, 1):
+                image_name = os.path.basename(test_image)
+                print(f"  [{idx}/{len(test_images)}] Testing: {image_name}")
+
+                # Test images
+                test_real_images_paths = [test_image]
+                test_fake_images_paths = []
+
+                try:
+                    # Start timing inference
+                    inference_start = time.time()
+
+                    test_set_metrics, best_threshold, y_pred, y_true = run_on_images(
+                        feature_extractor=feature_extractor,
+                        classifier=classifier,
+                        config=config,
+                        test_real_images_paths=test_real_images_paths,
+                        test_fake_images_paths=test_fake_images_paths,
+                        preprocess_settings=preprocess_settings,
+                        best_threshold=0.5,
+                        verbose=False
+                    )
+
+                    inference_time = time.time() - inference_start
+                    inference_times.append(inference_time)
+
+                    score = y_pred[0] if len(y_pred) > 0 else None
+                    prediction = "AI-Generated" if score and score > 0.5 else "Real"
+                    confidence = abs(score - 0.5) * 200 if score else 0
+
+                    results.append({
+                        'image': image_name,
+                        'score': score,
+                        'prediction': prediction,
+                        'confidence': confidence,
+                        'inference_time': inference_time
+                    })
+
+                    print(f"    ✓ Score: {score:.4f} → {prediction} ({confidence:.1f}% confidence) | Time: {inference_time:.3f}s")
+
+                except Exception as e:
+                    print(f"    ✗ Error: {e}")
+                    results.append({
+                        'image': image_name,
+                        'score': None,
+                        'prediction': 'Error',
+                        'confidence': 0,
+                        'inference_time': None
+                    })
+
+            all_results[model_name] = results
+
+            # Store latency statistics
+            if inference_times:
+                latency_stats[model_name] = {
+                    'model_load_time': model_load_time,
+                    'avg_inference_time': sum(inference_times) / len(inference_times),
+                    'min_inference_time': min(inference_times),
+                    'max_inference_time': max(inference_times),
+                    'total_inference_time': sum(inference_times),
+                    'num_images': len(inference_times)
+                }
+
+        except Exception as e:
+            print(f"✗ Failed to load {model_name.upper()} model: {e}")
+            all_results[model_name] = None
+
+    # Final Summary
+    print("\n" + "="*80)
+    print("FINAL SUMMARY - ALL MODELS")
     print("="*80)
 
-    try:
-        config_path = f"configs/{model_name}.yaml"
-        config = safe_load(open(config_path, "r"))
-
-        # Override settings
-        config["dataset"]["dataset_type"] = "GenImage"
-        config["checkpoints"]["resume_dirname"] = "GenImage/extensive/MarginContrastiveLoss_CrossEntropy"
-        config["checkpoints"]["resume_filename"] = "best_model.ckpt"
-        config["checkpoints"]["checkpoint_dirname"] = "extensive/MarginContrastiveLoss_CrossEntropy"
-        config["checkpoints"]["checkpoint_filename"] = "best_model.ckpt"
-
-        # Training settings (for testing)
-        config["train_settings"]["train"] = False
-        config["train_loss_fn"]["name"] = "CrossEntropy"
-        config["val_loss_fn"]["name"] = "CrossEntropy"
-
-        # Model setup
-        device = "cpu"
-        feature_extractor = networks.get_model(model_name=model_name, device=device)
-
-        # Classifier
-        config["classifier"]["hidden_layers"] = [1024]
-        classifier = networks.Classifier_Arch2(
-            input_dim=config["classifier"]["input_dim"],
-            hidden_layers=config["classifier"]["hidden_layers"]
-        )
-
-        # Preprocessing settings
-        preprocess_settings = {
-            "model_name": model_name,
-            "selected_transforms_name": "test",
-            "probability": -1,
-            "gaussian_blur_range": None,
-            "jpeg_compression_qfs": None,
-            "input_image_dimensions": (224, 224),
-            "resize": None
-        }
-
-        print(f"✓ {model_name.upper()} model loaded successfully\n")
-
-        results = []
-
-        # Test each image with this model
-        for idx, test_image in enumerate(test_images, 1):
-            image_name = os.path.basename(test_image)
-            print(f"  [{idx}/{len(test_images)}] Testing: {image_name}")
-
-            # Test images
-            test_real_images_paths = [test_image]
-            test_fake_images_paths = []
-
-            try:
-                test_set_metrics, best_threshold, y_pred, y_true = run_on_images(
-                    feature_extractor=feature_extractor,
-                    classifier=classifier,
-                    config=config,
-                    test_real_images_paths=test_real_images_paths,
-                    test_fake_images_paths=test_fake_images_paths,
-                    preprocess_settings=preprocess_settings,
-                    best_threshold=0.5,
-                    verbose=False
-                )
-
-                score = y_pred[0] if len(y_pred) > 0 else None
-                prediction = "AI-Generated" if score and score > 0.5 else "Real"
-                confidence = abs(score - 0.5) * 200 if score else 0
-
-                results.append({
-                    'image': image_name,
-                    'score': score,
-                    'prediction': prediction,
-                    'confidence': confidence
-                })
-
-                print(f"    ✓ Score: {score:.4f} → {prediction} ({confidence:.1f}% confidence)")
-
-            except Exception as e:
-                print(f"    ✗ Error: {e}")
-                results.append({
-                    'image': image_name,
-                    'score': None,
-                    'prediction': 'Error',
-                    'confidence': 0
-                })
-
-        all_results[model_name] = results
-
-    except Exception as e:
-        print(f"✗ Failed to load {model_name.upper()} model: {e}")
-        all_results[model_name] = None
-
-# Final Summary
-print("\n" + "="*80)
-print("FINAL SUMMARY - ALL MODELS")
-print("="*80)
-
-for model_name, results in all_results.items():
-    if results is None:
-        print(f"\n{model_name.upper()}: Failed to load")
-        continue
-
-    print(f"\n{model_name.upper()}:")
-    print("-"*80)
-    print(f"{'Image':<50} {'Score':<10} {'Prediction':<15} {'Confidence':<12}")
-    print("-"*80)
-
-    for r in results:
-        score_str = f"{r['score']:.4f}" if r['score'] is not None else "N/A"
-        conf_str = f"{r['confidence']:.1f}%" if r['score'] is not None else "N/A"
-        img_name = r['image'][:47] + "..." if len(r['image']) > 50 else r['image']
-        print(f"{img_name:<50} {score_str:<10} {r['prediction']:<15} {conf_str:<12}")
-
-    # Statistics
-    valid_predictions = [r for r in results if r['score'] is not None]
-    if valid_predictions:
-        avg_score = sum(r['score'] for r in valid_predictions) / len(valid_predictions)
-        ai_count = sum(1 for r in valid_predictions if r['score'] > 0.5)
-        real_count = len(valid_predictions) - ai_count
-        avg_confidence = sum(r['confidence'] for r in valid_predictions) / len(valid_predictions)
+    for model_name, results in all_results.items():
+        if results is None:
+            print(f"\n{model_name.upper()}: Failed to load")
+            continue
+
+        print(f"\n{model_name.upper()}:")
+        print("-"*80)
+        print(f"{'Image':<50} {'Score':<10} {'Prediction':<15} {'Confidence':<12}")
+        print("-"*80)
+
+        for r in results:
+            score_str = f"{r['score']:.4f}" if r['score'] is not None else "N/A"
+            conf_str = f"{r['confidence']:.1f}%" if r['score'] is not None else "N/A"
+            img_name = r['image'][:47] + "..." if len(r['image']) > 50 else r['image']
+            print(f"{img_name:<50} {score_str:<10} {r['prediction']:<15} {conf_str:<12}")
+
+        # Statistics
+        valid_predictions = [r for r in results if r['score'] is not None]
+        if valid_predictions:
+            avg_score = sum(r['score'] for r in valid_predictions) / len(valid_predictions)
+            ai_count = sum(1 for r in valid_predictions if r['score'] > 0.5)
+            real_count = len(valid_predictions) - ai_count
+            avg_confidence = sum(r['confidence'] for r in valid_predictions) / len(valid_predictions)
+
+            print("-"*80)
+            print(f"Average Score: {avg_score:.4f} | AI: {ai_count} | Real: {real_count} | Avg Confidence: {avg_confidence:.1f}%")
+
+    # Latency Summary
+    print("\n" + "="*80)
+    print("LATENCY PERFORMANCE COMPARISON")
+    print("="*80)
 
+    if latency_stats:
+        print(f"\n{'Model':<15} {'Load Time':<12} {'Avg Inference':<15} {'Min':<10} {'Max':<10} {'Total':<12}")
         print("-"*80)
-        print(f"Average Score: {avg_score:.4f} | AI: {ai_count} | Real: {real_count} | Avg Confidence: {avg_confidence:.1f}%")
 
-print("\n" + "="*80)
+        for model_name, stats in latency_stats.items():
+            print(f"{model_name.upper():<15} "
+                  f"{stats['model_load_time']:<12.3f} "
+                  f"{stats['avg_inference_time']:<15.3f} "
+                  f"{stats['min_inference_time']:<10.3f} "
+                  f"{stats['max_inference_time']:<10.3f} "
+                  f"{stats['total_inference_time']:<12.3f}")
+
+        print("\n" + "-"*80)
+        print("Timing units: seconds (s)")
+        print("Load Time: Time to load model and classifier")
+        print("Avg Inference: Average time per image inference")
+        print("Min/Max: Fastest/slowest single image inference")
+        print("Total: Total time for all images")
+
+        # Find fastest model
+        fastest_model = min(latency_stats.items(), key=lambda x: x[1]['avg_inference_time'])
+        slowest_model = max(latency_stats.items(), key=lambda x: x[1]['avg_inference_time'])
+
+        print("\n" + "-"*80)
+        print(f"⚡ Fastest Model: {fastest_model[0].upper()} ({fastest_model[1]['avg_inference_time']:.3f}s per image)")
+        print(f"🐌 Slowest Model: {slowest_model[0].upper()} ({slowest_model[1]['avg_inference_time']:.3f}s per image)")
+
+        speedup = slowest_model[1]['avg_inference_time'] / fastest_model[1]['avg_inference_time']
+        print(f"📊 Speed Difference: {speedup:.2f}x faster")
+
+    print("\n" + "="*80)

test_all_models.py.bak2

@@ -0,0 +1,170 @@
+"""
+Test all available models on the same image
+"""
+import os
+import sys
+
+if __name__ == '__main__':
+    # Available models - test all 5 IQA-based models
+    models = ['contrique', 'hyperiqa', 'tres', 'reiqa', 'arniqa']
+
+    # Test images directory
+    test_images_dir = "new_images_to_test"
+
+    # Get all images from the directory
+    import glob
+    image_extensions = ['*.jpg', '*.jpeg', '*.png', '*.JPG', '*.JPEG', '*.PNG']
+    test_images = []
+    for ext in image_extensions:
+        test_images.extend(glob.glob(os.path.join(test_images_dir, ext)))
+
+    if not test_images:
+        print(f"Error: No images found in {test_images_dir}/")
+        sys.exit(1)
+
+    print(f"Found {len(test_images)} image(s) in {test_images_dir}/")
+    print("=" * 80)
+
+    # Import libraries once
+    sys.path.insert(0, '.')
+    from yaml import safe_load
+    from functions.loss_optimizers_metrics import *
+    from functions.run_on_images_fn import run_on_images
+    import functions.utils as utils
+    import functions.networks as networks
+    import defaults
+    import warnings
+    warnings.filterwarnings("ignore")
+
+    all_results = {}
+
+    # Test each model
+    for model_idx, model_name in enumerate(models, 1):
+    print(f"\n{'='*80}")
+    print(f"[{model_idx}/{len(models)}] Testing model: {model_name.upper()}")
+    print("="*80)
+
+    try:
+        config_path = f"configs/{model_name}.yaml"
+        config = safe_load(open(config_path, "r"))
+
+        # Override settings
+        config["dataset"]["dataset_type"] = "GenImage"
+        config["checkpoints"]["resume_dirname"] = "GenImage/extensive/MarginContrastiveLoss_CrossEntropy"
+        config["checkpoints"]["resume_filename"] = "best_model.ckpt"
+        config["checkpoints"]["checkpoint_dirname"] = "extensive/MarginContrastiveLoss_CrossEntropy"
+        config["checkpoints"]["checkpoint_filename"] = "best_model.ckpt"
+
+        # Training settings (for testing)
+        config["train_settings"]["train"] = False
+        config["train_loss_fn"]["name"] = "CrossEntropy"
+        config["val_loss_fn"]["name"] = "CrossEntropy"
+
+        # Model setup - use CPU (MPS has compatibility issues)
+        device = "cpu"
+        feature_extractor = networks.get_model(model_name=model_name, device=device)
+
+        # Classifier
+        config["classifier"]["hidden_layers"] = [1024]
+        classifier = networks.Classifier_Arch2(
+            input_dim=config["classifier"]["input_dim"],
+            hidden_layers=config["classifier"]["hidden_layers"]
+        )
+
+        # Preprocessing settings
+        preprocess_settings = {
+            "model_name": model_name,
+            "selected_transforms_name": "test",
+            "probability": -1,
+            "gaussian_blur_range": None,
+            "jpeg_compression_qfs": None,
+            "input_image_dimensions": (224, 224),
+            "resize": None
+        }
+
+        print(f"✓ {model_name.upper()} model loaded successfully\n")
+
+        results = []
+
+        # Test each image with this model
+        for idx, test_image in enumerate(test_images, 1):
+            image_name = os.path.basename(test_image)
+            print(f"  [{idx}/{len(test_images)}] Testing: {image_name}")
+
+            # Test images
+            test_real_images_paths = [test_image]
+            test_fake_images_paths = []
+
+            try:
+                test_set_metrics, best_threshold, y_pred, y_true = run_on_images(
+                    feature_extractor=feature_extractor,
+                    classifier=classifier,
+                    config=config,
+                    test_real_images_paths=test_real_images_paths,
+                    test_fake_images_paths=test_fake_images_paths,
+                    preprocess_settings=preprocess_settings,
+                    best_threshold=0.5,
+                    verbose=False
+                )
+
+                score = y_pred[0] if len(y_pred) > 0 else None
+                prediction = "AI-Generated" if score and score > 0.5 else "Real"
+                confidence = abs(score - 0.5) * 200 if score else 0
+
+                results.append({
+                    'image': image_name,
+                    'score': score,
+                    'prediction': prediction,
+                    'confidence': confidence
+                })
+
+                print(f"    ✓ Score: {score:.4f} → {prediction} ({confidence:.1f}% confidence)")
+
+            except Exception as e:
+                print(f"    ✗ Error: {e}")
+                results.append({
+                    'image': image_name,
+                    'score': None,
+                    'prediction': 'Error',
+                    'confidence': 0
+                })
+
+        all_results[model_name] = results
+
+    except Exception as e:
+        print(f"✗ Failed to load {model_name.upper()} model: {e}")
+        all_results[model_name] = None
+
+# Final Summary
+print("\n" + "="*80)
+print("FINAL SUMMARY - ALL MODELS")
+print("="*80)
+
+for model_name, results in all_results.items():
+    if results is None:
+        print(f"\n{model_name.upper()}: Failed to load")
+        continue
+
+    print(f"\n{model_name.upper()}:")
+    print("-"*80)
+    print(f"{'Image':<50} {'Score':<10} {'Prediction':<15} {'Confidence':<12}")
+    print("-"*80)
+
+    for r in results:
+        score_str = f"{r['score']:.4f}" if r['score'] is not None else "N/A"
+        conf_str = f"{r['confidence']:.1f}%" if r['score'] is not None else "N/A"
+        img_name = r['image'][:47] + "..." if len(r['image']) > 50 else r['image']
+        print(f"{img_name:<50} {score_str:<10} {r['prediction']:<15} {conf_str:<12}")
+
+    # Statistics
+    valid_predictions = [r for r in results if r['score'] is not None]
+    if valid_predictions:
+        avg_score = sum(r['score'] for r in valid_predictions) / len(valid_predictions)
+        ai_count = sum(1 for r in valid_predictions if r['score'] > 0.5)
+        real_count = len(valid_predictions) - ai_count
+        avg_confidence = sum(r['confidence'] for r in valid_predictions) / len(valid_predictions)
+
+        print("-"*80)
+        print(f"Average Score: {avg_score:.4f} | AI: {ai_count} | Real: {real_count} | Avg Confidence: {avg_confidence:.1f}%")
+
+print("\n" + "="*80)

test_all_models_original.py

@@ -0,0 +1,170 @@
+"""
+Test all available models on the same image
+"""
+import os
+import sys
+
+if __name__ == '__main__':
+    # Available models - test all 5 IQA-based models
+    models = ['contrique', 'hyperiqa', 'tres', 'reiqa', 'arniqa']
+
+    # Test images directory
+    test_images_dir = "new_images_to_test"
+
+    # Get all images from the directory
+    import glob
+    image_extensions = ['*.jpg', '*.jpeg', '*.png', '*.JPG', '*.JPEG', '*.PNG']
+    test_images = []
+    for ext in image_extensions:
+        test_images.extend(glob.glob(os.path.join(test_images_dir, ext)))
+
+    if not test_images:
+        print(f"Error: No images found in {test_images_dir}/")
+        sys.exit(1)
+
+    print(f"Found {len(test_images)} image(s) in {test_images_dir}/")
+    print("=" * 80)
+
+    # Import libraries once
+    sys.path.insert(0, '.')
+    from yaml import safe_load
+    from functions.loss_optimizers_metrics import *
+    from functions.run_on_images_fn import run_on_images
+    import functions.utils as utils
+    import functions.networks as networks
+    import defaults
+    import warnings
+    warnings.filterwarnings("ignore")
+
+    all_results = {}
+
+    # Test each model
+    for model_idx, model_name in enumerate(models, 1):
+    print(f"\n{'='*80}")
+    print(f"[{model_idx}/{len(models)}] Testing model: {model_name.upper()}")
+    print("="*80)
+
+    try:
+        config_path = f"configs/{model_name}.yaml"
+        config = safe_load(open(config_path, "r"))
+
+        # Override settings
+        config["dataset"]["dataset_type"] = "GenImage"
+        config["checkpoints"]["resume_dirname"] = "GenImage/extensive/MarginContrastiveLoss_CrossEntropy"
+        config["checkpoints"]["resume_filename"] = "best_model.ckpt"
+        config["checkpoints"]["checkpoint_dirname"] = "extensive/MarginContrastiveLoss_CrossEntropy"
+        config["checkpoints"]["checkpoint_filename"] = "best_model.ckpt"
+
+        # Training settings (for testing)
+        config["train_settings"]["train"] = False
+        config["train_loss_fn"]["name"] = "CrossEntropy"
+        config["val_loss_fn"]["name"] = "CrossEntropy"
+
+        # Model setup - use CPU (MPS has compatibility issues)
+        device = "cpu"
+        feature_extractor = networks.get_model(model_name=model_name, device=device)
+
+        # Classifier
+        config["classifier"]["hidden_layers"] = [1024]
+        classifier = networks.Classifier_Arch2(
+            input_dim=config["classifier"]["input_dim"],
+            hidden_layers=config["classifier"]["hidden_layers"]
+        )
+
+        # Preprocessing settings
+        preprocess_settings = {
+            "model_name": model_name,
+            "selected_transforms_name": "test",
+            "probability": -1,
+            "gaussian_blur_range": None,
+            "jpeg_compression_qfs": None,
+            "input_image_dimensions": (224, 224),
+            "resize": None
+        }
+
+        print(f"✓ {model_name.upper()} model loaded successfully\n")
+
+        results = []
+
+        # Test each image with this model
+        for idx, test_image in enumerate(test_images, 1):
+            image_name = os.path.basename(test_image)
+            print(f"  [{idx}/{len(test_images)}] Testing: {image_name}")
+
+            # Test images
+            test_real_images_paths = [test_image]
+            test_fake_images_paths = []
+
+            try:
+                test_set_metrics, best_threshold, y_pred, y_true = run_on_images(
+                    feature_extractor=feature_extractor,
+                    classifier=classifier,
+                    config=config,
+                    test_real_images_paths=test_real_images_paths,
+                    test_fake_images_paths=test_fake_images_paths,
+                    preprocess_settings=preprocess_settings,
+                    best_threshold=0.5,
+                    verbose=False
+                )
+
+                score = y_pred[0] if len(y_pred) > 0 else None
+                prediction = "AI-Generated" if score and score > 0.5 else "Real"
+                confidence = abs(score - 0.5) * 200 if score else 0
+
+                results.append({
+                    'image': image_name,
+                    'score': score,
+                    'prediction': prediction,
+                    'confidence': confidence
+                })
+
+                print(f"    ✓ Score: {score:.4f} → {prediction} ({confidence:.1f}% confidence)")
+
+            except Exception as e:
+                print(f"    ✗ Error: {e}")
+                results.append({
+                    'image': image_name,
+                    'score': None,
+                    'prediction': 'Error',
+                    'confidence': 0
+                })
+
+        all_results[model_name] = results
+
+    except Exception as e:
+        print(f"✗ Failed to load {model_name.upper()} model: {e}")
+        all_results[model_name] = None
+
+# Final Summary
+print("\n" + "="*80)
+print("FINAL SUMMARY - ALL MODELS")
+print("="*80)
+
+for model_name, results in all_results.items():
+    if results is None:
+        print(f"\n{model_name.upper()}: Failed to load")
+        continue
+
+    print(f"\n{model_name.upper()}:")
+    print("-"*80)
+    print(f"{'Image':<50} {'Score':<10} {'Prediction':<15} {'Confidence':<12}")
+    print("-"*80)
+
+    for r in results:
+        score_str = f"{r['score']:.4f}" if r['score'] is not None else "N/A"
+        conf_str = f"{r['confidence']:.1f}%" if r['score'] is not None else "N/A"
+        img_name = r['image'][:47] + "..." if len(r['image']) > 50 else r['image']
+        print(f"{img_name:<50} {score_str:<10} {r['prediction']:<15} {conf_str:<12}")
+
+    # Statistics
+    valid_predictions = [r for r in results if r['score'] is not None]
+    if valid_predictions:
+        avg_score = sum(r['score'] for r in valid_predictions) / len(valid_predictions)
+        ai_count = sum(1 for r in valid_predictions if r['score'] > 0.5)
+        real_count = len(valid_predictions) - ai_count
+        avg_confidence = sum(r['confidence'] for r in valid_predictions) / len(valid_predictions)
+
+        print("-"*80)
+        print(f"Average Score: {avg_score:.4f} | AI: {ai_count} | Real: {real_count} | Avg Confidence: {avg_confidence:.1f}%")
+
+print("\n" + "="*80)

test_mps_compatibility.py

@@ -0,0 +1,137 @@
+"""
+Test MPS compatibility for each model individually
+"""
+import os
+import sys
+import glob
+import torch
+from yaml import safe_load
+import functions.networks as networks
+from functions.run_on_images_fn import run_on_images
+import warnings
+warnings.filterwarnings("ignore")
+
+if __name__ == '__main__':
+    # Get test images
+    test_images_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "new_images_to_test")
+    image_extensions = ['*.jpg', '*.jpeg', '*.png', '*.JPG', '*.JPEG', '*.PNG']
+    test_images = []
+    for ext in image_extensions:
+        test_images.extend([os.path.abspath(p) for p in glob.glob(os.path.join(test_images_dir, ext))])
+
+    if not test_images:
+        print("No test images found!")
+        sys.exit(1)
+
+    # Test one image for each model
+    test_image = test_images[0]
+    print(f"Testing with image: {os.path.basename(test_image)}\n")
+
+    # Available models
+    models = ['contrique', 'hyperiqa', 'tres', 'reiqa', 'arniqa']
+
+    # Check MPS availability
+    if not torch.backends.mps.is_available():
+        print("MPS not available on this system!")
+        sys.exit(1)
+
+    print(f"MPS is available. Built: {torch.backends.mps.is_built()}\n")
+    print("="*80)
+
+    results = {}
+
+    for model_name in models:
+        print(f"\nTesting model: {model_name.upper()}")
+        print("-"*80)
+
+        try:
+            # Load config
+            config_path = f"configs/{model_name}.yaml"
+            config = safe_load(open(config_path, "r"))
+
+            # Override settings
+            config["dataset"]["dataset_type"] = "GenImage"
+            config["checkpoints"]["resume_dirname"] = "GenImage/extensive/MarginContrastiveLoss_CrossEntropy"
+            config["checkpoints"]["resume_filename"] = "best_model.ckpt"
+            config["checkpoints"]["checkpoint_dirname"] = "extensive/MarginContrastiveLoss_CrossEntropy"
+            config["checkpoints"]["checkpoint_filename"] = "best_model.ckpt"
+            config["train_settings"]["train"] = False
+            config["train_loss_fn"]["name"] = "CrossEntropy"
+            config["val_loss_fn"]["name"] = "CrossEntropy"
+
+            # Try with MPS
+            device = "mps"
+            print(f"  Loading model on {device}...")
+            feature_extractor = networks.get_model(model_name=model_name, device=device)
+
+            # Classifier
+            config["classifier"]["hidden_layers"] = [1024]
+            classifier = networks.Classifier_Arch2(
+                input_dim=config["classifier"]["input_dim"],
+                hidden_layers=config["classifier"]["hidden_layers"]
+            )
+
+            # Preprocessing settings
+            preprocess_settings = {
+                "model_name": model_name,
+                "selected_transforms_name": "test",
+                "probability": -1,
+                "gaussian_blur_range": None,
+                "jpeg_compression_qfs": None,
+                "input_image_dimensions": (224, 224),
+                "resize": None
+            }
+
+            print(f"  Running inference...")
+
+            # Test on single image
+            test_real_images_paths = [test_image]
+            test_fake_images_paths = []
+
+            test_set_metrics, best_threshold, y_pred, y_true = run_on_images(
+                feature_extractor=feature_extractor,
+                classifier=classifier,
+                config=config,
+                test_real_images_paths=test_real_images_paths,
+                test_fake_images_paths=test_fake_images_paths,
+                preprocess_settings=preprocess_settings,
+                best_threshold=0.5,
+                verbose=False
+            )
+
+            score = y_pred[0] if len(y_pred) > 0 else None
+            prediction = "AI-Generated" if score and score > 0.5 else "Real"
+
+            print(f"  ✓ SUCCESS - Score: {score:.4f} → {prediction}")
+            results[model_name] = {"status": "SUCCESS", "score": score, "prediction": prediction, "error": None}
+
+        except Exception as e:
+            error_msg = str(e)
+            print(f"  ✗ FAILED - {error_msg[:100]}")
+            results[model_name] = {"status": "FAILED", "score": None, "prediction": None, "error": error_msg}
+
+# Summary
+print("\n" + "="*80)
+print("MPS COMPATIBILITY SUMMARY")
+print("="*80)
+
+successful = []
+failed = []
+
+for model_name, result in results.items():
+        status_icon = "✓" if result["status"] == "SUCCESS" else "✗"
+        print(f"{status_icon} {model_name.upper():<12} - {result['status']}")
+        if result["status"] == "SUCCESS":
+            successful.append(model_name)
+            print(f"   Score: {result['score']:.4f} → {result['prediction']}")
+        else:
+            failed.append(model_name)
+            # Print first line of error
+            error_line = result['error'].split('\n')[0]
+            print(f"   Error: {error_line[:70]}")
+
+print("\n" + "="*80)
+print(f"Summary: {len(successful)} successful, {len(failed)} failed")
+print(f"MPS-compatible models: {', '.join([m.upper() for m in successful]) if successful else 'None'}")
+print(f"CPU-only models: {', '.join([m.upper() for m in failed]) if failed else 'None'}")
+print("="*80)

test_mps_compatibility.py.bak

@@ -0,0 +1,137 @@
+"""
+Test MPS compatibility for each model individually
+"""
+import os
+import sys
+import glob
+import torch
+from yaml import safe_load
+import functions.networks as networks
+from functions.run_on_images_fn import run_on_images
+import warnings
+warnings.filterwarnings("ignore")
+
+if __name__ == '__main__':
+    # Get test images
+    test_images_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "new_images_to_test")
+    image_extensions = ['*.jpg', '*.jpeg', '*.png', '*.JPG', '*.JPEG', '*.PNG']
+    test_images = []
+    for ext in image_extensions:
+        test_images.extend([os.path.abspath(p) for p in glob.glob(os.path.join(test_images_dir, ext))])
+
+    if not test_images:
+        print("No test images found!")
+        sys.exit(1)
+
+    # Test one image for each model
+    test_image = test_images[0]
+    print(f"Testing with image: {os.path.basename(test_image)}\n")
+
+    # Available models
+    models = ['contrique', 'hyperiqa', 'tres', 'reiqa', 'arniqa']
+
+    # Check MPS availability
+    if not torch.backends.mps.is_available():
+        print("MPS not available on this system!")
+        sys.exit(1)
+
+    print(f"MPS is available. Built: {torch.backends.mps.is_built()}\n")
+    print("="*80)
+
+    results = {}
+
+    for model_name in models:
+    print(f"\nTesting model: {model_name.upper()}")
+    print("-"*80)
+
+    try:
+        # Load config
+        config_path = f"configs/{model_name}.yaml"
+        config = safe_load(open(config_path, "r"))
+
+        # Override settings
+        config["dataset"]["dataset_type"] = "GenImage"
+        config["checkpoints"]["resume_dirname"] = "GenImage/extensive/MarginContrastiveLoss_CrossEntropy"
+        config["checkpoints"]["resume_filename"] = "best_model.ckpt"
+        config["checkpoints"]["checkpoint_dirname"] = "extensive/MarginContrastiveLoss_CrossEntropy"
+        config["checkpoints"]["checkpoint_filename"] = "best_model.ckpt"
+        config["train_settings"]["train"] = False
+        config["train_loss_fn"]["name"] = "CrossEntropy"
+        config["val_loss_fn"]["name"] = "CrossEntropy"
+
+        # Try with MPS
+        device = "mps"
+        print(f"  Loading model on {device}...")
+        feature_extractor = networks.get_model(model_name=model_name, device=device)
+
+        # Classifier
+        config["classifier"]["hidden_layers"] = [1024]
+        classifier = networks.Classifier_Arch2(
+            input_dim=config["classifier"]["input_dim"],
+            hidden_layers=config["classifier"]["hidden_layers"]
+        )
+
+        # Preprocessing settings
+        preprocess_settings = {
+            "model_name": model_name,
+            "selected_transforms_name": "test",
+            "probability": -1,
+            "gaussian_blur_range": None,
+            "jpeg_compression_qfs": None,
+            "input_image_dimensions": (224, 224),
+            "resize": None
+        }
+
+        print(f"  Running inference...")
+
+        # Test on single image
+        test_real_images_paths = [test_image]
+        test_fake_images_paths = []
+
+        test_set_metrics, best_threshold, y_pred, y_true = run_on_images(
+            feature_extractor=feature_extractor,
+            classifier=classifier,
+            config=config,
+            test_real_images_paths=test_real_images_paths,
+            test_fake_images_paths=test_fake_images_paths,
+            preprocess_settings=preprocess_settings,
+            best_threshold=0.5,
+            verbose=False
+        )
+
+        score = y_pred[0] if len(y_pred) > 0 else None
+        prediction = "AI-Generated" if score and score > 0.5 else "Real"
+
+        print(f"  ✓ SUCCESS - Score: {score:.4f} → {prediction}")
+        results[model_name] = {"status": "SUCCESS", "score": score, "prediction": prediction, "error": None}
+
+    except Exception as e:
+        error_msg = str(e)
+        print(f"  ✗ FAILED - {error_msg[:100]}")
+        results[model_name] = {"status": "FAILED", "score": None, "prediction": None, "error": error_msg}
+
+# Summary
+print("\n" + "="*80)
+print("MPS COMPATIBILITY SUMMARY")
+print("="*80)
+
+successful = []
+failed = []
+
+for model_name, result in results.items():
+    status_icon = "✓" if result["status"] == "SUCCESS" else "✗"
+    print(f"{status_icon} {model_name.upper():<12} - {result['status']}")
+    if result["status"] == "SUCCESS":
+        successful.append(model_name)
+        print(f"   Score: {result['score']:.4f} → {result['prediction']}")
+    else:
+        failed.append(model_name)
+        # Print first line of error
+        error_line = result['error'].split('\n')[0]
+        print(f"   Error: {error_line[:70]}")
+
+print("\n" + "="*80)
+print(f"Summary: {len(successful)} successful, {len(failed)} failed")
+print(f"MPS-compatible models: {', '.join([m.upper() for m in successful]) if successful else 'None'}")
+print(f"CPU-only models: {', '.join([m.upper() for m in failed]) if failed else 'None'}")
+print("="*80)

test_on_images.py

@@ -132,8 +132,8 @@ if __name__ == '__main__':
 					f_model_name = config["dataset"]["f_model_name"]
 
 
-					# Model - use CPU for Mac (MPS not fully supported by all models)
-					device = "cpu"  # Change to "cuda" if you have NVIDIA GPU
+					# Model - use CPU (MPS has compatibility issues with adaptive pooling)
+					device = "cpu"  # Use "cuda" for NVIDIA GPU
 					feature_extractor = networks.get_model(model_name=config["dataset"]["model_name"], device=device)