Merge branch 'main' of https://huggingface.co/recklessforlife/Real_Vs_Placeholder_Front_Face

README.md

@@ -8,6 +8,13 @@ tags:
 
 # Face Authenticity Classifier
 
+![comprehensive_summary.png](https://cdn-uploads.huggingface.co/production/uploads/679f91389649bf59c458acdd/pwUgd2JXowKLgPP-ZoTiB.png)
+
+# while the model is built for detecting Placeholder images it tends to Identify false positives
+
+![comprehensive_summary.png](https://cdn-uploads.huggingface.co/production/uploads/679f91389649bf59c458acdd/otp3zWZBH__0rgH7hEHeM.png)
+
+
 ## Model Overview
 
 **Model Name:** Real_vs_Placeholder
@@ -174,4 +181,6 @@ The model employs a three-block convolutional architecture with progressive feat
 This model card should be updated regularly as the model is retrained, evaluated on new datasets, or deployed in new applications.
 
 
-![comprehensive_summary.png](https://cdn-uploads.huggingface.co/production/uploads/679f91389649bf59c458acdd/xvEMrZWWxYUepkJVJcPCk.png)
+![comprehensive_summary.png](https://cdn-uploads.huggingface.co/production/uploads/679f91389649bf59c458acdd/xvEMrZWWxYUepkJVJcPCk.png)
+
+

Test.py

@@ -0,0 +1,831 @@
+
+# =============================================================================
+# FACE CLASSIFIER TESTING PROGRAM
+# Tests trained model on images with face detection and cropping
+# =============================================================================
+
+import torch
+import torch.nn as nn
+import torchvision.transforms as transforms
+import cv2
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+import os
+import matplotlib.pyplot as plt
+from pathlib import Path
+import time
+from tqdm import tqdm
+
+# =============================================================================
+# CONFIGURATION
+# =============================================================================
+
+# Paths
+MODEL_PATH = r"../Training/best_face_classifier_real_data.pth"
+TEST_IMAGES_PATH = r"\Pictures\Saved Pictures"
+OUTPUT_PATH = "test_results"
+
+# Model parameters (must match training configuration)
+IMAGE_SIZE = 224
+INPUT_CHANNELS = 3
+NUM_CLASSES = 1
+CONV_FILTERS = [128, 256, 512]  # Updated to match TrainV3.py
+FC_SIZES = [1024, 512]
+DROPOUT_RATES = [0.3, 0.5]
+
+# Image processing
+FACE_DETECTION_SCALE_FACTOR = 1.1
+FACE_DETECTION_MIN_NEIGHBORS = 5
+MIN_FACE_SIZE = (30, 30)
+IMAGE_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.webp']
+
+# Visualization
+CONFIDENCE_THRESHOLD = 0.8
+SAVE_RESULTS = True
+SHOW_PLOTS = True
+SAVE_INDIVIDUAL_IMAGES = True  # Save each image with annotations
+CREATE_COMPREHENSIVE_SUMMARY = True  # Create complete grid summary
+
+# =============================================================================
+# MODEL ARCHITECTURE (Must match training)
+# =============================================================================
+
+class ImprovedFaceClassifierCNN(nn.Module):
+    """Same architecture as used in training"""
+
+    def __init__(self):
+        super().__init__()
+
+        # Feature extraction layers
+        self.features = nn.Sequential(
+            # Block 1: 224x224 -> 112x112
+            nn.Conv2d(INPUT_CHANNELS, CONV_FILTERS[0], 3, padding=1),
+            nn.BatchNorm2d(CONV_FILTERS[0]),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(CONV_FILTERS[0], CONV_FILTERS[0], 3, padding=1),
+            nn.BatchNorm2d(CONV_FILTERS[0]),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2, 2),
+            nn.Dropout(DROPOUT_RATES[0]),
+
+            # Block 2: 112x112 -> 56x56
+            nn.Conv2d(CONV_FILTERS[0], CONV_FILTERS[1], 3, padding=1),
+            nn.BatchNorm2d(CONV_FILTERS[1]),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(CONV_FILTERS[1], CONV_FILTERS[1], 3, padding=1),
+            nn.BatchNorm2d(CONV_FILTERS[1]),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2, 2),
+            nn.Dropout(DROPOUT_RATES[0]),
+
+            # Block 3: 56x56 -> 28x28
+            nn.Conv2d(CONV_FILTERS[1], CONV_FILTERS[2], 3, padding=1),
+            nn.BatchNorm2d(CONV_FILTERS[2]),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(CONV_FILTERS[2], CONV_FILTERS[2], 3, padding=1),
+            nn.BatchNorm2d(CONV_FILTERS[2]),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2, 2),
+            nn.Dropout(DROPOUT_RATES[0]),
+
+            # Global Average Pooling
+            nn.AdaptiveAvgPool2d((7, 7))
+        )
+
+        # Classifier
+        self.classifier = nn.Sequential(
+            nn.Linear(CONV_FILTERS[2] * 7 * 7, FC_SIZES[0]),
+            nn.BatchNorm1d(FC_SIZES[0]),
+            nn.ReLU(inplace=True),
+            nn.Dropout(DROPOUT_RATES[1]),
+
+            nn.Linear(FC_SIZES[0], FC_SIZES[1]),
+            nn.ReLU(inplace=True),
+            nn.Dropout(DROPOUT_RATES[1]),
+
+            nn.Linear(FC_SIZES[1], NUM_CLASSES)
+        )
+
+    def forward(self, x):
+        x = self.features(x)
+        x = x.view(x.size(0), -1)
+        return self.classifier(x)
+
+# =============================================================================
+# FACE DETECTION AND PROCESSING
+# =============================================================================
+
+class FaceProcessor:
+    """Face detection and processing for classification"""
+
+    def __init__(self):
+        # Initialize face detector (OpenCV Haar Cascade)
+        self.face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+
+        # Alternative: Try to use more accurate DNN face detector if available
+        try:
+            # Download OpenCV DNN face detector if not present
+            self.net = None
+            self.use_dnn = False
+            # Note: For production, you might want to use a more sophisticated face detector
+        except:
+            self.net = None
+            self.use_dnn = False
+
+        # Image preprocessing transform
+        self.transform = transforms.Compose([
+            transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        ])
+
+    def detect_faces(self, image):
+        """Detect faces in image and return bounding boxes with duplicate removal"""
+        if isinstance(image, Image.Image):
+            # Convert PIL to OpenCV format
+            image_cv = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+        else:
+            image_cv = image.copy()
+
+        # Convert to grayscale for face detection
+        gray = cv2.cvtColor(image_cv, cv2.COLOR_BGR2GRAY)
+
+        # Detect faces
+        faces = self.face_cascade.detectMultiScale(
+            gray,
+            scaleFactor=FACE_DETECTION_SCALE_FACTOR,
+            minNeighbors=FACE_DETECTION_MIN_NEIGHBORS,
+            minSize=MIN_FACE_SIZE,
+            flags=cv2.CASCADE_SCALE_IMAGE
+        )
+
+        # Remove duplicate/overlapping faces using Non-Maximum Suppression
+        if len(faces) > 1:
+            faces = self._remove_duplicate_faces(faces)
+
+        return faces
+
+    def _remove_duplicate_faces(self, faces, overlap_threshold=0.15):
+        """Remove duplicate/overlapping face detections using improved NMS"""
+        if len(faces) <= 1:
+            return faces
+
+        # Convert to list for easier manipulation
+        face_list = list(faces)
+        
+        # Calculate areas and create extended info
+        face_info = []
+        for i, (x, y, w, h) in enumerate(face_list):
+            area = w * h
+            face_info.append({
+                'index': i,
+                'bbox': (x, y, w, h),
+                'area': area,
+                'x1': x, 'y1': y, 'x2': x + w, 'y2': y + h
+            })
+        
+        # Sort by area (larger faces first - usually more reliable)
+        face_info.sort(key=lambda f: f['area'], reverse=True)
+        
+        keep_indices = []
+        
+        for i, current_face in enumerate(face_info):
+            should_keep = True
+            
+            # Check against all previously kept faces
+            for kept_idx in keep_indices:
+                kept_face = face_info[kept_idx]
+                
+                # Calculate intersection
+                x1 = max(current_face['x1'], kept_face['x1'])
+                y1 = max(current_face['y1'], kept_face['y1'])
+                x2 = min(current_face['x2'], kept_face['x2'])
+                y2 = min(current_face['y2'], kept_face['y2'])
+                
+                if x1 < x2 and y1 < y2:
+                    intersection = (x2 - x1) * (y2 - y1)
+                    
+                    # Calculate IoU
+                    union = current_face['area'] + kept_face['area'] - intersection
+                    iou = intersection / union if union > 0 else 0
+                    
+                    # Also check overlap ratio (intersection over smaller box)
+                    smaller_area = min(current_face['area'], kept_face['area'])
+                    overlap_ratio = intersection / smaller_area if smaller_area > 0 else 0
+                    
+                    # Remove if either IoU or overlap ratio is too high
+                    if iou > overlap_threshold or overlap_ratio > 0.5:
+                        should_keep = False
+                        break
+            
+            if should_keep:
+                keep_indices.append(i)
+        
+        # Return filtered faces
+        filtered_faces = np.array([face_info[i]['bbox'] for i in keep_indices])
+        
+        # Debug info
+        if len(faces) != len(filtered_faces):
+            print(f"   [NMS] Removed {len(faces) - len(filtered_faces)} duplicate faces "
+                  f"({len(faces)} → {len(filtered_faces)})")
+        
+        return filtered_faces
+
+    def crop_face(self, image, face_bbox, expand_ratio=0.2):
+        """Crop face from image with some padding"""
+        x, y, w, h = face_bbox
+
+        # Add padding around face
+        pad_x = int(w * expand_ratio)
+        pad_y = int(h * expand_ratio)
+
+        # Calculate expanded bounding box
+        x1 = max(0, x - pad_x)
+        y1 = max(0, y - pad_y)
+        x2 = min(image.width if isinstance(image, Image.Image) else image.shape[1], x + w + pad_x)
+        y2 = min(image.height if isinstance(image, Image.Image) else image.shape[0], y + h + pad_y)
+
+        # Crop the face
+        if isinstance(image, Image.Image):
+            face_crop = image.crop((x1, y1, x2, y2))
+        else:
+            # OpenCV format
+            face_crop = image[y1:y2, x1:x2]
+            face_crop = Image.fromarray(cv2.cvtColor(face_crop, cv2.COLOR_BGR2RGB))
+
+        return face_crop, (x1, y1, x2, y2)
+
+    def preprocess_face(self, face_image):
+        """Preprocess face for model input"""
+        # Ensure face is PIL Image
+        if not isinstance(face_image, Image.Image):
+            face_image = Image.fromarray(face_image)
+
+        # Apply transforms
+        face_tensor = self.transform(face_image)
+
+        # Add batch dimension
+        face_batch = face_tensor.unsqueeze(0)
+
+        return face_batch
+
+# =============================================================================
+# MODEL LOADER AND CLASSIFIER
+# =============================================================================
+
+class FaceClassifierTester:
+    """Test trained face classifier on new images"""
+
+    def __init__(self, model_path, device='auto'):
+        self.device = self._setup_device(device)
+        self.model = self._load_model(model_path)
+        self.face_processor = FaceProcessor()
+        self.results = []
+
+        print(f"[*] Face Classifier Tester initialized")
+        print(f"   Device: {self.device}")
+        print(f"   Model: {model_path}")
+
+    def _setup_device(self, device):
+        """Setup computing device"""
+        if device == 'auto':
+            if torch.cuda.is_available():
+                device = torch.device('cuda:0')
+                print(f"[GPU] Using GPU: {torch.cuda.get_device_name(0)}")
+            else:
+                device = torch.device('cpu')
+                print("[CPU] Using CPU")
+        else:
+            device = torch.device(device)
+
+        return device
+
+    def _load_model(self, model_path):
+        """Load trained model from checkpoint"""
+        try:
+            # Load checkpoint
+            checkpoint = torch.load(model_path, map_location=self.device)
+
+            # Initialize model
+            model = ImprovedFaceClassifierCNN()
+
+            # Load state dict
+            if 'model_state_dict' in checkpoint:
+                model.load_state_dict(checkpoint['model_state_dict'])
+                print(f"[OK] Model loaded from checkpoint")
+                print(f"   Epoch: {checkpoint.get('epoch', 'Unknown')}")
+                print(f"   Validation Accuracy: {checkpoint.get('val_acc', 'Unknown'):.2f}%")
+            else:
+                # Direct state dict
+                model.load_state_dict(checkpoint)
+                print(f"[OK] Model loaded successfully")
+
+            model.to(self.device)
+            model.eval()
+
+            return model
+
+        except Exception as e:
+            print(f"[ERROR] Error loading model: {e}")
+            print("Make sure the model file exists and matches the architecture")
+            raise
+
+    def classify_face(self, face_image):
+        """Classify a single face image"""
+        try:
+            # Preprocess face
+            face_tensor = self.face_processor.preprocess_face(face_image)
+            face_tensor = face_tensor.to(self.device)
+
+            # Run inference
+            with torch.no_grad():
+                logits = self.model(face_tensor)
+                probability = torch.sigmoid(logits).cpu().numpy()[0][0]
+
+                # Convert probability to prediction
+                prediction = "REAL" if probability > CONFIDENCE_THRESHOLD else "FAKE"
+                confidence = probability if prediction == "REAL" else (1 - probability)
+
+                return {
+                    'prediction': prediction,
+                    'confidence': confidence,
+                    'probability': probability,
+                    'raw_logit': logits.cpu().numpy()[0][0]
+                }
+
+        except Exception as e:
+            print(f"[ERROR] Error in classification: {e}")
+            return {
+                'prediction': 'ERROR',
+                'confidence': 0.0,
+                'probability': 0.0,
+                'raw_logit': 0.0
+            }
+
+    def process_image(self, image_path):
+        """Process a single image: detect faces and classify them"""
+        try:
+            # Load image
+            image = Image.open(image_path).convert('RGB')
+            image_name = os.path.basename(image_path)
+
+            print(f"\n[PROCESSING] {image_name}")
+
+            # Detect faces
+            faces = self.face_processor.detect_faces(image)
+
+            if len(faces) == 0:
+                print(f"   [WARNING] No faces detected in {image_name}")
+                return {
+                    'image_path': image_path,
+                    'image_name': image_name,
+                    'num_faces': 0,
+                    'faces': [],
+                    'status': 'no_faces'
+                }
+
+            print(f"   [FACES] Found {len(faces)} face(s)")
+
+            # Process each detected face
+            face_results = []
+            for i, face_bbox in enumerate(faces):
+                # Crop face
+                face_crop, expanded_bbox = self.face_processor.crop_face(image, face_bbox)
+
+                # Classify face
+                classification = self.classify_face(face_crop)
+
+                # Store results
+                face_result = {
+                    'face_id': i,
+                    'bbox': face_bbox.tolist(),
+                    'expanded_bbox': expanded_bbox,
+                    'face_crop': face_crop,
+                    'classification': classification
+                }
+                face_results.append(face_result)
+
+                print(f"   Face {i+1}: {classification['prediction']} "
+                      f"({classification['confidence']:.1%} confidence)")
+
+            return {
+                'image_path': image_path,
+                'image_name': image_name,
+                'image': image,
+                'num_faces': len(faces),
+                'faces': face_results,
+                'status': 'success'
+            }
+
+        except Exception as e:
+            print(f"[ERROR] Error processing {image_path}: {e}")
+            return {
+                'image_path': image_path,
+                'image_name': os.path.basename(image_path),
+                'num_faces': 0,
+                'faces': [],
+                'status': 'error',
+                'error': str(e)
+            }
+
+    def test_folder(self, folder_path, max_images=None):
+        """Test all images in a folder"""
+        print(f"\n[TESTING] FACE CLASSIFIER")
+        print(f"="*60)
+        print(f"Test folder: {folder_path}")
+        print(f"Model: {MODEL_PATH}")
+
+        # Check if folder exists
+        if not os.path.exists(folder_path):
+            print(f"[ERROR] Test folder not found: {folder_path}")
+            return []
+
+        # Get all image files (avoid duplicates from case variations)
+        image_files_set = set()
+        for ext in IMAGE_EXTENSIONS:
+            # Use case-insensitive glob patterns
+            image_files_set.update(Path(folder_path).glob(f"*{ext}"))
+            image_files_set.update(Path(folder_path).glob(f"*{ext.upper()}"))
+        
+        # Convert set back to list and remove duplicates by resolving paths
+        image_files = []
+        seen_paths = set()
+        for file_path in image_files_set:
+            resolved_path = file_path.resolve()
+            if resolved_path not in seen_paths:
+                image_files.append(file_path)
+                seen_paths.add(resolved_path)
+
+        if not image_files:
+            print(f"[ERROR] No images found in {folder_path}")
+            print(f"   Looking for extensions: {IMAGE_EXTENSIONS}")
+            return []
+
+        if max_images:
+            image_files = image_files[:max_images]
+
+        print(f"[FILES] Found {len(image_files)} images to process")
+
+        # Process each image
+        results = []
+        start_time = time.time()
+
+        for image_path in tqdm(image_files, desc="Processing images"):
+            result = self.process_image(str(image_path))
+            results.append(result)
+            self.results.append(result)
+
+        total_time = time.time() - start_time
+
+        # Print summary
+        self._print_summary(results, total_time)
+
+        # Save and visualize results
+        if SAVE_RESULTS:
+            self._save_results(results)
+            self._save_individual_images(results)  # Save each image with bounding boxes
+
+        if SHOW_PLOTS:
+            #self._visualize_results(results)
+            self._create_comprehensive_summary(results)  # Create complete grid summary
+
+        return results
+
+    def _print_summary(self, results, total_time):
+        """Print testing summary"""
+        print(f"\n[SUMMARY] TESTING SUMMARY")
+        print(f"="*40)
+
+        total_images = len(results)
+        successful = len([r for r in results if r['status'] == 'success'])
+        total_faces = sum(r['num_faces'] for r in results)
+        no_faces = len([r for r in results if r['status'] == 'no_faces'])
+        errors = len([r for r in results if r['status'] == 'error'])
+
+        print(f"Images processed: {total_images}")
+        print(f"Successful: {successful}")
+        print(f"No faces detected: {no_faces}")
+        print(f"Errors: {errors}")
+        print(f"Total faces detected: {total_faces}")
+        print(f"Processing time: {total_time:.1f}s")
+        print(f"Average time per image: {total_time/total_images:.2f}s")
+
+        # Classification summary
+        if total_faces > 0:
+            real_faces = sum(len([f for f in r['faces'] if f['classification']['prediction'] == 'REAL'])
+                           for r in results if r['status'] == 'success')
+            fake_faces = total_faces - real_faces
+
+            print(f"\n[RESULTS] Classification Results:")
+            print(f"Real faces: {real_faces} ({real_faces/total_faces:.1%})")
+            print(f"Fake faces: {fake_faces} ({fake_faces/total_faces:.1%})")
+
+    def _save_results(self, results):
+        """Save results to files"""
+        os.makedirs(OUTPUT_PATH, exist_ok=True)
+
+        # Save summary CSV
+        import csv
+        csv_path = os.path.join(OUTPUT_PATH, 'classification_results.csv')
+
+        with open(csv_path, 'w', newline='', encoding='utf-8') as csvfile:
+            writer = csv.writer(csvfile)
+            writer.writerow(['Image', 'Face_ID', 'Prediction', 'Confidence', 'Probability', 'Bbox_X', 'Bbox_Y', 'Bbox_W', 'Bbox_H'])
+
+            for result in results:
+                if result['status'] == 'success':
+                    for face in result['faces']:
+                        bbox = face['bbox']
+                        cls = face['classification']
+                        writer.writerow([
+                            result['image_name'],
+                            face['face_id'],
+                            cls['prediction'],
+                            f"{cls['confidence']:.3f}",
+                            f"{cls['probability']:.3f}",
+                            bbox[0], bbox[1], bbox[2], bbox[3]
+                        ])
+
+        print(f"[SAVED] Results saved to: {csv_path}")
+
+    def _save_individual_images(self, results):
+        """Save each processed image with bounding boxes and classifications"""
+        os.makedirs(OUTPUT_PATH, exist_ok=True)
+        individual_dir = os.path.join(OUTPUT_PATH, 'annotated_images')
+        os.makedirs(individual_dir, exist_ok=True)
+
+        saved_count = 0
+        for result in results:
+            if result['status'] in ['success', 'no_faces']:
+                try:
+                    # Load original image
+                    if 'image' in result:
+                        image = result['image'].copy()
+                    else:
+                        image = Image.open(result['image_path']).convert('RGB')
+
+                    # Draw bounding boxes and labels
+                    draw = ImageDraw.Draw(image)
+
+                    # Try to use a larger font
+                    try:
+                        font = ImageFont.truetype("arial.ttf", 20)
+                    except:
+                        font = ImageFont.load_default()
+
+                    if result['num_faces'] > 0:
+                        for face in result['faces']:
+                            bbox = face['bbox']
+                            cls = face['classification']
+                            
+                            # Choose color based on prediction
+                            color = 'green' if cls['prediction'] == 'REAL' else 'red'
+                            
+                            # Draw bounding box
+                            x, y, w, h = bbox
+                            draw.rectangle([x, y, x+w, y+h], outline=color, width=3)
+                            
+                            # Create label with prediction and confidence
+                            label = f"{cls['prediction']} ({cls['confidence']:.1%})"
+                            
+                            # Draw label background
+                            text_bbox = draw.textbbox((x, y-25), label, font=font)
+                            draw.rectangle(text_bbox, fill=color)
+                            
+                            # Draw label text
+                            draw.text((x, y-25), label, fill='white', font=font)
+                    else:
+                        # Add "NO FACES" label for images without faces
+                        draw.text((10, 10), "NO FACES DETECTED", fill='orange', font=font)
+
+                    # Save annotated image
+                    base_name = os.path.splitext(result['image_name'])[0]
+                    output_filename = f"{base_name}_annotated.jpg"
+                    output_path = os.path.join(individual_dir, output_filename)
+                    
+                    image.save(output_path, 'JPEG', quality=95)
+                    saved_count += 1
+
+                except Exception as e:
+                    print(f"[WARNING] Could not save annotated image for {result['image_name']}: {e}")
+
+        print(f"[SAVED] {saved_count} annotated images saved to: {individual_dir}")
+
+    def _visualize_results(self, results, max_display=6):
+        """Visualize results with matplotlib (limited sample)"""
+        try:
+            # Filter successful results with faces
+            display_results = [r for r in results if r['status'] == 'success' and r['num_faces'] > 0]
+            display_results = display_results[:max_display]
+
+            if not display_results:
+                print("No results to visualize")
+                return
+
+            # Create subplots
+            fig, axes = plt.subplots(2, 3, figsize=(15, 10))
+            axes = axes.flatten()
+
+            for i, result in enumerate(display_results):
+                if i >= len(axes):
+                    break
+
+                ax = axes[i]
+                image = result['image']
+
+                # Draw bounding boxes on image
+                draw_image = image.copy()
+                draw = ImageDraw.Draw(draw_image)
+
+                for face in result['faces']:
+                    bbox = face['bbox']
+                    cls = face['classification']
+
+                    # Choose color based on prediction
+                    color = 'green' if cls['prediction'] == 'REAL' else 'red'
+
+                    # Draw bounding box
+                    draw.rectangle([bbox[0], bbox[1], bbox[0]+bbox[2], bbox[1]+bbox[3]],
+                                 outline=color, width=3)
+
+                    # Add label
+                    label = f"{cls['prediction']} ({cls['confidence']:.1%})"
+                    draw.text((bbox[0], bbox[1]-20), label, fill=color)
+
+                # Display image
+                ax.imshow(draw_image)
+                ax.set_title(f"{result['image_name']}\n{result['num_faces']} face(s)")
+                ax.axis('off')
+
+            # Hide empty subplots
+            for i in range(len(display_results), len(axes)):
+                axes[i].axis('off')
+
+            plt.tight_layout()
+            plt.savefig(os.path.join(OUTPUT_PATH, 'sample_classification.png'), dpi=150, bbox_inches='tight')
+            plt.show()
+
+        except Exception as e:
+            print(f"[WARNING] Could not create sample visualization: {e}")
+
+    def _create_comprehensive_summary(self, results):
+        """Create a comprehensive grid summary of all processed images"""
+        try:
+            # Include all results (successful, no_faces, errors)
+            all_results = results
+            
+            if not all_results:
+                print("No results to create comprehensive summary")
+                return
+
+            # Calculate grid dimensions
+            total_images = len(all_results)
+            cols = 4  # 4 images per row
+            rows = (total_images + cols - 1) // cols  # Ceiling division
+            
+            # Create large figure
+            fig, axes = plt.subplots(rows, cols, figsize=(20, 5*rows))
+            
+            # Handle single row case
+            if rows == 1:
+                axes = axes.reshape(1, -1) if total_images > 1 else [axes]
+            
+            # Flatten axes for easier indexing
+            axes_flat = axes.flatten() if total_images > 1 else [axes]
+
+            for i, result in enumerate(all_results):
+                ax = axes_flat[i]
+                
+                try:
+                    # Load image
+                    if 'image' in result and result['image'] is not None:
+                        image = result['image'].copy()
+                    else:
+                        image = Image.open(result['image_path']).convert('RGB')
+                    
+                    # Create annotated copy
+                    draw_image = image.copy()
+                    draw = ImageDraw.Draw(draw_image)
+                    
+                    # Set up title based on status
+                    title_parts = [result['image_name'][:20]]  # Truncate long names
+                    
+                    if result['status'] == 'success':
+                        if result['num_faces'] > 0:
+                            # Draw faces with bounding boxes
+                            for face in result['faces']:
+                                bbox = face['bbox']
+                                cls = face['classification']
+                                
+                                # Choose color
+                                color = 'green' if cls['prediction'] == 'REAL' else 'red'
+                                
+                                # Draw bounding box
+                                x, y, w, h = bbox
+                                draw.rectangle([x, y, x+w, y+h], outline=color, width=2)
+                                
+                                # Add small label
+                                label = f"{cls['prediction']}\n{cls['confidence']:.0%}"
+                                draw.text((x, y-15), label, fill=color)
+                            
+                            title_parts.append(f"{result['num_faces']} face(s)")
+                            
+                            # Count real vs fake
+                            real_count = sum(1 for f in result['faces'] if f['classification']['prediction'] == 'REAL')
+                            fake_count = result['num_faces'] - real_count
+                            if real_count > 0:
+                                title_parts.append(f"Real: {real_count}")
+                            if fake_count > 0:
+                                title_parts.append(f"Fake: {fake_count}")
+                        else:
+                            title_parts.append("No faces")
+                            # Add text overlay
+                            draw.text((10, 10), "NO FACES", fill='orange')
+                    
+                    elif result['status'] == 'no_faces':
+                        title_parts.append("No faces detected")
+                        draw.text((10, 10), "NO FACES", fill='orange')
+                    
+                    elif result['status'] == 'error':
+                        title_parts.append("Error")
+                        draw.text((10, 10), "ERROR", fill='red')
+                    
+                    # Display image
+                    ax.imshow(draw_image)
+                    ax.set_title('\n'.join(title_parts), fontsize=8)
+                    ax.axis('off')
+                    
+                except Exception as e:
+                    # Handle individual image errors
+                    ax.text(0.5, 0.5, f"Error loading\n{result['image_name']}", 
+                           ha='center', va='center', transform=ax.transAxes)
+                    ax.set_title(f"Error: {result['image_name'][:20]}")
+                    ax.axis('off')
+            
+            # Hide unused subplots
+            for i in range(total_images, len(axes_flat)):
+                axes_flat[i].axis('off')
+            
+            # Add overall title with summary stats
+            total_faces = sum(r['num_faces'] for r in results if r['status'] == 'success')
+            real_faces = sum(len([f for f in r['faces'] if f['classification']['prediction'] == 'REAL']) 
+                           for r in results if r['status'] == 'success')
+            fake_faces = total_faces - real_faces
+            
+            fig.suptitle(f"Face Classification Results - {total_images} Images, {total_faces} Faces\n"
+                        f"Real: {real_faces} ({real_faces/total_faces*100 if total_faces > 0 else 0:.1f}%), "
+                        f"Fake: {fake_faces} ({fake_faces/total_faces*100 if total_faces > 0 else 0:.1f}%)", 
+                        fontsize=16, y=0.98)
+            
+            plt.tight_layout()
+            plt.subplots_adjust(top=0.92)
+            
+            # Save comprehensive summary
+            summary_path = os.path.join(OUTPUT_PATH, 'comprehensive_summary.png')
+            plt.savefig(summary_path, dpi=200, bbox_inches='tight')
+            print(f"[SAVED] Comprehensive summary saved to: {summary_path}")
+            
+            plt.show()
+
+        except Exception as e:
+            print(f"[WARNING] Could not create comprehensive summary: {e}")
+
+# =============================================================================
+# MAIN TESTING FUNCTION
+# =============================================================================
+
+def main():
+    """Main testing function"""
+    print("[*] FACE CLASSIFIER TESTING")
+    print("="*50)
+
+    # Check if model exists
+    if not os.path.exists(MODEL_PATH):
+        print(f"[ERROR] Model file not found: {MODEL_PATH}")
+        print("Please make sure you have trained the model first.")
+        print("Expected file: best_face_classifier_real_data.pth")
+        return
+
+    # Check if test folder exists
+    if not os.path.exists(TEST_IMAGES_PATH):
+        print(f"[ERROR] Test images folder not found: {TEST_IMAGES_PATH}")
+        print("Please check the path and make sure it contains images.")
+        return
+
+    try:
+        # Initialize tester
+        tester = FaceClassifierTester(MODEL_PATH)
+
+        # Run tests
+        results = tester.test_folder(TEST_IMAGES_PATH, max_images=20)  # Limit for demo
+
+        print(f"\n[OK] Testing completed!")
+        print(f"Check '{OUTPUT_PATH}' folder for detailed results.")
+
+    except Exception as e:
+        print(f"[ERROR] Testing failed: {e}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    main()