Spaces:

FocusGuard
/

IntegrationTest

Sleeping

App Files Files Community

Yingtao-Zheng commited on 8 days ago

Commit

8bbb872

1 Parent(s): 05616fb

Upload partially updated files

Browse files

This view is limited to 50 files because it contains too many changes. See raw diff

Files changed (50) hide show

.gitignore +41 -0
Dockerfile +27 -0
api/history +0 -0
api/import +0 -0
api/sessions +0 -0
app.py +1 -0
checkpoints/hybrid_focus_config.json +10 -0
checkpoints/meta_best.npz +3 -0
checkpoints/mlp_best.pt +3 -0
checkpoints/model_best.joblib +3 -0
checkpoints/scaler_best.joblib +3 -0
checkpoints/xgboost_face_orientation_best.json +0 -0
docker-compose.yml +5 -0
eslint.config.js +29 -0
index.html +17 -0
main.py +964 -0
models/README.md +53 -0
models/__init__.py +1 -0
models/cnn/CNN_MODEL/.claude/settings.local.json +7 -0
models/cnn/CNN_MODEL/.gitattributes +1 -0
models/cnn/CNN_MODEL/.gitignore +4 -0
models/cnn/CNN_MODEL/README.md +74 -0
models/cnn/CNN_MODEL/notebooks/eye_classifier_colab.ipynb +0 -0
models/cnn/CNN_MODEL/scripts/focus_infer.py +199 -0
models/cnn/CNN_MODEL/scripts/predict_image.py +49 -0
models/cnn/CNN_MODEL/scripts/video_infer.py +281 -0
models/cnn/CNN_MODEL/scripts/webcam_live.py +184 -0
models/cnn/CNN_MODEL/weights/yolo11s-cls.pt +3 -0
models/cnn/__init__.py +0 -0
models/cnn/eye_attention/__init__.py +1 -0
models/cnn/eye_attention/classifier.py +169 -0
models/cnn/eye_attention/crop.py +70 -0
models/cnn/eye_attention/train.py +0 -0
models/cnn/notebooks/EyeCNN.ipynb +107 -0
models/cnn/notebooks/EyeCNN_Train_Evaluate_new.ipynb +0 -0
models/cnn/notebooks/EyeCNN_Training_Evaluate.ipynb +0 -0
models/cnn/notebooks/README.md +1 -0
models/collect_features.py +356 -0
models/eye_classifier.py +69 -0
models/eye_crop.py +77 -0
models/eye_scorer.py +168 -0
models/face_mesh.py +94 -0
models/head_pose.py +121 -0
models/mlp/__init__.py +0 -0
models/mlp/eval_accuracy.py +54 -0
models/mlp/sweep.py +66 -0
models/mlp/train.py +232 -0
models/xgboost/add_accuracy.py +60 -0
models/xgboost/checkpoints/face_orientation_best.json +0 -0
models/xgboost/eval_accuracy.py +54 -0

.gitignore ADDED Viewed

	@@ -0,0 +1,41 @@

+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+node_modules/
+dist/
+dist-ssr/
+*.local
+# Editor directories and files
+.vscode/
+.idea/
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+*.py[cod]
+*$py.class
+*.so
+.Python
+venv/
+.venv/
+env/
+.env
+*.egg-info/
+.eggs/
+build/
+Thumbs.db
+# Project specific
+focus_guard.db
+static/
+__pycache__/
+docs/

Dockerfile ADDED Viewed

	@@ -0,0 +1,27 @@

