Upload 5 files

app.py

@@ -0,0 +1,262 @@
+import streamlit as st
+import tensorflow as tf
+import numpy as np
+import cv2
+from PIL import Image
+import math
+
+# Define the stress functions (copy these from your notebook)
+# Source: https://www.kaggle.com/code/ahmedmagaji/stress-detection/notebook
+# Formula: t = a*p + b; stress = c*ln(t)
+# where p is probability (0-1), t is intermediate value, and stress is the output
+def anger(p):
+    t = 0.343 * p + 1.003
+    return 2.332 * math.log(t)
+
+def fear(p):
+    t = 1.356 * p + 1
+    return 1.763 * math.log(t)
+
+def contempt(p):
+    t = 0.01229 * p + 1.036
+    return 5.03 * math.log(t)
+
+def disgust(p):
+    t = 0.0123 * p + 1.019
+    return 7.351 * math.log(t)
+
+def happy(p):
+    t = 5.221e-5 * p + 0.9997
+    return 532.2 * math.log(t)
+
+def sad(p):
+    t = 0.1328 * p + 1.009
+    return 2.851 * math.log(t)
+
+def surprise(p):
+    t = 0.2825 * p + 1.003
+    return 2.478 * math.log(t)
+
+# Mapping from emotion index to label and stress function
+emotion_map = {0: 'Angry', 1: 'Disgust', 2: 'Fear', 3: 'Happy', 4: 'Sad', 5: 'Surprise', 6: 'Neutral'}
+aligned_func = [anger, disgust, fear, happy, sad, surprise, contempt] # Ensure correct order matching emotion_map keys
+
+# Load Haar Cascade for face detection
+@st.cache_resource
+def load_face_cascade():
+    cascade_path = cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
+    return cv2.CascadeClassifier(cascade_path)
+
+# Load the trained model
+@st.cache_resource # Cache the model to avoid reloading on each interaction
+def load_model():
+    model_path = "models/model_fer_bloss.h5"
+    try:
+        model = tf.keras.models.load_model(model_path)
+        return model
+    except FileNotFoundError:
+        st.error(f"Model file not found at {model_path}. Please ensure the .h5 file is in the 'models/' folder.")
+        return None
+    except Exception as e:
+        st.error(f"Error loading model: {e}")
+        return None
+
+face_cascade = load_face_cascade()
+model = load_model()
+
+st.title("Facial Expression Stress Detector")
+st.write("Upload an image or use your camera to detect faces, process them, and estimate stress level.")
+st.markdown("---")
+
+# Tab selection for input method
+tab1, tab2 = st.tabs(["Upload Image", "Live Camera"])
+
+with tab1:
+    uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
+    image_source = uploaded_file
+
+with tab2:
+    camera_input = st.camera_input("Take a picture")
+    image_source = camera_input
+
+if image_source is not None:
+    # Load and display original image
+    original_image = Image.open(image_source).convert("RGB")
+    
+    col1, col2 = st.columns(2)
+    with col1:
+        st.subheader("1️⃣ Original Image")
+        st.image(original_image, use_container_width=True)
+    
+    # Convert to OpenCV format for processing
+    img_cv = cv2.cvtColor(np.array(original_image), cv2.COLOR_RGB2BGR)
+    gray_img = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
+    
+    # Apply histogram equalization to improve contrast
+    gray_img_eq = cv2.equalizeHist(gray_img)
+    
+    # Detect faces with multiple parameter sets (more lenient)
+    faces = face_cascade.detectMultiScale(
+        gray_img_eq,
+        scaleFactor=1.1,      # Reduced from 1.3 (slower but finds smaller faces)
+        minNeighbors=3,       # Reduced from 5 (more lenient)
+        minSize=(20, 20),     # Reduced from (30, 30)
+        maxSize=(400, 400)
+    )
+    
+    # If no faces found, try less strict parameters
+    if len(faces) == 0:
+        faces = face_cascade.detectMultiScale(
+            gray_img_eq,
+            scaleFactor=1.05,
+            minNeighbors=2,
+            minSize=(15, 15)
+        )
+    
+    # If still no faces, try original grayscale without equalization
+    if len(faces) == 0:
+        faces = face_cascade.detectMultiScale(
+            gray_img,
+            scaleFactor=1.1,
+            minNeighbors=3,
+            minSize=(20, 20)
+        )
+    
+    with col2:
+        st.subheader("📊 Detection Info")
+        st.write(f"**Faces Found:** {len(faces)}")
+        st.write(f"**Image Size:** {gray_img.shape}")
+    
+    if len(faces) == 0:
+        st.warning("⚠️ No face detected. Try:")
+        st.write("- Ensure your face is clearly visible")
+        st.write("- Make sure lighting is adequate")
+        st.write("- Face should be front-facing")
+        st.write("- Try uploading a cropped image with just the face")
+        
+        # Option to skip face detection
+        if st.checkbox("Skip face detection and process entire image?"):
+            st.info("Processing entire image as 48x48...")
+            
+            # Resize entire image to 48x48
+            face_resized = cv2.resize(gray_img, (48, 48))
+            face_normalized = face_resized / 255.0
+            input_img = np.reshape(face_normalized, (1, 48, 48, 1))
+            
+            if model:
+                predictions = model.predict(input_img, verbose=0)
+                predicted_emotion_index = np.argmax(predictions)
+                predicted_emotion_label = emotion_map[predicted_emotion_index]
+                confidence = np.max(predictions) * 100
+                probability = np.max(predictions)
+                
+                col_pred1, col_pred2 = st.columns(2)
+                with col_pred1:
+                    st.write(f"**Predicted Emotion:** {predicted_emotion_label}")
+                    st.write(f"**Confidence:** {confidence:.2f}%")
+                
+                if predicted_emotion_index < len(aligned_func):
+                    try:
+                        stress_score = aligned_func[predicted_emotion_index](probability)
+                        normalized_stress = (stress_score / 9) * 100
+                        
+                        with col_pred2:
+                            if normalized_stress < 33:
+                                st.success(f"**Stress:** {normalized_stress:.2f}% 🟢 Low")
+                            elif normalized_stress < 66:
+                                st.warning(f"**Stress:** {normalized_stress:.2f}% 🟡 Medium")
+                            else:
+                                st.error(f"**Stress:** {normalized_stress:.2f}% 🔴 High")
+                    except Exception as e:
+                        st.error(f"Error: {e}")
+    else:
+        st.success(f"✅ Detected {len(faces)} face(s)")
+        
+        # Process each detected face
+        for idx, (x, y, w, h) in enumerate(faces):
+            st.markdown(f"### Face {idx + 1}")
+            
+            col1, col2, col3, col4 = st.columns(4)
+            
+            # 1. Face Region (from original image)
+            face_region = gray_img[y:y+h, x:x+w]
+            with col1:
+                st.subheader("2️⃣ Detected Face")
+                face_pil = Image.fromarray(face_region)
+                st.image(face_pil, use_container_width=True)
+            
+            # 2. Resized to 48x48
+            face_resized = cv2.resize(face_region, (48, 48))
+            with col2:
+                st.subheader("3️⃣ Resized (48×48)")
+                resized_pil = Image.fromarray(face_resized)
+                st.image(resized_pil, use_container_width=True)
+            
+            # 3. Normalized (0-1 range)
+            face_normalized = face_resized / 255.0
+            face_normalized_display = (face_normalized * 255).astype(np.uint8)
+            with col3:
+                st.subheader("4️⃣ Normalized")
+                normalized_pil = Image.fromarray(face_normalized_display)
+                st.image(normalized_pil, use_container_width=True)
+            
+            # 4. Model Input Shape (1, 48, 48, 1)
+            input_img = np.reshape(face_normalized, (1, 48, 48, 1))
+            with col4:
+                st.subheader("5️⃣ Model Input")
+                st.write(f"**Shape:** {input_img.shape}")
+                st.write(f"**Min:** {input_img.min():.3f}")
+                st.write(f"**Max:** {input_img.max():.3f}")
+                st.write(f"**Mean:** {input_img.mean():.3f}")
+            
+            # Run model prediction
+            if model:
+                st.markdown("---")
+                st.subheader("📊 Prediction Results")
+                
+                predictions = model.predict(input_img, verbose=0)
+                predicted_emotion_index = np.argmax(predictions)
+                predicted_emotion_label = emotion_map[predicted_emotion_index]
+                confidence = np.max(predictions) * 100
+                probability = np.max(predictions)
+                
+                col_pred1, col_pred2 = st.columns(2)
+                with col_pred1:
+                    st.write(f"**Predicted Emotion:** {predicted_emotion_label}")
+                    st.write(f"**Confidence:** {confidence:.2f}%")
+                
+                # Calculate and display stress level
+                if predicted_emotion_index < len(aligned_func):
+                    try:
+                        stress_score = aligned_func[predicted_emotion_index](probability)
+                        normalized_stress = (stress_score / 9) * 100
+                        
+                        with col_pred2:
+                            # Color-coded stress level
+                            if normalized_stress < 33:
+                                st.success(f"**Stress Level:** {normalized_stress:.2f}% 🟢 Low")
+                            elif normalized_stress < 66:
+                                st.warning(f"**Stress Level:** {normalized_stress:.2f}% 🟡 Medium")
+                            else:
+                                st.error(f"**Stress Level:** {normalized_stress:.2f}% 🔴 High")
+                    except Exception as e:
+                        st.error(f"Could not calculate stress: {e}")
+                
+                # Display all emotion probabilities as bar chart
+                st.subheader("📈 All Emotion Probabilities")
+                emotion_probs = {emotion_map[i]: float(predictions[0][i]) * 100 for i in range(7)}
+                emotion_probs_sorted = dict(sorted(emotion_probs.items(), key=lambda x: x[1], reverse=True))
+                
+                col_chart1, col_chart2 = st.columns([2, 1])
+                with col_chart1:
+                    st.bar_chart(emotion_probs_sorted)
+                
+                with col_chart2:
+                    st.write("**Emotion Breakdown:**")
+                    for emotion, prob in emotion_probs_sorted.items():
+                        st.write(f"{emotion}: **{prob:.2f}%**")
+                
+                st.markdown("---")
+            else:
+                st.error("❌ Model not loaded. Please check the model path.")
+

