final version

app.py

@@ -1,70 +1,155 @@
-import gradio as gr
+import os
 import cv2
+import io
+import tempfile
+import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
-from deepface import DeepFace
-import tempfile
+from PIL import Image
+import torch
+import torch.nn.functional as F
+from torchvision import transforms
+from facenet_pytorch import MTCNN
+import gradio as gr
+
+class EmotionModel(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.net = torch.nn.Sequential(
+            torch.nn.Conv2d(1, 32, 3, padding=1),
+            torch.nn.ReLU(),
+            torch.nn.MaxPool2d(2),
+            torch.nn.Conv2d(32, 64, 3, padding=1),
+            torch.nn.ReLU(),
+            torch.nn.MaxPool2d(2),
+            torch.nn.Flatten(),
+            torch.nn.Linear(64 * 12 * 12, 128),
+            torch.nn.ReLU(),
+            torch.nn.Linear(128, 7)  # 7 emotion classes
+        )
+
+    def forward(self, x):
+        return self.net(x)
+
+class EmotionDetector:
+    def __init__(self, device='cpu'):
+        self.device = device
+        self.model = EmotionModel().to(self.device)
+        self.model.eval()
+        self.emotions = ['angry', 'disgust', 'fear', 'happy', 'sad', 'surprise', 'neutral']
+        self.face_detector = MTCNN(keep_all=False, device=self.device)
+        self.transform = transforms.Compose([
+            transforms.Resize((48, 48))
+            # No ToTensor() here – face already comes as tensor
+        ])
+        self.softmax = torch.nn.Softmax(dim=1)
+
+        # OPTIONAL: load pre-trained weights if available
+        # self.model.load_state_dict(torch.load("emotion_model.pt", map_location=self.device))
+
+    def detect_emotions_video(self, video_path, sample_rate=30, max_size_mb=50):
+        try:
+            if video_path is None:
+                return None, "No video provided"
+
+            if os.path.getsize(video_path) / (1024 * 1024) > max_size_mb:
+                return None, f"File too large (>{max_size_mb} MB)."
+
+            cap = cv2.VideoCapture(video_path)
+            fps = int(cap.get(cv2.CAP_PROP_FPS))
+            frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+            if frame_count == 0:
+                return None, "Invalid video file"
+
+            frame_indices = range(0, frame_count, sample_rate)
+            emotions_over_time = []
+
+            for frame_idx in frame_indices:
+                cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
+                ret, frame = cap.read()
+                if not ret:
+                    continue
+
+                img_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                img_pil = Image.fromarray(img_rgb)
+
+                face_tensor = self.face_detector(img_pil)
+                if face_tensor is None:
+                    continue
+
+                face_tensor = self.transform(face_tensor)  # Resize
+                face_tensor = face_tensor.mean(dim=0, keepdim=True)  # convert to grayscale
+                face_tensor = face_tensor.unsqueeze(0).to(self.device)  # Add batch + channel
+
+                with torch.no_grad():
+                    output = self.model(face_tensor)
+                    probs = self.softmax(output).cpu().numpy()[0]
+
+                emotion_data = {self.emotions[i]: float(probs[i]) * 100 for i in range(len(self.emotions))}
+                emotion_data['timestamp'] = frame_idx / fps
+                emotions_over_time.append(emotion_data)
+
+            cap.release()
+
+            if not emotions_over_time:
+                return None, "No emotions detected."
+
+            df = pd.DataFrame(emotions_over_time)
+
+            plt.figure(figsize=(12, 8))
+            for emotion in self.emotions:
+                if emotion in df.columns:
+                    plt.plot(df['timestamp'], df[emotion], label=emotion.title(), linewidth=2)
+
+            plt.xlabel('Time (seconds)')
+            plt.ylabel('Confidence (%)')
+            plt.title('Emotions Over Time')
+            plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
+            plt.grid(True)
+            plt.tight_layout()
+
+            img_buf = io.BytesIO()
+            plt.savefig(img_buf, format='png', dpi=150, bbox_inches='tight')
+            img_buf.seek(0)
+            plt.close()
+
+            chart_image = Image.open(img_buf)
+            avg_emotions = df[self.emotions].mean().sort_values(ascending=False)
+
+            result_text = f"**Video Analysis Complete**\n"
+            result_text += f"**Frames Analyzed:** {len(emotions_over_time)}\n"
+            result_text += f"**Duration:** {df['timestamp'].max():.1f} seconds\n\n"
+            result_text += "**Average Emotions:**\n"
+            for emotion, confidence in avg_emotions.items():
+                result_text += f"• {emotion.title()}: {confidence:.1f}%\n"
+
+            return chart_image, result_text
+
+        except Exception as e:
+            return None, f"Error: {str(e)}"
+
+def create_interface():
+    detector = EmotionDetector()
+
+    def process(video, sample_rate):
+        if video is None:
+            return None, "Please upload a video."
+        return detector.detect_emotions_video(video, sample_rate)
+
+    return gr.Interface(
+        fn=process,
+        inputs=[
+            gr.Video(label="Upload Video"),
+            gr.Slider(minimum=1, maximum=60, step=1, value=30, label="Sample Rate (Frames)")
+        ],
+        outputs=[
+            gr.Image(type="pil", label="Emotion Chart"),
+            gr.Textbox(label="Analysis Summary")
+        ],
+        title="PyTorch-Only Emotion Detection",
+        description="Analyze emotions from a video using PyTorch and facenet-pytorch."
+    )
 
-def analyze_emotions(video_path):
-    cap = cv2.VideoCapture(video_path)
-    frame_rate = cap.get(cv2.CAP_PROP_FPS)
-    frame_interval = int(frame_rate * 2)  # Analyze every 2 seconds
-
-    emotion_data = []
-    frame_count = 0
-
-    while True:
-        ret, frame = cap.read()
-        if not ret:
-            break
-        if frame_count % frame_interval == 0:
-            try:
-                analysis = DeepFace.analyze(
-                    frame,
-                    actions=["emotion"],
-                    detector_backend="opencv",  # TensorFlow-free
-                    enforce_detection=False
-                )
-                emotion_data.append(analysis[0]["emotion"])
-            except Exception as e:
-                print("Error analyzing frame:", e)
-        frame_count += 1
-
-    cap.release()
-
-    if not emotion_data:
-        return "No faces detected."
-
-    df = pd.DataFrame(emotion_data)
-    avg_emotions = df.mean().sort_values(ascending=False)
-
-    # Plot
-    fig, ax = plt.subplots(figsize=(6, 3))
-    avg_emotions.plot(kind='bar', ax=ax, color='skyblue')
-    ax.set_title("Average Emotions Across Video")
-    ax.set_ylabel("Confidence (%)")
-    ax.set_ylim(0, 100)
-    plt.tight_layout()
-
-    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmpfile:
-        plt.savefig(tmpfile.name)
-        plot_path = tmpfile.name
-
-    summary = f"""
-**Video Analysis Complete**  
-**Frames Analyzed:** {len(df)}  
-**Duration:** {round(frame_count / frame_rate, 1)} seconds  
-
-**Average Emotions:**\n""" + "\n".join([f"• {emotion}: {round(score, 1)}%" for emotion, score in avg_emotions.items()])
-
-    return summary, plot_path
-
-
-iface = gr.Interface(
-    fn=analyze_emotions,
-    inputs=gr.Video(label="Upload a Video"),
-    outputs=[gr.Markdown(), gr.Image(type="filepath", label="Emotion Summary Chart")],
-    title="Emotion Analysis from Video (No TensorFlow)"
-)
-
-iface.launch()
+if __name__ == "__main__":
+    create_interface().launch()