Initial deploy with models

Dockerfile

@@ -0,0 +1,38 @@
+# Base image with TensorFlow GPU support
+# Use CPU version for Hugging Face Spaces free tier compatibility if needed
+# But keeping GPU as the project is configured for it. 
+# HF Spaces offers CPU Basic (Free) and GPU upgrades. 
+# Using a lighter base image might be better for free tier, but TF is heavy anyway.
+FROM tensorflow/tensorflow:2.13.0
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies including libGL for OpenCV
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY src/ ./src/
+COPY frontend/ ./frontend/
+
+# Create a models directory
+# Note: You must upload your trained models here or use Git LFS
+COPY models/ ./models/
+
+# Expose the port Hugging Face Spaces expects
+EXPOSE 7860
+
+# Default command to run Streamlit on port 7860
+CMD ["streamlit", "run", "frontend/app.py", "--server.port", "7860", "--server.address", "0.0.0.0"]

frontend/app.py

@@ -0,0 +1,485 @@
+"""
+Streamlit Dashboard for Emotion Recognition System.
+"""
+import io
+import sys
+from pathlib import Path
+
+import streamlit as st
+import numpy as np
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from PIL import Image
+
+# Add project root to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from src.config import EMOTION_CLASSES, MODELS_DIR
+from src.inference.predictor import EmotionPredictor
+
+# Page configuration
+st.set_page_config(
+    page_title="Emotion Recognition Dashboard",
+    page_icon="😊",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 2.5rem;
+        font-weight: bold;
+        background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        text-align: center;
+        margin-bottom: 1rem;
+    }
+    .emotion-card {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        padding: 1.5rem;
+        border-radius: 1rem;
+        color: white;
+        text-align: center;
+        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+    }
+    .confidence-high {
+        color: #10b981;
+        font-weight: bold;
+    }
+    .confidence-medium {
+        color: #f59e0b;
+        font-weight: bold;
+    }
+    .confidence-low {
+        color: #ef4444;
+        font-weight: bold;
+    }
+    .stTabs [data-baseweb="tab-list"] {
+        gap: 2rem;
+    }
+    .stTabs [data-baseweb="tab"] {
+        height: 50px;
+        padding-left: 20px;
+        padding-right: 20px;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Emotion emoji mapping
+EMOTION_EMOJIS = {
+    "angry": "😠",
+    "disgusted": "🤢",
+    "fearful": "😨",
+    "happy": "😊",
+    "neutral": "😐",
+    "sad": "😢",
+    "surprised": "😲"
+}
+
+# Color palette for emotions
+EMOTION_COLORS = {
+    "angry": "#ef4444",
+    "disgusted": "#84cc16",
+    "fearful": "#a855f7",
+    "happy": "#22c55e",
+    "neutral": "#6b7280",
+    "sad": "#3b82f6",
+    "surprised": "#f59e0b"
+}
+
+
+@st.cache_resource
+def load_predictor(model_name: str):
+    """Load and cache the emotion predictor."""
+    predictor = EmotionPredictor(model_name)
+    if predictor.load():
+        return predictor
+    return None
+
+
+def get_intensity_class(intensity: str) -> str:
+    """Get CSS class for intensity."""
+    return f"confidence-{intensity}"
+
+
+def create_probability_chart(probabilities: dict) -> go.Figure:
+    """Create a horizontal bar chart for probabilities."""
+    emotions = list(probabilities.keys())
+    values = list(probabilities.values())
+    colors = [EMOTION_COLORS.get(e, "#6b7280") for e in emotions]
+    
+    fig = go.Figure(go.Bar(
+        x=values,
+        y=[f"{EMOTION_EMOJIS.get(e, '')} {e.capitalize()}" for e in emotions],
+        orientation='h',
+        marker_color=colors,
+        text=[f"{v:.1%}" for v in values],
+        textposition='outside'
+    ))
+    
+    fig.update_layout(
+        title="Emotion Probabilities",
+        xaxis_title="Probability",
+        yaxis_title="Emotion",
+        height=350,
+        margin=dict(l=20, r=20, t=40, b=20),
+        xaxis=dict(range=[0, 1.1])
+    )
+    
+    return fig
+
+
+def create_emotion_distribution_pie(counts: dict) -> go.Figure:
+    """Create a pie chart for emotion distribution."""
+    emotions = [e for e, c in counts.items() if c > 0]
+    values = [c for c in counts.values() if c > 0]
+    colors = [EMOTION_COLORS.get(e, "#6b7280") for e in emotions]
+    
+    fig = go.Figure(go.Pie(
+        labels=[f"{EMOTION_EMOJIS.get(e, '')} {e.capitalize()}" for e in emotions],
+        values=values,
+        marker_colors=colors,
+        hole=0.4,
+        textinfo='percent+label'
+    ))
+    
+    fig.update_layout(
+        title="Emotion Distribution",
+        height=400,
+        margin=dict(l=20, r=20, t=40, b=20)
+    )
+    
+    return fig
+
+
+def main():
+    """Main dashboard application."""
+    # Header
+    st.markdown('<h1 class="main-header">🎭 Emotion Recognition Dashboard</h1>', unsafe_allow_html=True)
+    st.markdown("---")
+    
+    # Sidebar
+    with st.sidebar:
+        st.image("https://img.icons8.com/clouds/200/brain.png", width=100)
+        st.title("⚙️ Settings")
+        
+        # Model selection
+        available_models = EmotionPredictor.get_available_models()
+        model_options = [name for name, available in available_models.items() if available]
+        
+        if not model_options:
+            st.error("No trained models found! Please train a model first.")
+            st.info("Run: `python scripts/train_models.py`")
+            model_name = None
+        else:
+            model_name = st.selectbox(
+                "🤖 Select Model",
+                model_options,
+                format_func=lambda x: {
+                    "custom_cnn": "Custom CNN",
+                    "mobilenet": "MobileNetV2",
+                    "vgg19": "VGG-19"
+                }.get(x, x)
+            )
+        
+        # Face detection toggle
+        detect_face = st.toggle("👤 Enable Face Detection", value=True)
+        
+        # Confidence threshold
+        confidence_threshold = st.slider(
+            "📊 Confidence Threshold",
+            min_value=0.0,
+            max_value=1.0,
+            value=0.5,
+            step=0.05
+        )
+        
+        st.markdown("---")
+        
+        # Model info
+        st.subheader("📋 Model Status")
+        for name, available in available_models.items():
+            icon = "✅" if available else "❌"
+            display_name = {
+                "custom_cnn": "Custom CNN",
+                "mobilenet": "MobileNetV2",
+                "vgg19": "VGG-19"
+            }.get(name, name)
+            st.write(f"{icon} {display_name}")
+    
+    # Main content
+    if model_name is None:
+        st.warning("Please train a model before using the dashboard.")
+        return
+    
+    # Load predictor
+    predictor = load_predictor(model_name)
+    if predictor is None:
+        st.error(f"Failed to load model: {model_name}")
+        return
+    
+    # Tabs
+    tab1, tab2, tab3 = st.tabs(["📷 Single Image", "📁 Batch Processing", "📊 Model Performance"])
+    
+    # Tab 1: Single Image Analysis
+    with tab1:
+        st.subheader("Upload an Image for Emotion Analysis")
+        
+        col1, col2 = st.columns([1, 1])
+        
+        with col1:
+            uploaded_file = st.file_uploader(
+                "Choose an image...",
+                type=["jpg", "jpeg", "png", "bmp"],
+                key="single_upload"
+            )
+            
+            if uploaded_file is not None:
+                image = Image.open(uploaded_file)
+                st.image(image, caption="Uploaded Image", width="stretch")
+        
+        with col2:
+            if uploaded_file is not None:
+                with st.spinner("Analyzing emotion..."):
+                    # Convert to numpy array
+                    image_array = np.array(image.convert("RGB"))
+                    
+                    # Predict
+                    result = predictor.predict(image_array, detect_face=detect_face)
+                
+                if "error" in result:
+                    st.error(f"❌ {result['error']}")
+                else:
+                    # Display result
+                    emotion = result["emotion"]
+                    confidence = result["confidence"]
+                    intensity = result["intensity"]
+                    
+                    # Emotion card
+                    st.markdown(f"""
+                    <div class="emotion-card">
+                        <h1 style="font-size: 4rem; margin: 0;">{EMOTION_EMOJIS.get(emotion, '🎭')}</h1>
+                        <h2 style="margin: 0.5rem 0;">{emotion.upper()}</h2>
+                        <p style="font-size: 1.2rem;">Confidence: {confidence:.1%}</p>
+                        <p>Intensity: {intensity.capitalize()}</p>
+                    </div>
+                    """, unsafe_allow_html=True)
+                    
+                    # Probability chart
+                    if "all_probabilities" in result:
+                        fig = create_probability_chart(result["all_probabilities"])
+                        st.plotly_chart(fig, use_container_width=True)
+                    
+                    # Face detection info
+                    if result["face_detected"]:
+                        st.success("✅ Face detected successfully")
+                    else:
+                        st.warning("⚠️ No face detected - using full image")
+    
+    # Tab 2: Batch Processing
+    with tab2:
+        st.subheader("Upload Multiple Images for Batch Analysis")
+        
+        uploaded_files = st.file_uploader(
+            "Choose images...",
+            type=["jpg", "jpeg", "png", "bmp"],
+            accept_multiple_files=True,
+            key="batch_upload"
+        )
+        
+        if uploaded_files:
+            st.write(f"📁 {len(uploaded_files)} files selected")
+            
+            if st.button("🚀 Analyze All", type="primary"):
+                progress_bar = st.progress(0)
+                status_text = st.empty()
+                
+                results = []
+                images = []
+                
+                for i, file in enumerate(uploaded_files):
+                    status_text.text(f"Processing image {i+1}/{len(uploaded_files)}...")
+                    progress_bar.progress((i + 1) / len(uploaded_files))
+                    
+                    try:
+                        image = Image.open(file)
+                        images.append(image)
+                        image_array = np.array(image.convert("RGB"))
+                        result = predictor.predict(image_array, detect_face=detect_face)
+                        result["filename"] = file.name
+                        results.append(result)
+                    except Exception as e:
+                        results.append({"error": str(e), "filename": file.name})
+                
+                status_text.text("✅ Analysis complete!")
+                
+                # Display results
+                col1, col2 = st.columns([1, 1])
+                
+                with col1:
+                    # Summary statistics
+                    successful = [r for r in results if "error" not in r]
+                    
+                    if successful:
+                        emotion_counts = {}
+                        for r in successful:
+                            emotion = r["emotion"]
+                            emotion_counts[emotion] = emotion_counts.get(emotion, 0) + 1
+                        
+                        # Pie chart
+                        fig = create_emotion_distribution_pie(emotion_counts)
+                        st.plotly_chart(fig, use_container_width=True)
+                    
+                    st.metric("Total Images", len(results))
+                    st.metric("Successful", len(successful))
+                    st.metric("Failed", len(results) - len(successful))
+                
+                with col2:
+                    # Results table
+                    table_data = []
+                    for r in results:
+                        if "error" in r:
+                            table_data.append({
+                                "File": r.get("filename", "Unknown"),
+                                "Emotion": "❌ Error",
+                                "Confidence": "-",
+                                "Intensity": "-"
+                            })
+                        else:
+                            table_data.append({
+                                "File": r.get("filename", "Unknown"),
+                                "Emotion": f"{EMOTION_EMOJIS.get(r['emotion'], '')} {r['emotion'].capitalize()}",
+                                "Confidence": f"{r['confidence']:.1%}",
+                                "Intensity": r["intensity"].capitalize()
+                            })
+                    
+                    df = pd.DataFrame(table_data)
+                    st.dataframe(df, use_container_width=True, height=400)
+                    
+                    # Download button
+                    csv = df.to_csv(index=False)
+                    st.download_button(
+                        "📥 Download Results (CSV)",
+                        csv,
+                        "emotion_results.csv",
+                        "text/csv"
+                    )
+                
+                # Image gallery with predictions
+                st.subheader("📷 Analyzed Images")
+                cols = st.columns(4)
+                for i, (img, result) in enumerate(zip(images, results)):
+                    with cols[i % 4]:
+                        if "error" not in result:
+                            emoji = EMOTION_EMOJIS.get(result["emotion"], "")
+                            st.image(img, caption=f"{emoji} {result['emotion']}", width="stretch")
+                        else:
+                            st.image(img, caption="❌ Error", width="stretch")
+    
+    # Tab 3: Model Performance
+    with tab3:
+        st.subheader("📊 Model Performance Metrics")
+        
+        # Check for saved metrics
+        metrics_path = MODELS_DIR / f"{model_name}.meta.json"
+        history_path = MODELS_DIR / f"{model_name}.history.json"
+        
+        if metrics_path.exists():
+            import json
+            with open(metrics_path, 'r') as f:
+                metadata = json.load(f)
+            
+            col1, col2, col3 = st.columns(3)
+            
+            with col1:
+                st.metric(
+                    "Best Validation Accuracy",
+                    f"{metadata.get('best_val_accuracy', 0):.1%}"
+                )
+            
+            with col2:
+                st.metric(
+                    "Training Duration",
+                    f"{metadata.get('training_duration_seconds', 0)/60:.1f} min"
+                )
+            
+            with col3:
+                st.metric(
+                    "Epochs Completed",
+                    metadata.get('epochs_completed', 0)
+                )
+            
+            if history_path.exists():
+                with open(history_path, 'r') as f:
+                    history = json.load(f)
+                
+                # Training curves
+                fig = go.Figure()
+                
+                epochs = list(range(1, len(history['accuracy']) + 1))
+                
+                fig.add_trace(go.Scatter(
+                    x=epochs, y=history['accuracy'],
+                    mode='lines', name='Training Accuracy',
+                    line=dict(color='#3b82f6')
+                ))
+                
+                fig.add_trace(go.Scatter(
+                    x=epochs, y=history['val_accuracy'],
+                    mode='lines', name='Validation Accuracy',
+                    line=dict(color='#ef4444')
+                ))
+                
+                fig.update_layout(
+                    title="Training History",
+                    xaxis_title="Epoch",
+                    yaxis_title="Accuracy",
+                    height=400
+                )
+                
+                st.plotly_chart(fig, use_container_width=True)
+                
+                # Loss curves
+                fig2 = go.Figure()
+                
+                fig2.add_trace(go.Scatter(
+                    x=epochs, y=history['loss'],
+                    mode='lines', name='Training Loss',
+                    line=dict(color='#3b82f6')
+                ))
+                
+                fig2.add_trace(go.Scatter(
+                    x=epochs, y=history['val_loss'],
+                    mode='lines', name='Validation Loss',
+                    line=dict(color='#ef4444')
+                ))
+                
+                fig2.update_layout(
+                    title="Loss History",
+                    xaxis_title="Epoch",
+                    yaxis_title="Loss",
+                    height=400
+                )
+                
+                st.plotly_chart(fig2, use_container_width=True)
+        else:
+            st.info("No training metrics found for this model. Train the model to see performance data.")
+            
+            # Show placeholder
+            st.markdown("""
+            ### Expected Metrics After Training
+            
+            | Model | Expected Accuracy | Training Time |
+            |-------|------------------|---------------|
+            | Custom CNN | 60-68% | ~30 min |
+            | MobileNetV2 | 65-72% | ~45 min |
+            | VGG-19 | 68-75% | ~60 min |
+            """)
+
+
+if __name__ == "__main__":
+    main()

models/custom_cnn.h5

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

models/custom_cnn.history.json

@@ -0,0 +1,262 @@
+{
+  "accuracy": [
+    0.15269069373607635,
+    0.15229885280132294,
+    0.14925113320350647,
+    0.16035354137420654,
+    0.14650818705558777,
+    0.1529519259929657,
+    0.18447405099868774,
+    0.20154127478599548,
+    0.20162835717201233,
+    0.2072448581457138,
+    0.2176506370306015,
+    0.23267154395580292,
+    0.23820097744464874,
+    0.23772205412387848,
+    0.2543974220752716,
+    0.2947579324245453,
+    0.31957507133483887,
+    0.3651602268218994,
+    0.3738679885864258,
+    0.3878439664840698,
+    0.4040403962135315,
+    0.40382272005081177,
+    0.42293626070022583,
+    0.4291187822818756,
+    0.43521422147750854,
+    0.4663880169391632,
+    0.47574886679649353,
+    0.480581670999527,
+    0.49076977372169495,
+    0.4974747598171234,
+    0.5010885000228882,
+    0.501349687576294,
+    0.5120167136192322,
+    0.5220306515693665,
+    0.522944986820221,
+    0.5263845324516296,
+    0.5292145609855652,
+    0.5357889533042908,
+    0.5326105952262878,
+    0.5370079874992371,
+    0.5618686676025391,
+    0.5710553526878357,
+    0.5716649293899536,
+    0.5865116715431213,
+    0.5881226062774658,
+    0.5922152400016785,
+    0.5961337685585022,
+    0.5938697457313538,
+    0.6016196608543396,
+    0.6010971665382385
+  ],
+  "loss": [
+    20.70295524597168,
+    6.6751275062561035,
+    3.4141359329223633,
+    2.6772806644439697,
+    2.363776922225952,
+    2.305654764175415,
+    2.403165102005005,
+    2.533033847808838,
+    2.592125415802002,
+    2.516871929168701,
+    2.634507179260254,
+    2.2788898944854736,
+    2.248971700668335,
+    2.259343147277832,
+    2.2574307918548584,
+    2.277164936065674,
+    2.2215516567230225,
+    2.0204102993011475,
+    2.056856632232666,
+    2.005807638168335,
+    2.003291368484497,
+    1.9824334383010864,
+    1.954105257987976,
+    1.9302726984024048,
+    1.9290143251419067,
+    1.7764708995819092,
+    1.699206829071045,
+    1.6769280433654785,
+    1.6617697477340698,
+    1.6487752199172974,
+    1.6480680704116821,
+    1.647431492805481,
+    1.618944525718689,
+    1.6199805736541748,
+    1.6172568798065186,
+    1.6095706224441528,
+    1.60358726978302,
+    1.5906955003738403,
+    1.5961298942565918,
+    1.5957502126693726,
+    1.4978364706039429,
+    1.4400925636291504,
+    1.4301934242248535,
+    1.3841499090194702,
+    1.3796941041946411,
+    1.3780864477157593,
+    1.367702603340149,
+    1.3718606233596802,
+    1.3513654470443726,
+    1.335976481437683
+  ],
+  "val_accuracy": [
+    0.019334610551595688,
+    0.03274690732359886,
+    0.17749521136283875,
+    0.09249259531497955,
+    0.16617314517498016,
+    0.1546768844127655,
+    0.17035359144210815,
+    0.14997386932373047,
+    0.18359170854091644,
+    0.12088486552238464,
+    0.23880857229232788,
+    0.28549033403396606,
+    0.2426406592130661,
+    0.14178714156150818,
+    0.16094757616519928,
+    0.21390001475811005,
+    0.2203448861837387,
+    0.352726012468338,
+    0.34628114104270935,
+    0.42222610116004944,
+    0.32328861951828003,
+    0.39296290278434753,
+    0.38094407320022583,
+    0.3227660655975342,
+    0.35046160221099854,
+    0.4741334319114685,
+    0.49294549226760864,
+    0.4274516701698303,
+    0.5124542713165283,
+    0.46873366832733154,
+    0.5080996155738831,
+    0.5359693169593811,
+    0.4953840672969818,
+    0.5192475318908691,
+    0.5549556016921997,
+    0.5014805793762207,
+    0.5380595922470093,
+    0.5481623411178589,
+    0.5141961574554443,
+    0.55303955078125,
+    0.5638390779495239,
+    0.5594844222068787,
+    0.6054694056510925,
+    0.5887476205825806,
+    0.5864831805229187,
+    0.5976310968399048,
+    0.5755094885826111,
+    0.5990245342254639,
+    0.5859606266021729,
+    0.5878766775131226
+  ],
+  "val_loss": [
+    10.306150436401367,
+    4.229166507720947,
+    2.9087648391723633,
+    2.51203989982605,
+    2.2901315689086914,
+    2.252924680709839,
+    2.433279275894165,
+    3.151798963546753,
+    2.5496649742126465,
+    2.702935218811035,
+    2.5200254917144775,
+    2.191758155822754,
+    2.398240089416504,
+    2.371654987335205,
+    2.4415881633758545,
+    2.3200838565826416,
+    2.431246519088745,
+    2.050586223602295,
+    2.0909876823425293,
+    1.967246413230896,
+    2.160478115081787,
+    2.0182101726531982,
+    1.986769676208496,
+    2.2352793216705322,
+    2.157156467437744,
+    1.7153019905090332,
+    1.662605881690979,
+    1.8105882406234741,
+    1.6218799352645874,
+    1.729047417640686,
+    1.681536316871643,
+    1.5821231603622437,
+    1.6714152097702026,
+    1.6351673603057861,
+    1.5606050491333008,
+    1.6746041774749756,
+    1.6208828687667847,
+    1.5802900791168213,
+    1.672598958015442,
+    1.58816397190094,
+    1.512089729309082,
+    1.5220553874969482,
+    1.3933297395706177,
+    1.4107120037078857,
+    1.4645394086837769,
+    1.416934609413147,
+    1.4484670162200928,
+    1.3919000625610352,
+    1.4328689575195312,
+    1.4462361335754395
+  ],
+  "learning_rate": [
+    0.0010000000474974513,
+    0.0010000000474974513,
+    0.0010000000474974513,
+    0.0010000000474974513,
+    0.0010000000474974513,
+    0.0010000000474974513,
+    0.0010000000474974513,
+    0.0010000000474974513,
+    0.0010000000474974513,
+    0.0010000000474974513,
+    0.0010000000474974513,
+    0.0005000000237487257,
+    0.0005000000237487257,
+    0.0005000000237487257,
+    0.0005000000237487257,
+    0.0005000000237487257,
+    0.0005000000237487257,
+    0.0002500000118743628,
+    0.0002500000118743628,
+    0.0002500000118743628,
+    0.0002500000118743628,
+    0.0002500000118743628,
+    0.0002500000118743628,
+    0.0002500000118743628,
+    0.0002500000118743628,
+    0.0001250000059371814,
+    0.0001250000059371814,
+    0.0001250000059371814,
+    0.0001250000059371814,
+    0.0001250000059371814,
+    0.0001250000059371814,
+    0.0001250000059371814,
+    0.0001250000059371814,
+    0.0001250000059371814,
+    0.0001250000059371814,
+    0.0001250000059371814,
+    0.0001250000059371814,
+    0.0001250000059371814,
+    0.0001250000059371814,
+    0.0001250000059371814,
+    6.25000029685907e-05,
+    6.25000029685907e-05,
+    6.25000029685907e-05,
+    6.25000029685907e-05,
+    6.25000029685907e-05,
+    6.25000029685907e-05,
+    6.25000029685907e-05,
+    6.25000029685907e-05,
+    6.25000029685907e-05,
+    6.25000029685907e-05
+  ]
+}

models/custom_cnn.meta.json

@@ -0,0 +1,15 @@
+{
+  "learning_rate": 0.001,
+  "loss_function": "categorical_crossentropy",
+  "metrics": [
+    "accuracy"
+  ],
+  "training_started": "2026-02-02T04:27:09.945021",
+  "epochs_requested": 50,
+  "training_ended": "2026-02-02T13:34:58.163201",
+  "training_duration_seconds": 32868.21818,
+  "epochs_completed": 50,
+  "final_accuracy": 0.6010971665382385,
+  "final_val_accuracy": 0.5878766775131226,
+  "best_val_accuracy": 0.6054694056510925
+}

models/logs/custom_cnn/train/events.out.tfevents.1769986631.JOSH_MARK.24880.0.v2

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

models/logs/custom_cnn/validation/events.out.tfevents.1769987506.JOSH_MARK.24880.1.v2

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

models/logs/mobilenet_v2/train/events.out.tfevents.1770019504.JOSH_MARK.24880.2.v2

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

models/logs/mobilenet_v2/train/events.out.tfevents.1770020997.JOSH_MARK.24880.4.v2

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

models/logs/mobilenet_v2/train/events.out.tfevents.1770060970.JOSH_MARK.1932.0.v2

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

models/logs/mobilenet_v2/train/events.out.tfevents.1770062582.JOSH_MARK.1932.2.v2

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

models/logs/mobilenet_v2/validation/events.out.tfevents.1770019615.JOSH_MARK.24880.3.v2

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

models/logs/mobilenet_v2/validation/events.out.tfevents.1770021071.JOSH_MARK.24880.5.v2

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

models/logs/mobilenet_v2/validation/events.out.tfevents.1770061342.JOSH_MARK.1932.1.v2

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

models/logs/mobilenet_v2/validation/events.out.tfevents.1770062665.JOSH_MARK.1932.3.v2

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

models/logs/vgg19/train/events.out.tfevents.1770023002.JOSH_MARK.24880.6.v2

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

models/logs/vgg19/train/events.out.tfevents.1770029728.JOSH_MARK.24880.8.v2

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

models/logs/vgg19/train/events.out.tfevents.1770063874.JOSH_MARK.14568.0.v2

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

models/logs/vgg19/train/events.out.tfevents.1770068280.JOSH_MARK.14988.0.v2

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

models/logs/vgg19/train/events.out.tfevents.1770082770.JOSH_MARK.14988.2.v2

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

models/logs/vgg19/validation/events.out.tfevents.1770023476.JOSH_MARK.24880.7.v2

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

models/logs/vgg19/validation/events.out.tfevents.1770030127.JOSH_MARK.24880.9.v2

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

models/logs/vgg19/validation/events.out.tfevents.1770064525.JOSH_MARK.14568.1.v2

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

models/logs/vgg19/validation/events.out.tfevents.1770068666.JOSH_MARK.14988.1.v2

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

models/logs/vgg19/validation/events.out.tfevents.1770083165.JOSH_MARK.14988.3.v2

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

models/mobilenet_v2.h5

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

models/mobilenet_v2.history.json

@@ -0,0 +1,67 @@
+{
+  "accuracy": [
+    0.2706809341907501,
+    0.30677464604377747,
+    0.315395325422287,
+    0.3210989236831665,
+    0.33437827229499817,
+    0.3370341360569,
+    0.3439567983150482,
+    0.34918147325515747,
+    0.3457418978214264,
+    0.3518373370170593,
+    0.3530564308166504
+  ],
+  "loss": [
+    1.8339711427688599,
+    1.7757574319839478,
+    1.743255615234375,
+    1.720676302909851,
+    1.689762830734253,
+    1.6830896139144897,
+    1.670864462852478,
+    1.6629376411437988,
+    1.6575630903244019,
+    1.650472640991211,
+    1.643319010734558
+  ],
+  "val_accuracy": [
+    0.25134992599487305,
+    0.25134992599487305,
+    0.14439992606639862,
+    0.25134992599487305,
+    0.25134992599487305,
+    0.25134992599487305,
+    0.26127851009368896,
+    0.25622713565826416,
+    0.11043372005224228,
+    0.11757533252239227,
+    0.11896882206201553
+  ],
+  "val_loss": [
+    6.824132442474365,
+    8.780102729797363,
+    8.830862998962402,
+    8.673893928527832,
+    10.961349487304688,
+    9.59477424621582,
+    7.310698986053467,
+    7.944781303405762,
+    10.567312240600586,
+    7.704894542694092,
+    6.902732849121094
+  ],
+  "learning_rate": [
+    9.999999747378752e-05,
+    9.999999747378752e-05,
+    9.999999747378752e-05,
+    9.999999747378752e-05,
+    9.999999747378752e-05,
+    9.999999747378752e-05,
+    4.999999873689376e-05,
+    4.999999873689376e-05,
+    4.999999873689376e-05,
+    4.999999873689376e-05,
+    4.999999873689376e-05
+  ]
+}

models/mobilenet_v2.meta.json

@@ -0,0 +1,15 @@
+{
+  "learning_rate": 0.0001,
+  "loss_function": "categorical_crossentropy",
+  "metrics": [
+    "accuracy"
+  ],
+  "training_started": "2026-02-03T01:33:02.533762",
+  "epochs_requested": 20,
+  "training_ended": "2026-02-03T01:51:17.847554",
+  "training_duration_seconds": 1095.313792,
+  "epochs_completed": 11,
+  "final_accuracy": 0.3530564308166504,
+  "final_val_accuracy": 0.11896882206201553,
+  "best_val_accuracy": 0.26127851009368896
+}

models/vgg19.h5

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

models/vgg19.history.json

@@ -0,0 +1,112 @@
+{
+  "accuracy": [
+    0.6472048163414001,
+    0.6577411890029907,
+    0.663314163684845,
+    0.6661877632141113,
+    0.6683211326599121,
+    0.6746777892112732,
+    0.678639829158783,
+    0.6781609058380127,
+    0.6804684996604919,
+    0.6846917271614075,
+    0.6875653266906738,
+    0.6928770542144775,
+    0.6930947303771973,
+    0.6967955231666565,
+    0.6986677050590515,
+    0.7037182450294495,
+    0.7013235688209534,
+    0.705329179763794,
+    0.7071577906608582,
+    0.7095524072647095
+  ],
+  "loss": [
+    0.9494282603263855,
+    0.9269279837608337,
+    0.9132461547851562,
+    0.9060502648353577,
+    0.8947601914405823,
+    0.8831118941307068,
+    0.8768442869186401,
+    0.874686062335968,
+    0.8647421002388,
+    0.8572869896888733,
+    0.8513924479484558,
+    0.8356429934501648,
+    0.8330938816070557,
+    0.8248153924942017,
+    0.827460765838623,
+    0.8220475912094116,
+    0.8190444111824036,
+    0.8056929111480713,
+    0.8031319379806519,
+    0.7939973473548889
+  ],
+  "val_accuracy": [
+    0.6099982857704163,
+    0.6087789535522461,
+    0.6148754358291626,
+    0.6120885014533997,
+    0.6239331364631653,
+    0.6180108189582825,
+    0.6162689328193665,
+    0.6113917231559753,
+    0.6174882650375366,
+    0.6145271062850952,
+    0.6225396394729614,
+    0.6141787171363831,
+    0.6279394030570984,
+    0.6181849837303162,
+    0.6190559267997742,
+    0.6277651786804199,
+    0.6309005618095398,
+    0.6220170855522156,
+    0.6244556903839111,
+    0.6169657111167908
+  ],
+  "val_loss": [
+    1.0432090759277344,
+    1.0663282871246338,
+    1.2026596069335938,
+    1.053371787071228,
+    1.1141172647476196,
+    1.0393040180206299,
+    1.0537439584732056,
+    1.0666412115097046,
+    1.0747647285461426,
+    1.0494613647460938,
+    1.0501089096069336,
+    1.0589252710342407,
+    1.0657376050949097,
+    1.0464764833450317,
+    1.0556851625442505,
+    1.0362597703933716,
+    1.051085352897644,
+    1.071323037147522,
+    1.0513226985931396,
+    1.1507371664047241
+  ],
+  "learning_rate": [
+    9.999999747378752e-05,
+    9.999999747378752e-05,
+    9.999999747378752e-05,
+    9.999999747378752e-05,
+    9.999999747378752e-05,
+    9.999999747378752e-05,
+    9.999999747378752e-05,
+    9.999999747378752e-05,
+    9.999999747378752e-05,
+    9.999999747378752e-05,
+    9.999999747378752e-05,
+    4.999999873689376e-05,
+    4.999999873689376e-05,
+    4.999999873689376e-05,
+    4.999999873689376e-05,
+    4.999999873689376e-05,
+    4.999999873689376e-05,
+    4.999999873689376e-05,
+    4.999999873689376e-05,
+    4.999999873689376e-05
+  ]
+}

models/vgg19.meta.json

@@ -0,0 +1,15 @@
+{
+  "learning_rate": 0.0001,
+  "loss_function": "categorical_crossentropy",
+  "metrics": [
+    "accuracy"
+  ],
+  "training_started": "2026-02-03T07:09:30.363125",
+  "epochs_requested": 20,
+  "training_ended": "2026-02-03T09:49:04.904804",
+  "training_duration_seconds": 9574.541679,
+  "epochs_completed": 20,
+  "final_accuracy": 0.7095524072647095,
+  "final_val_accuracy": 0.6169657111167908,
+  "best_val_accuracy": 0.6309005618095398
+}

requirements.txt

@@ -0,0 +1,28 @@
+# Core Deep Learning
+tensorflow>=2.10.0
+keras>=2.10.0
+numpy>=1.21.0
+pandas>=1.4.0
+scikit-learn>=1.0.0
+
+# Image Processing
+opencv-python>=4.5.0
+Pillow>=9.0.0
+mtcnn>=0.1.1
+
+# API
+fastapi>=0.95.0
+uvicorn>=0.21.0
+python-multipart>=0.0.6
+
+# Frontend
+streamlit>=1.22.0
+plotly>=5.13.0
+
+# Visualization
+matplotlib>=3.5.0
+seaborn>=0.12.0
+
+# Development
+pytest>=7.0.0
+httpx>=0.23.0

src/__init__.py

@@ -0,0 +1,2 @@
+# Emotion Recognition System
+__version__ = "1.0.0"

src/config.py

@@ -0,0 +1,76 @@
+"""
+Configuration settings for the Emotion Recognition System.
+"""
+import os
+from pathlib import Path
+
+# Project paths
+PROJECT_ROOT = Path(__file__).parent.parent
+DATA_DIR = PROJECT_ROOT / "data"
+TRAIN_DIR = DATA_DIR / "train"
+TEST_DIR = DATA_DIR / "test"
+MODELS_DIR = PROJECT_ROOT / "models"
+
+# Create models directory if it doesn't exist
+MODELS_DIR.mkdir(exist_ok=True)
+
+# Image settings
+IMAGE_SIZE = (48, 48)
+IMAGE_SIZE_TRANSFER = (96, 96)  # For transfer learning models
+NUM_CHANNELS = 1  # Grayscale
+NUM_CHANNELS_RGB = 3  # For transfer learning
+
+# Emotion classes (7 classes from FER dataset)
+EMOTION_CLASSES = [
+    "angry",
+    "disgusted",
+    "fearful",
+    "happy",
+    "neutral",
+    "sad",
+    "surprised"
+]
+NUM_CLASSES = len(EMOTION_CLASSES)
+
+# Emotion to index mapping
+EMOTION_TO_IDX = {emotion: idx for idx, emotion in enumerate(EMOTION_CLASSES)}
+IDX_TO_EMOTION = {idx: emotion for idx, emotion in enumerate(EMOTION_CLASSES)}
+
+# Training hyperparameters
+BATCH_SIZE = 64
+EPOCHS = 50
+LEARNING_RATE = 0.001
+LEARNING_RATE_FINE_TUNE = 0.0001
+VALIDATION_SPLIT = 0.2
+
+# Data augmentation parameters
+AUGMENTATION_CONFIG = {
+    "rotation_range": 15,
+    "width_shift_range": 0.1,
+    "height_shift_range": 0.1,
+    "horizontal_flip": True,
+    "zoom_range": 0.1,
+    "brightness_range": (0.9, 1.1),
+    "fill_mode": "nearest"
+}
+
+# Model save paths
+CUSTOM_CNN_PATH = MODELS_DIR / "custom_cnn.h5"
+MOBILENET_PATH = MODELS_DIR / "mobilenet_v2.h5"
+VGG_PATH = MODELS_DIR / "vgg19.h5"
+
+# Training callbacks
+EARLY_STOPPING_PATIENCE = 10
+REDUCE_LR_PATIENCE = 5
+REDUCE_LR_FACTOR = 0.5
+
+# Intensity thresholds
+INTENSITY_HIGH_THRESHOLD = 0.8
+INTENSITY_MEDIUM_THRESHOLD = 0.5
+
+# API settings
+API_HOST = "0.0.0.0"
+API_PORT = 8000
+
+# Streamlit settings
+STREAMLIT_PORT = 8501

src/inference/__init__.py

@@ -0,0 +1,3 @@
+from .predictor import EmotionPredictor
+
+__all__ = ["EmotionPredictor"]

src/inference/predictor.py

@@ -0,0 +1,346 @@
+"""
+Inference pipeline for emotion recognition.
+"""
+import numpy as np
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple, Union
+
+import cv2
+from PIL import Image
+import tensorflow as tf
+from tensorflow.keras.models import Model
+
+import sys
+sys.path.append(str(Path(__file__).parent.parent.parent))
+from src.config import (
+    IMAGE_SIZE, IMAGE_SIZE_TRANSFER, EMOTION_CLASSES, IDX_TO_EMOTION,
+    INTENSITY_HIGH_THRESHOLD, INTENSITY_MEDIUM_THRESHOLD,
+    CUSTOM_CNN_PATH, MOBILENET_PATH, VGG_PATH
+)
+from src.preprocessing.face_detector import FaceDetector
+from src.models.model_utils import load_model
+
+
+class EmotionPredictor:
+    """
+    Unified prediction interface for emotion recognition.
+    """
+    
+    def __init__(
+        self,
+        model_name: str = "custom_cnn",
+        model_path: Optional[Path] = None,
+        use_face_detection: bool = True
+    ):
+        """
+        Initialize the predictor.
+        
+        Args:
+            model_name: Name of the model ('custom_cnn', 'mobilenet', 'vgg19')
+            model_path: Optional custom model path
+            use_face_detection: Whether to detect faces before prediction
+        """
+        self.model_name = model_name
+        self.model = None
+        self.face_detector = FaceDetector() if use_face_detection else None
+        
+        # Determine model path
+        if model_path:
+            self.model_path = Path(model_path)
+        else:
+            paths = {
+                "custom_cnn": CUSTOM_CNN_PATH,
+                "mobilenet": MOBILENET_PATH,
+                "vgg19": VGG_PATH
+            }
+            self.model_path = paths.get(model_name)
+        
+        # Set preprocessing based on model type
+        self.is_transfer_model = model_name in ["mobilenet", "vgg19"]
+        self.target_size = IMAGE_SIZE_TRANSFER if self.is_transfer_model else IMAGE_SIZE
+        self.use_rgb = self.is_transfer_model
+    
+    def load(self) -> bool:
+        """
+        Load the model.
+        
+        Returns:
+            True if model loaded successfully
+        """
+        try:
+            if self.model_path and self.model_path.exists():
+                self.model = load_model(self.model_path)
+                return True
+            else:
+                print(f"Model file not found: {self.model_path}")
+                return False
+        except Exception as e:
+            print(f"Error loading model: {e}")
+            return False
+    
+    def preprocess_image(
+        self,
+        image: np.ndarray,
+        detect_face: bool = True
+    ) -> Tuple[Optional[np.ndarray], List[dict]]:
+        """
+        Preprocess an image for prediction.
+        
+        Args:
+            image: Input image (BGR or RGB format)
+            detect_face: Whether to detect and extract face
+            
+        Returns:
+            Tuple of (preprocessed image, face info)
+        """
+        faces_info = []
+        
+        if detect_face and self.face_detector:
+            # Detect and extract face
+            face, faces_info = self.face_detector.detect_and_extract(
+                image,
+                target_size=self.target_size,
+                to_grayscale=not self.use_rgb
+            )
+            
+            if face is None:
+                return None, faces_info
+            
+            processed = face
+        else:
+            # Resize directly
+            processed = cv2.resize(image, self.target_size)
+            
+            # Convert color if needed
+            if self.use_rgb:
+                if len(processed.shape) == 2:
+                    processed = cv2.cvtColor(processed, cv2.COLOR_GRAY2RGB)
+                elif processed.shape[2] == 1:
+                    processed = np.repeat(processed, 3, axis=2)
+            else:
+                if len(processed.shape) == 3 and processed.shape[2] == 3:
+                    processed = cv2.cvtColor(processed, cv2.COLOR_BGR2GRAY)
+        
+        # Normalize
+        processed = processed.astype(np.float32) / 255.0
+        
+        # Add channel dimension if grayscale
+        if len(processed.shape) == 2:
+            processed = np.expand_dims(processed, axis=-1)
+        
+        # Add batch dimension
+        processed = np.expand_dims(processed, axis=0)
+        
+        return processed, faces_info
+    
+    def predict(
+        self,
+        image: Union[np.ndarray, str, Path],
+        detect_face: bool = True,
+        return_all_scores: bool = True
+    ) -> Dict:
+        """
+        Predict emotion from an image.
+        
+        Args:
+            image: Input image (array, file path, or PIL Image)
+            detect_face: Whether to detect face first
+            return_all_scores: Whether to return all class scores
+            
+        Returns:
+            Prediction result dictionary
+        """
+        if self.model is None:
+            success = self.load()
+            if not success:
+                return {"error": "Model not loaded"}
+        
+        # Load image if path provided
+        if isinstance(image, (str, Path)):
+            image = cv2.imread(str(image))
+            if image is None:
+                return {"error": f"Could not load image: {image}"}
+        elif isinstance(image, Image.Image):
+            image = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+        
+        # Preprocess
+        processed, faces_info = self.preprocess_image(image, detect_face)
+        
+        if processed is None:
+            return {
+                "error": "No face detected",
+                "face_detected": False,
+                "faces_info": faces_info
+            }
+        
+        # Predict
+        predictions = self.model.predict(processed, verbose=0)
+        
+        # Get top prediction
+        pred_idx = int(np.argmax(predictions[0]))
+        confidence = float(predictions[0][pred_idx])
+        emotion = IDX_TO_EMOTION[pred_idx]
+        
+        # Calculate intensity
+        intensity = self._calculate_intensity(confidence)
+        
+        result = {
+            "emotion": emotion,
+            "confidence": confidence,
+            "intensity": intensity,
+            "face_detected": len(faces_info) > 0,
+            "faces_info": faces_info,
+            "model_used": self.model_name
+        }
+        
+        if return_all_scores:
+            result["all_probabilities"] = {
+                EMOTION_CLASSES[i]: float(predictions[0][i])
+                for i in range(len(EMOTION_CLASSES))
+            }
+        
+        return result
+    
+    def predict_batch(
+        self,
+        images: List[Union[np.ndarray, str, Path]],
+        detect_face: bool = True
+    ) -> Dict:
+        """
+        Predict emotions for multiple images.
+        
+        Args:
+            images: List of images
+            detect_face: Whether to detect faces
+            
+        Returns:
+            Batch prediction results
+        """
+        results = []
+        emotion_counts = {e: 0 for e in EMOTION_CLASSES}
+        successful_predictions = 0
+        
+        for i, image in enumerate(images):
+            result = self.predict(image, detect_face)
+            result["image_index"] = i
+            results.append(result)
+            
+            if "error" not in result:
+                emotion_counts[result["emotion"]] += 1
+                successful_predictions += 1
+        
+        # Calculate distribution
+        if successful_predictions > 0:
+            emotion_distribution = {
+                e: count / successful_predictions
+                for e, count in emotion_counts.items()
+            }
+        else:
+            emotion_distribution = {e: 0.0 for e in EMOTION_CLASSES}
+        
+        # Find dominant emotion
+        dominant_emotion = max(emotion_counts.items(), key=lambda x: x[1])
+        
+        return {
+            "results": results,
+            "summary": {
+                "total_images": len(images),
+                "successful_predictions": successful_predictions,
+                "failed_predictions": len(images) - successful_predictions,
+                "emotion_counts": emotion_counts,
+                "emotion_distribution": emotion_distribution,
+                "dominant_emotion": dominant_emotion[0],
+                "dominant_emotion_count": dominant_emotion[1]
+            },
+            "model_used": self.model_name
+        }
+    
+    def _calculate_intensity(self, confidence: float) -> str:
+        """
+        Calculate emotion intensity based on confidence.
+        
+        Args:
+            confidence: Prediction confidence
+            
+        Returns:
+            Intensity level ('high', 'medium', 'low')
+        """
+        if confidence >= INTENSITY_HIGH_THRESHOLD:
+            return "high"
+        elif confidence >= INTENSITY_MEDIUM_THRESHOLD:
+            return "medium"
+        else:
+            return "low"
+    
+    def visualize_prediction(
+        self,
+        image: np.ndarray,
+        prediction: Dict
+    ) -> np.ndarray:
+        """
+        Visualize prediction on image.
+        
+        Args:
+            image: Original image
+            prediction: Prediction result
+            
+        Returns:
+            Image with visualizations
+        """
+        result = image.copy()
+        
+        if self.face_detector and prediction.get("faces_info"):
+            # Draw face detection and emotion label
+            result = self.face_detector.draw_detections(
+                result,
+                prediction["faces_info"],
+                emotions=[prediction.get("emotion", "Unknown")],
+                confidences=[prediction.get("confidence", 0)]
+            )
+        
+        return result
+    
+    @staticmethod
+    def get_available_models() -> Dict[str, bool]:
+        """
+        Get available trained models.
+        
+        Returns:
+            Dictionary of model name -> availability
+        """
+        return {
+            "custom_cnn": CUSTOM_CNN_PATH.exists(),
+            "mobilenet": MOBILENET_PATH.exists(),
+            "vgg19": VGG_PATH.exists()
+        }
+
+
+def create_predictor(
+    model_name: str = "custom_cnn",
+    auto_load: bool = True
+) -> Optional[EmotionPredictor]:
+    """
+    Factory function to create a predictor.
+    
+    Args:
+        model_name: Name of the model
+        auto_load: Whether to automatically load the model
+        
+    Returns:
+        EmotionPredictor instance or None if loading fails
+    """
+    predictor = EmotionPredictor(model_name)
+    
+    if auto_load:
+        if not predictor.load():
+            return None
+    
+    return predictor
+
+
+if __name__ == "__main__":
+    # Show available models
+    print("Available models:")
+    for name, available in EmotionPredictor.get_available_models().items():
+        status = "✓" if available else "✗"
+        print(f"  {status} {name}")

src/models/__init__.py

@@ -0,0 +1,13 @@
+from .custom_cnn import build_custom_cnn
+from .mobilenet_model import build_mobilenet_model
+from .vgg_model import build_vgg_model
+from .model_utils import load_model, save_model, get_model_summary
+
+__all__ = [
+    "build_custom_cnn",
+    "build_mobilenet_model",
+    "build_vgg_model",
+    "load_model",
+    "save_model",
+    "get_model_summary"
+]

src/models/custom_cnn.py

@@ -0,0 +1,183 @@
+"""
+Custom CNN model architecture for emotion recognition.
+Optimized for 48x48 grayscale images.
+"""
+import tensorflow as tf
+from tensorflow.keras.models import Sequential, Model
+from tensorflow.keras.layers import (
+    Conv2D, MaxPooling2D, Dense, Dropout, Flatten,
+    BatchNormalization, Input, GlobalAveragePooling2D
+)
+from tensorflow.keras.regularizers import l2
+
+import sys
+from pathlib import Path
+sys.path.append(str(Path(__file__).parent.parent.parent))
+from src.config import IMAGE_SIZE, NUM_CLASSES, NUM_CHANNELS
+
+
+def build_custom_cnn(
+    input_shape: tuple = (*IMAGE_SIZE, NUM_CHANNELS),
+    num_classes: int = NUM_CLASSES,
+    dropout_rate: float = 0.25,
+    dense_dropout: float = 0.5,
+    l2_reg: float = 0.01
+) -> Model:
+    """
+    Build a custom CNN architecture for emotion recognition.
+    
+    Architecture:
+    - 4 Convolutional blocks with increasing filters (64 -> 128 -> 256 -> 512)
+    - Each block: Conv2D -> BatchNorm -> ReLU -> MaxPool -> Dropout
+    - Dense layers for classification
+    
+    Args:
+        input_shape: Input image shape (height, width, channels)
+        num_classes: Number of emotion classes
+        dropout_rate: Dropout rate for conv blocks
+        dense_dropout: Dropout rate for dense layers
+        l2_reg: L2 regularization factor
+        
+    Returns:
+        Compiled Keras model
+    """
+    model = Sequential([
+        # Input layer
+        Input(shape=input_shape),
+        
+        # Block 1: 64 filters
+        Conv2D(64, (3, 3), padding='same', activation='relu',
+               kernel_regularizer=l2(l2_reg)),
+        BatchNormalization(),
+        Conv2D(64, (3, 3), padding='same', activation='relu',
+               kernel_regularizer=l2(l2_reg)),
+        BatchNormalization(),
+        MaxPooling2D(pool_size=(2, 2)),
+        Dropout(dropout_rate),
+        
+        # Block 2: 128 filters
+        Conv2D(128, (3, 3), padding='same', activation='relu',
+               kernel_regularizer=l2(l2_reg)),
+        BatchNormalization(),
+        Conv2D(128, (3, 3), padding='same', activation='relu',
+               kernel_regularizer=l2(l2_reg)),
+        BatchNormalization(),
+        MaxPooling2D(pool_size=(2, 2)),
+        Dropout(dropout_rate),
+        
+        # Block 3: 256 filters
+        Conv2D(256, (3, 3), padding='same', activation='relu',
+               kernel_regularizer=l2(l2_reg)),
+        BatchNormalization(),
+        Conv2D(256, (3, 3), padding='same', activation='relu',
+               kernel_regularizer=l2(l2_reg)),
+        BatchNormalization(),
+        MaxPooling2D(pool_size=(2, 2)),
+        Dropout(dropout_rate),
+        
+        # Block 4: 512 filters
+        Conv2D(512, (3, 3), padding='same', activation='relu',
+               kernel_regularizer=l2(l2_reg)),
+        BatchNormalization(),
+        Conv2D(512, (3, 3), padding='same', activation='relu',
+               kernel_regularizer=l2(l2_reg)),
+        BatchNormalization(),
+        MaxPooling2D(pool_size=(2, 2)),
+        Dropout(dropout_rate),
+        
+        # Classification head
+        Flatten(),
+        Dense(512, activation='relu', kernel_regularizer=l2(l2_reg)),
+        BatchNormalization(),
+        Dropout(dense_dropout),
+        Dense(256, activation='relu', kernel_regularizer=l2(l2_reg)),
+        BatchNormalization(),
+        Dropout(dense_dropout),
+        Dense(num_classes, activation='softmax')
+    ], name='custom_emotion_cnn')
+    
+    return model
+
+
+def build_custom_cnn_v2(
+    input_shape: tuple = (*IMAGE_SIZE, NUM_CHANNELS),
+    num_classes: int = NUM_CLASSES
+) -> Model:
+    """
+    Alternative CNN architecture with residual-like connections.
+    
+    Args:
+        input_shape: Input image shape
+        num_classes: Number of emotion classes
+        
+    Returns:
+        Keras model
+    """
+    inputs = Input(shape=input_shape)
+    
+    # Initial convolution
+    x = Conv2D(32, (3, 3), padding='same', activation='relu')(inputs)
+    x = BatchNormalization()(x)
+    
+    # Block 1
+    x = Conv2D(64, (3, 3), padding='same', activation='relu')(x)
+    x = BatchNormalization()(x)
+    x = Conv2D(64, (3, 3), padding='same', activation='relu')(x)
+    x = BatchNormalization()(x)
+    x = MaxPooling2D(pool_size=(2, 2))(x)
+    x = Dropout(0.25)(x)
+    
+    # Block 2
+    x = Conv2D(128, (3, 3), padding='same', activation='relu')(x)
+    x = BatchNormalization()(x)
+    x = Conv2D(128, (3, 3), padding='same', activation='relu')(x)
+    x = BatchNormalization()(x)
+    x = MaxPooling2D(pool_size=(2, 2))(x)
+    x = Dropout(0.25)(x)
+    
+    # Block 3
+    x = Conv2D(256, (3, 3), padding='same', activation='relu')(x)
+    x = BatchNormalization()(x)
+    x = Conv2D(256, (3, 3), padding='same', activation='relu')(x)
+    x = BatchNormalization()(x)
+    x = MaxPooling2D(pool_size=(2, 2))(x)
+    x = Dropout(0.25)(x)
+    
+    # Global pooling and classification
+    x = GlobalAveragePooling2D()(x)
+    x = Dense(256, activation='relu')(x)
+    x = BatchNormalization()(x)
+    x = Dropout(0.5)(x)
+    outputs = Dense(num_classes, activation='softmax')(x)
+    
+    model = Model(inputs=inputs, outputs=outputs, name='custom_emotion_cnn_v2')
+    
+    return model
+
+
+def get_model_config() -> dict:
+    """
+    Get the default model configuration.
+    
+    Returns:
+        Dictionary with model configuration
+    """
+    return {
+        "name": "Custom CNN",
+        "input_shape": (*IMAGE_SIZE, NUM_CHANNELS),
+        "num_classes": NUM_CLASSES,
+        "expected_accuracy": "60-68%",
+        "training_time": "~30 minutes (GPU)",
+        "parameters": "~5M"
+    }
+
+
+if __name__ == "__main__":
+    # Build and display model summary
+    model = build_custom_cnn()
+    model.summary()
+    
+    print("\nModel configuration:")
+    config = get_model_config()
+    for key, value in config.items():
+        print(f"  {key}: {value}")

src/models/mobilenet_model.py

@@ -0,0 +1,203 @@
+"""
+MobileNetV2 transfer learning model for emotion recognition.
+"""
+import tensorflow as tf
+from tensorflow.keras.models import Model
+from tensorflow.keras.layers import (
+    Dense, Dropout, GlobalAveragePooling2D,
+    BatchNormalization, Input, Lambda
+)
+from tensorflow.keras.applications import MobileNetV2
+
+import sys
+from pathlib import Path
+sys.path.append(str(Path(__file__).parent.parent.parent))
+from src.config import IMAGE_SIZE_TRANSFER, NUM_CLASSES, NUM_CHANNELS_RGB
+
+
+def build_mobilenet_model(
+    input_shape: tuple = (*IMAGE_SIZE_TRANSFER, NUM_CHANNELS_RGB),
+    num_classes: int = NUM_CLASSES,
+    trainable_layers: int = 30,
+    dropout_rate: float = 0.5
+) -> Model:
+    """
+    Build MobileNetV2 transfer learning model for emotion recognition.
+    
+    Args:
+        input_shape: Input image shape (height, width, channels)
+        num_classes: Number of emotion classes
+        trainable_layers: Number of top layers to make trainable
+        dropout_rate: Dropout rate for dense layers
+        
+    Returns:
+        Keras model
+    """
+    # Load pre-trained MobileNetV2
+    base_model = MobileNetV2(
+        weights='imagenet',
+        include_top=False,
+        input_shape=input_shape
+    )
+    
+    # Freeze base layers
+    for layer in base_model.layers[:-trainable_layers]:
+        layer.trainable = False
+    
+    # Make top layers trainable
+    for layer in base_model.layers[-trainable_layers:]:
+        layer.trainable = True
+    
+    # Build the model
+    inputs = Input(shape=input_shape)
+    
+    # Preprocess input for MobileNetV2 using Rescaling layer
+    # MobileNetV2 expects inputs in [-1, 1] range
+    x = tf.keras.layers.Rescaling(scale=1./127.5, offset=-1.0)(inputs)
+    
+    # Pass through base model
+    x = base_model(x, training=True)
+    
+    # Classification head
+    x = GlobalAveragePooling2D()(x)
+    x = Dense(512, activation='relu')(x)
+    x = BatchNormalization()(x)
+    x = Dropout(dropout_rate)(x)
+    x = Dense(256, activation='relu')(x)
+    x = BatchNormalization()(x)
+    x = Dropout(dropout_rate)(x)
+    outputs = Dense(num_classes, activation='softmax')(x)
+    
+    model = Model(inputs=inputs, outputs=outputs, name='mobilenet_emotion')
+    
+    return model
+
+
+def build_mobilenet_from_grayscale(
+    input_shape: tuple = (*IMAGE_SIZE_TRANSFER, 1),
+    num_classes: int = NUM_CLASSES,
+    trainable_layers: int = 30,
+    dropout_rate: float = 0.5
+) -> Model:
+    """
+    Build MobileNetV2 model that accepts grayscale input.
+    Converts grayscale to RGB internally.
+    
+    Args:
+        input_shape: Input shape for grayscale images
+        num_classes: Number of emotion classes
+        trainable_layers: Number of top layers to make trainable
+        dropout_rate: Dropout rate
+        
+    Returns:
+        Keras model
+    """
+    # Load pre-trained MobileNetV2
+    base_model = MobileNetV2(
+        weights='imagenet',
+        include_top=False,
+        input_shape=(*IMAGE_SIZE_TRANSFER, 3)
+    )
+    
+    # Freeze base layers
+    for layer in base_model.layers[:-trainable_layers]:
+        layer.trainable = False
+    
+    # Input for grayscale image
+    inputs = Input(shape=input_shape)
+    
+    # Convert grayscale to RGB by repeating channels
+    x = tf.keras.layers.Concatenate()([inputs, inputs, inputs])
+    
+    # Preprocess for MobileNetV2 using Rescaling layer
+    x = tf.keras.layers.Rescaling(scale=1./127.5, offset=-1.0)(x)
+    
+    # Base model
+    x = base_model(x, training=True)
+    
+    # Classification head
+    x = GlobalAveragePooling2D()(x)
+    x = Dense(512, activation='relu')(x)
+    x = BatchNormalization()(x)
+    x = Dropout(dropout_rate)(x)
+    x = Dense(256, activation='relu')(x)
+    x = BatchNormalization()(x)
+    x = Dropout(dropout_rate)(x)
+    outputs = Dense(num_classes, activation='softmax')(x)
+    
+    model = Model(inputs=inputs, outputs=outputs, name='mobilenet_emotion_grayscale')
+    
+    return model
+
+
+def freeze_base_model(model: Model) -> Model:
+    """
+    Freeze all layers in the base MobileNetV2 model.
+    Useful for initial training with frozen weights.
+    
+    Args:
+        model: MobileNet emotion model
+        
+    Returns:
+        Model with frozen base
+    """
+    for layer in model.layers:
+        if 'mobilenet' in layer.name.lower():
+            layer.trainable = False
+    return model
+
+
+def unfreeze_top_layers(model: Model, num_layers: int = 30) -> Model:
+    """
+    Unfreeze top layers of the base model for fine-tuning.
+    
+    Args:
+        model: MobileNet emotion model
+        num_layers: Number of top layers to unfreeze
+        
+    Returns:
+        Model with partially unfrozen base
+    """
+    for layer in model.layers:
+        if 'mobilenet' in layer.name.lower():
+            # Get base model and unfreeze top layers
+            for base_layer in layer.layers[-num_layers:]:
+                base_layer.trainable = True
+    return model
+
+
+def get_model_config() -> dict:
+    """
+    Get the default model configuration.
+    
+    Returns:
+        Dictionary with model configuration
+    """
+    return {
+        "name": "MobileNetV2",
+        "input_shape": (*IMAGE_SIZE_TRANSFER, NUM_CHANNELS_RGB),
+        "num_classes": NUM_CLASSES,
+        "expected_accuracy": "65-72%",
+        "training_time": "~45 minutes (GPU)",
+        "parameters": "~3.5M",
+        "base_model": "MobileNetV2 (ImageNet)"
+    }
+
+
+if __name__ == "__main__":
+    # Build and display model summary
+    print("Building MobileNetV2 model...")
+    model = build_mobilenet_model()
+    
+    # Count trainable parameters
+    trainable = sum([tf.keras.backend.count_params(w) for w in model.trainable_weights])
+    non_trainable = sum([tf.keras.backend.count_params(w) for w in model.non_trainable_weights])
+    
+    print(f"\nTotal parameters: {trainable + non_trainable:,}")
+    print(f"Trainable parameters: {trainable:,}")
+    print(f"Non-trainable parameters: {non_trainable:,}")
+    
+    print("\nModel configuration:")
+    config = get_model_config()
+    for key, value in config.items():
+        print(f"  {key}: {value}")

src/models/model_utils.py

@@ -0,0 +1,491 @@
+# """
+# Model utility functions for saving, loading, and inspecting models.
+# """
+# import os
+# import json
+# from pathlib import Path
+# from typing import Dict, Optional, Union
+
+# import tensorflow as tf
+# from tensorflow.keras.models import Model, load_model as keras_load_model
+
+# import sys
+# sys.path.append(str(Path(__file__).parent.parent.parent))
+# from src.config import MODELS_DIR, CUSTOM_CNN_PATH, MOBILENET_PATH, VGG_PATH
+
+
+# def save_model(
+#     model: Model,
+#     save_path: Union[str, Path],
+#     save_format: str = 'h5',
+#     include_optimizer: bool = True,
+#     save_metadata: bool = True,
+#     metadata: Optional[Dict] = None
+# ) -> None:
+#     """
+#     Save a trained model to disk.
+    
+#     Args:
+#         model: Keras model to save
+#         save_path: Path to save the model
+#         save_format: Format to save ('h5' or 'tf')
+#         include_optimizer: Whether to include optimizer state
+#         save_metadata: Whether to save training metadata
+#         metadata: Optional metadata dictionary
+#     """
+#     save_path = Path(save_path)
+    
+#     # Create directory if needed
+#     save_path.parent.mkdir(parents=True, exist_ok=True)
+    
+#     if save_format == 'h5':
+#         model.save(str(save_path), include_optimizer=include_optimizer)
+#     else:
+#         # SavedModel format
+#         model.save(str(save_path.with_suffix('')), save_format='tf')
+    
+#     # Save metadata if requested
+#     if save_metadata and metadata:
+#         metadata_path = save_path.with_suffix('.json')
+#         with open(metadata_path, 'w') as f:
+#             json.dump(metadata, f, indent=2)
+    
+#     print(f"Model saved to: {save_path}")
+
+
+# def load_model(
+#     model_path: Union[str, Path],
+#     custom_objects: Optional[Dict] = None,
+#     compile_model: bool = True
+# ) -> Model:
+#     """
+#     Load a saved model from disk.
+    
+#     Args:
+#         model_path: Path to the saved model
+#         custom_objects: Optional custom objects for loading
+#         compile_model: Whether to compile the model
+        
+#     Returns:
+#         Loaded Keras model
+#     """
+#     model_path = Path(model_path)
+    
+#     if not model_path.exists():
+#         # Check if it's a SavedModel directory
+#         if model_path.with_suffix('').exists():
+#             model_path = model_path.with_suffix('')
+#         else:
+#             raise FileNotFoundError(f"Model not found: {model_path}")
+    
+#     model = keras_load_model(
+#         str(model_path),
+#         custom_objects=custom_objects,
+#         compile=compile_model
+#     )
+    
+#     print(f"Model loaded from: {model_path}")
+#     return model
+
+
+# def load_model_metadata(model_path: Union[str, Path]) -> Optional[Dict]:
+#     """
+#     Load metadata for a saved model.
+    
+#     Args:
+#         model_path: Path to the saved model
+        
+#     Returns:
+#         Metadata dictionary or None
+#     """
+#     metadata_path = Path(model_path).with_suffix('.json')
+    
+#     if metadata_path.exists():
+#         with open(metadata_path, 'r') as f:
+#             return json.load(f)
+#     return None
+
+
+# def get_model_summary(model: Model, print_summary: bool = True) -> Dict:
+#     """
+#     Get a summary of the model architecture.
+    
+#     Args:
+#         model: Keras model
+#         print_summary: Whether to print the summary
+        
+#     Returns:
+#         Dictionary with model statistics
+#     """
+#     if print_summary:
+#         model.summary()
+    
+#     # Calculate parameters
+#     trainable = sum([tf.keras.backend.count_params(w) for w in model.trainable_weights])
+#     non_trainable = sum([tf.keras.backend.count_params(w) for w in model.non_trainable_weights])
+    
+#     summary = {
+#         "name": model.name,
+#         "total_params": trainable + non_trainable,
+#         "trainable_params": trainable,
+#         "non_trainable_params": non_trainable,
+#         "num_layers": len(model.layers),
+#         "input_shape": model.input_shape,
+#         "output_shape": model.output_shape
+#     }
+    
+#     return summary
+
+
+# def get_available_models() -> Dict[str, Dict]:
+#     """
+#     Get information about available pre-trained models.
+    
+#     Returns:
+#         Dictionary with model information
+#     """
+#     models = {}
+    
+#     model_paths = {
+#         "custom_cnn": CUSTOM_CNN_PATH,
+#         "mobilenet": MOBILENET_PATH,
+#         "vgg19": VGG_PATH
+#     }
+    
+#     for name, path in model_paths.items():
+#         if Path(path).exists():
+#             metadata = load_model_metadata(path)
+#             models[name] = {
+#                 "path": str(path),
+#                 "exists": True,
+#                 "metadata": metadata
+#             }
+#         else:
+#             models[name] = {
+#                 "path": str(path),
+#                 "exists": False,
+#                 "metadata": None
+#             }
+    
+#     return models
+
+
+# def compare_models(models: Dict[str, Model]) -> Dict:
+#     """
+#     Compare multiple models.
+    
+#     Args:
+#         models: Dictionary of model name -> model
+        
+#     Returns:
+#         Comparison dictionary
+#     """
+#     comparison = {}
+    
+#     for name, model in models.items():
+#         summary = get_model_summary(model, print_summary=False)
+#         comparison[name] = {
+#             "params": summary["total_params"],
+#             "trainable_params": summary["trainable_params"],
+#             "layers": summary["num_layers"]
+#         }
+    
+#     return comparison
+
+
+# def export_to_tflite(
+#     model: Model,
+#     save_path: Union[str, Path],
+#     quantize: bool = False
+# ) -> None:
+#     """
+#     Export model to TensorFlow Lite format.
+    
+#     Args:
+#         model: Keras model to export
+#         save_path: Path to save the TFLite model
+#         quantize: Whether to apply quantization
+#     """
+#     converter = tf.lite.TFLiteConverter.from_keras_model(model)
+    
+#     if quantize:
+#         converter.optimizations = [tf.lite.Optimize.DEFAULT]
+    
+#     tflite_model = converter.convert()
+    
+#     save_path = Path(save_path)
+#     save_path.parent.mkdir(parents=True, exist_ok=True)
+    
+#     with open(save_path, 'wb') as f:
+#         f.write(tflite_model)
+    
+#     print(f"TFLite model saved to: {save_path}")
+
+
+# if __name__ == "__main__":
+#     print("Available models:")
+#     models = get_available_models()
+#     for name, info in models.items():
+#         status = "✓ Trained" if info["exists"] else "✗ Not trained"
+#         print(f"  {name}: {status}")
+
+"""
+Model utility functions for saving, loading, and inspecting models.
+"""
+import os
+import json
+from pathlib import Path
+from typing import Dict, Optional, Union
+
+import tensorflow as tf
+from tensorflow.keras.models import Model, load_model as keras_load_model
+
+import sys
+sys.path.append(str(Path(__file__).parent.parent.parent))
+from src.config import MODELS_DIR, CUSTOM_CNN_PATH, MOBILENET_PATH, VGG_PATH
+
+
+# ---------------------------------------------------------------------------
+# Legacy preprocessing functions
+# ---------------------------------------------------------------------------
+# Older saved .h5 models used Lambda layers that baked these functions in.
+# Current model code uses Rescaling layers instead, but these definitions
+# must remain so keras_load_model() can deserialise the old .h5 files.
+# ---------------------------------------------------------------------------
+
+def preprocess_mobilenet(x):
+    """Legacy MobileNetV2 preprocessor — scales pixels to [-1, 1]."""
+    return x / 127.5 - 1.0
+
+
+def preprocess_vgg(x):
+    """Legacy VGG-19 preprocessor — mean-subtracted scaling."""
+    return x * 255.0 - 127.5
+
+
+_LEGACY_CUSTOM_OBJECTS: Dict = {
+    "preprocess_mobilenet": preprocess_mobilenet,
+    "preprocess_vgg":       preprocess_vgg,
+}
+
+
+def save_model(
+    model: Model,
+    save_path: Union[str, Path],
+    save_format: str = 'h5',
+    include_optimizer: bool = True,
+    save_metadata: bool = True,
+    metadata: Optional[Dict] = None
+) -> None:
+    """
+    Save a trained model to disk.
+    
+    Args:
+        model: Keras model to save
+        save_path: Path to save the model
+        save_format: Format to save ('h5' or 'tf')
+        include_optimizer: Whether to include optimizer state
+        save_metadata: Whether to save training metadata
+        metadata: Optional metadata dictionary
+    """
+    save_path = Path(save_path)
+    
+    # Create directory if needed
+    save_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    if save_format == 'h5':
+        model.save(str(save_path), include_optimizer=include_optimizer)
+    else:
+        # SavedModel format
+        model.save(str(save_path.with_suffix('')), save_format='tf')
+    
+    # Save metadata if requested
+    if save_metadata and metadata:
+        metadata_path = save_path.with_suffix('.json')
+        with open(metadata_path, 'w') as f:
+            json.dump(metadata, f, indent=2)
+    
+    print(f"Model saved to: {save_path}")
+
+
+def load_model(
+    model_path: Union[str, Path],
+    custom_objects: Optional[Dict] = None,
+    compile_model: bool = True
+) -> Model:
+    """
+    Load a saved model from disk.
+    
+    Args:
+        model_path: Path to the saved model
+        custom_objects: Optional custom objects for loading
+        compile_model: Whether to compile the model
+        
+    Returns:
+        Loaded Keras model
+    """
+    model_path = Path(model_path)
+
+    # Always include legacy preprocessing functions so that old .h5 models
+    # saved with Lambda layers can be loaded without extra steps.
+    merged_objects = dict(_LEGACY_CUSTOM_OBJECTS)
+    if custom_objects:
+        merged_objects.update(custom_objects)
+
+    if not model_path.exists():
+        # Check if it's a SavedModel directory
+        if model_path.with_suffix('').exists():
+            model_path = model_path.with_suffix('')
+        else:
+            raise FileNotFoundError(f"Model not found: {model_path}")
+
+    model = keras_load_model(
+        str(model_path),
+        custom_objects=merged_objects,
+        compile=compile_model
+    )
+    
+    print(f"Model loaded from: {model_path}")
+    return model
+
+
+def load_model_metadata(model_path: Union[str, Path]) -> Optional[Dict]:
+    """
+    Load metadata for a saved model.
+    
+    Args:
+        model_path: Path to the saved model
+        
+    Returns:
+        Metadata dictionary or None
+    """
+    metadata_path = Path(model_path).with_suffix('.json')
+    
+    if metadata_path.exists():
+        with open(metadata_path, 'r') as f:
+            return json.load(f)
+    return None
+
+
+def get_model_summary(model: Model, print_summary: bool = True) -> Dict:
+    """
+    Get a summary of the model architecture.
+    
+    Args:
+        model: Keras model
+        print_summary: Whether to print the summary
+        
+    Returns:
+        Dictionary with model statistics
+    """
+    if print_summary:
+        model.summary()
+    
+    # Calculate parameters
+    trainable = sum([tf.keras.backend.count_params(w) for w in model.trainable_weights])
+    non_trainable = sum([tf.keras.backend.count_params(w) for w in model.non_trainable_weights])
+    
+    summary = {
+        "name": model.name,
+        "total_params": trainable + non_trainable,
+        "trainable_params": trainable,
+        "non_trainable_params": non_trainable,
+        "num_layers": len(model.layers),
+        "input_shape": model.input_shape,
+        "output_shape": model.output_shape
+    }
+    
+    return summary
+
+
+def get_available_models() -> Dict[str, Dict]:
+    """
+    Get information about available pre-trained models.
+    
+    Returns:
+        Dictionary with model information
+    """
+    models = {}
+    
+    model_paths = {
+        "custom_cnn": CUSTOM_CNN_PATH,
+        "mobilenet": MOBILENET_PATH,
+        "vgg19": VGG_PATH
+    }
+    
+    for name, path in model_paths.items():
+        if Path(path).exists():
+            metadata = load_model_metadata(path)
+            models[name] = {
+                "path": str(path),
+                "exists": True,
+                "metadata": metadata
+            }
+        else:
+            models[name] = {
+                "path": str(path),
+                "exists": False,
+                "metadata": None
+            }
+    
+    return models
+
+
+def compare_models(models: Dict[str, Model]) -> Dict:
+    """
+    Compare multiple models.
+    
+    Args:
+        models: Dictionary of model name -> model
+        
+    Returns:
+        Comparison dictionary
+    """
+    comparison = {}
+    
+    for name, model in models.items():
+        summary = get_model_summary(model, print_summary=False)
+        comparison[name] = {
+            "params": summary["total_params"],
+            "trainable_params": summary["trainable_params"],
+            "layers": summary["num_layers"]
+        }
+    
+    return comparison
+
+
+def export_to_tflite(
+    model: Model,
+    save_path: Union[str, Path],
+    quantize: bool = False
+) -> None:
+    """
+    Export model to TensorFlow Lite format.
+    
+    Args:
+        model: Keras model to export
+        save_path: Path to save the TFLite model
+        quantize: Whether to apply quantization
+    """
+    converter = tf.lite.TFLiteConverter.from_keras_model(model)
+    
+    if quantize:
+        converter.optimizations = [tf.lite.Optimize.DEFAULT]
+    
+    tflite_model = converter.convert()
+    
+    save_path = Path(save_path)
+    save_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    with open(save_path, 'wb') as f:
+        f.write(tflite_model)
+    
+    print(f"TFLite model saved to: {save_path}")
+
+
+if __name__ == "__main__":
+    print("Available models:")
+    models = get_available_models()
+    for name, info in models.items():
+        status = "✓ Trained" if info["exists"] else "✗ Not trained"
+        print(f"  {name}: {status}")

src/models/vgg_model.py

@@ -0,0 +1,257 @@
+"""
+VGG-19 transfer learning model for emotion recognition.
+"""
+import tensorflow as tf
+from tensorflow.keras.models import Model
+from tensorflow.keras.layers import (
+    Dense, Dropout, GlobalAveragePooling2D, Flatten,
+    BatchNormalization, Input, Lambda
+)
+from tensorflow.keras.applications import VGG19
+
+import sys
+from pathlib import Path
+sys.path.append(str(Path(__file__).parent.parent.parent))
+from src.config import IMAGE_SIZE_TRANSFER, NUM_CLASSES, NUM_CHANNELS_RGB
+
+
+def build_vgg_model(
+    input_shape: tuple = (*IMAGE_SIZE_TRANSFER, NUM_CHANNELS_RGB),
+    num_classes: int = NUM_CLASSES,
+    trainable_layers: int = 4,
+    dropout_rate: float = 0.5
+) -> Model:
+    """
+    Build VGG-19 transfer learning model for emotion recognition.
+    
+    Args:
+        input_shape: Input image shape (height, width, channels)
+        num_classes: Number of emotion classes
+        trainable_layers: Number of top convolutional layers to make trainable
+        dropout_rate: Dropout rate for dense layers
+        
+    Returns:
+        Keras model
+    """
+    # Load pre-trained VGG19
+    base_model = VGG19(
+        weights='imagenet',
+        include_top=False,
+        input_shape=input_shape
+    )
+    
+    # Freeze all layers initially
+    for layer in base_model.layers:
+        layer.trainable = False
+    
+    # Unfreeze top convolutional layers for fine-tuning
+    for layer in base_model.layers[-trainable_layers:]:
+        layer.trainable = True
+    
+    # Build the model
+    inputs = Input(shape=input_shape)
+    
+    # Preprocess input for VGG19 using Rescaling layer
+    # VGG19 expects inputs scaled to 0-255 range with mean subtraction
+    x = tf.keras.layers.Rescaling(scale=255.0, offset=-127.5)(inputs)
+    
+    # Pass through base model
+    x = base_model(x, training=True)
+    
+    # Classification head
+    x = GlobalAveragePooling2D()(x)
+    x = Dense(512, activation='relu')(x)
+    x = BatchNormalization()(x)
+    x = Dropout(dropout_rate)(x)
+    x = Dense(256, activation='relu')(x)
+    x = BatchNormalization()(x)
+    x = Dropout(dropout_rate)(x)
+    outputs = Dense(num_classes, activation='softmax')(x)
+    
+    model = Model(inputs=inputs, outputs=outputs, name='vgg19_emotion')
+    
+    return model
+
+
+def build_vgg_from_grayscale(
+    input_shape: tuple = (*IMAGE_SIZE_TRANSFER, 1),
+    num_classes: int = NUM_CLASSES,
+    trainable_layers: int = 4,
+    dropout_rate: float = 0.5
+) -> Model:
+    """
+    Build VGG-19 model that accepts grayscale input.
+    Converts grayscale to RGB internally.
+    
+    Args:
+        input_shape: Input shape for grayscale images
+        num_classes: Number of emotion classes
+        trainable_layers: Number of top layers to make trainable
+        dropout_rate: Dropout rate
+        
+    Returns:
+        Keras model
+    """
+    # Load pre-trained VGG19
+    base_model = VGG19(
+        weights='imagenet',
+        include_top=False,
+        input_shape=(*IMAGE_SIZE_TRANSFER, 3)
+    )
+    
+    # Freeze base layers
+    for layer in base_model.layers:
+        layer.trainable = False
+    
+    # Unfreeze top layers
+    for layer in base_model.layers[-trainable_layers:]:
+        layer.trainable = True
+    
+    # Input for grayscale image
+    inputs = Input(shape=input_shape)
+    
+    # Convert grayscale to RGB by repeating channels
+    x = tf.keras.layers.Concatenate()([inputs, inputs, inputs])
+    
+    # Preprocess for VGG19 using Rescaling layer
+    x = tf.keras.layers.Rescaling(scale=255.0, offset=-127.5)(x)
+    
+    # Base model
+    x = base_model(x, training=True)
+    
+    # Classification head
+    x = GlobalAveragePooling2D()(x)
+    x = Dense(512, activation='relu')(x)
+    x = BatchNormalization()(x)
+    x = Dropout(dropout_rate)(x)
+    x = Dense(256, activation='relu')(x)
+    x = BatchNormalization()(x)
+    x = Dropout(dropout_rate)(x)
+    outputs = Dense(num_classes, activation='softmax')(x)
+    
+    model = Model(inputs=inputs, outputs=outputs, name='vgg19_emotion_grayscale')
+    
+    return model
+
+
+def build_vgg_with_flatten(
+    input_shape: tuple = (*IMAGE_SIZE_TRANSFER, NUM_CHANNELS_RGB),
+    num_classes: int = NUM_CLASSES,
+    dropout_rate: float = 0.5
+) -> Model:
+    """
+    Alternative VGG-19 architecture using Flatten instead of GAP.
+    This is closer to the original VGG architecture.
+    
+    Args:
+        input_shape: Input image shape
+        num_classes: Number of emotion classes
+        dropout_rate: Dropout rate
+        
+    Returns:
+        Keras model
+    """
+    base_model = VGG19(
+        weights='imagenet',
+        include_top=False,
+        input_shape=input_shape
+    )
+    
+    # Freeze base model
+    for layer in base_model.layers:
+        layer.trainable = False
+    
+    inputs = Input(shape=input_shape)
+    x = tf.keras.layers.Rescaling(scale=255.0, offset=-127.5)(inputs)
+    x = base_model(x, training=False)
+    
+    # VGG-style classification head
+    x = Flatten()(x)
+    x = Dense(4096, activation='relu')(x)
+    x = Dropout(dropout_rate)(x)
+    x = Dense(4096, activation='relu')(x)
+    x = Dropout(dropout_rate)(x)
+    outputs = Dense(num_classes, activation='softmax')(x)
+    
+    model = Model(inputs=inputs, outputs=outputs, name='vgg19_emotion_flatten')
+    
+    return model
+
+
+def freeze_base_model(model: Model) -> Model:
+    """
+    Freeze all layers in the base VGG model.
+    
+    Args:
+        model: VGG emotion model
+        
+    Returns:
+        Model with frozen base
+    """
+    for layer in model.layers:
+        if 'vgg' in layer.name.lower():
+            layer.trainable = False
+    return model
+
+
+def unfreeze_top_blocks(model: Model, num_blocks: int = 1) -> Model:
+    """
+    Unfreeze top convolutional blocks of VGG for fine-tuning.
+    VGG19 has 5 blocks. Block 5 has 4 conv layers.
+    
+    Args:
+        model: VGG emotion model
+        num_blocks: Number of blocks to unfreeze from top
+        
+    Returns:
+        Model with partially unfrozen base
+    """
+    # Block layer counts: block1=2, block2=2, block3=4, block4=4, block5=4
+    block_layers = {5: 4, 4: 4, 3: 4, 2: 2, 1: 2}
+    
+    layers_to_unfreeze = sum([block_layers[i] for i in range(6 - num_blocks, 6)])
+    
+    for layer in model.layers:
+        if 'vgg' in layer.name.lower():
+            for vgg_layer in layer.layers[-layers_to_unfreeze:]:
+                if 'conv' in vgg_layer.name:
+                    vgg_layer.trainable = True
+    
+    return model
+
+
+def get_model_config() -> dict:
+    """
+    Get the default model configuration.
+    
+    Returns:
+        Dictionary with model configuration
+    """
+    return {
+        "name": "VGG-19",
+        "input_shape": (*IMAGE_SIZE_TRANSFER, NUM_CHANNELS_RGB),
+        "num_classes": NUM_CLASSES,
+        "expected_accuracy": "68-75%",
+        "training_time": "~60 minutes (GPU)",
+        "parameters": "~20M",
+        "base_model": "VGG-19 (ImageNet)"
+    }
+
+
+if __name__ == "__main__":
+    # Build and display model summary
+    print("Building VGG-19 model...")
+    model = build_vgg_model()
+    
+    # Count trainable parameters
+    trainable = sum([tf.keras.backend.count_params(w) for w in model.trainable_weights])
+    non_trainable = sum([tf.keras.backend.count_params(w) for w in model.non_trainable_weights])
+    
+    print(f"\nTotal parameters: {trainable + non_trainable:,}")
+    print(f"Trainable parameters: {trainable:,}")
+    print(f"Non-trainable parameters: {non_trainable:,}")
+    
+    print("\nModel configuration:")
+    config = get_model_config()
+    for key, value in config.items():
+        print(f"  {key}: {value}")