requirements.txt

@@ -1,3 +1,7 @@
-altair
-pandas
-streamlit
+streamlit
+tensorflow
+numpy
+opencv-python
+Pillow
+scipy
+matplotlib

stress_calculation_guide.ipynb

@@ -0,0 +1,159 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "9236892e",
+   "metadata": {},
+   "source": [
+    "# Stress Calculation Mathematics\n",
+    "\n",
+    "This notebook documents the stress calculation formulas used in the Facial Expression Stress Detector.\n",
+    "\n",
+    "Source: https://www.kaggle.com/code/ahmedmagaji/stress-detection/notebook\n",
+    "\n",
+    "## Formula Structure\n",
+    "\n",
+    "Each emotion has a stress function of the form:\n",
+    "- `t = a * p + b` (linear transformation of probability)\n",
+    "- `stress = c * ln(t)` (logarithmic scaling)\n",
+    "\n",
+    "Where `p` is the emotion probability (0-1 range)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7f7215a9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import math\n",
+    "\n",
+    "# Stress calculation formulas\n",
+    "stress_formulas = {\n",
+    "    'Angry': {\n",
+    "        'formula': 't = 0.343 * p + 1.003; stress = 2.332 * ln(t)',\n",
+    "        'a': 0.343, 'b': 1.003, 'c': 2.332\n",
+    "    },\n",
+    "    'Disgust': {\n",
+    "        'formula': 't = 0.0123 * p + 1.019; stress = 7.351 * ln(t)',\n",
+    "        'a': 0.0123, 'b': 1.019, 'c': 7.351\n",
+    "    },\n",
+    "    'Fear': {\n",
+    "        'formula': 't = 1.356 * p + 1; stress = 1.763 * ln(t)',\n",
+    "        'a': 1.356, 'b': 1.0, 'c': 1.763\n",
+    "    },\n",
+    "    'Happy': {\n",
+    "        'formula': 't = 5.221e-5 * p + 0.9997; stress = 532.2 * ln(t)',\n",
+    "        'a': 5.221e-5, 'b': 0.9997, 'c': 532.2\n",
+    "    },\n",
+    "    'Sad': {\n",
+    "        'formula': 't = 0.1328 * p + 1.009; stress = 2.851 * ln(t)',\n",
+    "        'a': 0.1328, 'b': 1.009, 'c': 2.851\n",
+    "    },\n",
+    "    'Surprise': {\n",
+    "        'formula': 't = 0.2825 * p + 1.003; stress = 2.478 * ln(t)',\n",
+    "        'a': 0.2825, 'b': 1.003, 'c': 2.478\n",
+    "    },\n",
+    "    'Contempt': {\n",
+    "        'formula': 't = 0.01229 * p + 1.036; stress = 5.03 * ln(t)',\n",
+    "        'a': 0.01229, 'b': 1.036, 'c': 5.03\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "# Display formulas\n",
+    "for emotion, details in stress_formulas.items():\n",
+    "    print(f\"{emotion}: {details['formula']}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d13c61d5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example calculations with probability = 0.5 (50% confidence)\n",
+    "def anger(p):\n",
+    "    t = 0.343 * p + 1.003\n",
+    "    return 2.332 * math.log(t)\n",
+    "\n",
+    "def fear(p):\n",
+    "    t = 1.356 * p + 1\n",
+    "    return 1.763 * math.log(t)\n",
+    "\n",
+    "def contempt(p):\n",
+    "    t = 0.01229 * p + 1.036\n",
+    "    return 5.03 * math.log(t)\n",
+    "\n",
+    "def disgust(p):\n",
+    "    t = 0.0123 * p + 1.019\n",
+    "    return 7.351 * math.log(t)\n",
+    "\n",
+    "def happy(p):\n",
+    "    t = 5.221e-5 * p + 0.9997\n",
+    "    return 532.2 * math.log(t)\n",
+    "\n",
+    "def sad(p):\n",
+    "    t = 0.1328 * p + 1.009\n",
+    "    return 2.851 * math.log(t)\n",
+    "\n",
+    "def surprise(p):\n",
+    "    t = 0.2825 * p + 1.003\n",
+    "    return 2.478 * math.log(t)\n",
+    "\n",
+    "# Test with p = 0.5\n",
+    "test_probability = 0.5\n",
+    "print(f\"\\nStress values for probability p = {test_probability}:\")\n",
+    "print(f\"Angry: {anger(test_probability):.4f}\")\n",
+    "print(f\"Disgust: {disgust(test_probability):.4f}\")\n",
+    "print(f\"Fear: {fear(test_probability):.4f}\")\n",
+    "print(f\"Happy: {happy(test_probability):.4f}\")\n",
+    "print(f\"Sad: {sad(test_probability):.4f}\")\n",
+    "print(f\"Surprise: {surprise(test_probability):.4f}\")\n",
+    "print(f\"Contempt: {contempt(test_probability):.4f}\")\n",
+    "\n",
+    "# Normalize to 0-100 scale (divide by 9 as mentioned in your code)\n",
+    "print(f\"\\nNormalized Stress Levels (0-100):\")\n",
+    "print(f\"Angry: {(anger(test_probability) / 9 * 100):.2f}\")\n",
+    "print(f\"Disgust: {(disgust(test_probability) / 9 * 100):.2f}\")\n",
+    "print(f\"Fear: {(fear(test_probability) / 9 * 100):.2f}\")\n",
+    "print(f\"Happy: {(happy(test_probability) / 9 * 100):.2f}\")\n",
+    "print(f\"Sad: {(sad(test_probability) / 9 * 100):.2f}\")\n",
+    "print(f\"Surprise: {(surprise(test_probability) / 9 * 100):.2f}\")\n",
+    "print(f\"Contempt: {(contempt(test_probability) / 9 * 100):.2f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "17bde9e1",
+   "metadata": {},
+   "source": [
+    "## Key Points\n",
+    "\n",
+    "1. **Input Range**: All stress functions expect `p` in range [0, 1] (probability, not percentage)\n",
+    "2. **Output Range**: Raw stress scores are typically 0-9\n",
+    "3. **Normalization**: Divide by 9 and multiply by 100 to get 0-100 scale\n",
+    "4. **Interpretation**:\n",
+    "   - Low stress (0-33): Calm, relaxed expressions\n",
+    "   - Medium stress (33-66): Moderate emotional intensity\n",
+    "   - High stress (66-100): High emotional intensity or negative emotions\n",
+    "\n",
+    "## Validation\n",
+    "\n",
+    "Your Streamlit app correctly:\n",
+    "- ✅ Extracts probability from model predictions (0-1 range)\n",
+    "- ✅ Applies the stress functions\n",
+    "- ✅ Normalizes to 0-100 scale\n",
+    "- ✅ Color-codes results by stress level"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

wesad.ipynb

@@ -0,0 +1,337 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6d1cc4dd",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# ============================================================================\n",
+    "# WESAD Stress Detection - Google Colab with T4 GPU Support\n",
+    "# ============================================================================\n",
+    "# Enable GPU: Runtime > Change runtime type > Hardware accelerator > T4 GPU\n",
+    "# ============================================================================\n",
+    "\n",
+    "# === 1. Install Required Packages ===\n",
+    "print(\"Installing dependencies...\")\n",
+    "!pip install -q kagglehub scipy scikit-learn pandas numpy joblib\n",
+    "\n",
+    "# Install RAPIDS cuML for GPU acceleration (T4 compatible)\n",
+    "try:\n",
+    "    import cuml\n",
+    "    print(\"✓ cuML already installed\")\n",
+    "except ImportError:\n",
+    "    print(\"Installing cuML for GPU acceleration...\")\n",
+    "    !pip install -q cuml-cu11 --extra-index-url=https://pypi.nvidia.com\n",
+    "    print(\"✓ cuML installed\")\n",
+    "\n",
+    "# === 2. Download WESAD Dataset ===\n",
+    "print(\"\\nDownloading WESAD dataset...\")\n",
+    "import kagglehub\n",
+    "import os\n",
+    "import glob\n",
+    "\n",
+    "# Download the dataset\n",
+    "path = kagglehub.dataset_download(\"orvile/wesad-wearable-stress-affect-detection-dataset\")\n",
+    "print(f\"Dataset downloaded to: {path}\")\n",
+    "\n",
+    "# Find all .pkl files\n",
+    "pkl_files = glob.glob(os.path.join(path, \"**/*.pkl\"), recursive=True)\n",
+    "print(f\"Found {len(pkl_files)} .pkl files\")\n",
+    "\n",
+    "# === 3. Import Libraries ===\n",
+    "import pickle\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from scipy import signal, stats\n",
+    "from sklearn.metrics import classification_report, f1_score, confusion_matrix\n",
+    "from sklearn.model_selection import LeaveOneGroupOut\n",
+    "import joblib\n",
+    "\n",
+    "# Try GPU-accelerated RandomForest\n",
+    "try:\n",
+    "    from cuml.ensemble import RandomForestClassifier as cuRFC\n",
+    "    import cupy as cp\n",
+    "    USE_GPU = True\n",
+    "    print(\"✓ Using GPU-accelerated cuML RandomForest\")\n",
+    "    # Check GPU availability\n",
+    "    !nvidia-smi --query-gpu=name,memory.total --format=csv\n",
+    "except ImportError:\n",
+    "    from sklearn.ensemble import RandomForestClassifier as cuRFC\n",
+    "    USE_GPU = False\n",
+    "    print(\"⚠ cuML not available, using CPU sklearn RandomForest\")\n",
+    "\n",
+    "# === 4. Load Subject Data ===\n",
+    "print(\"\\n\" + \"=\"*60)\n",
+    "print(\"LOADING SUBJECT DATA\")\n",
+    "print(\"=\"*60)\n",
+    "\n",
+    "subjects = []\n",
+    "for p in pkl_files:\n",
+    "    with open(p, 'rb') as f:\n",
+    "        data = pickle.load(f, encoding='latin1')\n",
+    "    \n",
+    "    subj = data['subject']\n",
+    "    sig = data['signal']\n",
+    "    \n",
+    "    chest = sig.get('chest', {})\n",
+    "    wrist = sig.get('wrist', {})\n",
+    "    \n",
+    "    subj_dict = {\n",
+    "        'id': subj,\n",
+    "        'ecg': np.asarray(chest.get('ECG', []), dtype=np.float64),\n",
+    "        'eda': np.asarray(chest.get('EDA', []) if 'EDA' in chest else wrist.get('EDA', []), dtype=np.float64),\n",
+    "        'temp': np.asarray(chest.get('TEMP', []) if 'TEMP' in chest else wrist.get('TEMP', []), dtype=np.float64),\n",
+    "        'label': np.asarray(data['label'], dtype=np.int32)\n",
+    "    }\n",
+    "    \n",
+    "    # Skip subjects with missing channels\n",
+    "    if subj_dict['ecg'].size==0 or subj_dict['eda'].size==0 or subj_dict['temp'].size==0:\n",
+    "        print(f\"  ⚠ Skipping {subj} - missing channel\")\n",
+    "        continue\n",
+    "    \n",
+    "    subjects.append(subj_dict)\n",
+    "    print(f\"  ✓ Loaded {subj}: ECG={len(subj_dict['ecg'])}, EDA={len(subj_dict['eda'])}, TEMP={len(subj_dict['temp'])}\")\n",
+    "\n",
+    "print(f\"\\n✓ Successfully loaded {len(subjects)} subjects: {[s['id'] for s in subjects]}\")\n",
+    "\n",
+    "# === 5. Signal Processing Functions ===\n",
+    "def to_numpy(x):\n",
+    "    \"\"\"Convert any array type to CPU numpy array\"\"\"\n",
+    "    if hasattr(x, 'get'):  # CuPy array\n",
+    "        return np.asarray(x.get(), dtype=np.float64).flatten()\n",
+    "    return np.asarray(x, dtype=np.float64).flatten()\n",
+    "\n",
+    "def downsample(x, orig_fs=700, target_fs=4):\n",
+    "    \"\"\"Downsample signal from 700 Hz to 4 Hz\"\"\"\n",
+    "    x = to_numpy(x)\n",
+    "    if x.size==0: \n",
+    "        return x\n",
+    "    factor = int(orig_fs/target_fs)\n",
+    "    if factor <= 1: \n",
+    "        return x\n",
+    "    return signal.decimate(x, factor, ftype='fir', zero_phase=True)\n",
+    "\n",
+    "def extract_features(ecg, eda, temp):\n",
+    "    \"\"\"Extract time-domain and signal-specific features\"\"\"\n",
+    "    # Convert all inputs to CPU numpy 1-D arrays\n",
+    "    ecg = to_numpy(ecg)\n",
+    "    eda = to_numpy(eda)\n",
+    "    temp = to_numpy(temp)\n",
+    "    \n",
+    "    feats = {}\n",
+    "    \n",
+    "    # Basic statistical features for all signals\n",
+    "    for name, arr in [('ecg', ecg), ('eda', eda), ('temp', temp)]:\n",
+    "        feats[f'{name}_mean'] = float(np.mean(arr))\n",
+    "        feats[f'{name}_std']  = float(np.std(arr, ddof=0))\n",
+    "        feats[f'{name}_min']  = float(np.min(arr))\n",
+    "        feats[f'{name}_max']  = float(np.max(arr))\n",
+    "        feats[f'{name}_skew'] = float(stats.skew(arr))\n",
+    "        feats[f'{name}_kurt'] = float(stats.kurtosis(arr))\n",
+    "        feats[f'{name}_rms']  = float(np.sqrt(np.mean(arr**2)))\n",
+    "    \n",
+    "    # EDA-specific: peak count (skin conductance responses)\n",
+    "    try:\n",
+    "        peaks, _ = signal.find_peaks(eda, distance=4, height=None)\n",
+    "        feats['eda_peaks_count'] = len(peaks)\n",
+    "    except Exception as e:\n",
+    "        feats['eda_peaks_count'] = 0\n",
+    "    \n",
+    "    # ECG-derived: Heart rate and HRV features\n",
+    "    try:\n",
+    "        ecg_peaks, _ = signal.find_peaks(ecg, distance=2, height=None)\n",
+    "        if len(ecg_peaks) >= 2:\n",
+    "            ibi = np.diff(ecg_peaks) / 4.0\n",
+    "            feats['hr_mean'] = float(60.0 / np.mean(ibi))\n",
+    "            feats['hr_std']  = float(np.std(60.0/ibi))\n",
+    "            feats['ibi_mean'] = float(np.mean(ibi))\n",
+    "            feats['ibi_sdnn'] = float(np.std(ibi, ddof=0))\n",
+    "        else:\n",
+    "            feats['hr_mean']=feats['hr_std']=feats['ibi_mean']=feats['ibi_sdnn']=0.0\n",
+    "    except Exception as e:\n",
+    "        feats['hr_mean']=feats['hr_std']=feats['ibi_mean']=feats['ibi_sdnn']=0.0\n",
+    "    \n",
+    "    return feats\n",
+    "\n",
+    "# === 6. Feature Extraction with Sliding Windows ===\n",
+    "print(\"\\n\" + \"=\"*60)\n",
+    "print(\"FEATURE EXTRACTION\")\n",
+    "print(\"=\"*60)\n",
+    "\n",
+    "window_sec = 60  # 60-second windows\n",
+    "fs = 4  # Target sampling frequency\n",
+    "win = window_sec * fs  # 240 samples per window\n",
+    "step = int(win * 0.5)  # 50% overlap (30-second step)\n",
+    "\n",
+    "X_rows, y_rows, groups = [], [], []\n",
+    "labels_map = {1:'baseline', 2:'stress', 3:'amusement', 4:'meditation'}\n",
+    "\n",
+    "for subj in subjects:\n",
+    "    print(f\"Processing {subj['id']}...\", end=' ')\n",
+    "    \n",
+    "    # Downsample all signals to 4 Hz\n",
+    "    ecg_ds = downsample(subj['ecg'])\n",
+    "    eda_ds = downsample(subj['eda'])\n",
+    "    temp_ds = downsample(subj['temp'])\n",
+    "    labels_ds = signal.decimate(subj['label'].astype(float), int(700/4), ftype='fir', zero_phase=True)\n",
+    "    \n",
+    "    # Ensure all signals have same length\n",
+    "    L = min(len(ecg_ds), len(eda_ds), len(temp_ds), len(labels_ds))\n",
+    "    ecg_ds = ecg_ds[:L]\n",
+    "    eda_ds = eda_ds[:L]\n",
+    "    temp_ds = temp_ds[:L]\n",
+    "    labels_ds = labels_ds[:L]\n",
+    "    \n",
+    "    window_count = 0\n",
+    "    # Sliding window extraction\n",
+    "    for start in range(0, L - win + 1, step):\n",
+    "        end = start + win\n",
+    "        lab_window = labels_ds[start:end]\n",
+    "        \n",
+    "        # Get majority label in window\n",
+    "        mode_result = stats.mode(lab_window, nan_policy='omit', keepdims=True)\n",
+    "        lab = int(mode_result.mode[0])\n",
+    "        \n",
+    "        # Keep only valid stress conditions\n",
+    "        if lab not in [1, 2, 3, 4]:\n",
+    "            continue\n",
+    "        \n",
+    "        # Extract features from window\n",
+    "        try:\n",
+    "            feats = extract_features(ecg_ds[start:end], eda_ds[start:end], temp_ds[start:end])\n",
+    "            X_rows.append(feats)\n",
+    "            y_rows.append(lab)\n",
+    "            groups.append(subj['id'])\n",
+    "            window_count += 1\n",
+    "        except Exception as e:\n",
+    "            print(f\"\\n  ⚠ Error processing window: {e}\")\n",
+    "            continue\n",
+    "    \n",
+    "    print(f\"{window_count} windows\")\n",
+    "\n",
+    "# Convert to DataFrame and arrays\n",
+    "X = pd.DataFrame(X_rows).fillna(0)\n",
+    "y = np.array(y_rows)\n",
+    "groups = np.array(groups)\n",
+    "\n",
+    "print(f\"\\n✓ Feature matrix: {X.shape} (samples × features)\")\n",
+    "print(f\"✓ Features: {list(X.columns)}\")\n",
+    "print(f\"✓ Class distribution:\")\n",
+    "for label_id in sorted(labels_map.keys()):\n",
+    "    count = np.sum(y == label_id)\n",
+    "    print(f\"    {labels_map[label_id]}: {count} windows\")\n",
+    "\n",
+    "# === 7. Leave-One-Subject-Out Cross-Validation ===\n",
+    "print(\"\\n\" + \"=\"*60)\n",
+    "print(\"LEAVE-ONE-SUBJECT-OUT CROSS-VALIDATION\")\n",
+    "print(\"=\"*60)\n",
+    "\n",
+    "logo = LeaveOneGroupOut()\n",
+    "f1s = []\n",
+    "all_predictions = []\n",
+    "all_true_labels = []\n",
+    "\n",
+    "for fold, (train_idx, test_idx) in enumerate(logo.split(X, y, groups), 1):\n",
+    "    test_subject = groups[test_idx][0]\n",
+    "    \n",
+    "    # Initialize model\n",
+    "    if USE_GPU:\n",
+    "        clf = cuRFC(n_estimators=200, random_state=42, max_depth=16)\n",
+    "    else:\n",
+    "        clf = cuRFC(n_estimators=200, random_state=42, n_jobs=-1)\n",
+    "    \n",
+    "    # Train\n",
+    "    clf.fit(X.iloc[train_idx], y[train_idx])\n",
+    "    \n",
+    "    # Predict\n",
+    "    y_pred = clf.predict(X.iloc[test_idx])\n",
+    "    \n",
+    "    all_predictions.extend(y_pred)\n",
+    "    all_true_labels.extend(y[test_idx])\n",
+    "    \n",
+    "    f1_macro = f1_score(y[test_idx], y_pred, average='macro')\n",
+    "    f1_weighted = f1_score(y[test_idx], y_pred, average='weighted')\n",
+    "    f1s.append(f1_macro)\n",
+    "    \n",
+    "    print(f\"Fold {fold:2d} | {test_subject} | F1-Macro: {f1_macro:.4f} | F1-Weighted: {f1_weighted:.4f}\")\n",
+    "\n",
+    "print(\"=\"*60)\n",
+    "print(f\"✓ Mean F1-Macro:    {np.mean(f1s):.4f} ± {np.std(f1s):.4f}\")\n",
+    "print(f\"✓ Median F1-Macro:  {np.median(f1s):.4f}\")\n",
+    "print(\"=\"*60)\n",
+    "\n",
+    "# Confusion Matrix\n",
+    "print(\"\\nConfusion Matrix:\")\n",
+    "cm = confusion_matrix(all_true_labels, all_predictions)\n",
+    "cm_df = pd.DataFrame(cm, \n",
+    "                     index=[labels_map[i] for i in sorted(labels_map.keys())],\n",
+    "                     columns=[labels_map[i] for i in sorted(labels_map.keys())])\n",
+    "print(cm_df)\n",
+    "\n",
+    "# === 8. Train Final Model on All Data ===\n",
+    "print(\"\\n\" + \"=\"*60)\n",
+    "print(\"TRAINING FINAL MODEL\")\n",
+    "print(\"=\"*60)\n",
+    "\n",
+    "if USE_GPU:\n",
+    "    clf_final = cuRFC(n_estimators=300, random_state=42, max_depth=16)\n",
+    "else:\n",
+    "    clf_final = cuRFC(n_estimators=300, random_state=42, n_jobs=-1)\n",
+    "\n",
+    "print(\"Training on all data...\")\n",
+    "clf_final.fit(X, y)\n",
+    "\n",
+    "y_pred_final = clf_final.predict(X)\n",
+    "print(\"\\nFinal Model Performance:\")\n",
+    "print(classification_report(y, y_pred_final, \n",
+    "                           target_names=[labels_map[i] for i in sorted(labels_map.keys())]))\n",
+    "\n",
+    "# === 9. Save Model and Artifacts ===\n",
+    "print(\"\\n\" + \"=\"*60)\n",
+    "print(\"SAVING MODEL\")\n",
+    "print(\"=\"*60)\n",
+    "\n",
+    "# Save to /content/ (Colab's default working directory)\n",
+    "model_path = '/content/wesad_rfc_model.joblib'\n",
+    "features_path = '/content/wesad_feature_names.joblib'\n",
+    "scaler_info_path = '/content/wesad_preprocessing_info.joblib'\n",
+    "\n",
+    "joblib.dump(clf_final, model_path)\n",
+    "joblib.dump(X.columns.tolist(), features_path)\n",
+    "joblib.dump({\n",
+    "    'labels_map': labels_map,\n",
+    "    'window_sec': window_sec,\n",
+    "    'fs': fs,\n",
+    "    'feature_count': X.shape[1]\n",
+    "}, scaler_info_path)\n",
+    "\n",
+    "print(f\"✓ Model saved\")\n",
+    "print(f\"✓ Feature names saved\")\n",
+    "print(f\"✓ Preprocessing info saved\")\n",
+    "print(\"\\n✓ Training complete!\")\n",
+    "\n",
+    "# === 10. Download Model Files ===\n",
+    "from google.colab import files\n",
+    "\n",
+    "print(\"\\nDownloading model files...\")\n",
+    "files.download('/content/wesad_rfc_model.joblib')\n",
+    "files.download('/content/wesad_feature_names.joblib')\n",
+    "files.download('/content/wesad_preprocessing_info.joblib')\n",
+    "print(\"✓ Downloads complete\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}