diff --git "a/data_preparation/MLP/train_mlp.ipynb" "b/data_preparation/MLP/train_mlp.ipynb"
deleted file mode 100644--- "a/data_preparation/MLP/train_mlp.ipynb"
+++ /dev/null
@@ -1,674 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# MLP Training Notebook\n",
-        "Train a Multi-Layer Perceptron to classify focused vs unfocused states.\n",
-        "\n",
-        "**Pipeline:**\n",
-        "1. Load & clean data\n",
-        "2. Feature selection\n",
-        "3. Preprocessing (StandardScaler)\n",
-        "4. Train/Val/Test split\n",
-        "5. MLP architecture + training\n",
-        "6. Evaluation (accuracy, F1, confusion matrix)\n",
-        "7. Save model + scaler"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 0. Imports & Config"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Selected 10 features: ['head_deviation', 's_face', 's_eye', 'h_gaze', 'pitch', 'ear_left', 'ear_avg', 'ear_right', 'gaze_offset', 'perclos']\n",
-            "Model output dir: /Users/mohammedalketbi22/GAP/shared/data_preparation/../MLP/models\n"
-          ]
-        }
-      ],
-      "source": [
-        "import numpy as np\n",
-        "import matplotlib.pyplot as plt\n",
-        "import os\n",
-        "import glob\n",
-        "import joblib\n",
-        "from sklearn.neural_network import MLPClassifier\n",
-        "from sklearn.preprocessing import StandardScaler\n",
-        "from sklearn.model_selection import train_test_split\n",
-        "from sklearn.metrics import (\n",
-        "    accuracy_score, f1_score, classification_report,\n",
-        "    confusion_matrix, ConfusionMatrixDisplay, roc_auc_score,\n",
-        "    RocCurveDisplay\n",
-        ")\n",
-        "from sklearn.pipeline import Pipeline\n",
-        "import warnings\n",
-        "warnings.filterwarnings('ignore')\n",
-        "\n",
-        "# ── PATH CONFIG ───────────────────────────────────────────────\n",
-        "BASE_DIR      = \"/Users/mohammedalketbi22/GAP/shared/data_preparation\"\n",
-        "COLLECTED_DIR = os.path.join(BASE_DIR, \"collected\")\n",
-        "MODEL_DIR     = os.path.join(BASE_DIR, \"..\", \"MLP\", \"models\")\n",
-        "os.makedirs(MODEL_DIR, exist_ok=True)\n",
-        "\n",
-        "# ── FEATURE SELECTION ────────────────────────────────────────\n",
-        "SELECTED_FEATURES = [\n",
-        "    'head_deviation',  # r = -0.634  strongest\n",
-        "    's_face',          # r = +0.623\n",
-        "    's_eye',           # r = +0.405\n",
-        "    'h_gaze',          # r = -0.401\n",
-        "    'pitch',           # r = -0.393\n",
-        "    'ear_left',        # r = +0.368\n",
-        "    'ear_avg',         # r = +0.338\n",
-        "    'ear_right',       # r = +0.294\n",
-        "    'gaze_offset',     # r = -0.287\n",
-        "    'perclos',         # r = -0.269\n",
-        "]\n",
-        "\n",
-        "RANDOM_SEED = 42\n",
-        "print(f\"Selected {len(SELECTED_FEATURES)} features: {SELECTED_FEATURES}\")\n",
-        "print(f\"Model output dir: {MODEL_DIR}\")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 1. Load & Clean Data"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Loading: /Users/mohammedalketbi22/GAP/shared/data_preparation/collected/session_20260224_010131.npz\n",
-            "Raw samples : 13218\n",
-            "Features    : 17\n",
-            "Labels      : 0=6227  1=6991\n",
-            "\n",
-            "Cleaning applied ✅\n"
-          ]
-        }
-      ],
-      "source": [
-        "# Auto-load latest .npz \n",
-        "npz_files = sorted(glob.glob(os.path.join(COLLECTED_DIR, \"*.npz\")))\n",
-        "\n",
-        "\n",
-        "merged = [f for f in npz_files if 'merged' in f]\n",
-        "NPZ_PATH = merged[-1] if merged else npz_files[-1]\n",
-        "print(f\"Loading: {NPZ_PATH}\")\n",
-        "\n",
-        "data     = np.load(NPZ_PATH, allow_pickle=True)\n",
-        "features = data['features'].astype(np.float32)\n",
-        "labels   = data['labels'].astype(np.int32)\n",
-        "names    = list(data['feature_names'])\n",
-        "\n",
-        "print(f\"Raw samples : {len(labels)}\")\n",
-        "print(f\"Features    : {features.shape[1]}\")\n",
-        "print(f\"Labels      : 0={int((labels==0).sum())}  1={int((labels==1).sum())}\")\n",
-        "\n",
-        "# ── CLEANING  ──────────────────────\n",
-        "# Clip head pose angles to realistic ranges\n",
-        "features[:, names.index('yaw')]   = np.clip(features[:, names.index('yaw')],   -45,  45)\n",
-        "features[:, names.index('pitch')] = np.clip(features[:, names.index('pitch')], -30,  30)\n",
-        "features[:, names.index('roll')]  = np.clip(features[:, names.index('roll')],  -30,  30)\n",
-        "# Clip EAR to valid range\n",
-        "for feat in ['ear_left', 'ear_right', 'ear_avg']:\n",
-        "    features[:, names.index(feat)] = np.clip(features[:, names.index(feat)], 0, 0.85)\n",
-        "\n",
-        "print(\"\\nCleaning applied ✅\")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 2. Feature Selection"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 4,
-      "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Feature matrix shape : (13218, 10)\n",
-            "Label vector shape   : (13218,)\n",
-            "\n",
-            "Features used:\n",
-            "  [ 0] head_deviation\n",
-            "  [ 1] s_face\n",
-            "  [ 2] s_eye\n",
-            "  [ 3] h_gaze\n",
-            "  [ 4] pitch\n",
-            "  [ 5] ear_left\n",
-            "  [ 6] ear_avg\n",
-            "  [ 7] ear_right\n",
-            "  [ 8] gaze_offset\n",
-            "  [ 9] perclos\n"
-          ]
-        }
-      ],
-      "source": [
-        "# Select only the 10 chosen features\n",
-        "feature_indices = [names.index(f) for f in SELECTED_FEATURES]\n",
-        "X = features[:, feature_indices]\n",
-        "y = labels\n",
-        "\n",
-        "print(f\"Feature matrix shape : {X.shape}\")\n",
-        "print(f\"Label vector shape   : {y.shape}\")\n",
-        "print(f\"\\nFeatures used:\")\n",
-        "for i, name in enumerate(SELECTED_FEATURES):\n",
-        "    print(f\"  [{i:2d}] {name}\")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 3. Train / Validation / Test Split"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Train :   9252 samples  (70.0%)\n",
-            "Val   :   1983 samples  (15.0%)\n",
-            "Test  :   1983 samples  (15.0%)\n",
-            "\n",
-            "Train balance: 4893 focused / 4359 unfocused\n",
-            "Val   balance: 1049 focused / 934 unfocused\n",
-            "Test  balance: 1049 focused / 934 unfocused\n"
-          ]
-        }
-      ],
-      "source": [
-        "# 70% train | 15% val | 15% test\n",
-        "# When all data is added, we will switch to subject-aware splitting.\n",
-        "\n",
-        "X_train_val, X_test, y_train_val, y_test = train_test_split(\n",
-        "    X, y, test_size=0.15, random_state=RANDOM_SEED, stratify=y\n",
-        ")\n",
-        "X_train, X_val, y_train, y_val = train_test_split(\n",
-        "    X_train_val, y_train_val,\n",
-        "    test_size=0.15 / 0.85,   # ~15% of total\n",
-        "    random_state=RANDOM_SEED, stratify=y_train_val\n",
-        ")\n",
-        "\n",
-        "print(f\"Train : {len(y_train):>6} samples  ({len(y_train)/len(y)*100:.1f}%)\")\n",
-        "print(f\"Val   : {len(y_val):>6} samples  ({len(y_val)/len(y)*100:.1f}%)\")\n",
-        "print(f\"Test  : {len(y_test):>6} samples  ({len(y_test)/len(y)*100:.1f}%)\")\n",
-        "print(f\"\\nTrain balance: {int((y_train==1).sum())} focused / {int((y_train==0).sum())} unfocused\")\n",
-        "print(f\"Val   balance: {int((y_val==1).sum())} focused / {int((y_val==0).sum())} unfocused\")\n",
-        "print(f\"Test  balance: {int((y_test==1).sum())} focused / {int((y_test==0).sum())} unfocused\")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 4. Preprocessing — StandardScaler"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "StandardScaler fitted on training data ✅\n",
-            "\n",
-            "Feature means (train): [27.0059  0.2774  0.6795  0.47   -1.2007  0.4882  0.4643  0.4359  0.1007\n",
-            "  0.0663]\n",
-            "Feature stds  (train): [17.107   0.2967  0.2903  0.0416 17.8555  0.1358  0.1423  0.1726  0.0723\n",
-            "  0.1533]\n"
-          ]
-        }
-      ],
-      "source": [
-        "scaler = StandardScaler()\n",
-        "X_train_sc = scaler.fit_transform(X_train)\n",
-        "X_val_sc   = scaler.transform(X_val)\n",
-        "X_test_sc  = scaler.transform(X_test)\n",
-        "\n",
-        "print(\"StandardScaler fitted on training data ✅\")\n",
-        "print(f\"\\nFeature means (train): {scaler.mean_.round(4)}\")\n",
-        "print(f\"Feature stds  (train): {scaler.scale_.round(4)}\")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 5. MLP Architecture & Training\n",
-        "Architecture: **10 → 64 → 32 → 16 → 1**  \n",
-        "- ReLU activations, Adam optimizer\n",
-        "- Early stopping on validation loss (patience=15)\n",
-        "- L2 regularization (alpha=0.001)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Training complete ✅\n",
-            "Iterations run : 84\n",
-            "Final loss     : 0.0726\n",
-            "\n",
-            "Validation Accuracy : 96.07%\n",
-            "Validation F1       : 0.9636\n"
-          ]
-        }
-      ],
-      "source": [
-        "mlp = MLPClassifier(\n",
-        "    hidden_layer_sizes=(64, 32, 16),\n",
-        "    activation='relu',\n",
-        "    solver='adam',\n",
-        "    alpha=0.001,              # L2 regularization\n",
-        "    batch_size=64,\n",
-        "    learning_rate_init=0.001,\n",
-        "    max_iter=500,\n",
-        "    early_stopping=True,\n",
-        "    validation_fraction=0.1,\n",
-        "    n_iter_no_change=15,      # patience\n",
-        "    random_state=RANDOM_SEED,\n",
-        "    verbose=False\n",
-        ")\n",
-        "\n",
-        "# Train — sklearn MLPClassifier uses internal val from training data\n",
-        "# We'll track val metrics manually \n",
-        "\n",
-        "train_accs, val_accs = [], []\n",
-        "train_losses = []\n",
-        "\n",
-        "# Full training run\n",
-        "mlp.fit(X_train_sc, y_train)\n",
-        "\n",
-        "print(f\"Training complete ✅\")\n",
-        "print(f\"Iterations run : {mlp.n_iter_}\")\n",
-        "print(f\"Final loss     : {mlp.loss_:.4f}\")\n",
-        "\n",
-        "val_pred = mlp.predict(X_val_sc)\n",
-        "val_acc  = accuracy_score(y_val, val_pred)\n",
-        "val_f1   = f1_score(y_val, val_pred)\n",
-        "print(f\"\\nValidation Accuracy : {val_acc*100:.2f}%\")\n",
-        "print(f\"Validation F1       : {val_f1:.4f}\")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 6. Training Loss Curve"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 9,
-      "metadata": {},
-      "outputs": [
-        {
-          "data": {
-            "image/png": "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",
-            "text/plain": [
-              "<Figure size 1000x400 with 1 Axes>"
-            ]
-          },
-          "metadata": {},
-          "output_type": "display_data"
-        },
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Converged at iteration 84 | Best loss: 0.0726\n"
-          ]
-        }
-      ],
-      "source": [
-        "fig, ax = plt.subplots(figsize=(10, 4))\n",
-        "ax.plot(mlp.loss_curve_, color='#00B4D8', linewidth=1.5, label='Training Loss')\n",
-        "ax.set_xlabel('Iteration')\n",
-        "ax.set_ylabel('Loss')\n",
-        "ax.set_title('MLP Training Loss Curve', fontweight='bold')\n",
-        "ax.legend()\n",
-        "ax.grid(True, alpha=0.3)\n",
-        "plt.tight_layout()\n",
-        "plt.show()\n",
-        "print(f\"Converged at iteration {mlp.n_iter_} | Best loss: {min(mlp.loss_curve_):.4f}\")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 7. Full Evaluation on Test Set"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 10,
-      "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "==================================================\n",
-            "  TEST SET RESULTS\n",
-            "==================================================\n",
-            "  Accuracy  : 95.06%\n",
-            "  F1 Score  : 0.9541\n",
-            "  ROC-AUC   : 0.9853\n",
-            "==================================================\n",
-            "\n",
-            "               precision    recall  f1-score   support\n",
-            "\n",
-            "Unfocused (0)       0.97      0.93      0.95       934\n",
-            "  Focused (1)       0.94      0.97      0.95      1049\n",
-            "\n",
-            "     accuracy                           0.95      1983\n",
-            "    macro avg       0.95      0.95      0.95      1983\n",
-            " weighted avg       0.95      0.95      0.95      1983\n",
-            "\n"
-          ]
-        }
-      ],
-      "source": [
-        "y_pred      = mlp.predict(X_test_sc)\n",
-        "y_pred_prob = mlp.predict_proba(X_test_sc)[:, 1]\n",
-        "\n",
-        "test_acc = accuracy_score(y_test, y_pred)\n",
-        "test_f1  = f1_score(y_test, y_pred)\n",
-        "test_auc = roc_auc_score(y_test, y_pred_prob)\n",
-        "\n",
-        "print(\"=\" * 50)\n",
-        "print(\"  TEST SET RESULTS\")\n",
-        "print(\"=\" * 50)\n",
-        "print(f\"  Accuracy  : {test_acc*100:.2f}%\")\n",
-        "print(f\"  F1 Score  : {test_f1:.4f}\")\n",
-        "print(f\"  ROC-AUC   : {test_auc:.4f}\")\n",
-        "print(\"=\" * 50)\n",
-        "print()\n",
-        "print(classification_report(y_test, y_pred,\n",
-        "      target_names=['Unfocused (0)', 'Focused (1)']))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 8. Confusion Matrix & ROC Curve"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 11,
-      "metadata": {},
-      "outputs": [
-        {
-          "data": {
-            "image/png": "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",
-            "text/plain": [
-              "<Figure size 1200x500 with 2 Axes>"
-            ]
-          },
-          "metadata": {},
-          "output_type": "display_data"
-        }
-      ],
-      "source": [
-        "fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n",
-        "\n",
-        "# Confusion Matrix\n",
-        "cm = confusion_matrix(y_test, y_pred)\n",
-        "disp = ConfusionMatrixDisplay(cm, display_labels=['Unfocused', 'Focused'])\n",
-        "disp.plot(ax=axes[0], colorbar=False, cmap='Blues')\n",
-        "axes[0].set_title('Confusion Matrix', fontweight='bold')\n",
-        "\n",
-        "# ROC Curve\n",
-        "RocCurveDisplay.from_predictions(y_test, y_pred_prob, ax=axes[1],\n",
-        "                                  color='#06D6A0', name=f'MLP (AUC={test_auc:.3f})')\n",
-        "axes[1].plot([0,1],[0,1],'--', color='gray', linewidth=0.8)\n",
-        "axes[1].set_title('ROC Curve', fontweight='bold')\n",
-        "\n",
-        "plt.tight_layout()\n",
-        "plt.show()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 9. Feature Importance (Permutation)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [
-        {
-          "data": {
-            "image/png": "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",
-            "text/plain": [
-              "<Figure size 1000x500 with 1 Axes>"
-            ]
-          },
-          "metadata": {},
-          "output_type": "display_data"
-        },
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "\n",
-            "Feature Importance Ranking:\n",
-            "  pitch                +0.2188 ± 0.0076\n",
-            "  ear_left             +0.2166 ± 0.0081\n",
-            "  s_face               +0.1939 ± 0.0071\n",
-            "  ear_right            +0.0886 ± 0.0064\n",
-            "  s_eye                +0.0838 ± 0.0056\n",
-            "  head_deviation       +0.0809 ± 0.0045\n",
-            "  h_gaze               +0.0786 ± 0.0037\n",
-            "  ear_avg              +0.0654 ± 0.0048\n",
-            "  perclos              +0.0491 ± 0.0046\n",
-            "  gaze_offset          +0.0210 ± 0.0023\n"
-          ]
-        }
-      ],
-      "source": [
-        "# Permutation \n",
-        "from sklearn.inspection import permutation_importance\n",
-        "\n",
-        "result = permutation_importance(\n",
-        "    mlp, X_test_sc, y_test,\n",
-        "    n_repeats=10, random_state=RANDOM_SEED, scoring='f1'\n",
-        ")\n",
-        "\n",
-        "sorted_idx = result.importances_mean.argsort()[::-1]\n",
-        "\n",
-        "fig, ax = plt.subplots(figsize=(10, 5))\n",
-        "colors = ['#06D6A0' if result.importances_mean[i] > 0 else '#EF476F'\n",
-        "          for i in sorted_idx]\n",
-        "ax.barh(\n",
-        "    [SELECTED_FEATURES[i] for i in sorted_idx],\n",
-        "    result.importances_mean[sorted_idx],\n",
-        "    xerr=result.importances_std[sorted_idx],\n",
-        "    color=colors, capsize=4\n",
-        ")\n",
-        "ax.set_xlabel('Mean F1 Drop (higher = more important)')\n",
-        "ax.set_title('Permutation Feature Importance on Test Set', fontweight='bold')\n",
-        "ax.axvline(0, color='gray', linewidth=0.5)\n",
-        "plt.tight_layout()\n",
-        "plt.show()\n",
-        "\n",
-        "print(\"\\nFeature Importance Ranking:\")\n",
-        "for i in sorted_idx:\n",
-        "    print(f\"  {SELECTED_FEATURES[i]:<20} {result.importances_mean[i]:+.4f} ± {result.importances_std[i]:.4f}\")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 10. Save Model & Scaler"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 13,
-      "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "==================================================\n",
-            "  MODEL SAVED\n",
-            "==================================================\n",
-            "  Model  -> /Users/mohammedalketbi22/GAP/shared/data_preparation/../MLP/models/mlp_20260224_024200.joblib\n",
-            "  Scaler -> /Users/mohammedalketbi22/GAP/shared/data_preparation/../MLP/models/scaler_20260224_024200.joblib\n",
-            "  Meta   -> /Users/mohammedalketbi22/GAP/shared/data_preparation/../MLP/models/meta_20260224_024200.npz\n",
-            "\n",
-            "  Accuracy : 95.06%\n",
-            "  F1       : 0.9541\n",
-            "  AUC      : 0.9853\n",
-            "==================================================\n"
-          ]
-        }
-      ],
-      "source": [
-        "from datetime import datetime\n",
-        "\n",
-        "timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')\n",
-        "model_path  = os.path.join(MODEL_DIR, f\"mlp_{timestamp}.joblib\")\n",
-        "scaler_path = os.path.join(MODEL_DIR, f\"scaler_{timestamp}.joblib\")\n",
-        "meta_path   = os.path.join(MODEL_DIR, f\"meta_{timestamp}.npz\")\n",
-        "\n",
-        "joblib.dump(mlp,    model_path)\n",
-        "joblib.dump(scaler, scaler_path)\n",
-        "np.savez(meta_path,\n",
-        "         feature_names=SELECTED_FEATURES,\n",
-        "         test_accuracy=test_acc,\n",
-        "         test_f1=test_f1,\n",
-        "         test_auc=test_auc)\n",
-        "\n",
-        "print(\"=\" * 50)\n",
-        "print(\"  MODEL SAVED\")\n",
-        "print(\"=\" * 50)\n",
-        "print(f\"  Model  -> {model_path}\")\n",
-        "print(f\"  Scaler -> {scaler_path}\")\n",
-        "print(f\"  Meta   -> {meta_path}\")\n",
-        "print()\n",
-        "print(f\"  Accuracy : {test_acc*100:.2f}%\")\n",
-        "print(f\"  F1       : {test_f1:.4f}\")\n",
-        "print(f\"  AUC      : {test_auc:.4f}\")\n",
-        "print(\"=\" * 50)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 11. Quick Sanity Check\n",
-        "Manually inspect a few predictions to make sure the model makes sense."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 14,
-      "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "#    True         Predicted    Confidence   Match\n",
-            "--------------------------------------------------\n",
-            "0    Unfocused    Unfocused    100.0      % ✅\n",
-            "1    Focused      Focused      85.4       % ✅\n",
-            "2    Focused      Focused      99.9       % ✅\n",
-            "3    Focused      Focused      99.9       % ✅\n",
-            "4    Focused      Focused      98.3       % ✅\n",
-            "5    Focused      Focused      93.4       % ✅\n",
-            "6    Focused      Focused      96.9       % ✅\n",
-            "7    Focused      Focused      99.9       % ✅\n",
-            "8    Focused      Focused      100.0      % ✅\n",
-            "9    Unfocused    Unfocused    99.1       % ✅\n"
-          ]
-        }
-      ],
-      "source": [
-        "# Show 10 random test samples with true vs predicted label\n",
-        "np.random.seed(RANDOM_SEED)\n",
-        "sample_idx = np.random.choice(len(y_test), 10, replace=False)\n",
-        "\n",
-        "print(f\"{'#':<4} {'True':<12} {'Predicted':<12} {'Confidence':<12} {'Match'}\")\n",
-        "print(\"-\" * 50)\n",
-        "for i, idx in enumerate(sample_idx):\n",
-        "    true_label = 'Focused' if y_test[idx] == 1 else 'Unfocused'\n",
-        "    pred_label = 'Focused' if y_pred[idx] == 1 else 'Unfocused'\n",
-        "    confidence = y_pred_prob[idx] if y_pred[idx] == 1 else 1 - y_pred_prob[idx]\n",
-        "    match = '✅' if y_test[idx] == y_pred[idx] else '❌'\n",
-        "    print(f\"{i:<4} {true_label:<12} {pred_label:<12} {confidence*100:<11.1f}% {match}\")"
-      ]
-    }
-  ],
-  "metadata": {
-    "kernelspec": {
-      "display_name": "venv",
-      "language": "python",
-      "name": "python3"
-    },
-    "language_info": {
-      "codemirror_mode": {
-        "name": "ipython",
-        "version": 3
-      },
-      "file_extension": ".py",
-      "mimetype": "text/x-python",
-      "name": "python",
-      "nbconvert_exporter": "python",
-      "pygments_lexer": "ipython3",
-      "version": "3.13.7"
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 4
-}