upload app and supporting files

app.py

@@ -0,0 +1,71 @@
+# app.py
+import streamlit as st
+from streamlit_webrtc import webrtc_streamer, VideoProcessorBase
+import av
+import cv2
+import torch
+import numpy as np
+from torchvision import transforms
+from utils.model_loader import load_model
+
+
+st.title("Facial Expression Recognition")
+
+# Load model
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+MODEL_PATH = "data/models/expression_predictor_cnn.pth"
+CLASSES = ['Angry', 'Disgust', 'Scared', 'Happy', 'Neutral', 'Sad', 'Surprised']
+model = load_model(MODEL_PATH, DEVICE)
+
+# Face detection
+face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+
+# Transform for inference
+transform = transforms.Compose([
+    transforms.ToPILImage(),
+    transforms.Grayscale(),
+    transforms.Resize((48, 48)),
+    transforms.ToTensor(),
+    transforms.Normalize((0.5,), (0.5,))
+])
+
+# Video processor
+livestatus = st.empty()
+class VideoProcessor(VideoProcessorBase):
+    def recv(self, frame):
+        global global_face_data
+        img = frame.to_ndarray(format="bgr24")
+        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5)
+        
+        face_data = []
+
+        for i, (x, y, w, h) in enumerate(faces):
+            face_crop = gray[y:y+h, x:x+w]
+            face_tensor = transform(face_crop).unsqueeze(0).to(DEVICE)
+
+            with torch.no_grad():
+                outputs = model(face_tensor)
+                probs = torch.nn.functional.softmax(outputs, dim=1)[0].cpu().numpy()
+                top_idx = np.argmax(probs)
+                label = CLASSES[top_idx]
+                
+            # Draw face + label on video
+            face_id = f"Face {i+1}"
+            cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 1)
+            cv2.putText(img, f"{face_id}: {label}", (x, y - 10),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)
+            
+        return av.VideoFrame.from_ndarray(img, format="bgr24")
+
+ctx = webrtc_streamer(
+    key="emotion-detect",
+    video_processor_factory=VideoProcessor,
+    media_stream_constraints={"video": True, "audio": False},
+    async_processing=True,
+)
+
+if ctx.state.playing:
+    livestatus.success("🟢 Live")
+else:
+    livestatus.error("🔴 Offline")

data/models/expression_predictor_cnn.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dbe74499e1659461a187bd820854520513fb94b2e9c094da7c2adf2915038d32
+size 1576685

src/streamlit_app.py

@@ -1,40 +0,0 @@
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))

utils/model_loader.py

@@ -0,0 +1,28 @@
+import torch
+import torch.nn as nn
+
+class ExpressionCNN(nn.Module):
+    def __init__(self, num_classes=7):
+        super(ExpressionCNN, self).__init__()
+        self.conv = nn.Sequential(
+            nn.Conv2d(1, 32, 3, padding=1), nn.ReLU(), nn.BatchNorm2d(32), nn.MaxPool2d(2),
+            nn.Conv2d(32, 64, 3, padding=1), nn.ReLU(), nn.BatchNorm2d(64), nn.MaxPool2d(2),
+            nn.Conv2d(64, 128, 3, padding=1), nn.ReLU(), nn.BatchNorm2d(128), nn.MaxPool2d(2),
+            nn.Conv2d(128, 256, 3, padding=1), nn.ReLU(), nn.BatchNorm2d(256), nn.AdaptiveAvgPool2d((1, 1))
+        )
+        self.fc = nn.Sequential(
+            nn.Flatten(),
+            nn.Linear(256, num_classes)
+        )
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = self.fc(x)
+        return x
+
+def load_model(model_path, device):
+    model = ExpressionCNN()
+    model.load_state_dict(torch.load(model_path, map_location=device))
+    model.to(device)
+    model.eval()
+    return model

utils/train.py

