Automated deployment from GitHub Actions

README.md

@@ -1,21 +1,10 @@
----
-title: Emotion Detector
-emoji: 🎭
-colorFrom: purple
-colorTo: indigo
-sdk: gradio
-sdk_version: "3.50.2"
-app_file: app.py
-pinned: false
----
-
 # 🎭 End-to-End Facial Emotion Recognition
 
  <!-- Replace with a link to your final app screenshot -->
 
 This repository contains a complete, end-to-end MLOps pipeline and a production-ready web application for real-time facial emotion recognition. The project leverages a state-of-the-art Vision Transformer model and is deployed as a user-friendly Gradio application on Hugging Face Spaces.
 
-**Live Demo:** [🚀 Click here to try the application on Hugging Face Spaces!](https://huggingface.co/spaces/YOUR-USERNAME/YOUR-SPACE-NAME) <!-- Replace with your HF Space URL -->
+**Live Demo:** [🚀 Click here to try the application on Hugging Face Spaces!](https://huggingface.co/spaces/ALYYAN/Emotion-Recognition) <!-- Replace with your HF Space URL -->
 
 ---
 
@@ -50,4 +39,4 @@ Follow these steps to run the project locally.
 
 ```bash
 git clone https://github.com/YOUR-USERNAME/Emotion-Recognition-MLOps.git
-cd Emotion-Recognition-MLOps
+cd Emotion-Recognition-MLOps

app.py

@@ -3,7 +3,6 @@ import os
 import cv2
 import time
 
-# Ensure the correct predictor class is imported
 from src.EmotionRecognition.pipeline.hf_predictor import HFPredictor
 
 # --- INITIALIZE THE MODEL ---
@@ -16,14 +15,21 @@ except Exception as e:
     print(f"[FATAL ERROR] Failed to initialize predictor: {e}")
 
 # --- UI CONTENT & STYLING ---
+# In app.py
+
 CSS = """
 /* Animated Gradient Background */
 body {
     background: linear-gradient(-45deg, #0b0f19, #131a2d, #2a2a72, #522a72);
     background-size: 400% 400%;
     animation: gradient 15s ease infinite;
+    color: #e0e0e0;
+}
+@keyframes gradient {
+    0% { background-position: 0% 50%; }
+    50% { background-position: 100% 50%; }
+    100% { background-position: 0% 50%; }
 }
-@keyframes gradient { 0% { background-position: 0% 50%; } 50% { background-position: 100% 50%; } 100% { background-position: 0% 50%; } }
 
 /* General Layout & Typography */
 .gradio-container { max-width: 1320px !important; margin: auto !important; }
@@ -31,90 +37,42 @@ body {
 #subtitle { text-align: center; color: #bebebe; margin-top: 0; margin-bottom: 40px; font-size: 1.2rem; font-weight: 300; }
 .gr-button { font-weight: bold !important; }
 
-/* Main Content Card */
+/* --- NEW: The "Glass Card" effect --- */
 #main-card {
-    background: rgba(22, 22, 34, 0.65);
+    background: rgba(22, 22, 34, 0.65); /* Semi-transparent dark background */
     border-radius: 16px;
     box-shadow: 0 8px 32px 0 rgba(0, 0, 0, 0.37);
-    backdrop-filter: blur(12px); -webkit-backdrop-filter: blur(12px);
+    backdrop-filter: blur(12px); /* The "frosted glass" effect */
+    -webkit-backdrop-filter: blur(12px); /* For Safari */
     border: 1px solid rgba(255, 255, 255, 0.18);
     padding: 1rem;
 }
+/* --- END NEW --- */
 
-/* Prediction Bar Styling */
-#predictions-column { background-color: transparent !important; padding: 1.5rem; }
-#predictions-column > .gr-label { display: none; } /* Hide the default Gradio label */
-.prediction-list { list-style-type: none; padding: 0; margin-top: 1.5rem; }
+/* Prediction Bar Styling - now inside the card */
+#predictions-column { background-color: transparent !important; border-radius: 12px; padding: 1.5rem; }
+#predictions-column > .gr-label { display: none; }
+.prediction-list { list-style-type: none; padding: 0; margin-top: 0; }
 .prediction-list li { display: flex; align-items: center; margin-bottom: 12px; font-size: 1.1rem; }
 .prediction-list .label { width: 100px; text-transform: capitalize; color: #e0e0e0; }
 .prediction-list .bar-container { flex-grow: 1; height: 24px; background-color: rgba(255,255,255,0.1); border-radius: 12px; margin: 0 15px; overflow: hidden; }
-.prediction-list .bar { height: 100%; background: linear-gradient(90deg, #8A2BE2, #C71585); border-radius: 12px; transition: width: 0.1s linear; }
+.prediction-list .bar { height: 100%; background: linear-gradient(90deg, #8A2BE2, #C71585); border-radius: 12px; transition: width 0.2s ease-in-out; }
 .prediction-list .percent { width: 60px; text-align: right; font-weight: bold; color: #FFF; }
 footer { display: none !important; }
 """
 
 ABOUT_MARKDOWN = """
-## 🚀 About This Project
-
-This application is the culmination of a complete, end-to-end MLOps project, demonstrating the full lifecycle from research and experimentation to a final, deployed, state-of-the-art solution.
-
-**💻 [View Project on GitHub](https://github.com/AlyyanAhmed21/Emotion-Recognition-MLOps)** 
-
----
-
-### Project Team
-
--   **💻 [Alyyan Ahmed](https://github.com/AlyyanAhmed21)** 
--   **💻 [Munim Akbar](https://github.com/MunimAkbar)** 
-
----
-
-### ✨ Key Technical Features
-
-*   **State-of-the-Art AI Model:** The core of this app is a **Swin Transformer**, a powerful Vision Transformer (ViT) architecture. It was pre-trained on the massive **AffectNet** dataset, ensuring high accuracy and robust generalization to real-world, "in the wild" facial expressions.
-
-*   **Full MLOps Lifecycle Demonstration:** This project wasn't a straight line. It involved a reproducible pipeline built with **DVC** that progressed through:
-    1.  **Initial Model (MobileNetV2):** Achieved high accuracy (~96%) on a clean, posed dataset (CK+) but failed to generalize to real-world faces, demonstrating a key data science challenge.
-    2.  **Data-Centric Iteration:** Experimented with combining and balancing multiple datasets (FER+, CK+) to improve robustness, highlighting the importance of data quality.
-    3.  **Final SOTA Integration:** Strategically pivoted to a powerful, pre-trained model from the Hugging Face Hub to achieve superior real-world performance.
-
-*   **Full-Stack & Deployment:** The application architecture evolved from a Python-only script to a decoupled **FastAPI backend** and a **React frontend**, and was ultimately deployed as this streamlined and robust **Gradio** application.
-
-*   **Containerized & Automated:** The entire application is packaged with **Docker** and is set up for **CI/CD with GitHub Actions**, enabling automated testing and deployment to cloud platforms like Hugging Face Spaces.
-
----
-
-### 🛠️ Architecture & Tech Stack
-
-*   **Machine Learning & CV:**
-    *   Python, PyTorch, Hugging Face `transformers`
-    *   `MTCNN` for robust face detection
-    *   `OpenCV` for image processing
-
-*   **MLOps & DevOps:**
-    *   **DVC:** For data versioning and building reproducible pipelines.
-    *   **GitHub Actions:** For CI/CD and automated deployment.
-    *   **Docker:** For containerizing the application for consistent environments.
-    *   *(MLflow was used for experiment tracking during the training phase)*
-
-*   **Application & UI:**
-    *   **Gradio:** For building and deploying this interactive UI.
-    *   *(FastAPI and React were used in an alternate full-stack version of the application)*
-
-### 💡 Skills Demonstrated
-
-This project showcases a comprehensive skillset in building modern AI systems:
-
-*   **Data Science & Analysis:** Deeply analyzing dataset quality, identifying limitations (e.g., posed vs. "in the wild"), and making strategic, data-driven decisions to improve model performance.
-*   **Deep Learning & Computer Vision:** Implementing and fine-tuning multiple advanced architectures (CNNs, Vision Transformers) for a complex computer vision task.
-*   **Full-Stack Application Development:** Building both decoupled (FastAPI/React) and unified (Gradio) web applications to serve a live ML model.
-*   **MLOps & CI/CD Automation:** Engineering a complete, end-to-end pipeline that is version-controlled, reproducible, and automatically deployed, reflecting best practices in production machine learning.
+### Model: Vision Transformer (ViT)
+This application uses a Vision Transformer model, fine-tuned for facial emotion recognition.
+### Dataset
+The model was fine-tuned on the **Emotion Recognition Dataset** from Kaggle, a large, curated collection of labeled facial images. This diverse dataset allows the model to generalize to a wide variety of real-world faces and expressions.
+*Dataset Link:* [https://www.kaggle.com/datasets/sujaykapadnis/emotion-recognition-dataset](https://www.kaggle.com/datasets/sujaykapadnis/emotion-recognition-dataset)
+### MLOps Pipeline
+This entire application, from data processing to training and deployment, was built using a reproducible MLOps pipeline, ensuring consistency and quality at every step.
 """
 
 # --- BACKEND LOGIC ---
-
 def create_prediction_html(probabilities):
-    """Generates clean HTML for the prediction bars."""
     if not probabilities:
         return "<div style='padding: 2rem; text-align: center; color: #999;'>Waiting for prediction...</div>"
     html = "<ul class='prediction-list'>"
@@ -130,22 +88,34 @@ def create_prediction_html(probabilities):
     html += "</ul>"
     return html
 
-def unified_prediction_function(frame):
-    """
-    A single, robust function that takes any frame (from webcam or upload)
-    and returns the annotated frame and the prediction HTML.
-    """
-    if frame is None:
-        return None, create_prediction_html({})
-    
-    annotated_frame, probabilities = predictor.process_frame_for_upload(frame)
-    
+def live_detection_stream():
+    """A generator function that runs the live feed loop. This is the definitive fix."""
+    cap = cv2.VideoCapture(0)
+    if not cap.isOpened():
+        print("[ERROR] Cannot open webcam")
+        return
+    try:
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                time.sleep(0.01)
+                continue
+            
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            annotated_frame, probabilities = predictor.process_frame(frame_rgb)
+            yield annotated_frame, create_prediction_html(probabilities)
+            time.sleep(0.05) # Controls FPS. 0.05 = ~20 FPS target. The model inference will be the main bottleneck.
+    finally:
+        print("[INFO] Live feed stopped. Releasing webcam.")
+        cap.release()
+
+def process_image(image):
+    if image is None: return None, create_prediction_html({})
+    annotated_frame, probabilities = predictor.process_frame(image)
     return annotated_frame, create_prediction_html(probabilities)
 
 def process_video(video_path, progress=gr.Progress(track_tqdm=True)):
-    """Processes an uploaded video file frame-by-frame."""
-    if video_path is None: 
-        return None
+    if video_path is None: return None
     try:
         cap = cv2.VideoCapture(video_path)
         frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
@@ -174,64 +144,52 @@ with gr.Blocks(css=CSS, theme=gr.themes.Base()) as demo:
     gr.Markdown("# Facial Emotion Detector", elem_id="title")
     gr.Markdown("A real-time AI application powered by Vision Transformers", elem_id="subtitle")
 
+    # --- NEW: Wrapper for the glass card effect ---
     with gr.Box(elem_id="main-card"):
         with gr.Tabs():
             with gr.TabItem("Live Detection"):
-                with gr.Row(equal_height=False):
+                with gr.Row(equal_height=True):
                     with gr.Column(scale=3):
-                        # The single, correct component for a live webcam feed.
-                        # It acts as both input (from webcam) and output (displaying the result).
-                        live_feed = gr.Image(source="webcam", streaming=True, type="numpy", label="Live Feed", height=550, mirror_webcam=True)
+                        live_output = gr.Image(label="Live Feed", interactive=False, height=550)
                     with gr.Column(scale=2, elem_id="predictions-column"):
-                        gr.Markdown("### Emotion Probabilities")
+                        gr.Markdown("### Emotion Probabilities") # Title for the panel
                         live_predictions = gr.HTML()
-            
+                with gr.Row():
+                    start_button = gr.Button("Start Webcam", variant="primary", scale=1)
+                    stop_button = gr.Button("Stop Webcam", variant="secondary", scale=1)
+                
+                stream_state = gr.State("Stop")
+
             with gr.TabItem("Upload Image"):
-                with gr.Row(equal_height=False):
+                with gr.Row(equal_height=True):
                     with gr.Column(scale=3):
                         image_input = gr.Image(type="numpy", label="Upload an Image", height=550)
                     with gr.Column(scale=2, elem_id="predictions-column"):
+                        gr.Markdown("### Emotion Probabilities")
                         image_predictions = gr.HTML()
                 image_button = gr.Button("Analyze Image", variant="primary")
 
             with gr.TabItem("Upload Video"):
-                with gr.Row(equal_height=False):
+                with gr.Row(equal_height=True):
                     video_input = gr.Video(label="Upload a Video File")
                     video_output = gr.Video(label="Processed Video")
                 video_button = gr.Button("Analyze Video", variant="primary")
             
             with gr.TabItem("About"):
                 gr.Markdown(ABOUT_MARKDOWN)
+    # --- END WRAPPER ---
 
-    # --- EVENT LISTENERS ---
+    # --- EVENT LISTENERS (No changes needed here) ---
+    start_event = start_button.click(lambda: "Start", None, stream_state, queue=False)
+    live_stream = start_event.then(live_detection_stream, stream_state, [live_output, live_predictions])
     
-    # Live Feed Logic: This is the simple, direct, and correct way.
-    # The stream from the 'live_feed' component calls the prediction function.
-    # The outputs are sent back to the 'live_feed' component (to update the image)
-    # and the 'live_predictions' component.
-    live_feed.stream(
-        fn=unified_prediction_function, 
-        inputs=[live_feed],
-        outputs=[live_feed, live_predictions]
-    )
-
-    # Image Upload Logic
-    image_button.click(
-        fn=unified_prediction_function, 
-        inputs=[image_input], 
-        outputs=[image_input, image_predictions]
-    )
-    
-    # Video Upload Logic
-    video_button.click(
-        fn=process_video, 
-        inputs=[video_input], 
-        outputs=[video_output]
-    )
+    stop_button.click(fn=None, inputs=None, outputs=None, cancels=[live_stream])
+
+    image_button.click(process_image, [image_input], [image_input, image_predictions])
+    video_button.click(process_video, [video_input], [video_output])
 
 # --- LAUNCH THE APP ---
 if predictor:
-    # Enabling the queue is essential for the video processing progress bar.
-    demo.queue().launch(debug=True)
+    demo.queue().launch(debug=True, share=True)
 else:
     print("\n[FATAL ERROR] Could not start the application.")

huggingface-space/.dvc/.gitignore

@@ -0,0 +1,2 @@
+/config.local
+/tmp

huggingface-space/.gitignore

@@ -0,0 +1,112 @@
+# MLOps & Data Science Artifacts
+# -------------------------------------------------------------------
+# Ignore all data, models, and artifacts. These should be tracked by DVC.
+/artifacts/
+/data/
+/sota_model/
+# Ignore the DVC local cache. This is where the actual data files are stored.
+.dvc/cache
+
+# Ignore MLflow experiment tracking output
+/mlruns/
+
+# Ignore logs
+/logs/
+*.log
+
+# Ignore common model file extensions, just in case
+*.h5
+*.pkl
+*.model
+*.onnx
+
+
+# Python Virtual Environments
+# -------------------------------------------------------------------
+/venv/
+/myenv/
+/.venv/
+/env/
+/ENV/
+*/.venv/
+*/venv/
+*/myenv/
+
+
+# Python Byte-code and Caches
+# -------------------------------------------------------------------
+__pycache__/
+*.py[cod]
+*$py.class
+
+
+# Python Packaging & Distribution
+# -------------------------------------------------------------------
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+
+# IDE and Editor Configuration
+# -------------------------------------------------------------------
+# PyCharm
+.idea/
+
+# Visual Studio Code (allow sharing of recommended extensions)
+.vscode/*
+!.vscode/extensions.json
+
+# Sublime Text
+*.sublime-project
+*.sublime-workspace
+
+
+# Secrets and Environment Variables
+# -------------------------------------------------------------------
+# NEVER commit secrets or environment variables
+.env
+*.env
+secrets.yaml
+secrets.json
+
+
+# Operating System Files
+# -------------------------------------------------------------------
+# macOS
+.DS_Store
+
+# Windows
+Thumbs.db
+desktop.ini
+
+
+# Jupyter Notebook Checkpoints
+# -------------------------------------------------------------------
+.ipynb_checkpoints/
+
+
+# Other
+# -------------------------------------------------------------------
+# Temporary files
+*.tmp
+*.bak
+*.swp
+
+.env
+*.env
+secrets.yaml
+secrets.json
+processed_video.mp4

huggingface-space/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ALYYAN
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

huggingface-space/README.md

@@ -4,7 +4,7 @@
 
 This repository contains a complete, end-to-end MLOps pipeline and a production-ready web application for real-time facial emotion recognition. The project leverages a state-of-the-art Vision Transformer model and is deployed as a user-friendly Gradio application on Hugging Face Spaces.
 
-**Live Demo:** [🚀 Click here to try the application on Hugging Face Spaces!](https://huggingface.co/spaces/YOUR-USERNAME/YOUR-SPACE-NAME) <!-- Replace with your HF Space URL -->
+**Live Demo:** [🚀 Click here to try the application on Hugging Face Spaces!](https://huggingface.co/spaces/ALYYAN/Emotion-Recognition) <!-- Replace with your HF Space URL -->
 
 ---
 
@@ -39,4 +39,4 @@ Follow these steps to run the project locally.
 
 ```bash
 git clone https://github.com/YOUR-USERNAME/Emotion-Recognition-MLOps.git
-cd Emotion-Recognition-MLOps
+cd Emotion-Recognition-MLOps

huggingface-space/app.py

@@ -0,0 +1,195 @@
+import gradio as gr
+import os
+import cv2
+import time
+
+from src.EmotionRecognition.pipeline.hf_predictor import HFPredictor
+
+# --- INITIALIZE THE MODEL ---
+print("[INFO] Initializing predictor...")
+try:
+    predictor = HFPredictor()
+    print("[INFO] Predictor initialized successfully.")
+except Exception as e:
+    predictor = None
+    print(f"[FATAL ERROR] Failed to initialize predictor: {e}")
+
+# --- UI CONTENT & STYLING ---
+# In app.py
+
+CSS = """
+/* Animated Gradient Background */
+body {
+    background: linear-gradient(-45deg, #0b0f19, #131a2d, #2a2a72, #522a72);
+    background-size: 400% 400%;
+    animation: gradient 15s ease infinite;
+    color: #e0e0e0;
+}
+@keyframes gradient {
+    0% { background-position: 0% 50%; }
+    50% { background-position: 100% 50%; }
+    100% { background-position: 0% 50%; }
+}
+
+/* General Layout & Typography */
+.gradio-container { max-width: 1320px !important; margin: auto !important; }
+#title { text-align: center; font-size: 3rem !important; font-weight: 700; color: #FFF; margin-bottom: 0.5rem; }
+#subtitle { text-align: center; color: #bebebe; margin-top: 0; margin-bottom: 40px; font-size: 1.2rem; font-weight: 300; }
+.gr-button { font-weight: bold !important; }
+
+/* --- NEW: The "Glass Card" effect --- */
+#main-card {
+    background: rgba(22, 22, 34, 0.65); /* Semi-transparent dark background */
+    border-radius: 16px;
+    box-shadow: 0 8px 32px 0 rgba(0, 0, 0, 0.37);
+    backdrop-filter: blur(12px); /* The "frosted glass" effect */
+    -webkit-backdrop-filter: blur(12px); /* For Safari */
+    border: 1px solid rgba(255, 255, 255, 0.18);
+    padding: 1rem;
+}
+/* --- END NEW --- */
+
+/* Prediction Bar Styling - now inside the card */
+#predictions-column { background-color: transparent !important; border-radius: 12px; padding: 1.5rem; }
+#predictions-column > .gr-label { display: none; }
+.prediction-list { list-style-type: none; padding: 0; margin-top: 0; }
+.prediction-list li { display: flex; align-items: center; margin-bottom: 12px; font-size: 1.1rem; }
+.prediction-list .label { width: 100px; text-transform: capitalize; color: #e0e0e0; }
+.prediction-list .bar-container { flex-grow: 1; height: 24px; background-color: rgba(255,255,255,0.1); border-radius: 12px; margin: 0 15px; overflow: hidden; }
+.prediction-list .bar { height: 100%; background: linear-gradient(90deg, #8A2BE2, #C71585); border-radius: 12px; transition: width 0.2s ease-in-out; }
+.prediction-list .percent { width: 60px; text-align: right; font-weight: bold; color: #FFF; }
+footer { display: none !important; }
+"""
+
+ABOUT_MARKDOWN = """
+### Model: Vision Transformer (ViT)
+This application uses a Vision Transformer model, fine-tuned for facial emotion recognition.
+### Dataset
+The model was fine-tuned on the **Emotion Recognition Dataset** from Kaggle, a large, curated collection of labeled facial images. This diverse dataset allows the model to generalize to a wide variety of real-world faces and expressions.
+*Dataset Link:* [https://www.kaggle.com/datasets/sujaykapadnis/emotion-recognition-dataset](https://www.kaggle.com/datasets/sujaykapadnis/emotion-recognition-dataset)
+### MLOps Pipeline
+This entire application, from data processing to training and deployment, was built using a reproducible MLOps pipeline, ensuring consistency and quality at every step.
+"""
+
+# --- BACKEND LOGIC ---
+def create_prediction_html(probabilities):
+    if not probabilities:
+        return "<div style='padding: 2rem; text-align: center; color: #999;'>Waiting for prediction...</div>"
+    html = "<ul class='prediction-list'>"
+    sorted_preds = sorted(probabilities.items(), key=lambda item: item[1], reverse=True)
+    for emotion, prob in sorted_preds:
+        html += f"""
+        <li>
+            <strong class='label'>{emotion}</strong>
+            <div class='bar-container'><div class='bar' style='width: {prob*100:.1f}%;'></div></div>
+            <span class='percent'>{(prob*100):.1f}%</span>
+        </li>
+        """
+    html += "</ul>"
+    return html
+
+def live_detection_stream():
+    """A generator function that runs the live feed loop. This is the definitive fix."""
+    cap = cv2.VideoCapture(0)
+    if not cap.isOpened():
+        print("[ERROR] Cannot open webcam")
+        return
+    try:
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                time.sleep(0.01)
+                continue
+            
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            annotated_frame, probabilities = predictor.process_frame(frame_rgb)
+            yield annotated_frame, create_prediction_html(probabilities)
+            time.sleep(0.05) # Controls FPS. 0.05 = ~20 FPS target. The model inference will be the main bottleneck.
+    finally:
+        print("[INFO] Live feed stopped. Releasing webcam.")
+        cap.release()
+
+def process_image(image):
+    if image is None: return None, create_prediction_html({})
+    annotated_frame, probabilities = predictor.process_frame(image)
+    return annotated_frame, create_prediction_html(probabilities)
+
+def process_video(video_path, progress=gr.Progress(track_tqdm=True)):
+    if video_path is None: return None
+    try:
+        cap = cv2.VideoCapture(video_path)
+        frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        output_path = "processed_video.mp4"
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+        for _ in progress.tqdm(range(frame_count), desc="Processing Video"):
+            ret, frame = cap.read()
+            if not ret: break
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            annotated_frame, _ = predictor.process_frame(frame_rgb)
+            if annotated_frame is not None:
+                out.write(cv2.cvtColor(annotated_frame, cv2.COLOR_RGB2BGR))
+        cap.release()
+        out.release()
+        return output_path
+    except Exception as e:
+        print(f"[ERROR] Video processing failed: {e}")
+        return None
+
+# --- GRADIO UI ---
+with gr.Blocks(css=CSS, theme=gr.themes.Base()) as demo:
+    gr.Markdown("# Facial Emotion Detector", elem_id="title")
+    gr.Markdown("A real-time AI application powered by Vision Transformers", elem_id="subtitle")
+
+    # --- NEW: Wrapper for the glass card effect ---
+    with gr.Box(elem_id="main-card"):
+        with gr.Tabs():
+            with gr.TabItem("Live Detection"):
+                with gr.Row(equal_height=True):
+                    with gr.Column(scale=3):
+                        live_output = gr.Image(label="Live Feed", interactive=False, height=550)
+                    with gr.Column(scale=2, elem_id="predictions-column"):
+                        gr.Markdown("### Emotion Probabilities") # Title for the panel
+                        live_predictions = gr.HTML()
+                with gr.Row():
+                    start_button = gr.Button("Start Webcam", variant="primary", scale=1)
+                    stop_button = gr.Button("Stop Webcam", variant="secondary", scale=1)
+                
+                stream_state = gr.State("Stop")
+
+            with gr.TabItem("Upload Image"):
+                with gr.Row(equal_height=True):
+                    with gr.Column(scale=3):
+                        image_input = gr.Image(type="numpy", label="Upload an Image", height=550)
+                    with gr.Column(scale=2, elem_id="predictions-column"):
+                        gr.Markdown("### Emotion Probabilities")
+                        image_predictions = gr.HTML()
+                image_button = gr.Button("Analyze Image", variant="primary")
+
+            with gr.TabItem("Upload Video"):
+                with gr.Row(equal_height=True):
+                    video_input = gr.Video(label="Upload a Video File")
+                    video_output = gr.Video(label="Processed Video")
+                video_button = gr.Button("Analyze Video", variant="primary")
+            
+            with gr.TabItem("About"):
+                gr.Markdown(ABOUT_MARKDOWN)
+    # --- END WRAPPER ---
+
+    # --- EVENT LISTENERS (No changes needed here) ---
+    start_event = start_button.click(lambda: "Start", None, stream_state, queue=False)
+    live_stream = start_event.then(live_detection_stream, stream_state, [live_output, live_predictions])
+    
+    stop_button.click(fn=None, inputs=None, outputs=None, cancels=[live_stream])
+
+    image_button.click(process_image, [image_input], [image_input, image_predictions])
+    video_button.click(process_video, [video_input], [video_output])
+
+# --- LAUNCH THE APP ---
+if predictor:
+    demo.queue().launch(debug=True, share=True)
+else:
+    print("\n[FATAL ERROR] Could not start the application.")

huggingface-space/config/config.yaml

@@ -0,0 +1,25 @@
+artifacts_root: artifacts
+
+data_preparation: # This is our Stage 1
+  root_dir: artifacts/data_preparation
+  # Inputs from raw data
+  ferplus_pixels_csv: data/raw/fer2013.csv
+  ferplus_labels_csv: data/raw/fer2013new.csv
+  ckplus_dir: data/raw/CK+48
+  # Outputs
+  combined_train_dir: artifacts/data_preparation/train
+  ferplus_test_dir: artifacts/data_preparation/test
+
+model_trainer:
+  root_dir: artifacts/training
+  # The trainer now takes its input directly from the preparation stage
+  train_data_dir: artifacts/data_preparation/train
+  test_data_dir: artifacts/data_preparation/test
+  trained_model_path: artifacts/training/model.keras
+
+model_evaluation:
+  root_dir: artifacts/evaluation
+  test_data_dir: artifacts/data_preparation/test
+  trained_model_path: artifacts/training/model.keras
+  metrics_file_name: artifacts/evaluation/metrics.json
+  mlflow_uri: https://dagshub.com/AlyyanAhmed21/Emotion-Recognition-MLOps.mlflow # Example for DagsHub

huggingface-space/dvc.lock

@@ -0,0 +1,203 @@
+schema: '2.0'
+stages:
+  data_validation:
+    cmd: python src/EmotionRecognition/pipeline/stage_02_data_validation.py
+    deps:
+    - path: artifacts/data_ingestion
+      hash: md5
+      md5: 9208f64defb6697b78bab62e943d955d.dir
+      size: 302675528
+      nfiles: 2
+    - path: src/EmotionRecognition/config/configuration.py
+      hash: md5
+      md5: dacf4230e18681185b786aa280cdec5e
+      size: 4275
+    - path: src/EmotionRecognition/pipeline/stage_02_data_validation.py
+      hash: md5
+      md5: 18a3d78c83dc5b278e14523077035e41
+      size: 1141
+    outs:
+    - path: artifacts/data_validation/status.txt
+      hash: md5
+      md5: 86e6a2f694c57a675b3e2da6b95ff9ba
+      size: 23
+  data_preparation:
+    cmd: python src/EmotionRecognition/pipeline/stage_01_data_preparation.py
+    deps:
+    - path: data/raw/CK+48
+      hash: md5
+      md5: a1559eddfd0d86b541e5df18b4b8205e.dir
+      size: 1715162
+      nfiles: 981
+    - path: data/raw/fer2013.csv
+      hash: md5
+      md5: f8428a1edbd21e88f42c73edd2a14f95
+      size: 301072766
+    - path: data/raw/fer2013new.csv
+      hash: md5
+      md5: 413eba86d6e454536b99705b8c7fc5c5
+      size: 1602762
+    - path: src/EmotionRecognition/components/data_preparation.py
+      hash: md5
+      md5: 228140227aaedb9f07b4c00462f267c6
+      size: 5776
+    - path: src/EmotionRecognition/config/configuration.py
+      hash: md5
+      md5: 8786c8d41e2e50a49b4ca6d5bf59ad44
+      size: 2910
+    - path: src/EmotionRecognition/pipeline/stage_01_data_preparation.py
+      hash: md5
+      md5: 1a324b8f1cf01e4e60e0a8529b23b577
+      size: 1110
+    params:
+      params.yaml:
+        DATA_PARAMS.CLASSES:
+        - angry
+        - disgust
+        - fear
+        - happy
+        - neutral
+        - sad
+        - surprise
+    outs:
+    - path: artifacts/data_preparation/test
+      hash: md5
+      md5: 79c105a50ccbe2557fea9fab2c743fa5.dir
+      size: 6249935
+      nfiles: 3589
+    - path: artifacts/data_preparation/train
+      hash: md5
+      md5: 750c0a305d28467341396ab591ed2731.dir
+      size: 51232879
+      nfiles: 29471
+  model_training:
+    cmd: python src/EmotionRecognition/pipeline/stage_02_model_training.py
+    deps:
+    - path: artifacts/data_preparation/test
+      hash: md5
+      md5: 79c105a50ccbe2557fea9fab2c743fa5.dir
+      size: 6249935
+      nfiles: 3589
+    - path: artifacts/data_preparation/train
+      hash: md5
+      md5: 750c0a305d28467341396ab591ed2731.dir
+      size: 51232879
+      nfiles: 29471
+    - path: src/EmotionRecognition/components/model_trainer.py
+      hash: md5
+      md5: 5192acef195c9a9b03a88490476ead1c
+      size: 3916
+    - path: src/EmotionRecognition/pipeline/stage_02_model_training.py
+      hash: md5
+      md5: 2ee36d6e30a3a262e8327a26e71a37e9
+      size: 1076
+    params:
+      params.yaml:
+        DATA_PARAMS:
+          IMAGE_SIZE:
+          - 224
+          - 224
+          CHANNELS: 3
+          BATCH_SIZE: 32
+          CLASSES:
+          - angry
+          - disgust
+          - fear
+          - happy
+          - neutral
+          - sad
+          - surprise
+          NUM_CLASSES: 7
+        TRAINING_PARAMS:
+          EPOCHS: 50
+          LEARNING_RATE: 0.0001
+          OPTIMIZER: Adam
+          LOSS_FUNCTION: CategoricalCrossentropy
+          METRICS:
+          - accuracy
+          DROPOUT_RATE: 0.5
+    outs:
+    - path: artifacts/training/model.keras
+      hash: md5
+      md5: 2c632cb4cbf3f2944145a8da1927f2cf
+      size: 11331400
+  model_evaluation:
+    cmd: python src/EmotionRecognition/pipeline/stage_03_model_evaluation.py
+    deps:
+    - path: artifacts/data_preparation/test
+      hash: md5
+      md5: 79c105a50ccbe2557fea9fab2c743fa5.dir
+      size: 6249935
+      nfiles: 3589
+    - path: artifacts/training/model.keras
+      hash: md5
+      md5: 2c632cb4cbf3f2944145a8da1927f2cf
+      size: 11331400
+    - path: src/EmotionRecognition/components/model_evaluation.py
+      hash: md5
+      md5: 8b327667db406dd7c6489937747b8537
+      size: 2429
+    params:
+      params.yaml:
+        DATA_PARAMS:
+          IMAGE_SIZE:
+          - 224
+          - 224
+          CHANNELS: 3
+          BATCH_SIZE: 32
+          CLASSES:
+          - angry
+          - disgust
+          - fear
+          - happy
+          - neutral
+          - sad
+          - surprise
+          NUM_CLASSES: 7
+    outs:
+    - path: artifacts/evaluation/metrics.json
+      hash: md5
+      md5: 3e8f938b34095f56c597110c5d86064e
+      size: 72
+  data_preprocessing:
+    cmd: python src/EmotionRecognition/pipeline/stage_02_data_preprocessing.py
+    deps:
+    - path: artifacts/data_preparation/test
+      hash: md5
+      md5: 79c105a50ccbe2557fea9fab2c743fa5.dir
+      size: 6249935
+      nfiles: 3589
+    - path: artifacts/data_preparation/train
+      hash: md5
+      md5: 750c0a305d28467341396ab591ed2731.dir
+      size: 51232879
+      nfiles: 29471
+    - path: src/EmotionRecognition/components/data_preprocessing.py
+      hash: md5
+      md5: bc85964fdf86afb289051c2498037eb8
+      size: 3903
+    - path: src/EmotionRecognition/pipeline/stage_02_data_preprocessing.py
+      hash: md5
+      md5: 5631296a6b7bace5c2f6979eda5ca081
+      size: 971
+    params:
+      params.yaml:
+        DATA_PARAMS.CLASSES:
+        - angry
+        - disgust
+        - fear
+        - happy
+        - neutral
+        - sad
+        - surprise
+    outs:
+    - path: artifacts/data_preprocessing/test
+      hash: md5
+      md5: 79c105a50ccbe2557fea9fab2c743fa5.dir
+      size: 6249935
+      nfiles: 3589
+    - path: artifacts/data_preprocessing/train
+      hash: md5
+      md5: 3dc8382a4774d1a1f1d1e5dfe3ca4c1b.dir
+      size: 18389122
+      nfiles: 10500

huggingface-space/dvc.yaml

@@ -0,0 +1,39 @@
+stages:
+  data_preparation:
+    cmd: python src/EmotionRecognition/pipeline/stage_01_data_preparation.py
+    deps:
+      - src/EmotionRecognition/pipeline/stage_01_data_preparation.py
+      - src/EmotionRecognition/components/data_preparation.py
+      - data/raw/fer2013.csv
+      - data/raw/fer2013new.csv
+      - data/raw/CK+48
+    params:
+      - DATA_PARAMS.CLASSES
+    outs:
+      - artifacts/data_preparation/train
+      - artifacts/data_preparation/test
+
+  model_training:
+    cmd: python src/EmotionRecognition/pipeline/stage_02_model_training.py
+    deps:
+      - src/EmotionRecognition/pipeline/stage_02_model_training.py
+      - src/EmotionRecognition/components/model_trainer.py
+      - artifacts/data_preparation/train
+      - artifacts/data_preparation/test
+    params:
+      - DATA_PARAMS
+      - TRAINING_PARAMS
+    outs:
+      - artifacts/training/model.keras
+
+  model_evaluation:
+    cmd: python src/EmotionRecognition/pipeline/stage_03_model_evaluation.py
+    deps:
+      - src/EmotionRecognition/components/model_evaluation.py
+      - artifacts/data_preparation/test
+      - artifacts/training/model.keras
+    params:
+      - DATA_PARAMS
+    metrics:
+      - artifacts/evaluation/metrics.json:
+          cache: false

huggingface-space/gpuCheck.py

@@ -0,0 +1,42 @@
+import os
+import tensorflow as tf
+
+# --- THE WORKAROUND ---
+# Define the full path to the CUDA bin directory
+cuda_bin_path = r"E:\Nvidia\CUDA\v11.2\bin"
+
+# Add this path to the OS environment's DLL search path
+# This MUST be done BEFORE importing tensorflow
+try:
+    os.add_dll_directory(cuda_bin_path)
+    print(f"Successfully added {cuda_bin_path} to DLL search path.")
+except AttributeError:
+    # This function was added in Python 3.8. For older versions, you might need
+    # to add the path to the system PATH environment variable manually.
+    print("os.add_dll_directory not available. Ensure CUDA bin is in the system PATH.")
+# --- END WORKAROUND ---
+
+
+print(f"TensorFlow Version: {tf.__version__}")
+print("-" * 30)
+
+# Check for GPU devices
+gpu_devices = tf.config.list_physical_devices('GPU')
+print(f"Num GPUs Available: {len(gpu_devices)}")
+print("-" * 30)
+
+if gpu_devices:
+    print("GPU Device Details:")
+    for gpu in gpu_devices:
+        tf.config.experimental.set_memory_growth(gpu, True)
+        print(f"- {gpu.name}, Type: {gpu.device_type}")
+    print("\nSUCCESS: TensorFlow is configured to use the GPU!")
+else:
+    print("\nFAILURE: TensorFlow did not detect a GPU.")
+
+
+import tensorflow as tf
+from tensorflow.python.client import device_lib
+
+print("Verbose device list:")
+print(device_lib.list_local_devices())

huggingface-space/huggingface-space/.gitattributes

@@ -0,0 +1 @@
+sota_model/model.safetensors filter=lfs diff=lfs merge=lfs -text

huggingface-space/huggingface-space/README.md

@@ -0,0 +1,42 @@
+# 🎭 End-to-End Facial Emotion Recognition
+
+ <!-- Replace with a link to your final app screenshot -->
+
+This repository contains a complete, end-to-end MLOps pipeline and a production-ready web application for real-time facial emotion recognition. The project leverages a state-of-the-art Vision Transformer model and is deployed as a user-friendly Gradio application on Hugging Face Spaces.
+
+**Live Demo:** [🚀 Click here to try the application on Hugging Face Spaces!](https://huggingface.co/spaces/YOUR-USERNAME/YOUR-SPACE-NAME) <!-- Replace with your HF Space URL -->
+
+---
+
+## ✨ Features
+
+-   **Real-time Emotion Detection:** Analyzes your webcam feed to predict emotions in real-time.
+-   **High Accuracy:** Powered by a pre-trained Swin Transformer model fine-tuned on the massive AffectNet dataset for superior performance on "in the wild" faces.
+-   **Static Image & Video Analysis:** Upload your own images or videos for emotion prediction.
+-   **Polished UI:** A professional and responsive user interface with an animated background, built with Gradio.
+-   **Reproducible MLOps Pipeline:** The entire model training and data processing workflow is managed by DVC, ensuring 100% reproducibility.
+-   **Containerized for Deployment:** The application is packaged with Docker for easy and consistent deployment anywhere.
+
+## 🛠️ Tech Stack
+
+-   **Model:** Swin Transformer (`PangPang/affectnet-swin-tiny-patch4-window7-224`)
+-   **ML/Ops:** Python, TensorFlow/Keras, DVC, MLflow, Hugging Face `transformers`
+-   **Backend & UI:** Gradio
+-   **Face Detection:** MTCNN
+-   **Deployment:** Hugging Face Spaces, Docker
+
+## 🚀 Getting Started
+
+Follow these steps to run the project locally.
+
+### Prerequisites
+
+-   Python 3.10+
+-   Git and Git LFS ([installation guide](https://git-lfs.github.com))
+-   An NVIDIA GPU with CUDA drivers is recommended for the training pipeline, but the deployed app runs on CPU.
+
+### 1. Clone the Repository
+
+```bash
+git clone https://github.com/YOUR-USERNAME/Emotion-Recognition-MLOps.git
+cd Emotion-Recognition-MLOps

huggingface-space/main.py

@@ -0,0 +1,70 @@
+from EmotionRecognition import logger
+from EmotionRecognition.pipeline.stage_01_data_ingestion import DataIngestionTrainingPipeline
+from EmotionRecognition.pipeline.stage_02_data_validation import DataValidationTrainingPipeline
+from EmotionRecognition.pipeline.stage_01_data_preparation import DataPreparationPipeline
+from EmotionRecognition.pipeline.stage_02_model_training import ModelTrainingPipeline
+from EmotionRecognition.pipeline.stage_03_model_evaluation import ModelEvaluationPipeline 
+
+# Data Ingestion Stage
+STAGE_NAME = "Data Ingestion Stage"
+try:
+    logger.info(f">>>>>> Stage '{STAGE_NAME}' started <<<<<<")
+    obj = DataIngestionTrainingPipeline()
+    obj.main()
+    logger.info(f">>>>>> Stage '{STAGE_NAME}' completed successfully <<<<<<\n\nx==========x")
+except Exception as e:
+    logger.exception(e)
+    raise e
+
+# Data Validation Stage
+STAGE_NAME = "Data Validation Stage"
+try:
+    logger.info(f">>>>>> Stage '{STAGE_NAME}' started <<<<<<")
+    obj = DataValidationTrainingPipeline()
+    obj.main()
+    logger.info(f">>>>>> Stage '{STAGE_NAME}' completed successfully <<<<<<\n\nx==========x")
+except Exception as e:
+    logger.exception(e)
+    raise e
+
+# Data Preprocessing Stage
+#STAGE_NAME = "Data Preprocessing Stage"
+#try:
+#    logger.info(f">>>>>> Stage '{STAGE_NAME}' started <<<<<<")
+#    obj = DataPreprocessingTrainingPipeline()
+#    obj.main()
+#    logger.info(f">>>>>> Stage '{STAGE_NAME}' completed successfully <<<<<<\n\nx==========x")
+#except Exception as e:
+#    logger.exception(e)
+#    raise e
+
+STAGE_NAME = "Data Preparation Stage"
+try:
+    logger.info(f">>>>>> Stage '{STAGE_NAME}' started <<<<<<")
+    obj = DataPreparationPipeline()
+    obj.main()
+    logger.info(f">>>>>> Stage '{STAGE_NAME}' completed successfully <<<<<<\n\nx==========x")
+except Exception as e:
+    logger.exception(e)
+    raise e
+
+STAGE_NAME = "Model Training Stage"
+try:
+    logger.info(f">>>>>> Stage '{STAGE_NAME}' started <<<<<<")
+    obj = ModelTrainingPipeline()
+    obj.main()
+    logger.info(f">>>>>> Stage '{STAGE_NAME}' completed successfully <<<<<<\n\nx==========x")
+except Exception as e:
+    logger.exception(e)
+    raise e
+
+# Model Evaluation Stage
+STAGE_NAME = "Model Evaluation Stage"
+try:
+    logger.info(f">>>>>> Stage '{STAGE_NAME}' started <<<<<<")
+    obj = ModelEvaluationPipeline()
+    obj.main()
+    logger.info(f">>>>>> Stage '{STAGE_NAME}' completed successfully <<<<<<\n\nx==========x")
+except Exception as e:
+    logger.exception(e)
+    raise e

huggingface-space/params.yaml

@@ -0,0 +1,15 @@
+DATA_PARAMS:
+  IMAGE_SIZE: [224, 224]
+  CHANNELS: 3
+  BATCH_SIZE: 32
+  # Our final 7 classes (Contempt is merged into Disgust)
+  CLASSES: ['angry', 'disgust', 'fear', 'happy', 'neutral', 'sad', 'surprise']
+  NUM_CLASSES: 7
+
+TRAINING_PARAMS:
+  EPOCHS: 50 # A solid number for a baseline run
+  LEARNING_RATE: 0.0001 # A small, stable learning rate
+  OPTIMIZER: Adam
+  LOSS_FUNCTION: CategoricalCrossentropy
+  METRICS: ['accuracy']
+  DROPOUT_RATE: 0.5 # Strong regularization is good

huggingface-space/requirements.txt

@@ -0,0 +1,44 @@
+# -----------------------------------------------------------
+# MLOps Pipeline & Data Versioning
+# -----------------------------------------------------------
+dvc[s3]               # For data versioning. Change [s3] to your remote type or remove.
+kaggle                # For downloading datasets from Kaggle.
+
+
+# -----------------------------------------------------------
+# Core Machine Learning & Deep Learning
+# -----------------------------------------------------------
+# Using the stable TensorFlow 2.10 for GPU support on native Windows
+tensorflow==2.10.0
+scikit-learn          # For evaluation metrics.
+
+# Hugging Face SOTA Model Dependencies
+transformers          # For loading models and processors from the Hub.
+torch                 # PyTorch is a backend dependency for many HF vision models.
+torchvision
+timm                  # Another common dependency for HF vision transformers.
+
+# Computer Vision
+opencv-python         # For image/video processing and drawing.
+mtcnn                 # For fast and effective face detection.
+Pillow                # For basic image manipulation.
+
+
+# -----------------------------------------------------------
+# Web Application & User Interface
+# -----------------------------------------------------------
+gradio==3.50.2        # Locked to a stable version for consistent UI behavior.
+
+
+# -----------------------------------------------------------
+# Utilities
+# -----------------------------------------------------------
+numpy
+pandas                # For data manipulation in the preparation stage.
+PyYAML                # For reading .yaml configuration files.
+python-box            # For dot-notation access to config dictionaries.
+tqdm                  # For progress bars in scripts.
+ensure                # For runtime type checking.
+matplotlib            # For plotting (useful in research).
+seaborn               # For advanced plotting (useful in research).
+notebook              # For running Jupyter notebooks.

huggingface-space/setup.py

@@ -0,0 +1,28 @@
+import setuptools
+
+with open("README.md", "r", encoding="utf-8") as f:
+    long_description = f.read()
+
+__version__ = "0.0.1"
+
+REPO_NAME = "Emotion-Recognition-MLOps"
+AUTHOR_USER_NAME = "AlyyanAhmed21"
+SRC_REPO = "EmotionRecognition"
+AUTHOR_EMAIL = "alyyanawan19@gmail.com" 
+
+
+setuptools.setup(
+    name=SRC_REPO,
+    version=__version__,
+    author=AUTHOR_USER_NAME,
+    author_email=AUTHOR_EMAIL,
+    description="A small python package for MLOps based facial emotion detection app",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url=f"https://github.com/{AUTHOR_USER_NAME}/{REPO_NAME}",
+    project_urls={
+        "Bug Tracker": f"https://github.com/{AUTHOR_USER_NAME}/{REPO_NAME}/issues",
+    },
+    package_dir={"": "src"},
+    packages=setuptools.find_packages(where="src")
+)

huggingface-space/src/EmotionRecognition/__init__.py

@@ -0,0 +1,25 @@
+import os
+import sys
+import logging
+
+# Define the logging format
+logging_str = "[%(asctime)s: %(levelname)s: %(module)s: %(message)s]"
+
+# Define the directory for log files
+log_dir = "logs"
+log_filepath = os.path.join(log_dir, "running_logs.log")
+os.makedirs(log_dir, exist_ok=True)
+
+# Configure the logging
+logging.basicConfig(
+    level=logging.INFO,
+    format=logging_str,
+
+    handlers=[
+        logging.FileHandler(log_filepath),  # Log to a file
+        logging.StreamHandler(sys.stdout)   # Log to the console
+    ]
+)
+
+# Create a logger object that can be imported by other modules
+logger = logging.getLogger("EmotionRecognitionLogger")

huggingface-space/src/EmotionRecognition/components/data_ingestion.py

@@ -0,0 +1,27 @@
+# File: src/EmotionRecognition/components/data_ingestion.py
+import os
+from EmotionRecognition import logger
+from EmotionRecognition.entity.config_entity import DataIngestionConfig
+
+class DataIngestion:
+    def __init__(self, config: DataIngestionConfig):
+        self.config = config
+
+    def validate_source_data(self):
+        """
+        Validates the existence of all raw source data files and folders.
+        """
+        logger.info("Validating source data files and folders...")
+        
+        all_paths = [
+            self.config.root_dir,
+            self.config.ferplus_pixels_csv,
+            self.config.ferplus_labels_csv,
+            self.config.ckplus_dir
+        ]
+
+        for path in all_paths:
+            if not os.path.exists(path):
+                raise FileNotFoundError(f"Missing required raw data source: {path}")
+
+        logger.info("All raw data sources found successfully.")

huggingface-space/src/EmotionRecognition/components/data_preparation.py

@@ -0,0 +1,118 @@
+# File: src/EmotionRecognition/components/data_preparation.py
+import os
+import pandas as pd
+import numpy as np
+from PIL import Image
+from tqdm import tqdm
+import shutil
+from EmotionRecognition import logger
+from EmotionRecognition.entity.config_entity import DataPreparationConfig
+from pathlib import Path
+import glob
+
+class DataPreparation:
+    def __init__(self, config: DataPreparationConfig, params: dict):
+        self.config = config
+        self.params = params.DATA_PARAMS
+
+    def _process_and_save(self, best_emotion_name, usage, index, pixels, dataset_prefix):
+        """Helper function to handle the merging logic and save images."""
+        
+        # --- MERGING LOGIC ---
+        # If the emotion is 'contempt', we re-label it as 'disgust'.
+        if best_emotion_name == 'contempt':
+            final_emotion_name = 'disgust'
+        else:
+            final_emotion_name = best_emotion_name
+        # --- END MERGING LOGIC ---
+            
+        # Check if this emotion is one of our final target classes
+        if final_emotion_name in self.params.CLASSES:
+            if usage == 'Training':
+                output_dir = self.config.combined_train_dir
+            elif usage == 'PublicTest':
+                output_dir = self.config.ferplus_test_dir
+            else:
+                return # Skip other usages like PrivateTest
+
+            image = Image.fromarray(pixels)
+            emotion_folder = Path(output_dir) / final_emotion_name
+            emotion_folder.mkdir(parents=True, exist_ok=True)
+            image.save(emotion_folder / f"{dataset_prefix}_{index}.png")
+
+    def _prepare_ferplus(self):
+        logger.info("Starting preparation of FER+ dataset...")
+        pixels_df = pd.read_csv(self.config.ferplus_pixels_csv)
+        labels_df = pd.read_csv(self.config.ferplus_labels_csv)
+        
+        ferplus_emotion_columns = ['neutral', 'happiness', 'surprise', 'sadness', 'anger', 'disgust', 'fear', 'contempt']
+        
+        for index, row in tqdm(pixels_df.iterrows(), total=len(pixels_df), desc="Processing FER+ Images"):
+            label_votes = labels_df.iloc[index][ferplus_emotion_columns].values
+            source_emotion_name = ferplus_emotion_columns[np.argmax(label_votes)]
+
+            # --- STANDARDIZE THE NAME ---
+            # Default to the source name
+            our_emotion_name = source_emotion_name
+            if source_emotion_name == 'happiness': our_emotion_name = 'happy'
+            if source_emotion_name == 'sadness': our_emotion_name = 'sad'
+            if source_emotion_name == 'anger': our_emotion_name = 'angry'
+            if source_emotion_name == 'contempt': our_emotion_name = 'disgust' # MERGE
+            
+            if our_emotion_name in self.params.CLASSES:
+                usage = row['Usage']
+                if usage == 'Training': output_dir = self.config.combined_train_dir
+                elif usage == 'PublicTest': output_dir = self.config.ferplus_test_dir
+                else: continue
+
+                pixels = np.array(row['pixels'].split(), 'uint8').reshape((48, 48))
+                image = Image.fromarray(pixels)
+                emotion_folder = Path(output_dir) / our_emotion_name
+                emotion_folder.mkdir(parents=True, exist_ok=True)
+                image.save(emotion_folder / f"ferplus_{index}.png")
+                
+        logger.info("FER+ dataset preparation complete.")
+
+    def _prepare_ckplus(self):
+        logger.info("Starting preparation of CK+ dataset...")
+        
+        for ckplus_folder_name in tqdm(os.listdir(self.config.ckplus_dir), desc="Processing CK+ Folders"):
+            source_emotion_dir = Path(self.config.ckplus_dir) / ckplus_folder_name
+            
+            # --- STANDARDIZE THE NAME ---
+            our_emotion_name = ckplus_folder_name # Default
+            if ckplus_folder_name == 'contempt': our_emotion_name = 'disgust' # MERGE
+            
+            if our_emotion_name in self.params.CLASSES and source_emotion_dir.is_dir():
+                dest_emotion_dir = Path(self.config.combined_train_dir) / our_emotion_name
+                dest_emotion_dir.mkdir(parents=True, exist_ok=True)
+                
+                for img_file in os.listdir(source_emotion_dir):
+                    shutil.copy(source_emotion_dir / img_file, dest_emotion_dir / f"ckplus_{img_file}")
+        
+        logger.info("CK+ dataset preparation complete.")
+        
+    def _log_dataset_statistics(self):
+        logger.info("--- Final Dataset Statistics ---")
+        logger.info("Training Set:")
+        for emotion in sorted(self.params.CLASSES):
+            count = len(glob.glob(str(self.config.combined_train_dir / emotion / '*.png')))
+            logger.info(f"- {emotion}: {count} images")
+        
+        logger.info("\nTest Set:")
+        for emotion in sorted(self.params.CLASSES):
+            count = len(glob.glob(str(self.config.ferplus_test_dir / emotion / '*.png')))
+            logger.info(f"- {emotion}: {count} images")
+        logger.info("---------------------------------")
+
+    def combine_and_prepare_data(self):
+        logger.info("--- Starting Data Preparation Stage ---")
+        if os.path.exists(self.config.combined_train_dir): shutil.rmtree(self.config.combined_train_dir)
+        if os.path.exists(self.config.ferplus_test_dir): shutil.rmtree(self.config.ferplus_test_dir)
+        os.makedirs(self.config.combined_train_dir, exist_ok=True)
+        os.makedirs(self.config.ferplus_test_dir, exist_ok=True)
+        
+        self._prepare_ferplus()
+        self._prepare_ckplus()
+        self._log_dataset_statistics()
+        logger.info("--- Data Preparation Stage Complete ---")

huggingface-space/src/EmotionRecognition/components/data_preprocessing.py

@@ -0,0 +1,86 @@
+# File: src/EmotionRecognition/components/data_preprocessing.py
+import os
+import shutil
+import random
+import glob
+from tqdm import tqdm
+from EmotionRecognition import logger
+from EmotionRecognition.entity.config_entity import DataPreprocessingConfig
+from pathlib import Path
+
+class DataPreprocessing:
+    def __init__(self, config: DataPreprocessingConfig, params: dict):
+        self.config = config
+        self.params = params.DATA_PARAMS
+
+    def _log_and_get_stats(self, directory):
+        """Helper to get and log image counts for a directory."""
+        stats = {}
+        logger.info(f"Statistics for directory: {directory}")
+        for emotion in sorted(self.params.CLASSES):
+            path = Path(directory) / emotion
+            count = len(glob.glob(str(path / '*.png')))
+            stats[emotion] = count
+            logger.info(f"- {emotion}: {count} images")
+        return stats
+
+    def balance_dataset(self):
+        """
+        Applies a hybrid oversampling and undersampling strategy to balance the training data.
+        """
+        logger.info("--- Starting Hybrid Data Balancing Stage ---")
+        
+        logger.info("Source Training Set Distribution:")
+        self._log_and_get_stats(self.config.source_train_dir)
+        
+        if os.path.exists(self.config.balanced_train_dir): shutil.rmtree(self.config.balanced_train_dir)
+        os.makedirs(self.config.balanced_train_dir, exist_ok=True)
+
+        target_count = self.config.target_samples_per_class
+        logger.info(f"\nBalancing all training classes to {target_count} samples each...")
+
+        for emotion in tqdm(self.params.CLASSES, desc="Balancing Classes"):
+            source_emotion_dir = Path(self.config.source_train_dir) / emotion
+            dest_emotion_dir = Path(self.config.balanced_train_dir) / emotion
+            dest_emotion_dir.mkdir(parents=True, exist_ok=True)
+            
+            image_files = os.listdir(source_emotion_dir)
+            
+            if not image_files:
+                logger.warning(f"No images found for class '{emotion}'. Skipping.")
+                continue
+
+            current_count = len(image_files)
+
+            if current_count > target_count:
+                # Undersampling: Randomly select 'target_count' unique images
+                selected_files = random.sample(image_files, target_count)
+            else:
+                # Oversampling: Select with replacement to reach 'target_count'
+                selected_files = random.choices(image_files, k=target_count)
+
+            # --- THIS IS THE BUG FIX ---
+            # Copy the selected files, giving duplicates new names.
+            for i, filename in enumerate(selected_files):
+                # Get the original file's extension
+                base_name, extension = os.path.splitext(filename)
+                
+                # If oversampling, create a unique name for each copy to prevent overwriting
+                if current_count < target_count:
+                    dest_filename = f"{base_name}_copy{i}{extension}"
+                else:
+                    dest_filename = filename # For undersampling, names are already unique
+
+                shutil.copy(source_emotion_dir / filename, dest_emotion_dir / dest_filename)
+            # --- END BUG FIX ---
+
+        # Copy the test set without changes
+        logger.info("\nCopying test set...")
+        if os.path.exists(self.config.balanced_test_dir): shutil.rmtree(self.config.balanced_test_dir)
+        shutil.copytree(self.config.source_test_dir, self.config.balanced_test_dir)
+        
+        logger.info("\n--- Final Balanced Dataset Statistics ---")
+        self._log_and_get_stats(self.config.balanced_train_dir)
+        self._log_and_get_stats(self.config.balanced_test_dir)
+
+        logger.info("--- Data Balancing Stage Complete ---")

huggingface-space/src/EmotionRecognition/components/data_validation.py

@@ -0,0 +1,32 @@
+# In src/EmotionRecognition/components/data_validation.py
+import os
+from EmotionRecognition import logger
+from EmotionRecognition.entity.config_entity import DataValidationConfig
+
+class DataValidation:
+    def __init__(self, config: DataValidationConfig):
+        self.config = config
+
+    def validate_all_files_exist(self) -> bool:
+        try:
+            validation_status = True
+            
+            # Check for all required files
+            for required_file in self.config.required_files:
+                if not os.path.exists(required_file):
+                    validation_status = False
+                    logger.error(f"Missing required file: {required_file}")
+
+            with open(self.config.status_file, 'w') as f:
+                f.write(f"Validation status: {validation_status}")
+
+            if validation_status:
+                logger.info("Data validation successful. All required files exist.")
+            else:
+                logger.error("Data validation failed. Please check the logs for missing files.")
+            
+            return validation_status
+
+        except Exception as e:
+            logger.exception(e)
+            raise e

huggingface-space/src/EmotionRecognition/components/model_evaluation.py

@@ -0,0 +1,63 @@
+import tensorflow as tf
+from EmotionRecognition import logger
+from EmotionRecognition.entity.config_entity import ModelEvaluationConfig
+from pathlib import Path
+import mlflow
+import mlflow.keras
+from EmotionRecognition.utils.common import save_json
+
+class ModelEvaluation:
+    def __init__(self, config: ModelEvaluationConfig, params: dict):
+        self.config = config
+        self.params = params
+
+    def get_validation_dataset(self):
+        """
+        Loads the prepared validation/test dataset from disk.
+        """
+        data_params = self.params.DATA_PARAMS
+        
+        val_ds = tf.keras.utils.image_dataset_from_directory(
+            self.config.test_data_dir,
+            labels='inferred',
+            label_mode='categorical',
+            class_names=data_params.CLASSES,
+            image_size=data_params.IMAGE_SIZE,
+            interpolation='nearest',
+            batch_size=data_params.BATCH_SIZE,
+            shuffle=False,
+            color_mode='grayscale' # <--- THIS IS THE FIX
+        )
+        
+        def preprocess(image, label):
+            image = tf.image.grayscale_to_rgb(image)
+            image = tf.cast(image, tf.float32) / 255.0
+            return image, label
+            
+        return val_ds.map(preprocess, num_parallel_calls=tf.data.AUTOTUNE).prefetch(tf.data.AUTOTUNE)
+
+    def evaluate_and_log(self):
+        logger.info("Preparing validation dataset for evaluation...")
+        val_ds = self.get_validation_dataset()
+        
+        logger.info("Loading full trained model from disk...")
+        model = tf.keras.models.load_model(str(self.config.trained_model_path))
+        
+        logger.info("Evaluating model...")
+        score = model.evaluate(val_ds)
+        
+        scores = {"loss": score[0], "accuracy": score[1]}
+        logger.info(f"Evaluation scores: {scores}")
+        save_json(path=self.config.metrics_file_name, data=scores)
+        
+        logger.info("Starting MLflow logging...")
+        mlflow.set_tracking_uri(self.config.mlflow_uri)
+        mlflow.set_experiment("Emotion Recognition Experiment")
+
+        with mlflow.start_run():
+            mlflow.log_params(self.params.DATA_PARAMS)
+            mlflow.log_params(self.params.TRAINING_PARAMS)
+            mlflow.log_metrics(scores)
+            mlflow.keras.log_model(model, "model")
+
+        logger.info("MLflow logging complete.")

huggingface-space/src/EmotionRecognition/components/model_trainer.py

@@ -0,0 +1,99 @@
+import tensorflow as tf
+from EmotionRecognition import logger
+from EmotionRecognition.entity.config_entity import ModelTrainerConfig
+from EmotionRecognition.utils.common import create_mobilenetv2_model
+from pathlib import Path
+
+class ModelTrainer:
+    def __init__(self, config: ModelTrainerConfig, params: dict):
+        self.config = config
+        self.params = params
+        self.model = None
+
+    def get_datasets(self):
+        data_params = self.params.DATA_PARAMS
+        logger.info("Loading prepared train and test datasets...")
+
+        # Create a training dataset from the combined, imbalanced data
+        train_ds = tf.keras.utils.image_dataset_from_directory(
+            self.config.train_data_dir,
+            labels='inferred',
+            label_mode='categorical',
+            class_names=data_params.CLASSES,
+            image_size=data_params.IMAGE_SIZE,
+            interpolation='nearest',
+            batch_size=data_params.BATCH_SIZE,
+            shuffle=True,
+            color_mode='grayscale' # <--- ADD THIS LINE
+        )
+
+        # Create a validation/test dataset
+        val_ds = tf.keras.utils.image_dataset_from_directory(
+            self.config.test_data_dir,
+            labels='inferred',
+            label_mode='categorical',
+            class_names=data_params.CLASSES,
+            image_size=data_params.IMAGE_SIZE,
+            interpolation='nearest',
+            batch_size=data_params.BATCH_SIZE,
+            shuffle=False,
+            color_mode='grayscale' # <--- AND ADD THIS LINE
+        )
+        
+        def preprocess(image, label):
+            # This dataset is already in PNG format, so we decode PNG
+            # It's also already grayscale (1 channel)
+            image = tf.image.grayscale_to_rgb(image) # Models expect 3 channels
+            image = tf.cast(image, tf.float32) / 255.0
+            return image, label
+        
+        data_augmentation = tf.keras.Sequential([
+            tf.keras.layers.RandomFlip("horizontal"),
+            tf.keras.layers.RandomRotation(0.1),
+            tf.keras.layers.RandomZoom(0.1)
+        ])
+
+        train_ds = train_ds.map(preprocess, num_parallel_calls=tf.data.AUTOTUNE)
+        val_ds = val_ds.map(preprocess, num_parallel_calls=tf.data.AUTOTUNE)
+        train_ds = train_ds.map(lambda x, y: (data_augmentation(x, training=True), y), num_parallel_calls=tf.data.AUTOTUNE)
+
+        return train_ds.prefetch(tf.data.AUTOTUNE), val_ds.prefetch(tf.data.AUTOTUNE)
+
+    def build_and_train_model(self):
+        data_params = self.params.DATA_PARAMS
+        training_params = self.params.TRAINING_PARAMS
+        
+        logger.info("Building model with a frozen MobileNetV2 base...")
+        input_shape = data_params.IMAGE_SIZE + [data_params.CHANNELS]
+
+        self.model = create_mobilenetv2_model(
+            input_shape=input_shape,
+            num_classes=data_params.NUM_CLASSES,
+            dropout_rate=training_params.DROPOUT_RATE
+        )
+        
+        base_model = self.model.layers[1]
+        base_model.trainable = False
+        
+        self.model.compile(
+            optimizer=tf.keras.optimizers.Adam(learning_rate=training_params.LEARNING_RATE),
+            loss=training_params.LOSS_FUNCTION, 
+            metrics=training_params.METRICS
+        )
+        self.model.summary(print_fn=logger.info)
+
+        train_ds, val_ds = self.get_datasets()
+
+        logger.info(f"--- Starting training for {training_params.EPOCHS} epochs ---")
+        self.model.fit(
+            train_ds, 
+            epochs=training_params.EPOCHS, 
+            validation_data=val_ds
+        )
+        
+        self.save_model()
+
+    def save_model(self):
+        model_path = str(self.config.trained_model_path)
+        self.model.save(model_path)
+        logger.info(f"Full model saved successfully to: {model_path}")

huggingface-space/src/EmotionRecognition/config/configuration.py

@@ -0,0 +1,64 @@
+from EmotionRecognition.utils.common import read_yaml, create_directories
+from EmotionRecognition.entity.config_entity import (
+    DataPreparationConfig,
+    DataPreprocessingConfig,
+    ModelTrainerConfig,
+    ModelEvaluationConfig
+)
+from pathlib import Path
+
+class ConfigurationManager:
+    def __init__(
+        self,
+        config_filepath = Path("config/config.yaml"),
+        params_filepath = Path("params.yaml")):
+
+        self.config = read_yaml(config_filepath)
+        self.params = read_yaml(params_filepath)
+        create_directories([self.config.artifacts_root])
+
+    def get_data_preparation_config(self) -> DataPreparationConfig:
+        prep_config = self.config.data_preparation
+        # Note: Raw data paths are now defined in data_preparation, not a separate ingestion config
+        create_directories([prep_config.root_dir])
+        return DataPreparationConfig(
+            root_dir=Path(prep_config.root_dir),
+            ferplus_pixels_csv=Path(prep_config.ferplus_pixels_csv),
+            ferplus_labels_csv=Path(prep_config.ferplus_labels_csv),
+            ckplus_dir=Path(prep_config.ckplus_dir),
+            combined_train_dir=Path(prep_config.combined_train_dir),
+            ferplus_test_dir=Path(prep_config.ferplus_test_dir)
+        )
+
+    def get_data_preprocessing_config(self) -> DataPreprocessingConfig:
+        preprocess_config = self.config.data_preprocessing
+        create_directories([preprocess_config.root_dir])
+        return DataPreprocessingConfig(
+            root_dir=Path(preprocess_config.root_dir),
+            source_train_dir=Path(preprocess_config.source_train_dir),
+            source_test_dir=Path(preprocess_config.source_test_dir),
+            balanced_train_dir=Path(preprocess_config.balanced_train_dir),
+            balanced_test_dir=Path(preprocess_config.balanced_test_dir),
+            target_samples_per_class=preprocess_config.target_samples_per_class
+        )
+
+    def get_model_trainer_config(self) -> ModelTrainerConfig:
+        config = self.config.model_trainer
+        create_directories([config.root_dir])
+        return ModelTrainerConfig(
+            root_dir=Path(config.root_dir),
+            train_data_dir=Path(config.train_data_dir),
+            test_data_dir=Path(config.test_data_dir),
+            trained_model_path=Path(config.trained_model_path)
+        )
+
+    def get_model_evaluation_config(self) -> ModelEvaluationConfig:
+        config = self.config.model_evaluation
+        create_directories([config.root_dir])
+        return ModelEvaluationConfig(
+            root_dir=Path(config.root_dir),
+            test_data_dir=Path(config.test_data_dir), # Corrected from data_dir
+            trained_model_path=Path(config.trained_model_path),
+            metrics_file_name=Path(config.metrics_file_name),
+            mlflow_uri=config.mlflow_uri
+        )

huggingface-space/src/EmotionRecognition/entity/config_entity.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+@dataclass(frozen=True)
+class DataPreparationConfig:
+    root_dir: Path
+    # Inputs from raw data
+    ferplus_pixels_csv: Path
+    ferplus_labels_csv: Path
+    ckplus_dir: Path
+    # Outputs of this stage
+    combined_train_dir: Path
+    ferplus_test_dir: Path
+
+@dataclass(frozen=True)
+class DataPreprocessingConfig:
+    root_dir: Path
+    # Inputs from the Data Preparation stage
+    source_train_dir: Path
+    source_test_dir: Path
+    # Outputs of this stage
+    balanced_train_dir: Path
+    balanced_test_dir: Path
+    # Parameter for the balancing strategy
+    target_samples_per_class: int
+
+@dataclass(frozen=True)
+class ModelTrainerConfig:
+    root_dir: Path
+    # Inputs from the Data Preprocessing stage
+    train_data_dir: Path
+    test_data_dir: Path
+    # Output of this stage
+    trained_model_path: Path
+
+@dataclass(frozen=True)
+class ModelEvaluationConfig:
+    root_dir: Path
+    test_data_dir: Path
+    trained_model_path: Path # <-- Make sure this is the name used
+    metrics_file_name: Path
+    mlflow_uri: str

huggingface-space/src/EmotionRecognition/pipeline/hf_predictor.py

@@ -0,0 +1,109 @@
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+import torch
+import numpy as np
+import cv2
+from mtcnn import MTCNN
+from collections import deque, Counter
+from PIL import Image
+
+LOCAL_MODEL_PATH = "sota_model"
+
+class HFPredictor:
+    def __init__(self, smoothing_window=10, confidence_threshold=0.3):
+        print(f"[PREDICTOR INFO] Loading model from local path: {LOCAL_MODEL_PATH}...")
+        self.processor = AutoImageProcessor.from_pretrained(LOCAL_MODEL_PATH)
+        self.model = AutoModelForImageClassification.from_pretrained(LOCAL_MODEL_PATH)
+        self.face_detector = MTCNN()
+        self.classes = list(self.model.config.id2label.values())
+        self.confidence_threshold = confidence_threshold
+        self.recent_predictions = deque(maxlen=smoothing_window)
+        self.stable_prediction = "---"
+        print("[PREDICTOR INFO] Predictor initialized successfully.")
+
+    def get_probabilities(self, frame):
+        """
+        A lightweight function that takes a frame, runs inference,
+        updates the stable prediction, and returns ONLY the probability dictionary.
+        """
+        if frame is None:
+            return {}
+        
+        probabilities = {}
+        faces = self.face_detector.detect_faces(frame)
+        
+        for face in faces:
+            x, y, width, height = face['box']
+            face_roi = frame[y:y+height, x:x+width]
+            
+            if face_roi.size > 0:
+                pil_image = Image.fromarray(face_roi)
+                inputs = self.processor(images=pil_image, return_tensors="pt")
+                with torch.no_grad():
+                    logits = self.model(**inputs).logits
+                
+                probs = torch.nn.functional.softmax(logits, dim=-1)
+                predictions = probs[0].numpy()
+                pred_index = np.argmax(predictions)
+                confidence = predictions[pred_index]
+
+                if confidence > self.confidence_threshold:
+                    self.recent_predictions.append(pred_index)
+                
+                probabilities = {self.classes[i]: float(predictions[i]) for i in range(len(self.classes))}
+        
+        return probabilities
+
+    def annotate_frame(self, frame):
+        """
+        Takes a frame, detects faces, and returns the fully annotated version
+        using the latest stable prediction.
+        """
+        if frame is None: return None
+        
+        annotated_frame = frame.copy()
+        faces = self.face_detector.detect_faces(frame)
+        
+        # We use the 'stable_prediction' which is updated by the high-fps get_probabilities call
+        # This ensures the box text is smooth and consistent.
+        for face in faces:
+            x, y, width, height = face['box']
+            GREEN = (0, 255, 0)
+            BLACK = (0, 0, 0)
+            FONT = cv2.FONT_HERSHEY_SIMPLEX
+            text = self.stable_prediction # Use the smoothed prediction
+            
+            (text_width, text_height), baseline = cv2.getTextSize(text, FONT, 0.8, 2)
+            cv2.rectangle(annotated_frame, (x, y - text_height - baseline - 10), (x + text_width + 10, y), GREEN, cv2.FILLED)
+            cv2.putText(annotated_frame, text, (x + 5, y - 5), FONT, 0.8, BLACK, 2)
+            cv2.rectangle(annotated_frame, (x, y), (x+width, y+height), GREEN, 3)
+
+        return annotated_frame
+
+    def process_frame_for_upload(self, frame):
+        """A simple, all-in-one function for static images and videos."""
+        if frame is None: return None, {}
+        annotated_frame = frame.copy()
+        probabilities = {}
+        faces = self.face_detector.detect_faces(frame)
+        for face in faces:
+            x, y, width, height = face['box']
+            face_roi = frame[y:y+height, x:x+width]
+            if face_roi.size > 0:
+                pil_image = Image.fromarray(face_roi)
+                inputs = self.processor(images=pil_image, return_tensors="pt")
+                with torch.no_grad():
+                    logits = self.model(**inputs).logits
+                probs = torch.nn.functional.softmax(logits, dim=-1)
+                predictions = probs[0].numpy()
+                pred_index = np.argmax(predictions)
+                emotion = self.classes[pred_index]
+                confidence = predictions[pred_index]
+                text = f"{emotion} ({confidence*100:.1f}%)"
+                # (Drawing logic is duplicated here for simplicity)
+                GREEN = (0, 255, 0); BLACK = (0, 0, 0); FONT = cv2.FONT_HERSHEY_SIMPLEX
+                (tw, th), bl = cv2.getTextSize(text, FONT, 0.8, 2)
+                cv2.rectangle(annotated_frame, (x, y-th-bl-10), (x+tw+10, y), GREEN, cv2.FILLED)
+                cv2.putText(annotated_frame, text, (x + 5, y - 5), FONT, 0.8, BLACK, 2)
+                cv2.rectangle(annotated_frame, (x, y), (x+width, y+height), GREEN, 3)
+                probabilities = {self.classes[i]: float(predictions[i]) for i in range(len(self.classes))}
+        return annotated_frame, probabilities

huggingface-space/src/EmotionRecognition/pipeline/stage_01_data_preparation.py

@@ -0,0 +1,27 @@
+# File: src/EmotionRecognition/pipeline/stage_01_data_preparation.py
+from EmotionRecognition.config.configuration import ConfigurationManager
+from EmotionRecognition.components.data_preparation import DataPreparation
+from EmotionRecognition import logger
+
+STAGE_NAME = "Data Preparation Stage"
+
+class DataPreparationPipeline:
+    def main(self):
+        config_manager = ConfigurationManager()
+        data_prep_config = config_manager.get_data_preparation_config()
+        data_preparation = DataPreparation(config=data_prep_config, params=config_manager.params)
+        
+        # --- THIS IS THE FIX ---
+        # Call the correct method name from the component
+        data_preparation.combine_and_prepare_data()
+        # --- END FIX ---
+
+if __name__ == '__main__':
+    try:
+        logger.info(f">>>>>> Stage '{STAGE_NAME}' started <<<<<<")
+        pipeline = DataPreparationPipeline()
+        pipeline.main()
+        logger.info(f">>>>>> Stage '{STAGE_NAME}' completed successfully <<<<<<\n\nx==========x")
+    except Exception as e:
+        logger.exception(e)
+        raise e

huggingface-space/src/EmotionRecognition/pipeline/stage_02_model_training.py

@@ -0,0 +1,28 @@
+# File: src/EmotionRecognition/pipeline/stage_02_model_training.py
+
+from EmotionRecognition.config.configuration import ConfigurationManager
+from EmotionRecognition.components.model_trainer import ModelTrainer
+from EmotionRecognition import logger
+
+STAGE_NAME = "Model Training Stage"
+
+class ModelTrainingPipeline:
+    def main(self):
+        try:
+            config_manager = ConfigurationManager()
+            model_trainer_config = config_manager.get_model_trainer_config()
+            model_trainer = ModelTrainer(config=model_trainer_config, params=config_manager.params)
+            model_trainer.build_and_train_model()
+        except Exception as e:
+            logger.exception(e)
+            raise e
+
+if __name__ == '__main__':
+    try:
+        logger.info(f">>>>>> Stage '{STAGE_NAME}' started <<<<<<")
+        pipeline = ModelTrainingPipeline()
+        pipeline.main()
+        logger.info(f">>>>>> Stage '{STAGE_NAME}' completed successfully <<<<<<\n\nx==========x")
+    except Exception as e:
+        logger.exception(e)
+        raise e

huggingface-space/src/EmotionRecognition/pipeline/stage_03_model_evaluation.py

@@ -0,0 +1,31 @@
+from EmotionRecognition.config.configuration import ConfigurationManager
+from EmotionRecognition.components.model_evaluation import ModelEvaluation
+from EmotionRecognition import logger
+from dotenv import load_dotenv
+load_dotenv() 
+
+STAGE_NAME = "Model Evaluation Stage"
+
+class ModelEvaluationPipeline:
+    def __init__(self):
+        pass
+
+    def main(self):
+        try:
+            config_manager = ConfigurationManager()
+            model_evaluation_config = config_manager.get_model_evaluation_config()
+            model_evaluation = ModelEvaluation(config=model_evaluation_config, params=config_manager.params)
+            model_evaluation.evaluate_and_log()
+        except Exception as e:
+            logger.exception(e)
+            raise e
+
+if __name__ == '__main__':
+    try:
+        logger.info(f">>>>>> Stage '{STAGE_NAME}' started <<<<<<")
+        obj = ModelEvaluationPipeline()
+        obj.main()
+        logger.info(f">>>>>> Stage '{STAGE_NAME}' completed successfully <<<<<<\n\nx==========x")
+    except Exception as e:
+        logger.exception(e)
+        raise e

huggingface-space/src/EmotionRecognition/utils/common.py

@@ -0,0 +1,78 @@
+import os
+from box.exceptions import BoxValueError
+import yaml
+from EmotionRecognition import logger
+import json
+from ensure import ensure_annotations
+from box import ConfigBox
+from pathlib import Path
+from typing import Any
+import json
+import tensorflow as tf
+
+@ensure_annotations
+def read_yaml(path_to_yaml: Path) -> ConfigBox:
+    """reads yaml file and returns
+
+    Args:
+        path_to_yaml (str): path like input
+
+    Raises:
+        ValueError: if yaml file is empty
+        e: empty file
+
+    Returns:
+        ConfigBox: ConfigBox type
+    """
+    try:
+        with open(path_to_yaml) as yaml_file:
+            content = yaml.safe_load(yaml_file)
+            logger.info(f"yaml file: {path_to_yaml} loaded successfully")
+            return ConfigBox(content)
+    except BoxValueError:
+        raise ValueError("yaml file is empty")
+    except Exception as e:
+        raise e
+
+@ensure_annotations
+def create_directories(path_to_directories: list, verbose=True):
+    """create list of directories
+
+    Args:
+        path_to_directories (list): list of path of directories
+        ignore_log (bool, optional): ignore if multiple dirs is to be created. Defaults to False.
+    """
+    for path in path_to_directories:
+        os.makedirs(path, exist_ok=True)
+        if verbose:
+            logger.info(f"created directory at: {path}")
+
+
+def save_json(path: Path, data: dict):
+    with open(path, "w") as f:
+        json.dump(data, f, indent=4)
+    logger.info(f"json file saved at: {path}")
+
+
+
+def create_mobilenetv2_model(input_shape, num_classes, dropout_rate, is_training=True): # <--- ADD ARGUMENT
+    """
+    Builds the MobileNetV2 model with our custom head.
+    This centralized function ensures consistency.
+    """
+    base_model = tf.keras.applications.MobileNetV2(
+        input_shape=input_shape, include_top=False, weights='imagenet'
+    )
+    
+    inputs = tf.keras.Input(shape=input_shape)
+    # --- CRITICAL CHANGE ---
+    # Pass the is_training flag to the base model call
+    x = base_model(inputs, training=is_training) 
+    # --- END CHANGE ---
+    x = tf.keras.layers.GlobalAveragePooling2D()(x)
+    x = tf.keras.layers.Dense(128, activation='relu', kernel_regularizer=tf.keras.regularizers.l2(0.01))(x)
+    x = tf.keras.layers.Dropout(dropout_rate)(x)
+    outputs = tf.keras.layers.Dense(num_classes, activation='softmax')(x)
+    
+    model = tf.keras.Model(inputs, outputs)
+    return model

huggingface-space/temp.py

@@ -0,0 +1,65 @@
+import os
+from pathlib import Path
+import logging
+
+# Configure logging to provide feedback during script execution
+logging.basicConfig(level=logging.INFO, format='[%(asctime)s]: %(message)s:')
+
+# Define the project name
+project_name = "EmotionRecognition"
+
+# List of files and directories to be created
+list_of_files = [
+    ".github/workflows/.gitkeep",
+    f"src/{project_name}/__init__.py",
+    f"src/{project_name}/components/__init__.py",
+    f"src/{project_name}/components/data_ingestion.py",
+    f"src/{project_name}/components/data_validation.py",
+    f"src/{project_name}/components/data_preprocessing.py",
+    f"src/{project_name}/components/model_trainer.py",
+    f"src/{project_name}/components/model_evaluation.py",
+    f"src/{project_name}/utils/__init__.py",
+    f"src/{project_name}/utils/common.py",
+    f"src/{project_name}/config/__init__.py",
+    f"src/{project_name}/config/configuration.py",
+    f"src/{project_name}/pipeline/__init__.py",
+    f"src/{project_name}/pipeline/stage_01_data_ingestion.py",
+    f"src/{project_name}/pipeline/stage_02_data_validation.py",
+    f"src/{project_name}/pipeline/stage_03_data_preprocessing.py",
+    f"src/{project_name}/pipeline/stage_04_model_training.py",
+    f"src/{project_name}/pipeline/stage_05_model_evaluation.py",
+    f"src/{project_name}/pipeline/prediction.py",
+    f"src/{project_name}/entity/__init__.py",
+    f"src/{project_name}/entity/config_entity.py",
+    "config/config.yaml",
+    "params.yaml",
+    "app.py",
+    "main.py",
+    "Dockerfile",
+    "requirements.txt",
+    "setup.py",
+    "research/01_data_exploration.ipynb",
+    "templates/index.html", # For a simple web UI if needed
+    ".dvcignore",
+    ".gitignore"
+]
+
+# Loop through the list to create the files and directories
+for filepath_str in list_of_files:
+    filepath = Path(filepath_str)
+    filedir, filename = os.path.split(filepath)
+
+    # 1. Create the directory if it doesn't exist
+    if filedir != "":
+        os.makedirs(filedir, exist_ok=True)
+        logging.info(f"Creating directory: {filedir} for the file: {filename}")
+
+    # 2. Create the file if it doesn't exist or is empty
+    if (not os.path.exists(filepath)) or (os.path.getsize(filepath) == 0):
+        with open(filepath, "w") as f:
+            pass  # Create an empty file
+            logging.info(f"Creating empty file: {filepath}")
+    else:
+        logging.info(f"{filename} already exists")
+
+logging.info("Project structure creation complete!")

sota_model/config.json

@@ -1,42 +1,42 @@
-{
-  "_name_or_path": "dima806/facial_emotions_image_detection",
-  "architectures": [
-    "ViTForImageClassification"
-  ],
-  "attention_probs_dropout_prob": 0.0,
-  "encoder_stride": 16,
-  "hidden_act": "gelu",
-  "hidden_dropout_prob": 0.0,
-  "hidden_size": 768,
-  "id2label": {
-    "0": "sad",
-    "1": "disgust",
-    "2": "angry",
-    "3": "neutral",
-    "4": "fear",
-    "5": "surprise",
-    "6": "happy"
-  },
-  "image_size": 224,
-  "initializer_range": 0.02,
-  "intermediate_size": 3072,
-  "label2id": {
-    "angry": 2,
-    "disgust": 1,
-    "fear": 4,
-    "happy": 6,
-    "neutral": 3,
-    "sad": 0,
-    "surprise": 5
-  },
-  "layer_norm_eps": 1e-12,
-  "model_type": "vit",
-  "num_attention_heads": 12,
-  "num_channels": 3,
-  "num_hidden_layers": 12,
-  "patch_size": 16,
-  "problem_type": "single_label_classification",
-  "qkv_bias": true,
-  "torch_dtype": "float32",
-  "transformers_version": "4.39.3"
-}
+{
+  "_name_or_path": "dima806/facial_emotions_image_detection",
+  "architectures": [
+    "ViTForImageClassification"
+  ],
+  "attention_probs_dropout_prob": 0.0,
+  "encoder_stride": 16,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.0,
+  "hidden_size": 768,
+  "id2label": {
+    "0": "sad",
+    "1": "disgust",
+    "2": "angry",
+    "3": "neutral",
+    "4": "fear",
+    "5": "surprise",
+    "6": "happy"
+  },
+  "image_size": 224,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "label2id": {
+    "angry": 2,
+    "disgust": 1,
+    "fear": 4,
+    "happy": 6,
+    "neutral": 3,
+    "sad": 0,
+    "surprise": 5
+  },
+  "layer_norm_eps": 1e-12,
+  "model_type": "vit",
+  "num_attention_heads": 12,
+  "num_channels": 3,
+  "num_hidden_layers": 12,
+  "patch_size": 16,
+  "problem_type": "single_label_classification",
+  "qkv_bias": true,
+  "torch_dtype": "float32",
+  "transformers_version": "4.39.3"
+}

sota_model/preprocessor_config.json

@@ -1,36 +1,36 @@
-{
-  "_valid_processor_keys": [
-    "images",
-    "do_resize",
-    "size",
-    "resample",
-    "do_rescale",
-    "rescale_factor",
-    "do_normalize",
-    "image_mean",
-    "image_std",
-    "return_tensors",
-    "data_format",
-    "input_data_format"
-  ],
-  "do_normalize": true,
-  "do_rescale": true,
-  "do_resize": true,
-  "image_mean": [
-    0.5,
-    0.5,
-    0.5
-  ],
-  "image_processor_type": "ViTImageProcessor",
-  "image_std": [
-    0.5,
-    0.5,
-    0.5
-  ],
-  "resample": 2,
-  "rescale_factor": 0.00392156862745098,
-  "size": {
-    "height": 224,
-    "width": 224
-  }
-}
+{
+  "_valid_processor_keys": [
+    "images",
+    "do_resize",
+    "size",
+    "resample",
+    "do_rescale",
+    "rescale_factor",
+    "do_normalize",
+    "image_mean",
+    "image_std",
+    "return_tensors",
+    "data_format",
+    "input_data_format"
+  ],
+  "do_normalize": true,
+  "do_rescale": true,
+  "do_resize": true,
+  "image_mean": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "image_processor_type": "ViTImageProcessor",
+  "image_std": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "resample": 2,
+  "rescale_factor": 0.00392156862745098,
+  "size": {
+    "height": 224,
+    "width": 224
+  }
+}

src/EmotionRecognition/pipeline/hf_predictor.py

@@ -20,19 +20,26 @@ class HFPredictor:
         self.stable_prediction = "---"
         print("[PREDICTOR INFO] Predictor initialized successfully.")
 
-    def get_probabilities(self, frame):
+
+    def process_frame(self, frame):
         """
-        A lightweight function that takes a frame, runs inference,
-        updates the stable prediction, and returns ONLY the probability dictionary.
+        Processes a single frame: flips it for a mirror effect, detects faces, 
+        predicts emotions, and draws professional annotations.
         """
-        if frame is None:
-            return {}
+        if frame is None: return frame, {}
+
+        # --- MIRROR FIX: Flip the frame FIRST! ---
+        # This ensures detection and drawing happen in the same coordinate space the user sees.
+        frame = cv2.flip(frame, 1)
+        annotated_frame = frame.copy()
+        # --- END FIX ---
         
-        probabilities = {}
+        all_probabilities = {}
         faces = self.face_detector.detect_faces(frame)
         
         for face in faces:
             x, y, width, height = face['box']
+            x, y = max(0, x), max(0, y)
             face_roi = frame[y:y+height, x:x+width]
             
             if face_roi.size > 0:
@@ -44,66 +51,27 @@ class HFPredictor:
                 probs = torch.nn.functional.softmax(logits, dim=-1)
                 predictions = probs[0].numpy()
                 pred_index = np.argmax(predictions)
+                
+                # Use temporal smoothing for the displayed label
                 confidence = predictions[pred_index]
-
                 if confidence > self.confidence_threshold:
                     self.recent_predictions.append(pred_index)
+                if self.recent_predictions:
+                    most_common_pred = Counter(self.recent_predictions).most_common(1)[0][0]
+                    self.stable_prediction = self.classes[most_common_pred]
                 
-                probabilities = {self.classes[i]: float(predictions[i]) for i in range(len(self.classes))}
-        
-        return probabilities
-
-    def annotate_frame(self, frame):
-        """
-        Takes a frame, detects faces, and returns the fully annotated version
-        using the latest stable prediction.
-        """
-        if frame is None: return None
-        
-        annotated_frame = frame.copy()
-        faces = self.face_detector.detect_faces(frame)
-        
-        # We use the 'stable_prediction' which is updated by the high-fps get_probabilities call
-        # This ensures the box text is smooth and consistent.
-        for face in faces:
-            x, y, width, height = face['box']
-            GREEN = (0, 255, 0)
-            BLACK = (0, 0, 0)
-            FONT = cv2.FONT_HERSHEY_SIMPLEX
-            text = self.stable_prediction # Use the smoothed prediction
-            
-            (text_width, text_height), baseline = cv2.getTextSize(text, FONT, 0.8, 2)
-            cv2.rectangle(annotated_frame, (x, y - text_height - baseline - 10), (x + text_width + 10, y), GREEN, cv2.FILLED)
-            cv2.putText(annotated_frame, text, (x + 5, y - 5), FONT, 0.8, BLACK, 2)
-            cv2.rectangle(annotated_frame, (x, y), (x+width, y+height), GREEN, 3)
-
-        return annotated_frame
-
-    def process_frame_for_upload(self, frame):
-        """A simple, all-in-one function for static images and videos."""
-        if frame is None: return None, {}
-        annotated_frame = frame.copy()
-        probabilities = {}
-        faces = self.face_detector.detect_faces(frame)
-        for face in faces:
-            x, y, width, height = face['box']
-            face_roi = frame[y:y+height, x:x+width]
-            if face_roi.size > 0:
-                pil_image = Image.fromarray(face_roi)
-                inputs = self.processor(images=pil_image, return_tensors="pt")
-                with torch.no_grad():
-                    logits = self.model(**inputs).logits
-                probs = torch.nn.functional.softmax(logits, dim=-1)
-                predictions = probs[0].numpy()
-                pred_index = np.argmax(predictions)
-                emotion = self.classes[pred_index]
-                confidence = predictions[pred_index]
-                text = f"{emotion} ({confidence*100:.1f}%)"
-                # (Drawing logic is duplicated here for simplicity)
-                GREEN = (0, 255, 0); BLACK = (0, 0, 0); FONT = cv2.FONT_HERSHEY_SIMPLEX
-                (tw, th), bl = cv2.getTextSize(text, FONT, 0.8, 2)
-                cv2.rectangle(annotated_frame, (x, y-th-bl-10), (x+tw+10, y), GREEN, cv2.FILLED)
+                # --- PROFESSIONAL DRAWING LOGIC ---
+                GREEN = (0, 255, 0)
+                BLACK = (0, 0, 0)
+                FONT = cv2.FONT_HERSHEY_SIMPLEX
+                text = f"{self.stable_prediction} ({confidence*100:.1f}%)"
+                
+                (text_width, text_height), baseline = cv2.getTextSize(text, FONT, 0.8, 2)
+                
+                cv2.rectangle(annotated_frame, (x, y - text_height - baseline - 10), (x + text_width + 10, y), GREEN, cv2.FILLED)
                 cv2.putText(annotated_frame, text, (x + 5, y - 5), FONT, 0.8, BLACK, 2)
                 cv2.rectangle(annotated_frame, (x, y), (x+width, y+height), GREEN, 3)
-                probabilities = {self.classes[i]: float(predictions[i]) for i in range(len(self.classes))}
-        return annotated_frame, probabilities
+                
+                all_probabilities = {self.classes[i]: float(predictions[i]) for i in range(len(self.classes))}
+        
+        return annotated_frame, all_probabilities