Create app.py

app.py

@@ -0,0 +1,516 @@
+import gradio as gr
+import torch
+import cv2
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+from transformers import pipeline
+import logging
+import time
+from typing import Tuple, List, Dict, Optional
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Model configuration
+MODEL_NAME = "abhilash88/face-emotion-detection"
+
+# Emotion labels and colors for visualization
+EMOTION_COLORS = {
+    'angry': '#FF4444',
+    'disgust': '#AA4444', 
+    'fear': '#4444FF',
+    'happy': '#44FF44',
+    'sad': '#4444AA',
+    'surprise': '#FFAA44',
+    'neutral': '#AAAAAA'
+}
+
+# Global variables for model
+emotion_classifier = None
+face_cascade = None
+
+def load_models():
+    """Load the emotion detection model and face cascade"""
+    global emotion_classifier, face_cascade
+    
+    try:
+        logger.info(f"Loading emotion detection model: {MODEL_NAME}")
+        emotion_classifier = pipeline(
+            "image-classification",
+            model=MODEL_NAME,
+            return_all_scores=True
+        )
+        logger.info("Emotion detection model loaded successfully")
+        
+        # Load OpenCV face cascade
+        face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+        logger.info("Face detection cascade loaded successfully")
+        
+        return True
+    except Exception as e:
+        logger.error(f"Error loading models: {e}")
+        return False
+
+def detect_faces(image: np.ndarray) -> List[Tuple[int, int, int, int]]:
+    """Detect faces in the image using OpenCV"""
+    try:
+        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+        faces = face_cascade.detectMultiScale(
+            gray, 
+            scaleFactor=1.1, 
+            minNeighbors=5, 
+            minSize=(30, 30)
+        )
+        return faces.tolist()
+    except Exception as e:
+        logger.error(f"Error detecting faces: {e}")
+        return []
+
+def predict_emotion(face_image: Image.Image) -> List[Dict]:
+    """Predict emotion for a single face"""
+    try:
+        if emotion_classifier is None:
+            return [{"label": "neutral", "score": 1.0}]
+        
+        results = emotion_classifier(face_image)
+        return results
+    except Exception as e:
+        logger.error(f"Error predicting emotion: {e}")
+        return [{"label": "neutral", "score": 1.0}]
+
+def draw_emotion_results(image: Image.Image, faces: List, emotions: List) -> Image.Image:
+    """Draw bounding boxes and emotion labels on the image"""
+    try:
+        draw = ImageDraw.Draw(image)
+        
+        # Try to load a font, fallback to default if not available
+        try:
+            font = ImageFont.truetype("arial.ttf", 16)
+        except:
+            font = ImageFont.load_default()
+        
+        for i, (x, y, w, h) in enumerate(faces):
+            if i < len(emotions):
+                # Get top emotion
+                top_emotion = max(emotions[i], key=lambda x: x['score'])
+                emotion_label = top_emotion['label']
+                confidence = top_emotion['score']
+                
+                # Get color for this emotion
+                color = EMOTION_COLORS.get(emotion_label, '#FFFFFF')
+                
+                # Draw bounding box
+                draw.rectangle([(x, y), (x + w, y + h)], outline=color, width=3)
+                
+                # Draw emotion label
+                label_text = f"{emotion_label}: {confidence:.2f}"
+                
+                # Calculate text size for background
+                bbox = draw.textbbox((0, 0), label_text, font=font)
+                text_width = bbox[2] - bbox[0]
+                text_height = bbox[3] - bbox[1]
+                
+                # Draw background for text
+                draw.rectangle(
+                    [(x, y - text_height - 5), (x + text_width + 10, y)],
+                    fill=color
+                )
+                
+                # Draw text
+                draw.text((x + 5, y - text_height - 2), label_text, fill='white', font=font)
+        
+        return image
+    except Exception as e:
+        logger.error(f"Error drawing results: {e}")
+        return image
+
+def process_single_image(image: Image.Image) -> Tuple[Image.Image, str]:
+    """Process a single image for emotion detection"""
+    try:
+        if image is None:
+            return None, "No image provided"
+        
+        # Convert PIL to numpy array
+        image_np = np.array(image)
+        
+        # Detect faces
+        faces = detect_faces(image_np)
+        
+        if not faces:
+            return image, "No faces detected in the image"
+        
+        # Process each face
+        emotions_list = []
+        for (x, y, w, h) in faces:
+            # Extract face region
+            face_region = image.crop((x, y, x + w, y + h))
+            
+            # Predict emotion
+            emotions = predict_emotion(face_region)
+            emotions_list.append(emotions)
+        
+        # Draw results
+        result_image = draw_emotion_results(image.copy(), faces, emotions_list)
+        
+        # Create summary text
+        summary_lines = [f"Detected {len(faces)} face(s):"]
+        for i, emotions in enumerate(emotions_list):
+            top_emotion = max(emotions, key=lambda x: x['score'])
+            summary_lines.append(f"Face {i+1}: {top_emotion['label']} ({top_emotion['score']:.2f})")
+        
+        summary = "\n".join(summary_lines)
+        
+        return result_image, summary
+        
+    except Exception as e:
+        logger.error(f"Error processing image: {e}")
+        return image, f"Error processing image: {str(e)}"
+
+def process_webcam_frame(image: Image.Image) -> Image.Image:
+    """Process webcam frame for real-time emotion detection"""
+    try:
+        if image is None:
+            return None
+        
+        # Convert PIL to numpy array
+        image_np = np.array(image)
+        
+        # Detect faces
+        faces = detect_faces(image_np)
+        
+        if not faces:
+            return image
+        
+        # Process each face
+        emotions_list = []
+        for (x, y, w, h) in faces:
+            # Extract face region
+            face_region = image.crop((x, y, x + w, y + h))
+            
+            # Predict emotion
+            emotions = predict_emotion(face_region)
+            emotions_list.append(emotions)
+        
+        # Draw results
+        result_image = draw_emotion_results(image.copy(), faces, emotions_list)
+        
+        return result_image
+        
+    except Exception as e:
+        logger.error(f"Error processing webcam frame: {e}")
+        return image
+
+def analyze_emotions_batch(images: List[Image.Image]) -> str:
+    """Analyze emotions in multiple images"""
+    try:
+        if not images:
+            return "No images provided"
+        
+        all_results = []
+        
+        for idx, image in enumerate(images):
+            if image is None:
+                continue
+                
+            # Convert PIL to numpy array
+            image_np = np.array(image)
+            
+            # Detect faces
+            faces = detect_faces(image_np)
+            
+            if not faces:
+                all_results.append(f"Image {idx+1}: No faces detected")
+                continue
+            
+            # Process each face
+            image_emotions = []
+            for (x, y, w, h) in faces:
+                # Extract face region
+                face_region = image.crop((x, y, x + w, y + h))
+                
+                # Predict emotion
+                emotions = predict_emotion(face_region)
+                top_emotion = max(emotions, key=lambda x: x['score'])
+                image_emotions.append(f"{top_emotion['label']} ({top_emotion['score']:.2f})")
+            
+            all_results.append(f"Image {idx+1}: {', '.join(image_emotions)}")
+        
+        return "\n".join(all_results)
+        
+    except Exception as e:
+        logger.error(f"Error in batch analysis: {e}")
+        return f"Error in batch analysis: {str(e)}"
+
+def get_emotion_statistics(image: Image.Image) -> str:
+    """Get detailed emotion statistics for an image"""
+    try:
+        if image is None:
+            return "No image provided"
+        
+        # Convert PIL to numpy array
+        image_np = np.array(image)
+        
+        # Detect faces
+        faces = detect_faces(image_np)
+        
+        if not faces:
+            return "No faces detected"
+        
+        # Collect all emotions
+        all_emotions = {}
+        
+        for (x, y, w, h) in faces:
+            # Extract face region
+            face_region = image.crop((x, y, x + w, y + h))
+            
+            # Predict emotion
+            emotions = predict_emotion(face_region)
+            
+            for emotion_data in emotions:
+                emotion = emotion_data['label']
+                score = emotion_data['score']
+                
+                if emotion not in all_emotions:
+                    all_emotions[emotion] = []
+                all_emotions[emotion].append(score)
+        
+        # Calculate statistics
+        stats_lines = [f"**Emotion Analysis for {len(faces)} face(s):**\n"]
+        
+        for emotion, scores in all_emotions.items():
+            avg_score = np.mean(scores)
+            max_score = np.max(scores)
+            count = len(scores)
+            
+            stats_lines.append(f"**{emotion.title()}:**")
+            stats_lines.append(f"  - Average confidence: {avg_score:.3f}")
+            stats_lines.append(f"  - Maximum confidence: {max_score:.3f}")
+            stats_lines.append(f"  - Detections: {count}")
+            stats_lines.append("")
+        
+        return "\n".join(stats_lines)
+        
+    except Exception as e:
+        logger.error(f"Error calculating statistics: {e}")
+        return f"Error calculating statistics: {str(e)}"
+
+# Create Gradio interface
+def create_interface():
+    # Custom CSS for modern styling
+    custom_css = """
+    .main-header {
+        text-align: center;
+        color: #2563eb;
+        margin-bottom: 2rem;
+    }
+    .emotion-box {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        margin: 1rem 0;
+    }
+    .stats-box {
+        background: #f8fafc;
+        border: 1px solid #e2e8f0;
+        border-radius: 0.5rem;
+        padding: 1rem;
+    }
+    """
+    
+    with gr.Blocks(
+        title="Live Face Emotion Detection",
+        theme=gr.themes.Soft(),
+        css=custom_css
+    ) as iface:
+        
+        # Header
+        gr.Markdown(
+            """
+            # 😊 Live Face Emotion Detection
+            
+            ### Real-time emotion recognition powered by deep learning
+            
+            This tool uses a fine-tuned model to detect and classify emotions in faces. It can identify 
+            7 different emotions: **angry**, **disgust**, **fear**, **happy**, **sad**, **surprise**, and **neutral**.
+            """,
+            elem_classes=["main-header"]
+        )
+        
+        with gr.Tab("📷 Single Image Analysis"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    single_image_input = gr.Image(
+                        label="Upload Image",
+                        type="pil",
+                        height=400
+                    )
+                    analyze_single_btn = gr.Button("Analyze Emotions", variant="primary", size="lg")
+                
+                with gr.Column(scale=1):
+                    single_image_output = gr.Image(
+                        label="Emotion Detection Results",
+                        height=400
+                    )
+                    single_result_text = gr.Textbox(
+                        label="Detection Summary",
+                        lines=5,
+                        show_copy_button=True
+                    )
+        
+        with gr.Tab("🎥 Live Webcam Detection"):
+            gr.Markdown(
+                """
+                ### Real-time Emotion Detection
+                Enable your webcam to see live emotion detection in action!
+                """
+            )
+            
+            webcam_interface = gr.Interface(
+                fn=process_webcam_frame,
+                inputs=gr.Image(source="webcam", streaming=True, type="pil"),
+                outputs=gr.Image(label="Live Emotion Detection"),
+                live=True,
+                title="",
+                description=""
+            )
+        
+        with gr.Tab("📊 Detailed Statistics"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    stats_image_input = gr.Image(
+                        label="Upload Image for Analysis",
+                        type="pil",
+                        height=400
+                    )
+                    analyze_stats_btn = gr.Button("Generate Statistics", variant="primary", size="lg")
+                
+                with gr.Column(scale=1):
+                    stats_output = gr.Markdown(
+                        value="Upload an image and click 'Generate Statistics' to see detailed emotion analysis...",
+                        label="Emotion Statistics"
+                    )
+        
+        with gr.Tab("🔄 Batch Processing"):
+            with gr.Column():
+                batch_images_input = gr.File(
+                    label="Upload Multiple Images",
+                    file_count="multiple",
+                    file_types=["image"]
+                )
+                batch_process_btn = gr.Button("Process Batch", variant="primary", size="lg")
+                batch_results_output = gr.Textbox(
+                    label="Batch Processing Results",
+                    lines=10,
+                    show_copy_button=True
+                )
+        
+        with gr.Tab("📚 About & Model Info"):
+            gr.Markdown(
+                """
+                ## About This Model
+                
+                This face emotion detection system uses a fine-tuned deep learning model specifically trained 
+                for emotion recognition. The model can detect 7 different emotional states with high accuracy.
+                
+                ### Supported Emotions
+                
+                - 😠 **Angry** - Expressions of anger, frustration, or annoyance
+                - 🤢 **Disgust** - Expressions of revulsion or distaste  
+                - 😨 **Fear** - Expressions of fear, anxiety, or worry
+                - 😊 **Happy** - Expressions of joy, contentment, or pleasure
+                - 😢 **Sad** - Expressions of sadness, sorrow, or melancholy
+                - 😲 **Surprise** - Expressions of surprise, shock, or amazement
+                - 😐 **Neutral** - Calm, neutral expressions with no strong emotion
+                
+                ### Technical Details
+                
+                - **Model:** Fine-tuned emotion classification model
+                - **Architecture:** Deep convolutional neural network
+                - **Training:** Specialized dataset for facial emotion recognition
+                - **Face Detection:** OpenCV Haar Cascade classifier
+                - **Real-time Processing:** Optimized for live webcam inference
+                
+                ### Use Cases
+                
+                - **Human-Computer Interaction:** Emotion-aware interfaces
+                - **Market Research:** Analyze customer emotional responses
+                - **Healthcare:** Monitor patient emotional states
+                - **Education:** Assess student engagement and understanding
+                - **Entertainment:** Emotion-responsive gaming and media
+                - **Security:** Detect emotional distress or suspicious behavior
+                
+                ### Privacy & Ethics
+                
+                - All processing is done locally in your browser
+                - No images are stored or transmitted to external servers
+                - Use responsibly and respect privacy in all applications
+                - Consider bias and fairness in emotion detection systems
+                
+                ### Performance Tips
+                
+                - Ensure good lighting for best results
+                - Face should be clearly visible and unobstructed
+                - Works best with frontal face views
+                - Multiple faces in one image are supported
+                
+                ---
+                
+                **Model Repository:** [abhilash88/face-emotion-detection](https://huggingface.co/abhilash88/face-emotion-detection)
+                
+                Made with ❤️ for emotion AI research and applications
+                """
+            )
+        
+        # Event handlers
+        analyze_single_btn.click(
+            fn=process_single_image,
+            inputs=single_image_input,
+            outputs=[single_image_output, single_result_text],
+            api_name="analyze_single_image"
+        )
+        
+        analyze_stats_btn.click(
+            fn=get_emotion_statistics,
+            inputs=stats_image_input,
+            outputs=stats_output,
+            api_name="get_emotion_statistics"
+        )
+        
+        # Example images
+        gr.Examples(
+            examples=[
+                ["https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=300&h=300&fit=crop&crop=face"],
+                ["https://images.unsplash.com/photo-1554151228-14d9def656e4?w=300&h=300&fit=crop&crop=face"],
+                ["https://images.unsplash.com/photo-1500648767791-00dcc994a43e?w=300&h=300&fit=crop&crop=face"],
+            ],
+            inputs=single_image_input,
+            label="Try these example images",
+            cache_examples=False
+        )
+    
+    return iface
+
+# Initialize and launch
+if __name__ == "__main__":
+    # Load models
+    logger.info("Initializing Face Emotion Detection System...")
+    
+    if load_models():
+        logger.info("Models loaded successfully!")
+        
+        # Create interface
+        iface = create_interface()
+        
+        # Launch
+        iface.launch(
+            share=False,
+            show_error=True,
+            server_name="0.0.0.0",
+            server_port=7860,
+            favicon_path=None,
+            show_api=True
+        )
+    else:
+        logger.error("Failed to load models. Please check your model configuration.")