@@ -0,0 +1,121 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torchvision import datasets, transforms
+from torch.utils.data import DataLoader
+import matplotlib.pyplot as plt
+from PIL import ImageFile
+
+# Configuration
+BATCH_SIZE = 64
+EPOCHS = 10
+IMG_SIZE = 48
+MODEL_PATH = "data/models/expression_predictor_cnn.pth"
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(f"Using device: {DEVICE}")
+
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+# Data transforms
+transform = transforms.Compose([
+    transforms.Grayscale(),
+    transforms.Resize((48, 48)),
+    transforms.RandomHorizontalFlip(),
+    transforms.RandomRotation(10),
+    transforms.RandomAffine(degrees=0, translate=(0.1, 0.1)),
+    transforms.ToTensor(),
+    transforms.Normalize((0.5,), (0.5,))
+])
+
+# Datasets and loaders
+train_dataset = datasets.ImageFolder("data/train", transform=transform)
+val_dataset = datasets.ImageFolder("data/validation", transform=transform)
+
+train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=0)
+val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE, num_workers=0)
+
+# Class names
+CLASSES = train_dataset.classes
+NUM_CLASSES = len(CLASSES)
+print(f"Classes: {CLASSES}")
+
+# CNN Model
+class ExpressionCNN(nn.Module):
+    def __init__(self):
+        super(ExpressionCNN, self).__init__()
+        self.conv = nn.Sequential(
+            nn.Conv2d(1, 32, 3, padding=1), nn.ReLU(), nn.BatchNorm2d(32), nn.MaxPool2d(2),
+            nn.Conv2d(32, 64, 3, padding=1), nn.ReLU(), nn.BatchNorm2d(64), nn.MaxPool2d(2),
+            nn.Conv2d(64, 128, 3, padding=1), nn.ReLU(), nn.BatchNorm2d(128), nn.MaxPool2d(2),
+            nn.Conv2d(128, 256, 3, padding=1), nn.ReLU(), nn.BatchNorm2d(256), nn.AdaptiveAvgPool2d((1, 1))
+        )
+        self.fc = nn.Sequential(
+            nn.Flatten(),
+            nn.Linear(256, NUM_CLASSES)
+        )
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = self.fc(x)
+        return x
+
+model = ExpressionCNN().to(DEVICE)
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.Adam(model.parameters(), lr=0.001)
+scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.5)
+
+# Training loop
+train_loss_log = []
+val_loss_log = []
+
+for epoch in range(EPOCHS):
+    print(f"\nStarting Epoch {epoch+1}/{EPOCHS}")
+    model.train()
+    running_loss = 0.0
+    for images, labels in train_loader:
+        images, labels = images.to(DEVICE), labels.to(DEVICE)
+        optimizer.zero_grad()
+        outputs = model(images)
+        loss = criterion(outputs, labels)
+        loss.backward()
+        optimizer.step()
+        running_loss += loss.item()
+    scheduler.step()
+
+    train_loss = running_loss / len(train_loader)
+    train_loss_log.append(train_loss)
+
+    # Validation
+    model.eval()
+    val_loss = 0.0
+    correct = 0
+    total = 0
+    with torch.no_grad():
+        for images, labels in val_loader:
+            images, labels = images.to(DEVICE), labels.to(DEVICE)
+            outputs = model(images)
+            loss = criterion(outputs, labels)
+            val_loss += loss.item()
+            _, predicted = torch.max(outputs, 1)
+            correct += (predicted == labels).sum().item()
+            total += labels.size(0)
+
+    val_loss /= len(val_loader)
+    val_loss_log.append(val_loss)
+    accuracy = correct / total * 100
+
+    print(f"[{epoch+1}/{EPOCHS}] Train Loss: {train_loss:.4f} | Val Loss: {val_loss:.4f} | Val Acc: {accuracy:.2f}%")
+
+# Save model
+torch.save(model.state_dict(), MODEL_PATH)
+print(f"✅ Model saved to {MODEL_PATH}")
+
+# Plot loss
+plt.plot(train_loss_log, label="Train")
+plt.plot(val_loss_log, label="Validation")
+plt.title("Loss Curve")
+plt.xlabel("Epoch")
+plt.ylabel("Loss")
+plt.legend()
+plt.grid()
+plt.savefig("training_loss_plot.png")