+FROM python:3.10-slim
+RUN useradd -m -u 1000 user
+ENV HOME=/home/user PATH=/home/user/.local/bin:$PATH
+ENV PYTHONUNBUFFERED=1
+WORKDIR /app
+RUN apt-get update && apt-get install -y --no-install-recommends libglib2.0-0 libsm6 libxrender1 libxext6 libxcb1 libgl1 libgomp1 ffmpeg libavcodec-dev libavformat-dev libavutil-dev libswscale-dev libavdevice-dev libopus-dev libvpx-dev libsrtp2-dev build-essential nodejs npm && rm -rf /var/lib/apt/lists/*
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+RUN npm install && npm run build && mkdir -p /app/static && cp -R dist/* /app/static/
+ENV FOCUSGUARD_CACHE_DIR=/app/.cache/focusguard
+RUN python -c "from models.face_mesh import _ensure_model; _ensure_model()"
+RUN mkdir -p /app/data && chown -R user:user /app
+USER user
+EXPOSE 7860
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860", "--log-level", "debug"]

api/history ADDED Viewed

File without changes

api/import ADDED Viewed

File without changes

api/sessions ADDED Viewed

File without changes

app.py ADDED Viewed

	@@ -0,0 +1 @@


1	+ from main import app

checkpoints/hybrid_focus_config.json ADDED Viewed

	@@ -0,0 +1,10 @@

+{
+  "w_mlp": 0.6000000000000001,
+  "w_geo": 0.3999999999999999,
+  "threshold": 0.35,
+  "use_yawn_veto": true,
+  "geo_face_weight": 0.4,
+  "geo_eye_weight": 0.6,
+  "mar_yawn_threshold": 0.55,
+  "metric": "f1"
+}

checkpoints/meta_best.npz ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:5d78d1df5e25536a2c82c4b8f5fd0c26dd35f44b28fd59761634cbf78c7546f8
+size 4196

checkpoints/mlp_best.pt ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:c2f55129785b6882c304483aa5399f5bf6c9ed6e73dfec7ca6f36cd0436156c8
+size 14497

checkpoints/model_best.joblib ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:183f2d4419e0eb1e58704e5a7312eb61e331523566d4dc551054a07b3aac7557
+size 5775881

checkpoints/scaler_best.joblib ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:02ed6b4c0d99e0254c6a740a949da2384db58ec7d3e6df6432b9bfcd3a296c71
+size 783

checkpoints/xgboost_face_orientation_best.json ADDED Viewed

The diff for this file is too large to render. See raw diff

docker-compose.yml ADDED Viewed

	@@ -0,0 +1,5 @@

+services:
+  focus-guard:
+    build: .
+    ports:
+      - "7860:7860"

eslint.config.js ADDED Viewed

	@@ -0,0 +1,29 @@

+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import { defineConfig, globalIgnores } from 'eslint/config'
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{js,jsx}'],
+    extends: [
+      js.configs.recommended,
+      reactHooks.configs.flat.recommended,
+      reactRefresh.configs.vite,
+    ],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+      parserOptions: {
+        ecmaVersion: 'latest',
+        ecmaFeatures: { jsx: true },
+        sourceType: 'module',
+      },
+    },
+    rules: {
+      'no-unused-vars': ['error', { varsIgnorePattern: '^[A-Z_]' }],
+    },
+  },
+])

index.html ADDED Viewed

	@@ -0,0 +1,17 @@

+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Focus Guard</title>
+  <link href="https://fonts.googleapis.com/css2?family=Nunito:wght@400;700&display=swap" rel="stylesheet">
+</head>
+<body>
+  <div id="root"></div>
+  <script type="module" src="/src/main.jsx"></script>
+</body>
+</html>

main.py ADDED Viewed

	@@ -0,0 +1,964 @@

+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException, Request
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import Optional, List, Any
+import base64
+import cv2
+import numpy as np
+import aiosqlite
+import json
+from datetime import datetime, timedelta
+import math
+import os
+from pathlib import Path
+from typing import Callable
+import asyncio
+import concurrent.futures
+import threading
+from aiortc import RTCPeerConnection, RTCSessionDescription, VideoStreamTrack
+from av import VideoFrame
+from mediapipe.tasks.python.vision import FaceLandmarksConnections
+from ui.pipeline import FaceMeshPipeline, MLPPipeline, HybridFocusPipeline, XGBoostPipeline
+from models.face_mesh import FaceMeshDetector
+# ================ FACE MESH DRAWING (server-side, for WebRTC) ================
+_FONT = cv2.FONT_HERSHEY_SIMPLEX
+_CYAN = (255, 255, 0)
+_GREEN = (0, 255, 0)
+_MAGENTA = (255, 0, 255)
+_ORANGE = (0, 165, 255)
+_RED = (0, 0, 255)
+_WHITE = (255, 255, 255)
+_LIGHT_GREEN = (144, 238, 144)
+_TESSELATION_CONNS = [(c.start, c.end) for c in FaceLandmarksConnections.FACE_LANDMARKS_TESSELATION]
+_CONTOUR_CONNS = [(c.start, c.end) for c in FaceLandmarksConnections.FACE_LANDMARKS_CONTOURS]
+_LEFT_EYEBROW = [70, 63, 105, 66, 107, 55, 65, 52, 53, 46]
+_RIGHT_EYEBROW = [300, 293, 334, 296, 336, 285, 295, 282, 283, 276]
+_NOSE_BRIDGE = [6, 197, 195, 5, 4, 1, 19, 94, 2]
+_LIPS_OUTER = [61, 146, 91, 181, 84, 17, 314, 405, 321, 375, 291, 409, 270, 269, 267, 0, 37, 39, 40, 185, 61]
+_LIPS_INNER = [78, 95, 88, 178, 87, 14, 317, 402, 318, 324, 308, 415, 310, 311, 312, 13, 82, 81, 80, 191, 78]
+_LEFT_EAR_POINTS = [33, 160, 158, 133, 153, 145]
+_RIGHT_EAR_POINTS = [362, 385, 387, 263, 373, 380]
+def _lm_px(lm, idx, w, h):
+    return (int(lm[idx, 0] * w), int(lm[idx, 1] * h))
+def _draw_polyline(frame, lm, indices, w, h, color, thickness):
+    for i in range(len(indices) - 1):
+        cv2.line(frame, _lm_px(lm, indices[i], w, h), _lm_px(lm, indices[i + 1], w, h), color, thickness, cv2.LINE_AA)
+def _draw_face_mesh(frame, lm, w, h):
+    """Draw tessellation, contours, eyebrows, nose, lips, eyes, irises, gaze lines."""
+    # Tessellation (gray triangular grid, semi-transparent)
+    overlay = frame.copy()
+    for s, e in _TESSELATION_CONNS:
+        cv2.line(overlay, _lm_px(lm, s, w, h), _lm_px(lm, e, w, h), (200, 200, 200), 1, cv2.LINE_AA)
+    cv2.addWeighted(overlay, 0.3, frame, 0.7, 0, frame)
+    # Contours
+    for s, e in _CONTOUR_CONNS:
+        cv2.line(frame, _lm_px(lm, s, w, h), _lm_px(lm, e, w, h), _CYAN, 1, cv2.LINE_AA)
+    # Eyebrows
+    _draw_polyline(frame, lm, _LEFT_EYEBROW, w, h, _LIGHT_GREEN, 2)
+    _draw_polyline(frame, lm, _RIGHT_EYEBROW, w, h, _LIGHT_GREEN, 2)
+    # Nose
+    _draw_polyline(frame, lm, _NOSE_BRIDGE, w, h, _ORANGE, 1)
+    # Lips
+    _draw_polyline(frame, lm, _LIPS_OUTER, w, h, _MAGENTA, 1)
+    _draw_polyline(frame, lm, _LIPS_INNER, w, h, (200, 0, 200), 1)
+    # Eyes
+    left_pts = np.array([_lm_px(lm, i, w, h) for i in FaceMeshDetector.LEFT_EYE_INDICES], dtype=np.int32)
+    cv2.polylines(frame, [left_pts], True, _GREEN, 2, cv2.LINE_AA)
+    right_pts = np.array([_lm_px(lm, i, w, h) for i in FaceMeshDetector.RIGHT_EYE_INDICES], dtype=np.int32)
+    cv2.polylines(frame, [right_pts], True, _GREEN, 2, cv2.LINE_AA)
+    # EAR key points
+    for indices in [_LEFT_EAR_POINTS, _RIGHT_EAR_POINTS]:
+        for idx in indices:
+            cv2.circle(frame, _lm_px(lm, idx, w, h), 3, (0, 255, 255), -1, cv2.LINE_AA)
+    # Irises + gaze lines
+    for iris_idx, eye_inner, eye_outer in [
+        (FaceMeshDetector.LEFT_IRIS_INDICES, 133, 33),
+        (FaceMeshDetector.RIGHT_IRIS_INDICES, 362, 263),
+    ]:
+        iris_pts = np.array([_lm_px(lm, i, w, h) for i in iris_idx], dtype=np.int32)
+        center = iris_pts[0]
+        if len(iris_pts) >= 5:
+            radii = [np.linalg.norm(iris_pts[j] - center) for j in range(1, 5)]
+            radius = max(int(np.mean(radii)), 2)
+            cv2.circle(frame, tuple(center), radius, _MAGENTA, 2, cv2.LINE_AA)
+            cv2.circle(frame, tuple(center), 2, _WHITE, -1, cv2.LINE_AA)
+        eye_cx = int((lm[eye_inner, 0] + lm[eye_outer, 0]) / 2.0 * w)
+        eye_cy = int((lm[eye_inner, 1] + lm[eye_outer, 1]) / 2.0 * h)
+        dx, dy = center[0] - eye_cx, center[1] - eye_cy
+        cv2.line(frame, tuple(center), (int(center[0] + dx * 3), int(center[1] + dy * 3)), _RED, 1, cv2.LINE_AA)
+def _draw_hud(frame, result, model_name):
+    """Draw status bar and detail overlay matching live_demo.py."""
+    h, w = frame.shape[:2]
+    is_focused = result["is_focused"]
+    status = "FOCUSED" if is_focused else "NOT FOCUSED"
+    color = _GREEN if is_focused else _RED
+    # Top bar
+    cv2.rectangle(frame, (0, 0), (w, 55), (0, 0, 0), -1)
+    cv2.putText(frame, status, (10, 28), _FONT, 0.8, color, 2, cv2.LINE_AA)
+    cv2.putText(frame, model_name.upper(), (w - 150, 28), _FONT, 0.45, _WHITE, 1, cv2.LINE_AA)
+    # Detail line
+    conf = result.get("mlp_prob", result.get("raw_score", 0.0))
+    mar_s = f" MAR:{result['mar']:.2f}" if result.get("mar") is not None else ""
+    sf = result.get("s_face", 0)
+    se = result.get("s_eye", 0)
+    detail = f"conf:{conf:.2f} S_face:{sf:.2f} S_eye:{se:.2f}{mar_s}"
+    cv2.putText(frame, detail, (10, 48), _FONT, 0.4, _WHITE, 1, cv2.LINE_AA)
+    # Head pose (top right)
+    if result.get("yaw") is not None:
+        cv2.putText(frame, f"yaw:{result['yaw']:+.0f} pitch:{result['pitch']:+.0f} roll:{result['roll']:+.0f}",
+                    (w - 280, 48), _FONT, 0.4, (180, 180, 180), 1, cv2.LINE_AA)
+    # Yawn indicator
+    if result.get("is_yawning"):
+        cv2.putText(frame, "YAWN", (10, 75), _FONT, 0.7, _ORANGE, 2, cv2.LINE_AA)
+# Landmark indices used for face mesh drawing on client (union of all groups).
+# Sending only these instead of all 478 saves ~60% of the landmarks payload.
+_MESH_INDICES = sorted(set(
+    [10,338,297,332,284,251,389,356,454,323,361,288,397,365,379,378,400,377,152,148,176,149,150,136,172,58,132,93,234,127,162,21,54,103,67,109]  # face oval
+    + [33,7,163,144,145,153,154,155,133,173,157,158,159,160,161,246]  # left eye
+    + [362,382,381,380,374,373,390,249,263,466,388,387,386,385,384,398]  # right eye
+    + [468,469,470,471,472, 473,474,475,476,477]  # irises
+    + [70,63,105,66,107,55,65,52,53,46]  # left eyebrow
+    + [300,293,334,296,336,285,295,282,283,276]  # right eyebrow
+    + [6,197,195,5,4,1,19,94,2]  # nose bridge
+    + [61,146,91,181,84,17,314,405,321,375,291,409,270,269,267,0,37,39,40,185]  # lips outer
+    + [78,95,88,178,87,14,317,402,318,324,308,415,310,311,312,13,82,81,80,191]  # lips inner
+    + [33,160,158,133,153,145]  # left EAR key points
+    + [362,385,387,263,373,380]  # right EAR key points
+))
+# Build a lookup: original_index -> position in sparse array, so client can reconstruct.
+_MESH_INDEX_SET = set(_MESH_INDICES)
+# Initialize FastAPI app
+app = FastAPI(title="Focus Guard API")
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+# Global variables
+db_path = "focus_guard.db"
+pcs = set()
+_cached_model_name = "mlp"  # in-memory cache, updated via /api/settings
+async def _wait_for_ice_gathering(pc: RTCPeerConnection):
+    if pc.iceGatheringState == "complete":
+        return
+    done = asyncio.Event()
+    @pc.on("icegatheringstatechange")
+    def _on_state_change():
+        if pc.iceGatheringState == "complete":
+            done.set()
+    await done.wait()
+# ================ DATABASE MODELS ================
+async def init_database():
+    """Initialize SQLite database with required tables"""
+    async with aiosqlite.connect(db_path) as db:
+        # FocusSessions table
+        await db.execute("""
+            CREATE TABLE IF NOT EXISTS focus_sessions (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                start_time TIMESTAMP NOT NULL,
+                end_time TIMESTAMP,
+                duration_seconds INTEGER DEFAULT 0,
+                focus_score REAL DEFAULT 0.0,
+                total_frames INTEGER DEFAULT 0,
+                focused_frames INTEGER DEFAULT 0,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+        # FocusEvents table
+        await db.execute("""
+            CREATE TABLE IF NOT EXISTS focus_events (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                session_id INTEGER NOT NULL,
+                timestamp TIMESTAMP NOT NULL,
+                is_focused BOOLEAN NOT NULL,
+                confidence REAL NOT NULL,
+                detection_data TEXT,
+                FOREIGN KEY (session_id) REFERENCES focus_sessions (id)
+            )
+        """)
+        # UserSettings table
+        await db.execute("""
+            CREATE TABLE IF NOT EXISTS user_settings (
+                id INTEGER PRIMARY KEY CHECK (id = 1),
+                sensitivity INTEGER DEFAULT 6,
+                notification_enabled BOOLEAN DEFAULT 1,
+                notification_threshold INTEGER DEFAULT 30,
+                frame_rate INTEGER DEFAULT 30,
+                model_name TEXT DEFAULT 'mlp'
+            )
+        """)
+        # Insert default settings if not exists
+        await db.execute("""
+            INSERT OR IGNORE INTO user_settings (id, sensitivity, notification_enabled, notification_threshold, frame_rate, model_name)
+            VALUES (1, 6, 1, 30, 30, 'mlp')
+        """)
+        await db.commit()
+# ================ PYDANTIC MODELS ================
+class SessionCreate(BaseModel):
+    pass
+class SessionEnd(BaseModel):
+    session_id: int
+class SettingsUpdate(BaseModel):
+    sensitivity: Optional[int] = None
+    notification_enabled: Optional[bool] = None
+    notification_threshold: Optional[int] = None
+    frame_rate: Optional[int] = None
+    model_name: Optional[str] = None
+class VideoTransformTrack(VideoStreamTrack):
+    def __init__(self, track, session_id: int, get_channel: Callable[[], Any]):
+        super().__init__()
+        self.track = track
+        self.session_id = session_id
+        self.get_channel = get_channel
+        self.last_inference_time = 0
+        self.min_inference_interval = 1 / 60
+        self.last_frame = None
+    async def recv(self):
+        frame = await self.track.recv()
+        img = frame.to_ndarray(format="bgr24")
+        if img is None:
+            return frame
+        # Normalize size for inference/drawing
+        img = cv2.resize(img, (640, 480))
+        now = datetime.now().timestamp()
+        do_infer = (now - self.last_inference_time) >= self.min_inference_interval
+        if do_infer:
+            self.last_inference_time = now
+            model_name = _cached_model_name
+            if model_name not in pipelines or pipelines.get(model_name) is None:
+                model_name = 'mlp'
+            active_pipeline = pipelines.get(model_name)
+            if active_pipeline is not None:
+                loop = asyncio.get_event_loop()
+                out = await loop.run_in_executor(
+                    _inference_executor,
+                    _process_frame_safe,
+                    active_pipeline,
+                    img,
+                    model_name,
+                )
+                is_focused = out["is_focused"]
+                confidence = out.get("mlp_prob", out.get("raw_score", 0.0))
+                metadata = {"s_face": out.get("s_face", 0.0), "s_eye": out.get("s_eye", 0.0), "mar": out.get("mar", 0.0), "model": model_name}
+                # Draw face mesh + HUD on the video frame
+                h_f, w_f = img.shape[:2]
+                lm = out.get("landmarks")
+                if lm is not None:
+                    _draw_face_mesh(img, lm, w_f, h_f)
+                _draw_hud(img, out, model_name)
+            else:
+                is_focused = False
+                confidence = 0.0
+                metadata = {"model": model_name}
+                cv2.rectangle(img, (0, 0), (img.shape[1], 55), (0, 0, 0), -1)
+                cv2.putText(img, "NO MODEL", (10, 28), _FONT, 0.8, _RED, 2, cv2.LINE_AA)
+            if self.session_id:
+                await store_focus_event(self.session_id, is_focused, confidence, metadata)
+            channel = self.get_channel()
+            if channel and channel.readyState == "open":
+                try:
+                    channel.send(json.dumps({"type": "detection", "focused": is_focused, "confidence": round(confidence, 3), "detections": detections}))
+                except Exception:
+                    pass
+            self.last_frame = img
+        elif self.last_frame is not None:
+            img = self.last_frame
+        new_frame = VideoFrame.from_ndarray(img, format="bgr24")
+        new_frame.pts = frame.pts
+        new_frame.time_base = frame.time_base
+        return new_frame
+# ================ DATABASE OPERATIONS ================
+async def create_session():
+    async with aiosqlite.connect(db_path) as db:
+        cursor = await db.execute(
+            "INSERT INTO focus_sessions (start_time) VALUES (?)",
+            (datetime.now().isoformat(),)
+        )
+        await db.commit()
+        return cursor.lastrowid
+async def end_session(session_id: int):
+    async with aiosqlite.connect(db_path) as db:
+        cursor = await db.execute(
+            "SELECT start_time, total_frames, focused_frames FROM focus_sessions WHERE id = ?",
+            (session_id,)
+        )
+        row = await cursor.fetchone()
+        if not row:
+            return None
+        start_time_str, total_frames, focused_frames = row
+        start_time = datetime.fromisoformat(start_time_str)
+        end_time = datetime.now()
+        duration = (end_time - start_time).total_seconds()
+        focus_score = focused_frames / total_frames if total_frames > 0 else 0.0
+        await db.execute("""
+            UPDATE focus_sessions
+            SET end_time = ?, duration_seconds = ?, focus_score = ?
+            WHERE id = ?
+        """, (end_time.isoformat(), int(duration), focus_score, session_id))
+        await db.commit()
+        return {
+            'session_id': session_id,
+            'start_time': start_time_str,
+            'end_time': end_time.isoformat(),
+            'duration_seconds': int(duration),
+            'focus_score': round(focus_score, 3),
+            'total_frames': total_frames,
+            'focused_frames': focused_frames
+        }
+async def store_focus_event(session_id: int, is_focused: bool, confidence: float, metadata: dict):
+    async with aiosqlite.connect(db_path) as db:
+        await db.execute("""
+            INSERT INTO focus_events (session_id, timestamp, is_focused, confidence, detection_data)
+            VALUES (?, ?, ?, ?, ?)
+        """, (session_id, datetime.now().isoformat(), is_focused, confidence, json.dumps(metadata)))
+        await db.execute("""
+            UPDATE focus_sessions
+            SET total_frames = total_frames + 1,
+                focused_frames = focused_frames + ?
+            WHERE id = ?
+        """, (1 if is_focused else 0, session_id))
+        await db.commit()
+class _EventBuffer:
+    """Buffer focus events in memory and flush to DB in batches to avoid per-frame DB writes."""
+    def __init__(self, flush_interval: float = 2.0):
+        self._buf: list = []
+        self._lock = asyncio.Lock()
+        self._flush_interval = flush_interval
+        self._task: asyncio.Task | None = None
+        self._total_frames = 0
+        self._focused_frames = 0
+    def start(self):
+        if self._task is None:
+            self._task = asyncio.create_task(self._flush_loop())
+    async def stop(self):
+        if self._task:
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+            self._task = None
+        await self._flush()
+    def add(self, session_id: int, is_focused: bool, confidence: float, metadata: dict):
+        self._buf.append((session_id, datetime.now().isoformat(), is_focused, confidence, json.dumps(metadata)))
+        self._total_frames += 1
+        if is_focused:
+            self._focused_frames += 1
+    async def _flush_loop(self):
+        while True:
+            await asyncio.sleep(self._flush_interval)
+            await self._flush()
+    async def _flush(self):
+        async with self._lock:
+            if not self._buf:
+                return
+            batch = self._buf[:]
+            total = self._total_frames
+            focused = self._focused_frames
+            self._buf.clear()
+            self._total_frames = 0
+            self._focused_frames = 0
+        if not batch:
+            return
+        session_id = batch[0][0]
+        try:
+            async with aiosqlite.connect(db_path) as db:
+                await db.executemany("""
+                    INSERT INTO focus_events (session_id, timestamp, is_focused, confidence, detection_data)
+                    VALUES (?, ?, ?, ?, ?)
+                """, batch)
+                await db.execute("""
+                    UPDATE focus_sessions
+                    SET total_frames = total_frames + ?,
+                        focused_frames = focused_frames + ?
+                    WHERE id = ?
+                """, (total, focused, session_id))
+                await db.commit()
+        except Exception as e:
+            print(f"[DB] Flush error: {e}")
+# ================ STARTUP/SHUTDOWN ================
+pipelines = {
+    "geometric": None,
+    "mlp": None,
+    "hybrid": None,
+    "xgboost": None,
+}
+# Thread pool for CPU-bound inference so the event loop stays responsive.
+_inference_executor = concurrent.futures.ThreadPoolExecutor(
+    max_workers=4,
+    thread_name_prefix="inference",
+)
+# One lock per pipeline so shared state (TemporalTracker, etc.) is not corrupted when
+# multiple frames are processed in parallel by the thread pool.
+_pipeline_locks = {name: threading.Lock() for name in ("geometric", "mlp", "hybrid", "xgboost")}
+def _process_frame_safe(pipeline, frame, model_name: str):
+    """Run process_frame in executor with per-pipeline lock."""
+    with _pipeline_locks[model_name]:
+        return pipeline.process_frame(frame)
+@app.on_event("startup")
+async def startup_event():
+    global pipelines, _cached_model_name
+    print(" Starting Focus Guard API...")
+    await init_database()
+    # Load cached model name from DB
+    async with aiosqlite.connect(db_path) as db:
+        cursor = await db.execute("SELECT model_name FROM user_settings WHERE id = 1")
+        row = await cursor.fetchone()
+        if row:
+            _cached_model_name = row[0]
+    print("[OK] Database initialized")
+    try:
+        pipelines["geometric"] = FaceMeshPipeline()
+        print("[OK] FaceMeshPipeline (geometric) loaded")
+    except Exception as e:
+        print(f"[WARN] FaceMeshPipeline unavailable: {e}")
+    try:
+        pipelines["mlp"] = MLPPipeline()
+        print("[OK] MLPPipeline loaded")
+    except Exception as e:
+        print(f"[ERR] Failed to load MLPPipeline: {e}")
+    try:
+        pipelines["hybrid"] = HybridFocusPipeline()
+        print("[OK] HybridFocusPipeline loaded")
+    except Exception as e:
+        print(f"[WARN] HybridFocusPipeline unavailable: {e}")
+    try:
+        pipelines["xgboost"] = XGBoostPipeline()
+        print("[OK] XGBoostPipeline loaded")
+    except Exception as e:
+        print(f"[ERR] Failed to load XGBoostPipeline: {e}")
+@app.on_event("shutdown")
+async def shutdown_event():
+    _inference_executor.shutdown(wait=False)
+    print(" Shutting down Focus Guard API...")
+# ================ WEBRTC SIGNALING ================
+@app.post("/api/webrtc/offer")
+async def webrtc_offer(offer: dict):
+    try:
+        print(f"Received WebRTC offer")
+        pc = RTCPeerConnection()
+        pcs.add(pc)
+        session_id = await create_session()
+        print(f"Created session: {session_id}")
+        channel_ref = {"channel": None}
+        @pc.on("datachannel")
+        def on_datachannel(channel):
+            print(f"Data channel opened")
+            channel_ref["channel"] = channel
+        @pc.on("track")
+        def on_track(track):
+            print(f"Received track: {track.kind}")
+            if track.kind == "video":
+                local_track = VideoTransformTrack(track, session_id, lambda: channel_ref["channel"])
+                pc.addTrack(local_track)
+                print(f"Video track added")
+            @track.on("ended")
+            async def on_ended():
+                print(f"Track ended")
+        @pc.on("connectionstatechange")
+        async def on_connectionstatechange():
+            print(f"Connection state changed: {pc.connectionState}")
+            if pc.connectionState in ("failed", "closed", "disconnected"):
+                try:
+                    await end_session(session_id)
+                except Exception as e:
+                    print(f"⚠Error ending session: {e}")
+                pcs.discard(pc)
+                await pc.close()
+        await pc.setRemoteDescription(RTCSessionDescription(sdp=offer["sdp"], type=offer["type"]))
+        print(f"Remote description set")
+        answer = await pc.createAnswer()
+        await pc.setLocalDescription(answer)
+        print(f"Answer created")
+        await _wait_for_ice_gathering(pc)
+        print(f"ICE gathering complete")
+        return {"sdp": pc.localDescription.sdp, "type": pc.localDescription.type, "session_id": session_id}
+    except Exception as e:
+        print(f"WebRTC offer error: {e}")
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"WebRTC error: {str(e)}")
+# ================ WEBSOCKET ================
+@app.websocket("/ws/video")
+async def websocket_endpoint(websocket: WebSocket):
+    await websocket.accept()
+    session_id = None
+    frame_count = 0
+    running = True
+    event_buffer = _EventBuffer(flush_interval=2.0)
+    # Latest frame slot — only the most recent frame is kept, older ones are dropped.
+    # Using a dict so nested functions can mutate without nonlocal issues.
+    _slot = {"frame": None}
+    _frame_ready = asyncio.Event()
+    async def _receive_loop():
+        """Receive messages as fast as possible. Binary = frame, text = control."""
+        nonlocal session_id, running
+        try:
+            while running:
+                msg = await websocket.receive()
+                msg_type = msg.get("type", "")
+                if msg_type == "websocket.disconnect":
+                    running = False
+                    _frame_ready.set()
+                    return
+                # Binary message → JPEG frame (fast path, no base64)
+                raw_bytes = msg.get("bytes")
+                if raw_bytes is not None and len(raw_bytes) > 0:
+                    _slot["frame"] = raw_bytes
+                    _frame_ready.set()
+                    continue
+                # Text message → JSON control command (or legacy base64 frame)
+                text = msg.get("text")
+                if not text:
+                    continue
+                data = json.loads(text)
+                if data["type"] == "frame":
+                    # Legacy base64 path (fallback)
+                    _slot["frame"] = base64.b64decode(data["image"])
+                    _frame_ready.set()
+                elif data["type"] == "start_session":
+                    session_id = await create_session()
+                    event_buffer.start()
+                    for p in pipelines.values():
+                        if p is not None and hasattr(p, "reset_session"):
+                            p.reset_session()
+                    await websocket.send_json({"type": "session_started", "session_id": session_id})
+                elif data["type"] == "end_session":
+                    if session_id:
+                        await event_buffer.stop()
+                        summary = await end_session(session_id)
+                        if summary:
+                            await websocket.send_json({"type": "session_ended", "summary": summary})
+                        session_id = None
+        except WebSocketDisconnect:
+            running = False
+            _frame_ready.set()
+        except Exception as e:
+            print(f"[WS] receive error: {e}")
+            running = False
+            _frame_ready.set()
+    async def _process_loop():
+        """Process only the latest frame, dropping stale ones."""
+        nonlocal frame_count, running
+        loop = asyncio.get_event_loop()
+        while running:
+            await _frame_ready.wait()
+            _frame_ready.clear()
+            if not running:
+                return
+            # Grab latest frame and clear slot
+            raw = _slot["frame"]
+            _slot["frame"] = None
+            if raw is None:
+                continue
+            try:
+                nparr = np.frombuffer(raw, np.uint8)
+                frame = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+                if frame is None:
+                    continue
+                frame = cv2.resize(frame, (640, 480))
+                model_name = _cached_model_name
+                if model_name not in pipelines or pipelines.get(model_name) is None:
+                    model_name = "mlp"
+                active_pipeline = pipelines.get(model_name)
+                landmarks_list = None
+                if active_pipeline is not None:
+                    out = await loop.run_in_executor(
+                        _inference_executor,
+                        _process_frame_safe,
+                        active_pipeline,
+                        frame,
+                        model_name,
+                    )
+                    is_focused = out["is_focused"]
+                    confidence = out.get("mlp_prob", out.get("raw_score", 0.0))
+                    lm = out.get("landmarks")
+                    if lm is not None:
+                        # Send all 478 landmarks as flat array for tessellation drawing
+                        landmarks_list = [
+                            [round(float(lm[i, 0]), 3), round(float(lm[i, 1]), 3)]
+                            for i in range(lm.shape[0])
+                        ]
+                    if session_id:
+                        event_buffer.add(session_id, is_focused, confidence, {
+                            "s_face": out.get("s_face", 0.0),
+                            "s_eye": out.get("s_eye", 0.0),
+                            "mar": out.get("mar", 0.0),
+                            "model": model_name,
+                        })
+                else:
+                    is_focused = False
+                    confidence = 0.0
+                resp = {
+                    "type": "detection",
+                    "focused": is_focused,
+                    "confidence": round(confidence, 3),
+                    "model": model_name,
+                    "fc": frame_count,
+                }
+                if active_pipeline is not None:
+                    # Send detailed metrics for HUD
+                    if out.get("yaw") is not None:
+                        resp["yaw"] = round(out["yaw"], 1)
+                        resp["pitch"] = round(out["pitch"], 1)
+                        resp["roll"] = round(out["roll"], 1)
+                    if out.get("mar") is not None:
+                        resp["mar"] = round(out["mar"], 3)
+                    resp["sf"] = round(out.get("s_face", 0), 3)
+                    resp["se"] = round(out.get("s_eye", 0), 3)
+                if landmarks_list is not None:
+                    resp["lm"] = landmarks_list
+                await websocket.send_json(resp)
+                frame_count += 1
+            except Exception as e:
+                print(f"[WS] process error: {e}")
+    try:
+        await asyncio.gather(_receive_loop(), _process_loop())
+    except Exception:
+        pass
+    finally:
+        running = False
+        if session_id:
+            await event_buffer.stop()
+            await end_session(session_id)
+# ================ API ENDPOINTS ================
+@app.post("/api/sessions/start")
+async def api_start_session():
+    session_id = await create_session()
+    return {"session_id": session_id}
+@app.post("/api/sessions/end")
+async def api_end_session(data: SessionEnd):
+    summary = await end_session(data.session_id)
+    if not summary: raise HTTPException(status_code=404, detail="Session not found")
+    return summary
+@app.get("/api/sessions")
+async def get_sessions(filter: str = "all", limit: int = 50, offset: int = 0):
+    async with aiosqlite.connect(db_path) as db:
+        db.row_factory = aiosqlite.Row
+        # NEW: If importing/exporting all, remove limit if special flag or high limit
+        # For simplicity: if limit is -1, return all
+        limit_clause = "LIMIT ? OFFSET ?"
+        params = []
+        base_query = "SELECT * FROM focus_sessions"
+        where_clause = ""
+        if filter == "today":
+            date_filter = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+            where_clause = " WHERE start_time >= ?"
+            params.append(date_filter.isoformat())
+        elif filter == "week":
+            date_filter = datetime.now() - timedelta(days=7)
+            where_clause = " WHERE start_time >= ?"
+            params.append(date_filter.isoformat())
+        elif filter == "month":
+            date_filter = datetime.now() - timedelta(days=30)
+            where_clause = " WHERE start_time >= ?"
+            params.append(date_filter.isoformat())
+        elif filter == "all":
+            # Just ensure we only get completed sessions or all sessions
+            where_clause = " WHERE end_time IS NOT NULL"
+        query = f"{base_query}{where_clause} ORDER BY start_time DESC"
+        # Handle Limit for Exports
+        if limit == -1:
+            # No limit clause for export
+            pass
+        else:
+            query += f" {limit_clause}"
+            params.extend([limit, offset])
+        cursor = await db.execute(query, tuple(params))
+        rows = await cursor.fetchall()
+        return [dict(row) for row in rows]
+# --- NEW: Import Endpoint ---
+@app.post("/api/import")
+async def import_sessions(sessions: List[dict]):
+    count = 0
+    try:
+        async with aiosqlite.connect(db_path) as db:
+            for session in sessions:
+                # Use .get() to handle potential missing fields from older versions or edits
+                await db.execute("""
+                    INSERT INTO focus_sessions (start_time, end_time, duration_seconds, focus_score, total_frames, focused_frames, created_at)
+                    VALUES (?, ?, ?, ?, ?, ?, ?)
+                """, (
+                    session.get('start_time'),
+                    session.get('end_time'),
+                    session.get('duration_seconds', 0),
+                    session.get('focus_score', 0.0),
+                    session.get('total_frames', 0),
+                    session.get('focused_frames', 0),
+                    session.get('created_at', session.get('start_time'))
+                ))
+                count += 1
+            await db.commit()
+        return {"status": "success", "count": count}
+    except Exception as e:
+        print(f"Import Error: {e}")
+        return {"status": "error", "message": str(e)}
+# --- NEW: Clear History Endpoint ---
+@app.delete("/api/history")
+async def clear_history():
+    try:
+        async with aiosqlite.connect(db_path) as db:
+            # Delete events first (foreign key good practice)
+            await db.execute("DELETE FROM focus_events")
+            await db.execute("DELETE FROM focus_sessions")
+            await db.commit()
+        return {"status": "success", "message": "History cleared"}
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+@app.get("/api/sessions/{session_id}")
+async def get_session(session_id: int):
+    async with aiosqlite.connect(db_path) as db:
+        db.row_factory = aiosqlite.Row
+        cursor = await db.execute("SELECT * FROM focus_sessions WHERE id = ?", (session_id,))
+        row = await cursor.fetchone()
+        if not row: raise HTTPException(status_code=404, detail="Session not found")
+        session = dict(row)
+        cursor = await db.execute("SELECT * FROM focus_events WHERE session_id = ? ORDER BY timestamp", (session_id,))
+        events = [dict(r) for r in await cursor.fetchall()]
+        session['events'] = events
+        return session
+@app.get("/api/settings")
+async def get_settings():
+    async with aiosqlite.connect(db_path) as db:
+        db.row_factory = aiosqlite.Row
+        cursor = await db.execute("SELECT * FROM user_settings WHERE id = 1")
+        row = await cursor.fetchone()
+        if row: return dict(row)
+        else: return {'sensitivity': 6, 'notification_enabled': True, 'notification_threshold': 30, 'frame_rate': 30, 'model_name': 'mlp'}
+@app.put("/api/settings")
+async def update_settings(settings: SettingsUpdate):
+    async with aiosqlite.connect(db_path) as db:
+        cursor = await db.execute("SELECT id FROM user_settings WHERE id = 1")
+        exists = await cursor.fetchone()
+        if not exists:
+            await db.execute("INSERT INTO user_settings (id, sensitivity) VALUES (1, 6)")
+            await db.commit()
+        updates = []
+        params = []
+        if settings.sensitivity is not None:
+            updates.append("sensitivity = ?")
+            params.append(max(1, min(10, settings.sensitivity)))
+        if settings.notification_enabled is not None:
+            updates.append("notification_enabled = ?")
+            params.append(settings.notification_enabled)
+        if settings.notification_threshold is not None:
+            updates.append("notification_threshold = ?")
+            params.append(max(5, min(300, settings.notification_threshold)))
+        if settings.frame_rate is not None:
+            updates.append("frame_rate = ?")
+            params.append(max(5, min(60, settings.frame_rate)))
+        if settings.model_name is not None and settings.model_name in pipelines and pipelines[settings.model_name] is not None:
+            updates.append("model_name = ?")
+            params.append(settings.model_name)
+            global _cached_model_name
+            _cached_model_name = settings.model_name
+        if updates:
+            query = f"UPDATE user_settings SET {', '.join(updates)} WHERE id = 1"
+            await db.execute(query, params)
+            await db.commit()
+        return {"status": "success", "updated": len(updates) > 0}
+@app.get("/api/stats/summary")
+async def get_stats_summary():
+    async with aiosqlite.connect(db_path) as db:
+        cursor = await db.execute("SELECT COUNT(*) FROM focus_sessions WHERE end_time IS NOT NULL")
+        total_sessions = (await cursor.fetchone())[0]
+        cursor = await db.execute("SELECT SUM(duration_seconds) FROM focus_sessions WHERE end_time IS NOT NULL")
+        total_focus_time = (await cursor.fetchone())[0] or 0
+        cursor = await db.execute("SELECT AVG(focus_score) FROM focus_sessions WHERE end_time IS NOT NULL")
+        avg_focus_score = (await cursor.fetchone())[0] or 0.0
+        cursor = await db.execute("SELECT DISTINCT DATE(start_time) as session_date FROM focus_sessions WHERE end_time IS NOT NULL ORDER BY session_date DESC")
+        dates = [row[0] for row in await cursor.fetchall()]
+        streak_days = 0
+        if dates:
+            current_date = datetime.now().date()
+            for i, date_str in enumerate(dates):
+                session_date = datetime.fromisoformat(date_str).date()
+                expected_date = current_date - timedelta(days=i)
+                if session_date == expected_date: streak_days += 1
+                else: break
+        return {
+            'total_sessions': total_sessions,
+            'total_focus_time': int(total_focus_time),
+            'avg_focus_score': round(avg_focus_score, 3),
+            'streak_days': streak_days
+        }
+@app.get("/api/models")
+async def get_available_models():
+    """Return list of loaded model names and which is currently active."""
+    available = [name for name, p in pipelines.items() if p is not None]
+    async with aiosqlite.connect(db_path) as db:
+        cursor = await db.execute("SELECT model_name FROM user_settings WHERE id = 1")
+        row = await cursor.fetchone()
+        current = row[0] if row else "mlp"
+        if current not in available and available:
+            current = available[0]
+    return {"available": available, "current": current}
+@app.get("/api/mesh-topology")
+async def get_mesh_topology():
+    """Return tessellation edge pairs for client-side face mesh drawing (cached by client)."""
+    return {"tessellation": _TESSELATION_CONNS}
+@app.get("/health")
+async def health_check():
+    available = [name for name, p in pipelines.items() if p is not None]
+    return {"status": "healthy", "models_loaded": available, "database": os.path.exists(db_path)}
+# ================ STATIC FILES (SPA SUPPORT) ================
+# Resolve static dir from this file so it works regardless of cwd
+_STATIC_DIR = Path(__file__).resolve().parent / "static"
+_ASSETS_DIR = _STATIC_DIR / "assets"
+# 1. Mount the assets folder (JS/CSS) first so /assets/* is never caught by catch-all
+if _ASSETS_DIR.is_dir():
+    app.mount("/assets", StaticFiles(directory=str(_ASSETS_DIR)), name="assets")
+# 2. Catch-all for SPA: serve index.html for app routes, never for /assets (would break JS MIME type)
+@app.get("/{full_path:path}")
+async def serve_react_app(full_path: str, request: Request):
+    if full_path.startswith("api") or full_path.startswith("ws"):
+        raise HTTPException(status_code=404, detail="Not Found")
+    # Don't serve HTML for asset paths; let them 404 so we don't break module script loading
+    if full_path.startswith("assets") or full_path.startswith("assets/"):
+        raise HTTPException(status_code=404, detail="Not Found")
+    index_path = _STATIC_DIR / "index.html"
+    if index_path.is_file():
+        return FileResponse(str(index_path))
+    return {"message": "React app not found. Please run 'npm run build' and copy dist to static."}

models/README.md ADDED Viewed

	@@ -0,0 +1,53 @@

+# models/
+Feature extraction modules and model training scripts.
+## 1. Feature Extraction
+Root-level modules form the real-time inference pipeline:
+| Module | Input | Output |
+|--------|-------|--------|
+| `face_mesh.py` | BGR frame | 478 MediaPipe landmarks |
+| `head_pose.py` | Landmarks, frame size | yaw, pitch, roll, face/eye score, gaze offset, head deviation |
+| `eye_scorer.py` | Landmarks | EAR (left/right/avg), gaze ratio (h/v), MAR |
+| `eye_crop.py` | Landmarks, frame | Cropped eye region images |
+| `eye_classifier.py` | Eye crops or landmarks | Eye open/closed prediction (geometric fallback) |
+| `collect_features.py` | BGR frame | 17-d feature vector + temporal features (PERCLOS, blink rate, etc.) |
+## 2. Training Scripts
+| Folder | Model | Command |
+|--------|-------|---------|
+| `mlp/` | PyTorch MLP (64→32, 2-class) | `python -m models.mlp.train` |
+| `xgboost/` | XGBoost (600 trees, depth 8) | `python -m models.xgboost.train` |
+### mlp/
+- `train.py` — training loop with early stopping, ClearML opt-in
+- `sweep.py` — hyperparameter search (Optuna: lr, batch_size)
+- `eval_accuracy.py` — load checkpoint and print test metrics
+- Saves to **`checkpoints/mlp_best.pt`**
+### xgboost/
+- `train.py` — training with eval-set logging
+- `sweep.py` / `sweep_local.py` — hyperparameter search (Optuna + ClearML)
+- `eval_accuracy.py` — load checkpoint and print test metrics
+- Saves to **`checkpoints/xgboost_face_orientation_best.json`**
+## 3. Data Loading
+All training scripts import from `data_preparation.prepare_dataset`:
+```python
+from data_preparation.prepare_dataset import get_numpy_splits   # XGBoost
+from data_preparation.prepare_dataset import get_dataloaders     # MLP (PyTorch)
+```
+## 4. Results
+| Model | Test Accuracy | F1 | ROC-AUC |
+|-------|--------------|-----|---------|
+| XGBoost | 95.87% | 0.959 | 0.991 |
+| MLP | 92.92% | 0.929 | 0.971 |

models/__init__.py ADDED Viewed

	@@ -0,0 +1 @@


1	+

models/cnn/CNN_MODEL/.claude/settings.local.json ADDED Viewed

	@@ -0,0 +1,7 @@

+{
+  "permissions": {
+    "allow": [
+      "Bash(# Check Dataset_subset counts echo \"\"=== Dataset_subset/train/open ===\"\" && ls /Users/mohammedalketbi22/Downloads/GAP_Large_project-feature-dataset-model-test-92_30-clean/Dataset_subset/train/open/ | wc -l && echo \"\"=== Dataset_subset/train/closed ===\"\" && ls /Users/mohammedalketbi22/Downloads/GAP_Large_project-feature-dataset-model-test-92_30-clean/Dataset_subset/train/closed/ | wc -l && echo \"\"=== Dataset_subset/val/open ===\"\" && ls /Users/mohammedalketbi22/Downloads/GAP_Large_project-feature-dataset-model-test-92_30-clean/Dataset_subset/val/open/ | wc -l && echo \"\"=== Dataset_subset/val/closed ===\"\" && ls /Users/mohammedalketbi22/Downloads/GAP_Large_project-feature-dataset-model-test-92_30-clean/Dataset_subset/val/closed/)"
+    ]
+  }
+}

models/cnn/CNN_MODEL/.gitattributes ADDED Viewed

	@@ -0,0 +1 @@


1	+ DATA/** filter=lfs diff=lfs merge=lfs -text

models/cnn/CNN_MODEL/.gitignore ADDED Viewed

	@@ -0,0 +1,4 @@

+Dataset/train/
+Dataset/val/
+Dataset/test/
+.DS_Store

models/cnn/CNN_MODEL/README.md ADDED Viewed

	@@ -0,0 +1,74 @@

+# Eye Open / Closed Classifier (YOLOv11-CLS)
+Binary classifier: **open** vs **closed** eyes.
+Used as a baseline for eye-tracking, drowsiness, or focus detection.
+---
+## Model team task
+- **Train** the YOLOv11s-cls eye classifier in a **separate notebook** (data split, epochs, GPU, export `best.pt`).
+- Provide **trained weights** (`best.pt`) for this repo’s evaluation and inference scripts.
+---
+## Repo contents
+- **notebooks/eye_classifier_colab.ipynb** — Data download (Kaggle), clean, split, undersample, **evaluate** (needs `best.pt` from model team), export.
+- **scripts/predict_image.py** — Run classifier on single images (needs `best.pt`).
+- **scripts/webcam_live.py** — Live webcam open/closed (needs `best.pt` + optional `weights/face_landmarker.task`).
+- **scripts/video_infer.py** — Run on video files.
+- **scripts/focus_infer.py** — Focus/attention inference.
+- **weights/** — Put `best.pt` here; `face_landmarker.task` is downloaded on first webcam run if missing.
+- **docs/** — Extra docs (e.g. UNNECESSARY_FILES.md if present).
+---
+## Dataset
+- **Source:** [Kaggle — open/closed eyes](https://www.kaggle.com/datasets/sehriyarmemmedli/open-closed-eyes-dataset)
+- The Colab notebook downloads it via `kagglehub`; no local copy in repo.
+---
+## Weights
+- Put **best.pt** from the model team in **weights/best.pt** (or `runs/classify/runs_cls/eye_open_closed_cpu/weights/best.pt`).
+- For webcam: **face_landmarker.task** is downloaded into **weights/** on first run if missing.
+---
+## Local setup
+```bash
+pip install ultralytics opencv-python mediapipe "numpy<2"
+```
+Optional: use a venv. From repo root:
+- `python scripts/predict_image.py <image.png>`
+- `python scripts/webcam_live.py`
+- `python scripts/video_infer.py` (expects 1.mp4 / 2.mp4 in repo root or set `VIDEOS` env)
+- `python scripts/focus_infer.py`
+---
+## Project structure
+```
+├── notebooks/
+│   └── eye_classifier_colab.ipynb   # Data + eval (no training)
+├── scripts/
+│   ├── predict_image.py
+│   ├── webcam_live.py
+│   ├── video_infer.py
+│   └── focus_infer.py
+├── weights/                     # best.pt, face_landmarker.task
+├── docs/                        # extra docs
+├── README.md
+└── venv/                        # optional
+```
+Training and weight generation: **model team, separate notebook.**

models/cnn/CNN_MODEL/notebooks/eye_classifier_colab.ipynb ADDED Viewed

The diff for this file is too large to render. See raw diff

models/cnn/CNN_MODEL/scripts/focus_infer.py ADDED Viewed

	@@ -0,0 +1,199 @@

+from __future__ import annotations
+from pathlib import Path
+import os
+import cv2
+import numpy as np
+from ultralytics import YOLO
+def list_images(folder: Path):
+    exts = {".png", ".jpg", ".jpeg", ".bmp", ".webp"}
+    return sorted([p for p in folder.iterdir() if p.suffix.lower() in exts])
+def find_weights(project_root: Path) -> Path | None:
+    candidates = [
+        project_root / "weights" / "best.pt",
+        project_root / "runs" / "classify" / "runs_cls" / "eye_open_closed_cpu" / "weights" / "best.pt",
+        project_root / "runs" / "classify" / "runs_cls" / "eye_open_closed_cpu" / "weights" / "last.pt",
+        project_root / "runs_cls" / "eye_open_closed_cpu" / "weights" / "best.pt",
+        project_root / "runs_cls" / "eye_open_closed_cpu" / "weights" / "last.pt",
+    ]
+    return next((p for p in candidates if p.is_file()), None)
+def detect_eyelid_boundary(gray: np.ndarray) -> np.ndarray | None:
+    """
+    Returns an ellipse fit to the largest contour near the eye boundary.
+    Output format: (center(x,y), (axis1, axis2), angle) or None.
+    """
+    blur = cv2.GaussianBlur(gray, (5, 5), 0)
+    edges = cv2.Canny(blur, 40, 120)
+    edges = cv2.dilate(edges, np.ones((3, 3), np.uint8), iterations=1)
+    contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    if not contours:
+        return None
+    contours = sorted(contours, key=cv2.contourArea, reverse=True)
+    for c in contours:
+        if len(c) >= 5 and cv2.contourArea(c) > 50:
+            return cv2.fitEllipse(c)
+    return None
+def detect_pupil_center(gray: np.ndarray) -> tuple[int, int] | None:
+    """
+    More robust pupil detection:
+    - enhance contrast (CLAHE)
+    - find dark blobs
+    - score by circularity and proximity to center
+    """
+    h, w = gray.shape
+    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+    eq = clahe.apply(gray)
+    blur = cv2.GaussianBlur(eq, (7, 7), 0)
+    # Focus on the central region to avoid eyelashes/edges
+    cx, cy = w // 2, h // 2
+    rx, ry = int(w * 0.3), int(h * 0.3)
+    x0, x1 = max(cx - rx, 0), min(cx + rx, w)
+    y0, y1 = max(cy - ry, 0), min(cy + ry, h)
+    roi = blur[y0:y1, x0:x1]
+    # Inverted threshold to capture dark pupil
+    _, thresh = cv2.threshold(roi, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+    thresh = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, np.ones((3, 3), np.uint8), iterations=2)
+    thresh = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, np.ones((5, 5), np.uint8), iterations=1)
+    contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    if not contours:
+        return None
+    best = None
+    best_score = -1.0
+    for c in contours:
+        area = cv2.contourArea(c)
+        if area < 15:
+            continue
+        perimeter = cv2.arcLength(c, True)
+        if perimeter <= 0:
+            continue
+        circularity = 4 * np.pi * (area / (perimeter * perimeter))
+        if circularity < 0.3:
+            continue
+        m = cv2.moments(c)
+        if m["m00"] == 0:
+            continue
+        px = int(m["m10"] / m["m00"]) + x0
+        py = int(m["m01"] / m["m00"]) + y0
+        # Score by circularity and distance to center
+        dist = np.hypot(px - cx, py - cy) / max(w, h)
+        score = circularity - dist
+        if score > best_score:
+            best_score = score
+            best = (px, py)
+    return best
+def is_focused(pupil_center: tuple[int, int], img_shape: tuple[int, int]) -> bool:
+    """
+    Decide focus based on pupil offset from image center.
+    """
+    h, w = img_shape
+    cx, cy = w // 2, h // 2
+    px, py = pupil_center
+    dx = abs(px - cx) / max(w, 1)
+    dy = abs(py - cy) / max(h, 1)
+    return (dx < 0.12) and (dy < 0.12)
+def annotate(img_bgr: np.ndarray, ellipse, pupil_center, focused: bool, cls_label: str, conf: float):
+    out = img_bgr.copy()
+    if ellipse is not None:
+        cv2.ellipse(out, ellipse, (0, 255, 255), 2)
+    if pupil_center is not None:
+        cv2.circle(out, pupil_center, 4, (0, 0, 255), -1)
+    label = f"{cls_label} ({conf:.2f}) | focused={int(focused)}"
+    cv2.putText(out, label, (8, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
+    return out
+def main():
+    project_root = Path(__file__).resolve().parent.parent
+    data_dir = project_root / "Dataset"
+    alt_data_dir = project_root / "DATA"
+    out_dir = project_root / "runs_focus"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    weights = find_weights(project_root)
+    if weights is None:
+        print("Weights not found. Train first.")
+        return
+    # Support both Dataset/test/{open,closed} and Dataset/{open,closed}
+    def resolve_test_dirs(root: Path):
+        test_open = root / "test" / "open"
+        test_closed = root / "test" / "closed"
+        if test_open.exists() and test_closed.exists():
+            return test_open, test_closed
+        test_open = root / "open"
+        test_closed = root / "closed"
+        if test_open.exists() and test_closed.exists():
+            return test_open, test_closed
+        alt_closed = root / "close"
+        if test_open.exists() and alt_closed.exists():
+            return test_open, alt_closed
+        return None, None
+    test_open, test_closed = resolve_test_dirs(data_dir)
+    if (test_open is None or test_closed is None) and alt_data_dir.exists():
+        test_open, test_closed = resolve_test_dirs(alt_data_dir)
+    if not test_open.exists() or not test_closed.exists():
+        print("Test folders missing. Expected:")
+        print(test_open)
+        print(test_closed)
+        return
+    test_files = list_images(test_open) + list_images(test_closed)
+    print("Total test images:", len(test_files))
+    max_images = int(os.getenv("MAX_IMAGES", "0"))
+    if max_images > 0:
+        test_files = test_files[:max_images]
+        print("Limiting to MAX_IMAGES:", max_images)
+    model = YOLO(str(weights))
+    results = model.predict(test_files, imgsz=224, device="cpu", verbose=False)
+    names = model.names
+    for r in results:
+        probs = r.probs
+        top_idx = int(probs.top1)
+        top_conf = float(probs.top1conf)
+        pred_label = names[top_idx]
+        img = cv2.imread(r.path)
+        if img is None:
+            continue
+        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        ellipse = detect_eyelid_boundary(gray)
+        pupil_center = detect_pupil_center(gray)
+        focused = False
+        if pred_label.lower() == "open" and pupil_center is not None:
+            focused = is_focused(pupil_center, gray.shape)
+        annotated = annotate(img, ellipse, pupil_center, focused, pred_label, top_conf)
+        out_path = out_dir / (Path(r.path).stem + "_annotated.jpg")
+        cv2.imwrite(str(out_path), annotated)
+        print(f"{Path(r.path).name}: pred={pred_label} conf={top_conf:.3f} focused={focused}")
+    print(f"\nAnnotated outputs saved to: {out_dir}")
+if __name__ == "__main__":
+    main()

models/cnn/CNN_MODEL/scripts/predict_image.py ADDED Viewed

	@@ -0,0 +1,49 @@

+"""Run the eye open/closed model on one or more images."""
+import sys
+from pathlib import Path
+from ultralytics import YOLO
+def main():
+    project_root = Path(__file__).resolve().parent.parent
+    weight_candidates = [
+        project_root / "weights" / "best.pt",
+        project_root / "runs" / "classify" / "runs_cls" / "eye_open_closed_cpu" / "weights" / "best.pt",
+        project_root / "runs" / "classify" / "runs_cls" / "eye_open_closed_cpu" / "weights" / "last.pt",
+    ]
+    weights = next((p for p in weight_candidates if p.is_file()), None)
+    if weights is None:
+        print("Weights not found. Put best.pt in weights/ or runs/.../weights/ (from model team).")
+        sys.exit(1)
+    if len(sys.argv) < 2:
+        print("Usage: python scripts/predict_image.py <image1> [image2 ...]")
+        print("Example: python scripts/predict_image.py path/to/image.png")
+        sys.exit(0)
+    model = YOLO(str(weights))
+    names = model.names
+    for path in sys.argv[1:]:
+        p = Path(path)
+        if not p.is_file():
+            print(p, "- file not found")
+            continue
+        try:
+            results = model.predict(str(p), imgsz=224, device="cpu", verbose=False)
+        except Exception as e:
+            print(p, "- error:", e)
+            continue
+        if not results:
+            print(p, "- no result")
+            continue
+        r = results[0]
+        top_idx = int(r.probs.top1)
+        conf = float(r.probs.top1conf)
+        label = names[top_idx]
+        print(f"{p.name}: {label} ({conf:.2%})")
+if __name__ == "__main__":
+    main()

models/cnn/CNN_MODEL/scripts/video_infer.py ADDED Viewed

	@@ -0,0 +1,281 @@

+from __future__ import annotations
+import os
+from pathlib import Path
+import cv2
+import numpy as np
+from ultralytics import YOLO
+try:
+    import mediapipe as mp
+except Exception:  # pragma: no cover
+    mp = None
+def find_weights(project_root: Path) -> Path | None:
+    candidates = [
+        project_root / "weights" / "best.pt",
+        project_root / "runs" / "classify" / "runs_cls" / "eye_open_closed_cpu" / "weights" / "best.pt",
+        project_root / "runs" / "classify" / "runs_cls" / "eye_open_closed_cpu" / "weights" / "last.pt",
+        project_root / "runs_cls" / "eye_open_closed_cpu" / "weights" / "best.pt",
+        project_root / "runs_cls" / "eye_open_closed_cpu" / "weights" / "last.pt",
+    ]
+    return next((p for p in candidates if p.is_file()), None)
+def detect_pupil_center(gray: np.ndarray) -> tuple[int, int] | None:
+    h, w = gray.shape
+    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+    eq = clahe.apply(gray)
+    blur = cv2.GaussianBlur(eq, (7, 7), 0)
+    cx, cy = w // 2, h // 2
+    rx, ry = int(w * 0.3), int(h * 0.3)
+    x0, x1 = max(cx - rx, 0), min(cx + rx, w)
+    y0, y1 = max(cy - ry, 0), min(cy + ry, h)
+    roi = blur[y0:y1, x0:x1]
+    _, thresh = cv2.threshold(roi, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+    thresh = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, np.ones((3, 3), np.uint8), iterations=2)
+    thresh = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, np.ones((5, 5), np.uint8), iterations=1)
+    contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    if not contours:
+        return None
+    best = None
+    best_score = -1.0
+    for c in contours:
+        area = cv2.contourArea(c)
+        if area < 15:
+            continue
+        perimeter = cv2.arcLength(c, True)
+        if perimeter <= 0:
+            continue
+        circularity = 4 * np.pi * (area / (perimeter * perimeter))
+        if circularity < 0.3:
+            continue
+        m = cv2.moments(c)
+        if m["m00"] == 0:
+            continue
+        px = int(m["m10"] / m["m00"]) + x0
+        py = int(m["m01"] / m["m00"]) + y0
+        dist = np.hypot(px - cx, py - cy) / max(w, h)
+        score = circularity - dist
+        if score > best_score:
+            best_score = score
+            best = (px, py)
+    return best
+def is_focused(pupil_center: tuple[int, int], img_shape: tuple[int, int]) -> bool:
+    h, w = img_shape
+    cx = w // 2
+    px, _ = pupil_center
+    dx = abs(px - cx) / max(w, 1)
+    return dx < 0.12
+def classify_frame(model: YOLO, frame: np.ndarray) -> tuple[str, float]:
+    # Use classifier directly on frame (assumes frame is eye crop)
+    results = model.predict(frame, imgsz=224, device="cpu", verbose=False)
+    r = results[0]
+    probs = r.probs
+    top_idx = int(probs.top1)
+    top_conf = float(probs.top1conf)
+    pred_label = model.names[top_idx]
+    return pred_label, top_conf
+def annotate_frame(frame: np.ndarray, label: str, focused: bool, conf: float, time_sec: float):
+    out = frame.copy()
+    text = f"{label} | focused={int(focused)} | conf={conf:.2f} | t={time_sec:.2f}s"
+    cv2.putText(out, text, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2)
+    return out
+def write_segments(path: Path, segments: list[tuple[float, float, str]]):
+    with path.open("w") as f:
+        for start, end, label in segments:
+            f.write(f"{start:.2f},{end:.2f},{label}\n")
+def process_video(video_path: Path, model: YOLO | None):
+    cap = cv2.VideoCapture(str(video_path))
+    if not cap.isOpened():
+        print(f"Failed to open {video_path}")
+        return
+    fps = cap.get(cv2.CAP_PROP_FPS) or 30.0
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    out_path = video_path.with_name(video_path.stem + "_pred.mp4")
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+    writer = cv2.VideoWriter(str(out_path), fourcc, fps, (width, height))
+    csv_path = video_path.with_name(video_path.stem + "_predictions.csv")
+    seg_path = video_path.with_name(video_path.stem + "_segments.txt")
+    frame_idx = 0
+    last_label = None
+    seg_start = 0.0
+    segments: list[tuple[float, float, str]] = []
+    with csv_path.open("w") as fcsv:
+        fcsv.write("time_sec,label,focused,conf\n")
+        if mp is None:
+            print("mediapipe is not installed. Falling back to classifier-only mode.")
+        use_mp = mp is not None
+        if use_mp:
+            mp_face_mesh = mp.solutions.face_mesh
+            face_mesh = mp_face_mesh.FaceMesh(
+                static_image_mode=False,
+                max_num_faces=1,
+                refine_landmarks=True,
+                min_detection_confidence=0.5,
+                min_tracking_confidence=0.5,
+            )
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+            time_sec = frame_idx / fps
+            conf = 0.0
+            pred_label = "open"
+            focused = False
+            if use_mp:
+                rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                res = face_mesh.process(rgb)
+                if res.multi_face_landmarks:
+                    lm = res.multi_face_landmarks[0].landmark
+                    h, w = frame.shape[:2]
+                    # Eye landmarks (MediaPipe FaceMesh)
+                    left_eye = [33, 160, 158, 133, 153, 144]
+                    right_eye = [362, 385, 387, 263, 373, 380]
+                    left_iris = [468, 469, 470, 471]
+                    right_iris = [473, 474, 475, 476]
+                    def pts(idxs):
+                        return np.array([(int(lm[i].x * w), int(lm[i].y * h)) for i in idxs])
+                    def ear(eye_pts):
+                        # EAR using 6 points
+                        p1, p2, p3, p4, p5, p6 = eye_pts
+                        v1 = np.linalg.norm(p2 - p6)
+                        v2 = np.linalg.norm(p3 - p5)
+                        h1 = np.linalg.norm(p1 - p4)
+                        return (v1 + v2) / (2.0 * h1 + 1e-6)
+                    le = pts(left_eye)
+                    re = pts(right_eye)
+                    le_ear = ear(le)
+                    re_ear = ear(re)
+                    ear_avg = (le_ear + re_ear) / 2.0
+                    # openness threshold
+                    pred_label = "open" if ear_avg > 0.22 else "closed"
+                    # iris centers
+                    li = pts(left_iris)
+                    ri = pts(right_iris)
+                    li_c = li.mean(axis=0).astype(int)
+                    ri_c = ri.mean(axis=0).astype(int)
+                    # eye centers (midpoint of corners)
+                    le_c = ((le[0] + le[3]) / 2).astype(int)
+                    re_c = ((re[0] + re[3]) / 2).astype(int)
+                    # focus = iris close to eye center horizontally for both eyes
+                    le_dx = abs(li_c[0] - le_c[0]) / max(np.linalg.norm(le[0] - le[3]), 1)
+                    re_dx = abs(ri_c[0] - re_c[0]) / max(np.linalg.norm(re[0] - re[3]), 1)
+                    focused = (pred_label == "open") and (le_dx < 0.18) and (re_dx < 0.18)
+                    # draw eye boundaries
+                    cv2.polylines(frame, [le], True, (0, 255, 255), 1)
+                    cv2.polylines(frame, [re], True, (0, 255, 255), 1)
+                    # draw iris centers
+                    cv2.circle(frame, tuple(li_c), 3, (0, 0, 255), -1)
+                    cv2.circle(frame, tuple(ri_c), 3, (0, 0, 255), -1)
+                else:
+                    pred_label = "closed"
+                    focused = False
+            else:
+                if model is not None:
+                    pred_label, conf = classify_frame(model, frame)
+                gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+                pupil_center = detect_pupil_center(gray) if pred_label.lower() == "open" else None
+                focused = False
+                if pred_label.lower() == "open" and pupil_center is not None:
+                    focused = is_focused(pupil_center, gray.shape)
+            if pred_label.lower() != "open":
+                focused = False
+            label = "open_focused" if (pred_label.lower() == "open" and focused) else "open_not_focused"
+            if pred_label.lower() != "open":
+                label = "closed_not_focused"
+            fcsv.write(f"{time_sec:.2f},{label},{int(focused)},{conf:.4f}\n")
+            if last_label is None:
+                last_label = label
+                seg_start = time_sec
+            elif label != last_label:
+                segments.append((seg_start, time_sec, last_label))
+                seg_start = time_sec
+                last_label = label
+            annotated = annotate_frame(frame, label, focused, conf, time_sec)
+            writer.write(annotated)
+            frame_idx += 1
+    if last_label is not None:
+        end_time = frame_idx / fps
+        segments.append((seg_start, end_time, last_label))
+    write_segments(seg_path, segments)
+    cap.release()
+    writer.release()
+    print(f"Saved: {out_path}")
+    print(f"CSV: {csv_path}")
+    print(f"Segments: {seg_path}")
+def main():
+    project_root = Path(__file__).resolve().parent.parent
+    weights = find_weights(project_root)
+    model = YOLO(str(weights)) if weights is not None else None
+    # Default to 1.mp4 and 2.mp4 in project root
+    videos = []
+    for name in ["1.mp4", "2.mp4"]:
+        p = project_root / name
+        if p.exists():
+            videos.append(p)
+    # Also allow passing paths via env var
+    extra = os.getenv("VIDEOS", "")
+    for v in [x.strip() for x in extra.split(",") if x.strip()]:
+        vp = Path(v)
+        if not vp.is_absolute():
+            vp = project_root / vp
+        if vp.exists():
+            videos.append(vp)
+    if not videos:
+        print("No videos found. Expected 1.mp4 / 2.mp4 in project root.")
+        return
+    for v in videos:
+        process_video(v, model)
+if __name__ == "__main__":
+    main()

models/cnn/CNN_MODEL/scripts/webcam_live.py ADDED Viewed

	@@ -0,0 +1,184 @@

+"""
+Live webcam: detect face, crop each eye, run open/closed classifier, show on screen.
+Requires: opencv-python, ultralytics, mediapipe (pip install mediapipe).
+Press 'q' to quit.
+"""
+import urllib.request
+from pathlib import Path
+import cv2
+import numpy as np
+from ultralytics import YOLO
+try:
+    import mediapipe as mp
+    _mp_has_solutions = hasattr(mp, "solutions")
+except ImportError:
+    mp = None
+    _mp_has_solutions = False
+# New MediaPipe Tasks API (Face Landmarker) eye indices
+LEFT_EYE_INDICES_NEW = [263, 249, 390, 373, 374, 380, 381, 382, 362, 466, 388, 387, 386, 385, 384, 398]
+RIGHT_EYE_INDICES_NEW = [33, 7, 163, 144, 145, 153, 154, 155, 133, 246, 161, 160, 159, 158, 157, 173]
+# Old Face Mesh (solutions) indices
+LEFT_EYE_INDICES_OLD = [33, 160, 158, 133, 153, 144]
+RIGHT_EYE_INDICES_OLD = [362, 385, 387, 263, 373, 380]
+EYE_PADDING = 0.35
+def find_weights(project_root: Path) -> Path | None:
+    candidates = [
+        project_root / "weights" / "best.pt",
+        project_root / "runs" / "classify" / "runs_cls" / "eye_open_closed_cpu" / "weights" / "best.pt",
+        project_root / "runs" / "classify" / "runs_cls" / "eye_open_closed_cpu" / "weights" / "last.pt",
+    ]
+    return next((p for p in candidates if p.is_file()), None)
+def get_eye_roi(frame: np.ndarray, landmarks, indices: list[int]) -> np.ndarray | None:
+    h, w = frame.shape[:2]
+    pts = np.array([(int(landmarks[i].x * w), int(landmarks[i].y * h)) for i in indices])
+    x_min, y_min = pts.min(axis=0)
+    x_max, y_max = pts.max(axis=0)
+    dx = max(int((x_max - x_min) * EYE_PADDING), 8)
+    dy = max(int((y_max - y_min) * EYE_PADDING), 8)
+    x0 = max(0, x_min - dx)
+    y0 = max(0, y_min - dy)
+    x1 = min(w, x_max + dx)
+    y1 = min(h, y_max + dy)
+    if x1 <= x0 or y1 <= y0:
+        return None
+    return frame[y0:y1, x0:x1].copy()
+def _run_with_solutions(mp, model, cap):
+    face_mesh = mp.solutions.face_mesh.FaceMesh(
+        static_image_mode=False,
+        max_num_faces=1,
+        refine_landmarks=True,
+        min_detection_confidence=0.5,
+        min_tracking_confidence=0.5,
+    )
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        results = face_mesh.process(rgb)
+        left_label, left_conf = "—", 0.0
+        right_label, right_conf = "—", 0.0
+        if results.multi_face_landmarks:
+            lm = results.multi_face_landmarks[0].landmark
+            for roi, indices, side in [
+                (get_eye_roi(frame, lm, LEFT_EYE_INDICES_OLD), LEFT_EYE_INDICES_OLD, "left"),
+                (get_eye_roi(frame, lm, RIGHT_EYE_INDICES_OLD), RIGHT_EYE_INDICES_OLD, "right"),
+            ]:
+                if roi is not None and roi.size > 0:
+                    try:
+                        pred = model.predict(roi, imgsz=224, device="cpu", verbose=False)
+                        if pred:
+                            r = pred[0]
+                            label = model.names[int(r.probs.top1)]
+                            conf = float(r.probs.top1conf)
+                            if side == "left":
+                                left_label, left_conf = label, conf
+                            else:
+                                right_label, right_conf = label, conf
+                    except Exception:
+                        pass
+        cv2.putText(frame, f"L: {left_label} ({left_conf:.0%})", (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
+        cv2.putText(frame, f"R: {right_label} ({right_conf:.0%})", (20, 80), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
+        cv2.imshow("Eye open/closed (q to quit)", frame)
+        if cv2.waitKey(1) & 0xFF == ord("q"):
+            break
+def _run_with_tasks(project_root: Path, model, cap):
+    from mediapipe.tasks.python import BaseOptions
+    from mediapipe.tasks.python.vision import FaceLandmarker, FaceLandmarkerOptions
+    from mediapipe.tasks.python.vision.core import vision_task_running_mode as running_mode
+    from mediapipe.tasks.python.vision.core import image as image_lib
+    model_path = project_root / "weights" / "face_landmarker.task"
+    if not model_path.is_file():
+        print("Downloading face_landmarker.task ...")
+        url = "https://storage.googleapis.com/mediapipe-models/face_landmarker/face_landmarker/float16/1/face_landmarker.task"
+        urllib.request.urlretrieve(url, model_path)
+        print("Done.")
+    options = FaceLandmarkerOptions(
+        base_options=BaseOptions(model_asset_path=str(model_path)),
+        running_mode=running_mode.VisionTaskRunningMode.IMAGE,
+        num_faces=1,
+    )
+    face_landmarker = FaceLandmarker.create_from_options(options)
+    ImageFormat = image_lib.ImageFormat
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        left_label, left_conf = "—", 0.0
+        right_label, right_conf = "—", 0.0
+        rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        rgb_contiguous = np.ascontiguousarray(rgb)
+        mp_image = image_lib.Image(ImageFormat.SRGB, rgb_contiguous)
+        result = face_landmarker.detect(mp_image)
+        if result.face_landmarks:
+            lm = result.face_landmarks[0]
+            for roi, side in [
+                (get_eye_roi(frame, lm, LEFT_EYE_INDICES_NEW), "left"),
+                (get_eye_roi(frame, lm, RIGHT_EYE_INDICES_NEW), "right"),
+            ]:
+                if roi is not None and roi.size > 0:
+                    try:
+                        pred = model.predict(roi, imgsz=224, device="cpu", verbose=False)
+                        if pred:
+                            r = pred[0]
+                            label = model.names[int(r.probs.top1)]
+                            conf = float(r.probs.top1conf)
+                            if side == "left":
+                                left_label, left_conf = label, conf
+                            else:
+                                right_label, right_conf = label, conf
+                    except Exception:
+                        pass
+        cv2.putText(frame, f"L: {left_label} ({left_conf:.0%})", (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
+        cv2.putText(frame, f"R: {right_label} ({right_conf:.0%})", (20, 80), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
+        cv2.imshow("Eye open/closed (q to quit)", frame)
+        if cv2.waitKey(1) & 0xFF == ord("q"):
+            break
+def main():
+    project_root = Path(__file__).resolve().parent.parent
+    weights = find_weights(project_root)
+    if weights is None:
+        print("Weights not found. Put best.pt in weights/ or runs/.../weights/ (from model team).")
+        return
+    if mp is None:
+        print("MediaPipe required. Install: pip install mediapipe")
+        return
+    model = YOLO(str(weights))
+    cap = cv2.VideoCapture(0)
+    if not cap.isOpened():
+        print("Could not open webcam.")
+        return
+    print("Live eye open/closed on your face. Press 'q' to quit.")
+    try:
+        if _mp_has_solutions:
+            _run_with_solutions(mp, model, cap)
+        else:
+            _run_with_tasks(project_root, model, cap)
+    finally:
+        cap.release()
+        cv2.destroyAllWindows()
+if __name__ == "__main__":
+    main()

models/cnn/CNN_MODEL/weights/yolo11s-cls.pt ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:e2b605d1c8c212b434a75a32759a6f7adf1d2b29c35f76bdccd4c794cb653cf2
+size 13630112

models/cnn/__init__.py ADDED Viewed

File without changes

models/cnn/eye_attention/__init__.py ADDED Viewed

	@@ -0,0 +1 @@


1	+

models/cnn/eye_attention/classifier.py ADDED Viewed

	@@ -0,0 +1,169 @@

+from __future__ import annotations
+import os
+from abc import ABC, abstractmethod
+import numpy as np
+class EyeClassifier(ABC):
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        pass
+    @abstractmethod
+    def predict_score(self, crops_bgr: list[np.ndarray]) -> float:
+        pass
+class GeometricOnlyClassifier(EyeClassifier):
+    @property
+    def name(self) -> str:
+        return "geometric"
+    def predict_score(self, crops_bgr: list[np.ndarray]) -> float:
+        return 1.0
+class YOLOv11Classifier(EyeClassifier):
+    def __init__(self, checkpoint_path: str, device: str = "cpu"):
+        from ultralytics import YOLO
+        self._model = YOLO(checkpoint_path)
+        self._device = device
+        names = self._model.names
+        self._attentive_idx = None
+        for idx, cls_name in names.items():
+            if cls_name in ("open", "attentive"):
+                self._attentive_idx = idx
+                break
+        if self._attentive_idx is None:
+            self._attentive_idx = max(names.keys())
+        print(f"[YOLO] Classes: {names}, attentive_idx={self._attentive_idx}")
+    @property
+    def name(self) -> str:
+        return "yolo"
+    def predict_score(self, crops_bgr: list[np.ndarray]) -> float:
+        if not crops_bgr:
+            return 1.0
+        results = self._model.predict(crops_bgr, device=self._device, verbose=False)
+        scores = [float(r.probs.data[self._attentive_idx]) for r in results]
+        return sum(scores) / len(scores) if scores else 1.0
+class EyeCNNClassifier(EyeClassifier):
+    """Loader for the custom PyTorch EyeCNN (trained on Kaggle eye crops)."""
+    def __init__(self, checkpoint_path: str, device: str = "cpu"):
+        import torch
+        import torch.nn as nn
+        class EyeCNN(nn.Module):
+            def __init__(self, num_classes=2, dropout_rate=0.3):
+                super().__init__()
+                self.conv_layers = nn.Sequential(
+                    nn.Conv2d(3, 32, 3, 1, 1), nn.BatchNorm2d(32), nn.ReLU(), nn.MaxPool2d(2, 2),
+                    nn.Conv2d(32, 64, 3, 1, 1), nn.BatchNorm2d(64), nn.ReLU(), nn.MaxPool2d(2, 2),
+                    nn.Conv2d(64, 128, 3, 1, 1), nn.BatchNorm2d(128), nn.ReLU(), nn.MaxPool2d(2, 2),
+                    nn.Conv2d(128, 256, 3, 1, 1), nn.BatchNorm2d(256), nn.ReLU(), nn.MaxPool2d(2, 2),
+                )
+                self.fc_layers = nn.Sequential(
+                    nn.AdaptiveAvgPool2d((1, 1)), nn.Flatten(),
+                    nn.Linear(256, 512), nn.ReLU(), nn.Dropout(dropout_rate),
+                    nn.Linear(512, num_classes),
+                )
+            def forward(self, x):
+                return self.fc_layers(self.conv_layers(x))
+        self._device = torch.device(device)
+        checkpoint = torch.load(checkpoint_path, map_location=self._device, weights_only=False)
+        dropout_rate = checkpoint.get("config", {}).get("dropout_rate", 0.35)
+        self._model = EyeCNN(num_classes=2, dropout_rate=dropout_rate)
+        self._model.load_state_dict(checkpoint["model_state_dict"])
+        self._model.to(self._device)
+        self._model.eval()
+        self._transform = None  # built lazily
+    def _get_transform(self):
+        if self._transform is None:
+            from torchvision import transforms
+            self._transform = transforms.Compose([
+                transforms.ToPILImage(),
+                transforms.Resize((96, 96)),
+                transforms.ToTensor(),
+                transforms.Normalize(
+                    mean=[0.485, 0.456, 0.406],
+                    std=[0.229, 0.224, 0.225],
+                ),
+            ])
+        return self._transform
+    @property
+    def name(self) -> str:
+        return "eye_cnn"
+    def predict_score(self, crops_bgr: list[np.ndarray]) -> float:
+        if not crops_bgr:
+            return 1.0
+        import torch
+        import cv2
+        transform = self._get_transform()
+        scores = []
+        for crop in crops_bgr:
+            if crop is None or crop.size == 0:
+                scores.append(1.0)
+                continue
+            rgb = cv2.cvtColor(crop, cv2.COLOR_BGR2RGB)
+            tensor = transform(rgb).unsqueeze(0).to(self._device)
+            with torch.no_grad():
+                output = self._model(tensor)
+                prob = torch.softmax(output, dim=1)[0, 1].item()  # prob of "open"
+            scores.append(prob)
+        return sum(scores) / len(scores)
+_EXT_TO_BACKEND = {".pth": "cnn", ".pt": "yolo"}
+def load_eye_classifier(
+    path: str | None = None,
+    backend: str = "yolo",
+    device: str = "cpu",
+) -> EyeClassifier:
+    if backend == "geometric":
+        return GeometricOnlyClassifier()
+    if path is None:
+        print(f"[CLASSIFIER] No model path for backend {backend!r}, falling back to geometric")
+        return GeometricOnlyClassifier()
+    ext = os.path.splitext(path)[1].lower()
+    inferred = _EXT_TO_BACKEND.get(ext)
+    if inferred and inferred != backend:
+        print(f"[CLASSIFIER] File extension {ext!r} implies backend {inferred!r}, "
+              f"overriding requested {backend!r}")
+        backend = inferred
+    print(f"[CLASSIFIER] backend={backend!r}, path={path!r}")
+    if backend == "cnn":
+        return EyeCNNClassifier(path, device=device)
+    if backend == "yolo":
+        try:
+            return YOLOv11Classifier(path, device=device)
+        except ImportError:
+            print("[CLASSIFIER] ultralytics required for YOLO. pip install ultralytics")
+            raise
+    raise ValueError(
+        f"Unknown eye backend {backend!r}. Choose from: yolo, cnn, geometric"
+    )

models/cnn/eye_attention/crop.py ADDED Viewed

	@@ -0,0 +1,70 @@

+import cv2
+import numpy as np
+from models.pretrained.face_mesh.face_mesh import FaceMeshDetector
+LEFT_EYE_CONTOUR = FaceMeshDetector.LEFT_EYE_INDICES
+RIGHT_EYE_CONTOUR = FaceMeshDetector.RIGHT_EYE_INDICES
+IMAGENET_MEAN = (0.485, 0.456, 0.406)
+IMAGENET_STD = (0.229, 0.224, 0.225)
+CROP_SIZE = 96
+def _bbox_from_landmarks(
+    landmarks: np.ndarray,
+    indices: list[int],
+    frame_w: int,
+    frame_h: int,
+    expand: float = 0.4,
+) -> tuple[int, int, int, int]:
+    pts = landmarks[indices, :2]
+    px = pts[:, 0] * frame_w
+    py = pts[:, 1] * frame_h
+    x_min, x_max = px.min(), px.max()
+    y_min, y_max = py.min(), py.max()
+    w = x_max - x_min
+    h = y_max - y_min
+    cx = (x_min + x_max) / 2
+    cy = (y_min + y_max) / 2
+    size = max(w, h) * (1 + expand)
+    half = size / 2
+    x1 = int(max(cx - half, 0))
+    y1 = int(max(cy - half, 0))
+    x2 = int(min(cx + half, frame_w))
+    y2 = int(min(cy + half, frame_h))
+    return x1, y1, x2, y2
+def extract_eye_crops(
+    frame: np.ndarray,
+    landmarks: np.ndarray,
+    expand: float = 0.4,
+    crop_size: int = CROP_SIZE,
+) -> tuple[np.ndarray, np.ndarray, tuple, tuple]:
+    h, w = frame.shape[:2]
+    left_bbox = _bbox_from_landmarks(landmarks, LEFT_EYE_CONTOUR, w, h, expand)
+    right_bbox = _bbox_from_landmarks(landmarks, RIGHT_EYE_CONTOUR, w, h, expand)
+    left_crop = frame[left_bbox[1] : left_bbox[3], left_bbox[0] : left_bbox[2]]
+    right_crop = frame[right_bbox[1] : right_bbox[3], right_bbox[0] : right_bbox[2]]
+    left_crop = cv2.resize(left_crop, (crop_size, crop_size), interpolation=cv2.INTER_AREA)
+    right_crop = cv2.resize(right_crop, (crop_size, crop_size), interpolation=cv2.INTER_AREA)
+    return left_crop, right_crop, left_bbox, right_bbox
+def crop_to_tensor(crop_bgr: np.ndarray):
+    import torch
+    rgb = cv2.cvtColor(crop_bgr, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0
+    for c in range(3):
+        rgb[:, :, c] = (rgb[:, :, c] - IMAGENET_MEAN[c]) / IMAGENET_STD[c]
+    return torch.from_numpy(rgb.transpose(2, 0, 1))

models/cnn/eye_attention/train.py ADDED Viewed

File without changes

models/cnn/notebooks/EyeCNN.ipynb ADDED Viewed

	@@ -0,0 +1,107 @@

+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "import torch\n",
+        "import torch.nn as nn\n",
+        "import torch.optim as optim\n",
+        "from torch.utils.data import DataLoader\n",
+        "from torchvision import datasets, transforms\n",
+        "\n",
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')\n",
+        "!cp -r /content/drive/MyDrive/Dataset_clean /content/\n",
+        "\n",
+        "#Verify structure\n",
+        "for split in ['train', 'val', 'test']:\n",
+        "    path = f'/content/Dataset_clean/{split}'\n",
+        "    classes = os.listdir(path)\n",
+        "    total = sum(len(os.listdir(os.path.join(path, c))) for c in classes)\n",
+        "    print(f'{split}: {total} images | classes: {classes}')"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "sE1F3em-V5go",
+        "outputId": "2c73a9a6-a198-468c-a2cc-253b2de7cc3f"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "nG2bh66rQ56G"
+      },
+      "outputs": [],
+      "source": [
+        "class EyeCNN(nn.Module):\n",
+        "    def __init__(self, num_classes=2):\n",
+        "        super(EyeCNN, self).__init__()\n",
+        "        self.conv_layers = nn.Sequential(\n",
+        "            nn.Conv2d(3, 32, 3, 1, 1),\n",
+        "            nn.BatchNorm2d(32),\n",
+        "            nn.ReLU(),\n",
+        "            nn.MaxPool2d(2, 2),\n",
+        "\n",
+        "            nn.Conv2d(32, 64, 3, 1, 1),\n",
+        "            nn.BatchNorm2d(64),\n",
+        "            nn.ReLU(),\n",
+        "            nn.MaxPool2d(2, 2),\n",
+        "\n",
+        "            nn.Conv2d(64, 128, 3, 1, 1),\n",
+        "            nn.BatchNorm2d(128),\n",
+        "            nn.ReLU(),\n",
+        "            nn.MaxPool2d(2, 2),\n",
+        "\n",
+        "            nn.Conv2d(128, 256, 3, 1, 1),\n",
+        "            nn.BatchNorm2d(256),\n",
+        "            nn.ReLU(),\n",
+        "            nn.MaxPool2d(2, 2)\n",
+        "        )\n",
+        "\n",
+        "        self.fc_layers = nn.Sequential(\n",
+        "            nn.AdaptiveAvgPool2d((1, 1)),\n",
+        "            nn.Flatten(),\n",
+        "            nn.Linear(256, 512),\n",
+        "            nn.ReLU(),\n",
+        "            nn.Dropout(0.35),\n",
+        "            nn.Linear(512, num_classes)\n",
+        "        )\n",
+        "\n",
+        "    def forward(self, x):\n",
+        "        x = self.conv_layers(x)\n",
+        "        x = self.fc_layers(x)\n",
+        "        return x"
+      ]
+    }
+  ]
+}

models/cnn/notebooks/EyeCNN_Train_Evaluate_new.ipynb ADDED Viewed

The diff for this file is too large to render. See raw diff

models/cnn/notebooks/EyeCNN_Training_Evaluate.ipynb ADDED Viewed

The diff for this file is too large to render. See raw diff

models/cnn/notebooks/README.md ADDED Viewed

	@@ -0,0 +1 @@


1	+ # GAP Large Project

models/collect_features.py ADDED Viewed

	@@ -0,0 +1,356 @@

+import argparse
+import collections
+import math
+import os
+import sys
+import time
+import cv2
+import numpy as np
+_PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if _PROJECT_ROOT not in sys.path:
+    sys.path.insert(0, _PROJECT_ROOT)
+from models.face_mesh import FaceMeshDetector
+from models.head_pose import HeadPoseEstimator
+from models.eye_scorer import EyeBehaviourScorer, compute_gaze_ratio, compute_mar
+FONT = cv2.FONT_HERSHEY_SIMPLEX
+GREEN = (0, 255, 0)
+RED = (0, 0, 255)
+WHITE = (255, 255, 255)
+YELLOW = (0, 255, 255)
+ORANGE = (0, 165, 255)
+GRAY = (120, 120, 120)
+FEATURE_NAMES = [
+    "ear_left", "ear_right", "ear_avg", "h_gaze", "v_gaze", "mar",
+    "yaw", "pitch", "roll", "s_face", "s_eye", "gaze_offset", "head_deviation",
+    "perclos", "blink_rate", "closure_duration", "yawn_duration",
+]
+NUM_FEATURES = len(FEATURE_NAMES)
+assert NUM_FEATURES == 17
+class TemporalTracker:
+    EAR_BLINK_THRESH = 0.21
+    MAR_YAWN_THRESH = 0.55
+    PERCLOS_WINDOW = 60
+    BLINK_WINDOW_SEC = 30.0
+    def __init__(self):
+        self.ear_history = collections.deque(maxlen=self.PERCLOS_WINDOW)
+        self.blink_timestamps = collections.deque()
+        self._eyes_closed = False
+        self._closure_start = None
+        self._yawn_start = None
+    def update(self, ear_avg, mar, now=None):
+        if now is None:
+            now = time.time()
+        closed = ear_avg < self.EAR_BLINK_THRESH
+        self.ear_history.append(1.0 if closed else 0.0)
+        perclos = sum(self.ear_history) / len(self.ear_history) if self.ear_history else 0.0
+        if self._eyes_closed and not closed:
+            self.blink_timestamps.append(now)
+        self._eyes_closed = closed
+        cutoff = now - self.BLINK_WINDOW_SEC
+        while self.blink_timestamps and self.blink_timestamps[0] < cutoff:
+            self.blink_timestamps.popleft()
+        blink_rate = len(self.blink_timestamps) * (60.0 / self.BLINK_WINDOW_SEC)
+        if closed:
+            if self._closure_start is None:
+                self._closure_start = now
+            closure_dur = now - self._closure_start
+        else:
+            self._closure_start = None
+            closure_dur = 0.0
+        yawning = mar > self.MAR_YAWN_THRESH
+        if yawning:
+            if self._yawn_start is None:
+                self._yawn_start = now
+            yawn_dur = now - self._yawn_start
+        else:
+            self._yawn_start = None
+            yawn_dur = 0.0
+        return perclos, blink_rate, closure_dur, yawn_dur
+def extract_features(landmarks, w, h, head_pose, eye_scorer, temporal,
+                     *, _pre=None):
+    from models.eye_scorer import _LEFT_EYE_EAR, _RIGHT_EYE_EAR, compute_ear
+    p = _pre or {}
+    ear_left = p.get("ear_left", compute_ear(landmarks, _LEFT_EYE_EAR))
+    ear_right = p.get("ear_right", compute_ear(landmarks, _RIGHT_EYE_EAR))
+    ear_avg = (ear_left + ear_right) / 2.0
+    if "h_gaze" in p and "v_gaze" in p:
+        h_gaze, v_gaze = p["h_gaze"], p["v_gaze"]
+    else:
+        h_gaze, v_gaze = compute_gaze_ratio(landmarks)
+    mar = p.get("mar", compute_mar(landmarks))
+    angles = p.get("angles")
+    if angles is None:
+        angles = head_pose.estimate(landmarks, w, h)
+    yaw = angles[0] if angles else 0.0
+    pitch = angles[1] if angles else 0.0
+    roll = angles[2] if angles else 0.0
+    s_face = p.get("s_face", head_pose.score(landmarks, w, h))
+    s_eye = p.get("s_eye", eye_scorer.score(landmarks))
+    gaze_offset = math.sqrt((h_gaze - 0.5) ** 2 + (v_gaze - 0.5) ** 2)
+    head_deviation = math.sqrt(yaw ** 2 + pitch ** 2)  # cleaned downstream
+    perclos, blink_rate, closure_dur, yawn_dur = temporal.update(ear_avg, mar)
+    return np.array([
+        ear_left, ear_right, ear_avg,
+        h_gaze, v_gaze,
+        mar,
+        yaw, pitch, roll,
+        s_face, s_eye,
+        gaze_offset,
+        head_deviation,
+        perclos, blink_rate, closure_dur, yawn_dur,
+    ], dtype=np.float32)
+def quality_report(labels):
+    n = len(labels)
+    n1 = int((labels == 1).sum())
+    n0 = n - n1
+    transitions = int(np.sum(np.diff(labels) != 0))
+    duration_sec = n / 30.0  # approximate at 30fps
+    warnings = []
+    print(f"\n{'='*50}")
+    print(f"  DATA QUALITY REPORT")
+    print(f"{'='*50}")
+    print(f"  Total samples : {n}")
+    print(f"  Focused       : {n1} ({n1/max(n,1)*100:.1f}%)")
+    print(f"  Unfocused     : {n0} ({n0/max(n,1)*100:.1f}%)")
+    print(f"  Duration      : {duration_sec:.0f}s ({duration_sec/60:.1f} min)")
+    print(f"  Transitions   : {transitions}")
+    if transitions > 0:
+        print(f"  Avg segment   : {n/transitions:.0f} frames ({n/transitions/30:.1f}s)")
+    # checks
+    if duration_sec < 120:
+        warnings.append(f"TOO SHORT: {duration_sec:.0f}s — aim for 5-10 minutes (300-600s)")
+    if n < 3000:
+        warnings.append(f"LOW SAMPLE COUNT: {n} frames — aim for 9000+ (5 min at 30fps)")
+    balance = n1 / max(n, 1)
+    if balance < 0.3 or balance > 0.7:
+        warnings.append(f"IMBALANCED: {balance:.0%} focused — aim for 35-65% focused")
+    if transitions < 10:
+        warnings.append(f"TOO FEW TRANSITIONS: {transitions} — switch every 10-30s, aim for 20+")
+    if transitions == 1:
+        warnings.append("SINGLE BLOCK: you recorded one unfocused + one focused block — "
+                         "model will learn temporal position, not focus patterns")
+    if warnings:
+        print(f"\n  ⚠️  WARNINGS ({len(warnings)}):")
+        for w in warnings:
+            print(f"    • {w}")
+        print(f"\n  Consider re-recording this session.")
+    else:
+        print(f"\n  ✅ All checks passed!")
+    print(f"{'='*50}\n")
+    return len(warnings) == 0
+# ---------------------------------------------------------------------------
+# Main
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--name", type=str, default="session",
+                        help="Your name or session ID")
+    parser.add_argument("--camera", type=int, default=0,
+                        help="Camera index")
+    parser.add_argument("--duration", type=int, default=600,
+                        help="Max recording time (seconds, default 10 min)")
+    parser.add_argument("--output-dir", type=str,
+                        default=os.path.join(_PROJECT_ROOT, "data", "collected_data"),
+                        help="Where to save .npz files")
+    args = parser.parse_args()
+    os.makedirs(args.output_dir, exist_ok=True)
+    detector = FaceMeshDetector()
+    head_pose = HeadPoseEstimator()
+    eye_scorer = EyeBehaviourScorer()
+    temporal = TemporalTracker()
+    cap = cv2.VideoCapture(args.camera)
+    if not cap.isOpened():
+        print("[COLLECT] ERROR: can't open camera")
+        return
+    print("[COLLECT] Data Collection Tool")
+    print(f"[COLLECT] Session: {args.name}, max {args.duration}s")
+    print(f"[COLLECT] Features per frame: {NUM_FEATURES}")
+    print("[COLLECT] Controls:")
+    print("  1 = FOCUSED       (looking at screen normally)")
+    print("  0 = NOT FOCUSED   (phone, away, eyes closed, yawning)")
+    print("  p = pause")
+    print("  q = save & quit")
+    print()
+    print("[COLLECT] TIPS for good data:")
+    print("  • Switch between 1 and 0 every 10-30 seconds")
+    print("  • Aim for 20+ transitions total")
+    print("  • Act out varied scenarios: reading, phone, talking, drowsy")
+    print("  • Record at least 5 minutes")
+    print()
+    features_list = []
+    labels_list = []
+    label = None        # None = paused
+    transitions = 0     # count label switches
+    prev_label = None
+    status = "PAUSED -- press 1 (focused) or 0 (not focused)"
+    t_start = time.time()
+    prev_time = time.time()
+    fps = 0.0
+    try:
+        while True:
+            elapsed = time.time() - t_start
+            if elapsed > args.duration:
+                print(f"[COLLECT] Time limit ({args.duration}s)")
+                break
+            ret, frame = cap.read()
+            if not ret:
+                break
+            h, w = frame.shape[:2]
+            landmarks = detector.process(frame)
+            face_ok = landmarks is not None
+            if face_ok and label is not None:
+                vec = extract_features(landmarks, w, h, head_pose, eye_scorer, temporal)
+                features_list.append(vec)
+                labels_list.append(label)
+                if prev_label is not None and label != prev_label:
+                    transitions += 1
+                prev_label = label
+            now = time.time()
+            fps = 0.9 * fps + 0.1 * (1.0 / max(now - prev_time, 1e-6))
+            prev_time = now
+            # --- draw UI ---
+            n = len(labels_list)
+            n1 = sum(1 for x in labels_list if x == 1)
+            n0 = n - n1
+            remaining = max(0, args.duration - elapsed)
+            bar_color = GREEN if label == 1 else (RED if label == 0 else (80, 80, 80))
+            cv2.rectangle(frame, (0, 0), (w, 70), (0, 0, 0), -1)
+            cv2.putText(frame, status, (10, 22), FONT, 0.55, bar_color, 2, cv2.LINE_AA)
+            cv2.putText(frame, f"Samples: {n}  (F:{n1}  U:{n0})  Switches: {transitions}",
+                        (10, 48), FONT, 0.42, WHITE, 1, cv2.LINE_AA)
+            cv2.putText(frame, f"FPS:{fps:.0f}", (w - 80, 22), FONT, 0.45, WHITE, 1, cv2.LINE_AA)
+            cv2.putText(frame, f"{int(remaining)}s left", (w - 80, 48), FONT, 0.42, YELLOW, 1, cv2.LINE_AA)
+            if n > 0:
+                bar_w = min(w - 20, 300)
+                bar_x = w - bar_w - 10
+                bar_y = 58
+                frac = n1 / n
+                cv2.rectangle(frame, (bar_x, bar_y), (bar_x + bar_w, bar_y + 8), (40, 40, 40), -1)
+                cv2.rectangle(frame, (bar_x, bar_y), (bar_x + int(bar_w * frac), bar_y + 8), GREEN, -1)
+                cv2.putText(frame, f"{frac:.0%}F", (bar_x + bar_w + 4, bar_y + 8),
+                            FONT, 0.3, GRAY, 1, cv2.LINE_AA)
+            if not face_ok:
+                cv2.putText(frame, "NO FACE", (w // 2 - 60, h // 2), FONT, 0.7, RED, 2, cv2.LINE_AA)
+            # red dot = recording
+            if label is not None and face_ok:
+                cv2.circle(frame, (w - 20, 80), 8, RED, -1)
+            # live warnings
+            warn_y = h - 35
+            if n > 100 and transitions < 3:
+                cv2.putText(frame, "! Switch more often (aim for 20+ transitions)",
+                            (10, warn_y), FONT, 0.38, ORANGE, 1, cv2.LINE_AA)
+                warn_y -= 18
+            if elapsed > 30 and n > 0:
+                bal = n1 / n
+                if bal < 0.25 or bal > 0.75:
+                    cv2.putText(frame, f"! Imbalanced ({bal:.0%} focused) - record more of the other",
+                                (10, warn_y), FONT, 0.38, ORANGE, 1, cv2.LINE_AA)
+                    warn_y -= 18
+            cv2.putText(frame, "1:focused  0:unfocused  p:pause  q:save+quit",
+                        (10, h - 10), FONT, 0.38, GRAY, 1, cv2.LINE_AA)
+            cv2.imshow("FocusGuard -- Data Collection", frame)
+            key = cv2.waitKey(1) & 0xFF
+            if key == ord("1"):
+                label = 1
+                status = "Recording: FOCUSED"
+                print(f"[COLLECT] -> FOCUSED (n={n}, transitions={transitions})")
+            elif key == ord("0"):
+                label = 0
+                status = "Recording: NOT FOCUSED"
+                print(f"[COLLECT] -> NOT FOCUSED (n={n}, transitions={transitions})")
+            elif key == ord("p"):
+                label = None
+                status = "PAUSED"
+                print(f"[COLLECT] paused (n={n})")
+            elif key == ord("q"):
+                break
+    finally:
+        cap.release()
+        cv2.destroyAllWindows()
+        detector.close()
+        if len(features_list) > 0:
+            feats = np.stack(features_list)
+            labs = np.array(labels_list, dtype=np.int64)
+            ts = time.strftime("%Y%m%d_%H%M%S")
+            fname = f"{args.name}_{ts}.npz"
+            fpath = os.path.join(args.output_dir, fname)
+            np.savez(fpath,
+                     features=feats,
+                     labels=labs,
+                     feature_names=np.array(FEATURE_NAMES))
+            print(f"\n[COLLECT] Saved {len(labs)} samples -> {fpath}")
+            print(f"  Shape: {feats.shape}  ({NUM_FEATURES} features)")
+            quality_report(labs)
+        else:
+            print("\n[COLLECT] No data collected")
+        print("[COLLECT] Done")
+if __name__ == "__main__":
+    main()

models/eye_classifier.py ADDED Viewed

	@@ -0,0 +1,69 @@

+from __future__ import annotations
+from abc import ABC, abstractmethod
+import numpy as np
+class EyeClassifier(ABC):
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        pass
+    @abstractmethod
+    def predict_score(self, crops_bgr: list[np.ndarray]) -> float:
+        pass
+class GeometricOnlyClassifier(EyeClassifier):
+    @property
+    def name(self) -> str:
+        return "geometric"
+    def predict_score(self, crops_bgr: list[np.ndarray]) -> float:
+        return 1.0
+class YOLOv11Classifier(EyeClassifier):
+    def __init__(self, checkpoint_path: str, device: str = "cpu"):
+        from ultralytics import YOLO
+        self._model = YOLO(checkpoint_path)
+        self._device = device
+        names = self._model.names
+        self._attentive_idx = None
+        for idx, cls_name in names.items():
+            if cls_name in ("open", "attentive"):
+                self._attentive_idx = idx
+                break
+        if self._attentive_idx is None:
+            self._attentive_idx = max(names.keys())
+        print(f"[YOLO] Classes: {names}, attentive_idx={self._attentive_idx}")
+    @property
+    def name(self) -> str:
+        return "yolo"
+    def predict_score(self, crops_bgr: list[np.ndarray]) -> float:
+        if not crops_bgr:
+            return 1.0
+        results = self._model.predict(crops_bgr, device=self._device, verbose=False)
+        scores = [float(r.probs.data[self._attentive_idx]) for r in results]
+        return sum(scores) / len(scores) if scores else 1.0
+def load_eye_classifier(
+    path: str | None = None,
+    backend: str = "yolo",
+    device: str = "cpu",
+) -> EyeClassifier:
+    if path is None or backend == "geometric":
+        return GeometricOnlyClassifier()
+    try:
+        return YOLOv11Classifier(path, device=device)
+    except ImportError:
+        print("[CLASSIFIER] ultralytics required for YOLO. pip install ultralytics")
+        raise

models/eye_crop.py ADDED Viewed

	@@ -0,0 +1,77 @@

+import cv2
+import numpy as np
+from models.face_mesh import FaceMeshDetector
+LEFT_EYE_CONTOUR = FaceMeshDetector.LEFT_EYE_INDICES
+RIGHT_EYE_CONTOUR = FaceMeshDetector.RIGHT_EYE_INDICES
+IMAGENET_MEAN = (0.485, 0.456, 0.406)
+IMAGENET_STD = (0.229, 0.224, 0.225)
+CROP_SIZE = 96
+def _bbox_from_landmarks(
+    landmarks: np.ndarray,
+    indices: list[int],
+    frame_w: int,
+    frame_h: int,
+    expand: float = 0.4,
+) -> tuple[int, int, int, int]:
+    pts = landmarks[indices, :2]
+    px = pts[:, 0] * frame_w
+    py = pts[:, 1] * frame_h
+    x_min, x_max = px.min(), px.max()
+    y_min, y_max = py.min(), py.max()
+    w = x_max - x_min
+    h = y_max - y_min
+    cx = (x_min + x_max) / 2
+    cy = (y_min + y_max) / 2
+    size = max(w, h) * (1 + expand)
+    half = size / 2
+    x1 = int(max(cx - half, 0))
+    y1 = int(max(cy - half, 0))
+    x2 = int(min(cx + half, frame_w))
+    y2 = int(min(cy + half, frame_h))
+    return x1, y1, x2, y2
+def extract_eye_crops(
+    frame: np.ndarray,
+    landmarks: np.ndarray,
+    expand: float = 0.4,
+    crop_size: int = CROP_SIZE,
+) -> tuple[np.ndarray, np.ndarray, tuple, tuple]:
+    h, w = frame.shape[:2]
+    left_bbox = _bbox_from_landmarks(landmarks, LEFT_EYE_CONTOUR, w, h, expand)
+    right_bbox = _bbox_from_landmarks(landmarks, RIGHT_EYE_CONTOUR, w, h, expand)
+    left_crop = frame[left_bbox[1] : left_bbox[3], left_bbox[0] : left_bbox[2]]
+    right_crop = frame[right_bbox[1] : right_bbox[3], right_bbox[0] : right_bbox[2]]
+    if left_crop.size == 0:
+        left_crop = np.zeros((crop_size, crop_size, 3), dtype=np.uint8)
+    else:
+        left_crop = cv2.resize(left_crop, (crop_size, crop_size), interpolation=cv2.INTER_AREA)
+    if right_crop.size == 0:
+        right_crop = np.zeros((crop_size, crop_size, 3), dtype=np.uint8)
+    else:
+        right_crop = cv2.resize(right_crop, (crop_size, crop_size), interpolation=cv2.INTER_AREA)
+    return left_crop, right_crop, left_bbox, right_bbox
+def crop_to_tensor(crop_bgr: np.ndarray):
+    import torch
+    rgb = cv2.cvtColor(crop_bgr, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0
+    for c in range(3):
+        rgb[:, :, c] = (rgb[:, :, c] - IMAGENET_MEAN[c]) / IMAGENET_STD[c]
+    return torch.from_numpy(rgb.transpose(2, 0, 1))

models/eye_scorer.py ADDED Viewed

	@@ -0,0 +1,168 @@

+import math
+import numpy as np
+_LEFT_EYE_EAR = [33, 160, 158, 133, 153, 145]
+_RIGHT_EYE_EAR = [362, 385, 387, 263, 373, 380]
+_LEFT_IRIS_CENTER = 468
+_RIGHT_IRIS_CENTER = 473
+_LEFT_EYE_INNER = 133
+_LEFT_EYE_OUTER = 33
+_RIGHT_EYE_INNER = 362
+_RIGHT_EYE_OUTER = 263
+_LEFT_EYE_TOP = 159
+_LEFT_EYE_BOTTOM = 145
+_RIGHT_EYE_TOP = 386
+_RIGHT_EYE_BOTTOM = 374
+_MOUTH_TOP = 13
+_MOUTH_BOTTOM = 14
+_MOUTH_LEFT = 78
+_MOUTH_RIGHT = 308
+_MOUTH_UPPER_1 = 82
+_MOUTH_UPPER_2 = 312
+_MOUTH_LOWER_1 = 87
+_MOUTH_LOWER_2 = 317
+MAR_YAWN_THRESHOLD = 0.55
+def _distance(p1: np.ndarray, p2: np.ndarray) -> float:
+    return float(np.linalg.norm(p1 - p2))
+def compute_ear(landmarks: np.ndarray, eye_indices: list[int]) -> float:
+    p1 = landmarks[eye_indices[0], :2]
+    p2 = landmarks[eye_indices[1], :2]
+    p3 = landmarks[eye_indices[2], :2]
+    p4 = landmarks[eye_indices[3], :2]
+    p5 = landmarks[eye_indices[4], :2]
+    p6 = landmarks[eye_indices[5], :2]
+    vertical1 = _distance(p2, p6)
+    vertical2 = _distance(p3, p5)
+    horizontal = _distance(p1, p4)
+    if horizontal < 1e-6:
+        return 0.0
+    return (vertical1 + vertical2) / (2.0 * horizontal)
+def compute_avg_ear(landmarks: np.ndarray) -> float:
+    left_ear = compute_ear(landmarks, _LEFT_EYE_EAR)
+    right_ear = compute_ear(landmarks, _RIGHT_EYE_EAR)
+    return (left_ear + right_ear) / 2.0
+def compute_gaze_ratio(landmarks: np.ndarray) -> tuple[float, float]:
+    left_iris = landmarks[_LEFT_IRIS_CENTER, :2]
+    left_inner = landmarks[_LEFT_EYE_INNER, :2]
+    left_outer = landmarks[_LEFT_EYE_OUTER, :2]
+    left_top = landmarks[_LEFT_EYE_TOP, :2]
+    left_bottom = landmarks[_LEFT_EYE_BOTTOM, :2]
+    right_iris = landmarks[_RIGHT_IRIS_CENTER, :2]
+    right_inner = landmarks[_RIGHT_EYE_INNER, :2]
+    right_outer = landmarks[_RIGHT_EYE_OUTER, :2]
+    right_top = landmarks[_RIGHT_EYE_TOP, :2]
+    right_bottom = landmarks[_RIGHT_EYE_BOTTOM, :2]
+    left_h_total = _distance(left_inner, left_outer)
+    right_h_total = _distance(right_inner, right_outer)
+    if left_h_total < 1e-6 or right_h_total < 1e-6:
+        return 0.5, 0.5
+    left_h_ratio = _distance(left_outer, left_iris) / left_h_total
+    right_h_ratio = _distance(right_outer, right_iris) / right_h_total
+    h_ratio = (left_h_ratio + right_h_ratio) / 2.0
+    left_v_total = _distance(left_top, left_bottom)
+    right_v_total = _distance(right_top, right_bottom)
+    if left_v_total < 1e-6 or right_v_total < 1e-6:
+        return h_ratio, 0.5
+    left_v_ratio = _distance(left_top, left_iris) / left_v_total
+    right_v_ratio = _distance(right_top, right_iris) / right_v_total
+    v_ratio = (left_v_ratio + right_v_ratio) / 2.0
+    return float(np.clip(h_ratio, 0, 1)), float(np.clip(v_ratio, 0, 1))
+def compute_mar(landmarks: np.ndarray) -> float:
+    top = landmarks[_MOUTH_TOP, :2]
+    bottom = landmarks[_MOUTH_BOTTOM, :2]
+    left = landmarks[_MOUTH_LEFT, :2]
+    right = landmarks[_MOUTH_RIGHT, :2]
+    upper1 = landmarks[_MOUTH_UPPER_1, :2]
+    lower1 = landmarks[_MOUTH_LOWER_1, :2]
+    upper2 = landmarks[_MOUTH_UPPER_2, :2]
+    lower2 = landmarks[_MOUTH_LOWER_2, :2]
+    horizontal = _distance(left, right)
+    if horizontal < 1e-6:
+        return 0.0
+    v1 = _distance(upper1, lower1)
+    v2 = _distance(top, bottom)
+    v3 = _distance(upper2, lower2)
+    return (v1 + v2 + v3) / (2.0 * horizontal)
+class EyeBehaviourScorer:
+    def __init__(
+        self,
+        ear_open: float = 0.30,
+        ear_closed: float = 0.16,
+        gaze_max_offset: float = 0.28,
+    ):
+        self.ear_open = ear_open
+        self.ear_closed = ear_closed
+        self.gaze_max_offset = gaze_max_offset
+    def _ear_score(self, ear: float) -> float:
+        if ear >= self.ear_open:
+            return 1.0
+        if ear <= self.ear_closed:
+            return 0.0
+        return (ear - self.ear_closed) / (self.ear_open - self.ear_closed)
+    def _gaze_score(self, h_ratio: float, v_ratio: float) -> float:
+        h_offset = abs(h_ratio - 0.5)
+        v_offset = abs(v_ratio - 0.5)
+        offset = math.sqrt(h_offset**2 + v_offset**2)
+        t = min(offset / self.gaze_max_offset, 1.0)
+        return 0.5 * (1.0 + math.cos(math.pi * t))
+    def score(self, landmarks: np.ndarray) -> float:
+        left_ear = compute_ear(landmarks, _LEFT_EYE_EAR)
+        right_ear = compute_ear(landmarks, _RIGHT_EYE_EAR)
+        # Use minimum EAR so closing ONE eye is enough to drop the score
+        ear = min(left_ear, right_ear)
+        ear_s = self._ear_score(ear)
+        if ear_s < 0.3:
+            return ear_s
+        h_ratio, v_ratio = compute_gaze_ratio(landmarks)
+        gaze_s = self._gaze_score(h_ratio, v_ratio)
+        return ear_s * gaze_s
+    def detailed_score(self, landmarks: np.ndarray) -> dict:
+        left_ear = compute_ear(landmarks, _LEFT_EYE_EAR)
+        right_ear = compute_ear(landmarks, _RIGHT_EYE_EAR)
+        ear = min(left_ear, right_ear)
+        ear_s = self._ear_score(ear)
+        h_ratio, v_ratio = compute_gaze_ratio(landmarks)
+        gaze_s = self._gaze_score(h_ratio, v_ratio)
+        s_eye = ear_s if ear_s < 0.3 else ear_s * gaze_s
+        return {
+            "ear": round(ear, 4),
+            "ear_score": round(ear_s, 4),
+            "h_gaze": round(h_ratio, 4),
+            "v_gaze": round(v_ratio, 4),
+            "gaze_score": round(gaze_s, 4),
+            "s_eye": round(s_eye, 4),
+        }

models/face_mesh.py ADDED Viewed

	@@ -0,0 +1,94 @@

+import os
+import time
+from pathlib import Path
+from urllib.request import urlretrieve
+import cv2
+import numpy as np
+import mediapipe as mp
+from mediapipe.tasks.python.vision import FaceLandmarkerOptions, FaceLandmarker, RunningMode
+from mediapipe.tasks import python as mp_tasks
+_MODEL_URL = (
+    "https://storage.googleapis.com/mediapipe-models/face_landmarker/"
+    "face_landmarker/float16/latest/face_landmarker.task"
+)
+def _ensure_model() -> str:
+    cache_dir = Path(os.environ.get(
+        "FOCUSGUARD_CACHE_DIR",
+        Path.home() / ".cache" / "focusguard",
+    ))
+    model_path = cache_dir / "face_landmarker.task"
+    if model_path.exists():
+        return str(model_path)
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    print(f"[FACE_MESH] Downloading model to {model_path}...")
+    urlretrieve(_MODEL_URL, model_path)
+    print("[FACE_MESH] Download complete.")
+    return str(model_path)
+class FaceMeshDetector:
+    LEFT_EYE_INDICES = [33, 7, 163, 144, 145, 153, 154, 155, 133, 173, 157, 158, 159, 160, 161, 246]
+    RIGHT_EYE_INDICES = [362, 382, 381, 380, 374, 373, 390, 249, 263, 466, 388, 387, 386, 385, 384, 398]
+    LEFT_IRIS_INDICES = [468, 469, 470, 471, 472]
+    RIGHT_IRIS_INDICES = [473, 474, 475, 476, 477]
+    def __init__(
+        self,
+        max_num_faces: int = 1,
+        min_detection_confidence: float = 0.5,
+        min_tracking_confidence: float = 0.5,
+    ):
+        model_path = _ensure_model()
+        options = FaceLandmarkerOptions(
+            base_options=mp_tasks.BaseOptions(model_asset_path=model_path),
+            num_faces=max_num_faces,
+            min_face_detection_confidence=min_detection_confidence,
+            min_face_presence_confidence=min_detection_confidence,
+            min_tracking_confidence=min_tracking_confidence,
+            running_mode=RunningMode.VIDEO,
+        )
+        self._landmarker = FaceLandmarker.create_from_options(options)
+        self._t0 = time.monotonic()
+        self._last_ts = 0
+    def process(self, bgr_frame: np.ndarray) -> np.ndarray | None:
+        # BGR in -> (478,3) norm x,y,z or None
+        rgb = cv2.cvtColor(bgr_frame, cv2.COLOR_BGR2RGB)
+        mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb)
+        ts = max(int((time.monotonic() - self._t0) * 1000), self._last_ts + 1)
+        self._last_ts = ts
+        result = self._landmarker.detect_for_video(mp_image, ts)
+        if not result.face_landmarks:
+            return None
+        face = result.face_landmarks[0]
+        return np.array([(lm.x, lm.y, lm.z) for lm in face], dtype=np.float32)
+    def get_pixel_landmarks(self, landmarks: np.ndarray, frame_w: int, frame_h: int) -> np.ndarray:
+        # norm -> pixel (x,y)
+        pixel = np.zeros((landmarks.shape[0], 2), dtype=np.int32)
+        pixel[:, 0] = (landmarks[:, 0] * frame_w).astype(np.int32)
+        pixel[:, 1] = (landmarks[:, 1] * frame_h).astype(np.int32)
+        return pixel
+    def get_3d_landmarks(self, landmarks: np.ndarray, frame_w: int, frame_h: int) -> np.ndarray:
+        # norm -> pixel-scale x,y,z (z scaled by width)
+        pts = np.zeros_like(landmarks)
+        pts[:, 0] = landmarks[:, 0] * frame_w
+        pts[:, 1] = landmarks[:, 1] * frame_h
+        pts[:, 2] = landmarks[:, 2] * frame_w
+        return pts
+    def close(self):
+        self._landmarker.close()
+    def __enter__(self):
+        return self
+    def __exit__(self, *args):
+        self.close()

models/head_pose.py ADDED Viewed

	@@ -0,0 +1,121 @@

+import math
+import cv2
+import numpy as np
+_LANDMARK_INDICES = [1, 152, 33, 263, 61, 291]
+_MODEL_POINTS = np.array(
+    [
+        [0.0, 0.0, 0.0],
+        [0.0, -330.0, -65.0],
+        [-225.0, 170.0, -135.0],
+        [225.0, 170.0, -135.0],
+        [-150.0, -150.0, -125.0],
+        [150.0, -150.0, -125.0],
+    ],
+    dtype=np.float64,
+)
+class HeadPoseEstimator:
+    def __init__(self, max_angle: float = 30.0, roll_weight: float = 0.5):
+        self.max_angle = max_angle
+        self.roll_weight = roll_weight
+        self._camera_matrix = None
+        self._frame_size = None
+        self._dist_coeffs = np.zeros((4, 1), dtype=np.float64)
+        self._cache_key = None
+        self._cache_result = None
+    def _get_camera_matrix(self, frame_w: int, frame_h: int) -> np.ndarray:
+        if self._camera_matrix is not None and self._frame_size == (frame_w, frame_h):
+            return self._camera_matrix
+        focal_length = float(frame_w)
+        cx, cy = frame_w / 2.0, frame_h / 2.0
+        self._camera_matrix = np.array(
+            [[focal_length, 0, cx], [0, focal_length, cy], [0, 0, 1]],
+            dtype=np.float64,
+        )
+        self._frame_size = (frame_w, frame_h)
+        return self._camera_matrix
+    def _solve(self, landmarks: np.ndarray, frame_w: int, frame_h: int):
+        key = (landmarks.data.tobytes(), frame_w, frame_h)
+        if self._cache_key == key:
+            return self._cache_result
+        image_points = np.array(
+            [
+                [landmarks[i, 0] * frame_w, landmarks[i, 1] * frame_h]
+                for i in _LANDMARK_INDICES
+            ],
+            dtype=np.float64,
+        )
+        camera_matrix = self._get_camera_matrix(frame_w, frame_h)
+        success, rvec, tvec = cv2.solvePnP(
+            _MODEL_POINTS,
+            image_points,
+            camera_matrix,
+            self._dist_coeffs,
+            flags=cv2.SOLVEPNP_ITERATIVE,
+        )
+        result = (success, rvec, tvec, image_points)
+        self._cache_key = key
+        self._cache_result = result
+        return result
+    def estimate(
+        self, landmarks: np.ndarray, frame_w: int, frame_h: int
+    ) -> tuple[float, float, float] | None:
+        success, rvec, tvec, _ = self._solve(landmarks, frame_w, frame_h)
+        if not success:
+            return None
+        rmat, _ = cv2.Rodrigues(rvec)
+        nose_dir = rmat @ np.array([0.0, 0.0, 1.0])
+        face_up = rmat @ np.array([0.0, 1.0, 0.0])
+        yaw = math.degrees(math.atan2(nose_dir[0], -nose_dir[2]))
+        pitch = math.degrees(math.asin(np.clip(-nose_dir[1], -1.0, 1.0)))
+        roll = math.degrees(math.atan2(face_up[0], -face_up[1]))
+        return (yaw, pitch, roll)
+    def score(self, landmarks: np.ndarray, frame_w: int, frame_h: int) -> float:
+        angles = self.estimate(landmarks, frame_w, frame_h)
+        if angles is None:
+            return 0.0
+        yaw, pitch, roll = angles
+        deviation = math.sqrt(yaw**2 + pitch**2 + (self.roll_weight * roll) ** 2)
+        t = min(deviation / self.max_angle, 1.0)
+        return 0.5 * (1.0 + math.cos(math.pi * t))
+    def draw_axes(
+        self,
+        frame: np.ndarray,
+        landmarks: np.ndarray,
+        axis_length: float = 50.0,
+    ) -> np.ndarray:
+        h, w = frame.shape[:2]
+        success, rvec, tvec, image_points = self._solve(landmarks, w, h)
+        if not success:
+            return frame
+        camera_matrix = self._get_camera_matrix(w, h)
+        nose = tuple(image_points[0].astype(int))
+        axes_3d = np.float64(
+            [[axis_length, 0, 0], [0, axis_length, 0], [0, 0, axis_length]]
+        )
+        projected, _ = cv2.projectPoints(
+            axes_3d, rvec, tvec, camera_matrix, self._dist_coeffs
+        )
+        colors = [(0, 0, 255), (0, 255, 0), (255, 0, 0)]
+        for i, color in enumerate(colors):
+            pt = tuple(projected[i].ravel().astype(int))
+            cv2.line(frame, nose, pt, color, 2)
+        return frame

models/mlp/__init__.py ADDED Viewed

File without changes

models/mlp/eval_accuracy.py ADDED Viewed

	@@ -0,0 +1,54 @@

+"""Load saved MLP checkpoint and print test accuracy, F1, AUC."""
+import os
+import sys
+import numpy as np
+import torch
+from sklearn.metrics import f1_score, roc_auc_score
+REPO_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+if REPO_ROOT not in sys.path:
+    sys.path.insert(0, REPO_ROOT)
+from data_preparation.prepare_dataset import get_dataloaders
+from models.mlp.train import BaseModel
+CKPT_PATH = os.path.join(REPO_ROOT, "checkpoints", "mlp_best.pt")
+def main():
+    if not os.path.isfile(CKPT_PATH):
+        print(f"No checkpoint at {CKPT_PATH}. Train first: python -m models.mlp.train")
+        return
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    train_loader, val_loader, test_loader, num_features, num_classes, _ = get_dataloaders(
+        model_name="face_orientation",
+        batch_size=32,
+        split_ratios=(0.7, 0.15, 0.15),
+        seed=42,
+    )
+    model = BaseModel(num_features, num_classes).to(device)
+    model.load_state_dict(torch.load(CKPT_PATH, map_location=device, weights_only=True))
+    model.eval()
+    criterion = torch.nn.CrossEntropyLoss()
+    test_loss, test_acc, test_probs, test_preds, test_labels = model.test_step(
+        test_loader, criterion, device
+    )
+    f1 = float(f1_score(test_labels, test_preds, average="weighted"))
+    if num_classes > 2:
+        auc = float(roc_auc_score(test_labels, test_probs, multi_class="ovr", average="weighted"))
+    else:
+        auc = float(roc_auc_score(test_labels, test_probs[:, 1]))
+    print("MLP (face_orientation) — test set")
+    print("  Accuracy: {:.2%}".format(test_acc))
+    print("  F1:       {:.4f}".format(f1))
+    print("  ROC-AUC:  {:.4f}".format(auc))
+if __name__ == "__main__":
+    main()

models/mlp/sweep.py ADDED Viewed

	@@ -0,0 +1,66 @@

+"""
+MLP Hyperparameter Sweep (Optuna).
+Run: python -m models.mlp.sweep
+"""
+import os
+import sys
+import optuna
+import torch
+import torch.nn as nn
+import torch.optim as optim
+REPO_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+if REPO_ROOT not in sys.path:
+    sys.path.insert(0, REPO_ROOT)
+from data_preparation.prepare_dataset import get_dataloaders
+from models.mlp.train import BaseModel, set_seed
+SEED = 42
+N_TRIALS = 20
+EPOCHS_PER_TRIAL = 15
+def objective(trial):
+    set_seed(SEED)
+    lr = trial.suggest_float("lr", 1e-4, 1e-2, log=True)
+    batch_size = trial.suggest_categorical("batch_size", [16, 32, 64])
+    train_loader, val_loader, _, num_features, num_classes, _ = get_dataloaders(
+        model_name="face_orientation",
+        batch_size=batch_size,
+        split_ratios=(0.7, 0.15, 0.15),
+        seed=SEED,
+    )
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = BaseModel(num_features, num_classes).to(device)
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.Adam(model.parameters(), lr=lr)
+    best_val_acc = 0.0
+    for epoch in range(1, EPOCHS_PER_TRIAL + 1):
+        model.training_step(train_loader, optimizer, criterion, device)
+        val_loss, val_acc = model.validation_step(val_loader, criterion, device)
+        if val_acc > best_val_acc:
+            best_val_acc = val_acc
+    return 1.0 - best_val_acc  # minimize (1 - accuracy)
+def main():
+    study = optuna.create_study(direction="minimize", study_name="mlp_sweep")
+    print(f"[SWEEP] MLP Optuna sweep: {N_TRIALS} trials, {EPOCHS_PER_TRIAL} epochs each")
+    study.optimize(objective, n_trials=N_TRIALS)
+    print("\n[SWEEP] Top-5 trials by validation accuracy")
+    best = sorted(study.trials, key=lambda t: t.value if t.value is not None else float("inf"))[:5]
+    for i, t in enumerate(best, 1):
+        acc = (1.0 - t.value) * 100
+        print(f"  #{i}  Val Acc: {acc:.2f}%  params={t.params}")
+if __name__ == "__main__":
+    main()

models/mlp/train.py ADDED Viewed

	@@ -0,0 +1,232 @@

+import json
+import os, sys
+import random
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from sklearn.metrics import f1_score, roc_auc_score
+from data_preparation.prepare_dataset import get_dataloaders
+USE_CLEARML = False
+_PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+CFG = {
+    "model_name": "face_orientation",
+    "epochs": 30,
+    "batch_size": 32,
+    "lr": 1e-3,
+    "seed": 42,
+    "split_ratios": (0.7, 0.15, 0.15),
+    "checkpoints_dir": os.path.join(_PROJECT_ROOT, "checkpoints"),
+    "logs_dir": os.path.join(_PROJECT_ROOT, "evaluation", "logs"),
+}
+# ==== ClearML (opt-in) =============================================
+task = None
+if USE_CLEARML:
+    from clearml import Task
+    task = Task.init(
+        project_name="Focus Guard",
+        task_name="MLP Model Training",
+        tags=["training", "mlp_model"]
+    )
+    task.connect(CFG)
+# ==== Model =============================================
+def set_seed(seed: int):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+class BaseModel(nn.Module):
+    def __init__(self, num_features: int, num_classes: int):
+        super().__init__()
+        self.network = nn.Sequential(
+            nn.Linear(num_features, 64),
+            nn.ReLU(),
+            nn.Linear(64, 32),
+            nn.ReLU(),
+            nn.Linear(32, num_classes),
+        )
+    def forward(self, x):
+        return self.network(x)
+    def training_step(self, loader, optimizer, criterion, device):
+        self.train()
+        total_loss = 0.0
+        correct = 0
+        total = 0
+        for features, labels in loader:
+            features, labels = features.to(device), labels.to(device)
+            optimizer.zero_grad()
+            outputs = self(features)
+            loss = criterion(outputs, labels)
+            loss.backward()
+            optimizer.step()
+            total_loss += loss.item() * features.size(0)
+            correct += (outputs.argmax(dim=1) == labels).sum().item()
+            total += features.size(0)
+        return total_loss / total, correct / total
+    @torch.no_grad()
+    def validation_step(self, loader, criterion, device):
+        self.eval()
+        total_loss = 0.0
+        correct = 0
+        total = 0
+        for features, labels in loader:
+            features, labels = features.to(device), labels.to(device)
+            outputs = self(features)
+            loss = criterion(outputs, labels)
+            total_loss += loss.item() * features.size(0)
+            correct += (outputs.argmax(dim=1) == labels).sum().item()
+            total += features.size(0)
+        return total_loss / total, correct / total
+    @torch.no_grad()
+    def test_step(self, loader, criterion, device):
+        self.eval()
+        total_loss = 0.0
+        correct = 0
+        total = 0
+        all_preds = []
+        all_labels = []
+        all_probs = []
+        for features, labels in loader:
+            features, labels = features.to(device), labels.to(device)
+            outputs = self(features)
+            loss = criterion(outputs, labels)
+            total_loss += loss.item() * features.size(0)
+            preds = outputs.argmax(dim=1)
+            correct += (preds == labels).sum().item()
+            total += features.size(0)
+            probs = torch.softmax(outputs, dim=1)
+            all_preds.extend(preds.cpu().numpy())
+            all_labels.extend(labels.cpu().numpy())
+            all_probs.extend(probs.cpu().numpy())
+        return total_loss / total, correct / total, np.array(all_probs), np.array(all_preds), np.array(all_labels)
+def main():
+    set_seed(CFG["seed"])
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"[TRAIN] Device: {device}")
+    print(f"[TRAIN] Model: {CFG['model_name']}")
+    train_loader, val_loader, test_loader, num_features, num_classes, scaler = get_dataloaders(
+        model_name=CFG["model_name"],
+        batch_size=CFG["batch_size"],
+        split_ratios=CFG["split_ratios"],
+        seed=CFG["seed"],
+    )
+    model = BaseModel(num_features, num_classes).to(device)
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.Adam(model.parameters(), lr=CFG["lr"])
+    param_count = sum(p.numel() for p in model.parameters())
+    print(f"[TRAIN] Parameters: {param_count:,}")
+    ckpt_dir = CFG["checkpoints_dir"]
+    os.makedirs(ckpt_dir, exist_ok=True)
+    best_ckpt_path = os.path.join(ckpt_dir, "mlp_best.pt")
+    history = {
+        "model_name": CFG["model_name"],
+        "param_count": param_count,
+        "epochs": [],
+        "train_loss": [],
+        "train_acc": [],
+        "val_loss": [],
+        "val_acc": [],
+    }
+    best_val_acc = 0.0
+    print(f"\n{'Epoch':>6} | {'Train Loss':>10} | {'Train Acc':>9} | {'Val Loss':>10} | {'Val Acc':>9}")
+    print("-" * 60)
+    for epoch in range(1, CFG["epochs"] + 1):
+        train_loss, train_acc = model.training_step(train_loader, optimizer, criterion, device)
+        val_loss, val_acc = model.validation_step(val_loader, criterion, device)
+        history["epochs"].append(epoch)
+        history["train_loss"].append(round(train_loss, 4))
+        history["train_acc"].append(round(train_acc, 4))
+        history["val_loss"].append(round(val_loss, 4))
+        history["val_acc"].append(round(val_acc, 4))
+        current_lr = optimizer.param_groups[0]['lr']
+        if task is not None:
+            task.logger.report_scalar("Loss",          "Train", float(train_loss), iteration=epoch)
+            task.logger.report_scalar("Accuracy",      "Train", float(train_acc),  iteration=epoch)
+            task.logger.report_scalar("Loss",          "Val",   float(val_loss),   iteration=epoch)
+            task.logger.report_scalar("Accuracy",      "Val",   float(val_acc),    iteration=epoch)
+            task.logger.report_scalar("Learning Rate", "LR",    float(current_lr), iteration=epoch)
+            task.logger.flush()
+        marker = ""
+        if val_acc > best_val_acc:
+            best_val_acc = val_acc
+            torch.save(model.state_dict(), best_ckpt_path)
+            marker = " *"
+        print(f"{epoch:>6} | {train_loss:>10.4f} | {train_acc:>8.2%} | {val_loss:>10.4f} | {val_acc:>8.2%}{marker}")
+    print(f"\nBest validation accuracy: {best_val_acc:.2%}")
+    print(f"Checkpoint saved to: {best_ckpt_path}")
+    model.load_state_dict(torch.load(best_ckpt_path, weights_only=True))
+    test_loss, test_acc, test_probs, test_preds, test_labels = model.test_step(test_loader, criterion, device)
+    test_f1 = f1_score(test_labels, test_preds, average='weighted')
+    # Handle potentially >2 classes for AUC
+    if num_classes > 2:
+        test_auc = roc_auc_score(test_labels, test_probs, multi_class='ovr', average='weighted')
+    else:
+        test_auc = roc_auc_score(test_labels, test_probs[:, 1])
+    print(f"\n[TEST] Loss: {test_loss:.4f} | Accuracy: {test_acc:.2%}")
+    print(f"[TEST] F1: {test_f1:.4f} | ROC-AUC: {test_auc:.4f}")
+    history["test_loss"] = round(test_loss, 4)
+    history["test_acc"] = round(test_acc, 4)
+    history["test_f1"] = round(test_f1, 4)
+    history["test_auc"] = round(test_auc, 4)
+    logs_dir = CFG["logs_dir"]
+    os.makedirs(logs_dir, exist_ok=True)
+    log_path = os.path.join(logs_dir, f"{CFG['model_name']}_training_log.json")
+    with open(log_path, "w") as f:
+        json.dump(history, f, indent=2)
+    print(f"[LOG] Training history saved to: {log_path}")
+if __name__ == "__main__":
+    main()

models/xgboost/add_accuracy.py ADDED Viewed

	@@ -0,0 +1,60 @@

+import pandas as pd
+import numpy as np
+from xgboost import XGBClassifier
+from sklearn.metrics import accuracy_score
+from data_preparation.prepare_dataset import get_numpy_splits
+import os
+print("Loading dataset for evaluation...")
+splits, _, _, _ = get_numpy_splits(
+    model_name="face_orientation",
+    split_ratios=(0.7, 0.15, 0.15),
+    seed=42,
+    scale=False
+)
+X_train, y_train = splits["X_train"], splits["y_train"]
+X_val,   y_val   = splits["X_val"],   splits["y_val"]
+csv_path = 'models/xgboost/sweep_results_all_40.csv'
+df = pd.read_csv(csv_path)
+# We will calculate accuracy for each row
+accuracies = []
+print(f"Re-evaluating {len(df)} configurations for accuracy. This will take a few minutes...")
+for idx, row in df.iterrows():
+    params = {
+        "n_estimators": int(row["n_estimators"]),
+        "max_depth": int(row["max_depth"]),
+        "learning_rate": float(row["learning_rate"]),
+        "subsample": float(row["subsample"]),
+        "colsample_bytree": float(row["colsample_bytree"]),
+        "reg_alpha": float(row["reg_alpha"]),
+        "reg_lambda": float(row["reg_lambda"]),
+        "random_state": 42,
+        "use_label_encoder": False,
+        "verbosity": 0,
+        "eval_metric": "logloss"
+    }
+    # Train the exact same model quickly
+    model = XGBClassifier(**params)
+    model.fit(X_train, y_train)
+    # Get validation predictions and calculate accuracy
+    val_preds = model.predict(X_val)
+    acc = accuracy_score(y_val, val_preds)
+    accuracies.append(round(acc, 4))
+    if (idx + 1) % 5 == 0:
+        print(f"Processed {idx + 1}/{len(df)} trials...")
+# Add accuracy column and save back to CSV
+df.insert(2, 'val_accuracy', accuracies)
+df.to_csv(csv_path, index=False)
+print(f"\nDone! Updated {csv_path} with 'val_accuracy'.")
+# Display the top 5 by accuracy now just to see
+top5_acc = df.nlargest(5, 'val_accuracy')[['task_id', 'val_accuracy', 'val_f1', 'val_loss']]
+print("\nTop 5 Trials by Accuracy:")
+print(top5_acc.to_string(index=False))

models/xgboost/checkpoints/face_orientation_best.json ADDED Viewed

The diff for this file is too large to render. See raw diff

models/xgboost/eval_accuracy.py ADDED Viewed

	@@ -0,0 +1,54 @@

+"""Load saved XGBoost checkpoint and print test accuracy, F1, AUC."""
+import os
+import sys
+import numpy as np
+from sklearn.metrics import f1_score, roc_auc_score
+from xgboost import XGBClassifier
+# run from repo root: python -m models.xgboost.eval_accuracy
+REPO_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+if REPO_ROOT not in sys.path:
+    sys.path.insert(0, REPO_ROOT)
+from data_preparation.prepare_dataset import get_numpy_splits
+MODEL_NAME = "face_orientation"
+CKPT_DIR = os.path.join(REPO_ROOT, "checkpoints")
+MODEL_PATH = os.path.join(CKPT_DIR, f"xgboost_{MODEL_NAME}_best.json")
+def main():
+    if not os.path.isfile(MODEL_PATH):
+        print(f"No checkpoint at {MODEL_PATH}. Train first: python -m models.xgboost.train")
+        return
+    splits, num_features, num_classes, _ = get_numpy_splits(
+        model_name=MODEL_NAME,
+        split_ratios=(0.7, 0.15, 0.15),
+        seed=42,
+        scale=False,
+    )
+    X_test = splits["X_test"]
+    y_test = splits["y_test"]
+    model = XGBClassifier()
+    model.load_model(MODEL_PATH)
+    preds = model.predict(X_test)
+    probs = model.predict_proba(X_test)
+    acc = float(np.mean(preds == y_test))
+    f1 = float(f1_score(y_test, preds, average="weighted"))
+    if num_classes > 2:
+        auc = float(roc_auc_score(y_test, probs, multi_class="ovr", average="weighted"))
+    else:
+        auc = float(roc_auc_score(y_test, probs[:, 1]))
+    print("XGBoost (face_orientation) — test set")
+    print("  Accuracy: {:.2%}".format(acc))
+    print("  F1:       {:.4f}".format(f1))
+    print("  ROC-AUC:  {:.4f}".format(auc))
+if __name__ == "__main__":
+    main()