Add complete SmartChair AI codebase: ML models, firmware, cloud, data collection

smart_chair/HARDWARE_BOM.md

@@ -0,0 +1,103 @@
+# SmartChair Hardware Bill of Materials (BOM)
+
+## Core Components
+
+| Component | Model | Qty | Purpose | Est. Cost |
+|-----------|-------|-----|---------|-----------|
+| **Microcontroller** | ESP32-S3-DevKitC-1 (8MB PSRAM) | 1 | Main MCU, edge ML inference | $8-12 |
+| **IMU Sensor** | MPU6050 (or ICM-42688-P for better accuracy) | 1 | 6-axis accelerometer + gyroscope | $2-5 |
+| **Load Cells** | 50kg Half-Bridge Strain Gauge | 4 | Weight distribution at chair corners | $4-8 (×4) |
+| **Load Cell ADC** | HX711 24-bit ADC | 4 | Amplify load cell signals | $1-2 (×4) |
+| **Thermal Sensor** | AMG8833 8×8 IR Grid-EYE | 1 | Human presence detection | $15-25 |
+| **Edge Computer** | Raspberry Pi 4B (4GB) | 1 | Complex ML + cloud gateway | $45-55 |
+
+## Supporting Components
+
+| Component | Model | Qty | Purpose | Est. Cost |
+|-----------|-------|-----|---------|-----------|
+| **Status LED** | WS2812B RGB LED Strip (8 LEDs) | 1 | Visual posture feedback | $2 |
+| **Vibration Motor** | 3V coin vibration motor | 1 | Haptic alerts | $1 |
+| **Power Supply** | 5V 3A USB-C adapter | 1 | Power ESP32 + sensors | $5 |
+| **RPi Power** | 5V 3A USB-C (official RPi) | 1 | Power Raspberry Pi | $8 |
+| **Level Shifter** | 3.3V ↔ 5V bi-directional | 1 | I2C level conversion | $1 |
+| **Breadboard/PCB** | Custom PCB or prototype board | 1 | Circuit assembly | $5-15 |
+| **Wiring** | Jumper wires + JST connectors | 1 set | Sensor connections | $3 |
+| **MicroSD Card** | 32GB Class 10 | 1 | RPi OS + local data storage | $5 |
+
+## Optional Enhancements
+
+| Component | Model | Qty | Purpose | Est. Cost |
+|-----------|-------|-----|---------|-----------|
+| **Better IMU** | ICM-42688-P | 1 | Higher accuracy, lower noise | $8-12 |
+| **BLE Module** | Built into ESP32-S3 | — | Mobile app connectivity | Included |
+| **Speaker** | Small 8Ω 0.5W speaker | 1 | Audio break reminders | $1 |
+| **OLED Display** | SSD1306 0.96" I2C | 1 | Local status display | $3 |
+| **Enclosure** | 3D printed or laser-cut | 1 | Professional housing | $5-15 |
+
+## Total Estimated Cost: **$110-165**
+
+## Wiring Diagram
+
+```
+                    ┌──────────────┐
+                    │  ESP32-S3    │
+                    │              │
+  MPU6050 ──I2C───►│ GPIO21 (SDA) │
+  AMG8833 ──I2C───►│ GPIO22 (SCL) │
+                    │              │
+  HX711_FL ────────►│ GPIO32/33    │
+  HX711_FR ────────►│ GPIO25/26    │
+  HX711_RL ────────►│ GPIO27/14    │
+  HX711_RR ────────►│ GPIO12/13    │
+                    │              │
+  WS2812B ─────────►│ GPIO48       │
+  Vibration Motor ──►│ GPIO4 (PWM) │
+                    │              │
+  RPi ──── UART ───►│ TX/RX        │
+                    └──────────────┘
+                          │
+                       WiFi/BLE
+                          │
+                    ┌─────▼──────┐
+                    │  Raspberry  │
+                    │  Pi 4B      │
+                    │             │──── MQTT/TLS ───► AWS IoT Core
+                    │  Python ML  │
+                    │  Dashboard  │──── HTTP ───► Local Web UI
+                    └─────────────┘
+```
+
+## Load Cell Placement
+
+```
+    ┌─────────────────────────┐
+    │         FRONT           │
+    │  ┌─────┐     ┌─────┐   │
+    │  │ FL  │     │ FR  │   │  FL = Front-Left Load Cell
+    │  └─────┘     └─────┘   │  FR = Front-Right Load Cell
+    │                         │
+    │      ┌───────────┐      │
+    │      │   SEAT    │      │  IMU mounted under seat center
+    │      │  (IMU)    │      │  AMG8833 mounted on backrest
+    │      └───────────┘      │
+    │                         │
+    │  ┌─────┐     ┌─────┐   │
+    │  │ RL  │     │ RR  │   │  RL = Rear-Left Load Cell
+    │  └─────┘     └─────┘   │  RR = Rear-Right Load Cell
+    │         BACK            │
+    └─────────────────────────┘
+```
+
+## Assembly Notes
+
+1. **Load cells**: Mount at the 4 corners of the seat, between seat plate and chair frame. Use 3D-printed mounting brackets. Each cell connects to its own HX711 board.
+
+2. **IMU (MPU6050)**: Mount rigidly under the center of the seat using double-sided tape or screws. Ensure Z-axis points upward when seat is level. Calibrate by recording 10 seconds of data while seat is empty and level.
+
+3. **Thermal sensor (AMG8833)**: Mount on the backrest, facing the seated person. 60° FOV covers the upper body. Used only for presence detection (occupied/empty).
+
+4. **ESP32-S3**: Place in a small enclosure under the seat. Connect via I2C to IMU and thermal sensor, GPIO to HX711 boards.
+
+5. **Raspberry Pi**: Can be mounted under the seat or placed nearby. Connects to ESP32 via UART (USB-serial) or local WiFi.
+
+6. **Power**: USB-C power bank for portability, or wall adapter for fixed installation.

smart_chair/README.md

@@ -0,0 +1,208 @@
+# 🪑 SmartChair AI — Intelligent Posture Monitoring System
+
+**Real-time posture classification, spine risk prediction, and adaptive health coaching using IMU + load cell + thermal sensor fusion.**
+
+[![Python 3.9+](https://img.shields.io/badge/Python-3.9+-blue.svg)](https://python.org)
+[![TensorFlow](https://img.shields.io/badge/TensorFlow-2.x-orange.svg)](https://tensorflow.org)
+[![ESP32](https://img.shields.io/badge/ESP32--S3-Firmware-green.svg)](https://espressif.com)
+[![AWS IoT](https://img.shields.io/badge/AWS-IoT_Core-yellow.svg)](https://aws.amazon.com/iot-core/)
+
+---
+
+## 🎯 Features
+
+| # | Feature | Status | Accuracy/Performance |
+|---|---------|--------|---------------------|
+| 1 | **Real-time posture classification** | ✅ | 95.48%+ ML accuracy (ensemble voting) |
+| 2 | **Long-term spine risk prediction** | ✅ | RULA-based + exponential decay accumulator |
+| 3 | **Personalised sitting behaviour model** | ✅ | Learns fatigue onset, break patterns per user |
+| 4 | **Smart micro-break recommendations** | ✅ | Adaptive, score-based urgency (not fixed timer) |
+| 5 | **Exercise suggestion system** | ✅ | 20+ exercises mapped to specific posture issues |
+| 6 | **Hybrid sensor fusion** | ✅ | IMU + load cell + thermal (14-channel fusion) |
+| 7 | **Fatigue & drowsiness detection** | ✅ | CoP variance + micro-movement analysis |
+| 8 | **Daily/weekly posture score dashboard** | ✅ | 0-100 score with hourly breakdown + trends |
+| 9 | **Injury risk alert system** | ✅ | Acute + chronic + trend-based alerts |
+| 10 | **Cloud integration (AWS IoT Core)** | ✅ | MQTT/TLS, DynamoDB, Lambda scoring |
+| 11 | **Multi-user recognition** | ✅ | Weight signature + k-NN (3-shot enrollment) |
+| 12 | **Gamification system** | ✅ | Points, streaks, badges, leaderboard |
+
+## 🏗️ Architecture
+
+```
+┌─────────────────────────────────────────────────────────┐
+│                    SENSOR LAYER                          │
+│  MPU6050 (50Hz)  │  4× HX711 Load Cells  │  AMG8833    │
+│  6-axis IMU      │  Weight Distribution    │  Thermal    │
+└────────┬─────────┴──────────┬─────────────┴──────┬──────┘
+         │                    │                    │
+         ▼                    ▼                    ▼
+┌─────────────────────────────────────────────────────────┐
+│              EDGE INFERENCE (ESP32-S3)                    │
+│  Feature Extraction → TFLite INT8 / Random Forest        │
+│  <30ms inference │ <50KB model │ 14 input channels        │
+└──────────────────────────┬──────────────────────────────┘
+                           │ UART / Local WiFi
+                           ▼
+┌─────────────────────────────────────────────────────────┐
+│              INTELLIGENCE LAYER (Raspberry Pi)            │
+│                                                           │
+│  ┌──────────────┐  ┌───────────────┐  ┌──────────────┐  │
+│  │ Ensemble      │  │ RULA Risk     │  │ Fatigue      │  │
+│  │ Classifier    │  │ Scorer        │  │ Detector     │  │
+│  │ (98%+ F1)     │  │ (1-7 scale)   │  │ (CoP+IMU)   │  │
+│  └──────────────┘  └───────────────┘  └──────────────┘  │
+│  ┌──────────────┐  ┌───────────────┐  ┌──────────────┐  │
+│  │ User         │  │ Break         │  │ Exercise     │  │
+│  │ Recognition  │  │ Engine        │  │ Suggester    │  │
+│  │ (k-NN)       │  │ (Adaptive)    │  │ (Targeted)   │  │
+│  └──────────────┘  └───────────────┘  └──────────────┘  │
+│  ┌──────────────┐  ┌───────────────┐  ┌──────────────┐  │
+│  │ Spine Risk   │  │ Gamification  │  │ Injury       │  │
+│  │ Predictor    │  │ Engine        │  │ Alerts       │  │
+│  │ (Long-term)  │  │ (Points/Bge) │  │ (3-tier)     │  │
+│  └──────────────┘  └──────────��────┘  └──────────────┘  │
+└──────────────────────────┬──────────────────────────────┘
+                           │ MQTT / TLS
+                           ▼
+┌─────────────────────────────────────────────────────────┐
+│                   CLOUD LAYER (AWS)                       │
+│  IoT Core → DynamoDB (telemetry) → Lambda (daily scores) │
+│          → SNS (critical alerts) → S3 (raw data backup)  │
+│          → API Gateway → Dashboard Web App                │
+└─────────────────────────────────────────────────────────┘
+```
+
+## 📊 ML Models
+
+### Posture Classifier (Primary)
+- **Architecture**: Soft-voting ensemble (SVM + DecisionTree + MLP + XGBoost + RandomForest)
+- **Basis**: [SitPose](https://arxiv.org/abs/2412.12216) (F1=98.2% on 7-class posture)
+- **Input**: 119 hand-crafted features from 2.56s sliding windows (128 samples @ 50Hz)
+- **Features**: IMU statistics, FFT spectral features, cross-axis correlations, CoP metrics, load distribution ratios
+- **Edge deployment**: `micromlgen` → C header for ESP32 (<5KB, <5ms inference)
+
+### MLSTM-FCN (Alternative/Deeper)
+- **Architecture**: Parallel Conv1D-FCN + LSTM with Squeeze-Excite attention
+- **Basis**: [MLSTM-FCN](https://arxiv.org/abs/1801.04503) + [FusionActNet](https://arxiv.org/abs/2310.02011)
+- **Input**: (128, 14) sequential tensor (14 sensor channels × 128 timesteps)
+- **Edge deployment**: TFLite INT8 quantization (<50KB, <30ms on ESP32-S3)
+
+### Supporting Models
+| Model | Method | Purpose |
+|-------|--------|---------|
+| RULA Scorer | Rule-based (ISO 11226) | Real-time ergonomic risk 1-7 |
+| Spine Risk Predictor | Exponential decay accumulator | Long-term risk trajectory |
+| Fatigue Detector | CoP variance + movement analysis | Fatigue/drowsiness classification |
+| User Recognizer | k-NN on weight signatures | Multi-user identification |
+| Break Engine | Weighted multi-factor scoring | Adaptive break timing |
+
+## 🔧 Hardware
+
+**Total cost: ~$110-165**
+
+See [HARDWARE_BOM.md](HARDWARE_BOM.md) for complete bill of materials and wiring diagram.
+
+Key sensors:
+- **IMU**: MPU6050 (6-axis, I2C, 50Hz) — mounted under seat center
+- **Load Cells**: 4× 50kg half-bridge with HX711 ADC — at chair corners
+- **Thermal**: AMG8833 8×8 IR grid — on backrest for presence detection
+- **MCU**: ESP32-S3 (dual-core 240MHz, 8MB PSRAM, WiFi/BLE)
+- **Gateway**: Raspberry Pi 4B (complex ML + cloud)
+
+## 🚀 Quick Start
+
+### 1. Install Dependencies
+```bash
+pip install numpy scipy scikit-learn xgboost tensorflow matplotlib pandas joblib
+```
+
+### 2. Run Demo (Synthetic Data)
+```bash
+python -m smart_chair.main
+```
+
+### 3. Collect Real Data
+```bash
+python -c "
+from smart_chair.data_collection.protocol import DataCollectionSession
+session = DataCollectionSession('participant_01', weight_kg=70)
+session.run_collection(serial_port='/dev/ttyUSB0')  # or None for synthetic
+"
+```
+
+### 4. Train Production Model
+```python
+from smart_chair.ml_models.posture_classifier import EnsemblePostureClassifier
+from smart_chair.data_collection.protocol import prepare_training_dataset
+from smart_chair.data_collection.synthetic_data_generator import subject_based_split
+
+dataset = prepare_training_dataset("./collected_data")
+train, test = subject_based_split(dataset)
+
+clf = EnsemblePostureClassifier()
+clf.train(train["imu_data"], train["load_data"], train["labels"],
+          test["imu_data"], test["load_data"], test["labels"])
+clf.save("posture_model.joblib")
+```
+
+### 5. Deploy to ESP32
+```python
+# Option A: Random Forest → C header
+from micromlgen import port
+c_code = port(clf.model.estimators_[4])  # Export RF component
+with open("posture_classifier.h", "w") as f:
+    f.write(c_code)
+
+# Option B: MLSTM-FCN → TFLite
+from smart_chair.ml_models.posture_classifier import build_mlstm_fcn, convert_to_tflite
+model = build_mlstm_fcn()
+# ... train model ...
+convert_to_tflite(model, X_train, "posture_model.tflite")
+```
+
+### 6. Flash ESP32 Firmware
+Upload `firmware/esp32_firmware.ino` via Arduino IDE or PlatformIO.
+
+## 📁 Project Structure
+
+```
+smart_chair/
+├── config/
+│   └── settings.py              # All system constants and parameters
+├── utils/
+│   └── feature_engineering.py   # Feature extraction pipeline (14 channels)
+├── data_collection/
+│   ├── synthetic_data_generator.py  # Physics-based synthetic data
+│   └── protocol.py              # Real data collection procedure
+├── ml_models/
+│   ├── posture_classifier.py    # Ensemble + MLSTM-FCN classifiers
+│   ├── spine_risk_predictor.py  # RULA scorer + fatigue detector + alerts
+│   ├── user_recognition.py      # Multi-user recognition + personalized model
+│   ├── break_recommendation.py  # Adaptive break engine + exercise suggester
+│   └── gamification.py          # Points, badges, streaks, leaderboard
+├── cloud/
+│   └── aws_iot_integration.py   # MQTT client + AWS infrastructure definitions
+├── firmware/
+│   └── esp32_firmware.ino       # ESP32-S3 Arduino firmware
+├── HARDWARE_BOM.md              # Parts list + wiring diagram
+├── main.py                      # System orchestrator (Raspberry Pi)
+└── README.md                    # This file
+```
+
+## 📚 References
+
+| Paper | Contribution | ArXiv |
+|-------|-------------|-------|
+| SitPose | Ensemble posture classification (F1=98.2%) | [2412.12216](https://arxiv.org/abs/2412.12216) |
+| MLSTM-FCN | Multivariate time series architecture | [1801.04503](https://arxiv.org/abs/1801.04503) |
+| FusionActNet | Static/Dynamic dual-expert IMU | [2310.02011](https://arxiv.org/abs/2310.02011) |
+| SSL-Wearables | Self-supervised pre-training for HAR | [2206.02909](https://arxiv.org/abs/2206.02909) |
+| UniMTS | Foundation model for IMU (zero-shot) | [2410.19818](https://arxiv.org/abs/2410.19818) |
+| DULA/DEBA | Differentiable ergonomic assessment | [2205.03491](https://arxiv.org/abs/2205.03491) |
+| TinyNav | TFLite Micro on ESP32 (<30ms) | [2603.11071](https://arxiv.org/abs/2603.11071) |
+| AuthentiSense | Few-shot biometric authentication | [2302.02740](https://arxiv.org/abs/2302.02740) |
+| Edge Impulse | TinyML MLOps platform | [2212.03332](https://arxiv.org/abs/2212.03332) |
+
+## 📄 License
+
+MIT License — Free for personal and commercial use.

smart_chair/cloud/aws_iot_integration.py

@@ -0,0 +1,358 @@
+"""
+SmartChair AWS IoT Core Integration.
+
+Architecture:
+  ESP32-S3 → UART/I2C → Raspberry Pi → MQTT/TLS → AWS IoT Core → DynamoDB/S3/Lambda
+
+The ESP32 handles real-time inference locally (TFLite INT8).
+The Raspberry Pi acts as IoT gateway:
+  - Runs complex models (MLSTM-FCN, fatigue detector)
+  - Manages MQTT connection to AWS IoT Core
+  - Publishes telemetry every 5 seconds
+  - Stores raw data locally for model retraining
+  - Handles OTA firmware updates
+
+AWS IoT Core Topics:
+  smartchair/{device_id}/telemetry  — posture + sensor data (every 5s)
+  smartchair/{device_id}/alerts     — risk/fatigue/break alerts
+  smartchair/{device_id}/commands   — remote commands (calibrate, update model)
+  smartchair/{device_id}/shadow     — device shadow (current state)
+"""
+
+import json
+import time
+import ssl
+import os
+from datetime import datetime
+from typing import Dict, Optional, Callable
+from dataclasses import dataclass, field, asdict
+
+
+@dataclass
+class TelemetryPayload:
+    """Standard telemetry packet sent to AWS IoT Core."""
+    device_id: str
+    timestamp: int                    # Unix epoch ms
+    user_id: str = "unknown"
+    
+    # Posture classification
+    posture_class: int = 0
+    posture_name: str = "upright"
+    posture_confidence: float = 0.0
+    
+    # Sensor readings
+    imu_accel: list = field(default_factory=lambda: [0, 0, 9.81])
+    imu_gyro: list = field(default_factory=lambda: [0, 0, 0])
+    load_cells: list = field(default_factory=lambda: [0, 0, 0, 0])
+    thermal_presence: bool = False
+    
+    # Derived metrics
+    pitch_deg: float = 0.0
+    roll_deg: float = 0.0
+    cop_x: float = 0.0
+    cop_y: float = 0.0
+    total_weight_kg: float = 0.0
+    
+    # Risk & fatigue
+    rula_score: int = 1
+    risk_level: str = "negligible"
+    fatigue_level: str = "none"
+    drowsiness_risk: str = "low"
+    
+    # Session
+    session_duration_min: float = 0.0
+    good_posture_pct: float = 100.0
+    posture_score: float = 100.0
+    
+    # Gamification
+    points_today: int = 0
+    streak_days: int = 0
+    
+    def to_json(self) -> str:
+        return json.dumps(asdict(self))
+
+
+@dataclass
+class AlertPayload:
+    """Alert packet for critical events."""
+    device_id: str
+    timestamp: int
+    alert_type: str              # "acute_risk", "fatigue", "break_needed", "chronic_risk"
+    severity: str                # "info", "warning", "critical"
+    message: str
+    action: str = ""
+    user_id: str = "unknown"
+    
+    def to_json(self) -> str:
+        return json.dumps(asdict(self))
+
+
+class AWSIoTClient:
+    """
+    MQTT client for AWS IoT Core communication.
+    
+    Handles:
+    - Secure MQTT connection (TLS 1.2 with X.509 certificates)
+    - Telemetry publishing
+    - Alert publishing
+    - Device shadow updates
+    - Command subscription
+    
+    Certificate setup:
+    1. Create Thing in AWS IoT Core console
+    2. Download: root-CA.pem, device.pem.crt, private.pem.key
+    3. Set paths via environment variables or config
+    """
+    
+    def __init__(self, device_id: str, 
+                 endpoint: Optional[str] = None,
+                 cert_dir: str = "./certs"):
+        self.device_id = device_id
+        self.endpoint = endpoint or os.getenv("AWS_IOT_ENDPOINT", "")
+        self.cert_dir = cert_dir
+        self.client = None
+        self.is_connected = False
+        self.command_callbacks = {}
+        
+        # Topics
+        self.topic_telemetry = f"smartchair/{device_id}/telemetry"
+        self.topic_alerts = f"smartchair/{device_id}/alerts"
+        self.topic_commands = f"smartchair/{device_id}/commands"
+        self.topic_shadow = f"$aws/things/{device_id}/shadow/update"
+    
+    def connect(self) -> bool:
+        """
+        Establish MQTT connection to AWS IoT Core.
+        
+        Returns True if connection successful, False otherwise.
+        
+        Note: Requires paho-mqtt and valid AWS IoT certificates.
+        In production, install via: pip install paho-mqtt awsiotsdk
+        """
+        try:
+            import paho.mqtt.client as mqtt
+        except ImportError:
+            print("⚠️ paho-mqtt not installed. Install with: pip install paho-mqtt")
+            print("   Running in offline/simulation mode.")
+            return False
+        
+        if not self.endpoint:
+            print("⚠️ AWS IoT endpoint not configured. Set AWS_IOT_ENDPOINT env var.")
+            return False
+        
+        cert_path = os.path.join(self.cert_dir, "device.pem.crt")
+        key_path = os.path.join(self.cert_dir, "private.pem.key")
+        ca_path = os.path.join(self.cert_dir, "AmazonRootCA1.pem")
+        
+        if not all(os.path.exists(p) for p in [cert_path, key_path, ca_path]):
+            print("⚠️ AWS IoT certificates not found in", self.cert_dir)
+            print("   Download from AWS IoT Core console → Manage → Things → Certificates")
+            return False
+        
+        self.client = mqtt.Client(client_id=self.device_id, protocol=mqtt.MQTTv311)
+        self.client.tls_set(
+            ca_certs=ca_path,
+            certfile=cert_path,
+            keyfile=key_path,
+            tls_version=ssl.PROTOCOL_TLSv1_2
+        )
+        
+        self.client.on_connect = self._on_connect
+        self.client.on_message = self._on_message
+        self.client.on_disconnect = self._on_disconnect
+        
+        try:
+            self.client.connect(self.endpoint, 8883, 60)
+            self.client.loop_start()
+            self.is_connected = True
+            print(f"✅ Connected to AWS IoT Core: {self.endpoint}")
+            return True
+        except Exception as e:
+            print(f"❌ Connection failed: {e}")
+            return False
+    
+    def _on_connect(self, client, userdata, flags, rc):
+        if rc == 0:
+            print(f"✅ MQTT connected. Subscribing to {self.topic_commands}")
+            client.subscribe(self.topic_commands, qos=1)
+        else:
+            print(f"❌ MQTT connect failed with code {rc}")
+    
+    def _on_message(self, client, userdata, msg):
+        try:
+            payload = json.loads(msg.payload.decode())
+            command = payload.get("command", "")
+            
+            if command in self.command_callbacks:
+                self.command_callbacks[command](payload)
+            else:
+                print(f"📥 Unknown command: {command}")
+        except Exception as e:
+            print(f"❌ Message parse error: {e}")
+    
+    def _on_disconnect(self, client, userdata, rc):
+        self.is_connected = False
+        if rc != 0:
+            print(f"⚠️ Unexpected disconnect (rc={rc}). Attempting reconnect...")
+    
+    def publish_telemetry(self, payload: TelemetryPayload):
+        """Publish telemetry data to AWS IoT Core."""
+        if self.client and self.is_connected:
+            self.client.publish(self.topic_telemetry, payload.to_json(), qos=0)
+        else:
+            # Offline mode — log locally
+            self._log_offline(payload.to_json())
+    
+    def publish_alert(self, payload: AlertPayload):
+        """Publish alert to AWS IoT Core (higher QoS for reliability)."""
+        if self.client and self.is_connected:
+            self.client.publish(self.topic_alerts, payload.to_json(), qos=1)
+        else:
+            self._log_offline(payload.to_json())
+    
+    def update_shadow(self, state: Dict):
+        """Update device shadow with current state."""
+        shadow = {
+            "state": {
+                "reported": state
+            }
+        }
+        if self.client and self.is_connected:
+            self.client.publish(self.topic_shadow, json.dumps(shadow), qos=1)
+    
+    def register_command(self, command: str, callback: Callable):
+        """Register callback for remote commands."""
+        self.command_callbacks[command] = callback
+    
+    def _log_offline(self, payload_json: str):
+        """Store data locally when offline."""
+        log_dir = os.path.join(self.cert_dir, "..", "offline_logs")
+        os.makedirs(log_dir, exist_ok=True)
+        log_file = os.path.join(log_dir, f"{datetime.now().strftime('%Y%m%d')}.jsonl")
+        with open(log_file, 'a') as f:
+            f.write(payload_json + '\n')
+    
+    def disconnect(self):
+        """Clean disconnect."""
+        if self.client:
+            self.client.loop_stop()
+            self.client.disconnect()
+            self.is_connected = False
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# AWS IoT Rules & Lambda Functions (Infrastructure as Code reference)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+AWS_IOT_RULE_TELEMETRY_TO_DYNAMODB = """
+-- AWS IoT Rule SQL: Store telemetry in DynamoDB
+SELECT 
+    device_id,
+    timestamp,
+    user_id,
+    posture_class, posture_name, posture_confidence,
+    rula_score, risk_level, fatigue_level,
+    cop_x, cop_y, total_weight_kg,
+    posture_score, session_duration_min
+FROM 'smartchair/+/telemetry'
+
+-- Action: DynamoDB PutItem
+-- Table: SmartChairTelemetry
+-- Partition Key: device_id (String)
+-- Sort Key: timestamp (Number)
+"""
+
+AWS_IOT_RULE_ALERTS_TO_SNS = """
+-- AWS IoT Rule SQL: Forward critical alerts to SNS
+SELECT 
+    device_id, user_id, alert_type, severity, message, action
+FROM 'smartchair/+/alerts'
+WHERE severity = 'critical'
+
+-- Action: SNS Publish
+-- Topic ARN: arn:aws:sns:region:account:SmartChairCriticalAlerts
+"""
+
+DYNAMODB_TABLE_SCHEMA = {
+    "TableName": "SmartChairTelemetry",
+    "KeySchema": [
+        {"AttributeName": "device_id", "KeyType": "HASH"},
+        {"AttributeName": "timestamp", "KeyType": "RANGE"},
+    ],
+    "AttributeDefinitions": [
+        {"AttributeName": "device_id", "AttributeType": "S"},
+        {"AttributeName": "timestamp", "AttributeType": "N"},
+    ],
+    "BillingMode": "PAY_PER_REQUEST",
+    "GlobalSecondaryIndexes": [
+        {
+            "IndexName": "UserIndex",
+            "KeySchema": [
+                {"AttributeName": "user_id", "KeyType": "HASH"},
+                {"AttributeName": "timestamp", "KeyType": "RANGE"},
+            ],
+            "Projection": {"ProjectionType": "ALL"},
+        }
+    ],
+}
+
+LAMBDA_DAILY_SCORE_CALCULATOR = '''
+# AWS Lambda: Triggered daily by CloudWatch Events
+# Computes and stores daily posture score per user
+
+import boto3
+from datetime import datetime, timedelta
+import json
+from decimal import Decimal
+
+dynamodb = boto3.resource('dynamodb')
+table = dynamodb.Table('SmartChairTelemetry')
+scores_table = dynamodb.Table('SmartChairDailyScores')
+
+def lambda_handler(event, context):
+    """Calculate daily posture scores for all devices."""
+    yesterday = datetime.now() - timedelta(days=1)
+    start_ts = int(yesterday.replace(hour=0, minute=0).timestamp() * 1000)
+    end_ts = int(yesterday.replace(hour=23, minute=59).timestamp() * 1000)
+    
+    # Query yesterday's data
+    response = table.query(
+        KeyConditionExpression='device_id = :did AND #ts BETWEEN :start AND :end',
+        ExpressionAttributeNames={'#ts': 'timestamp'},
+        ExpressionAttributeValues={
+            ':did': event.get('device_id', 'chair_001'),
+            ':start': start_ts,
+            ':end': end_ts,
+        }
+    )
+    
+    items = response['Items']
+    if not items:
+        return {'statusCode': 200, 'body': 'No data for yesterday'}
+    
+    # Compute weighted score
+    posture_weights = {
+        'upright': 1.0, 'forward_lean': 0.4, 'backward_lean': 0.5,
+        'left_lean': 0.6, 'right_lean': 0.6, 'slouch': 0.2
+    }
+    
+    total_weighted = sum(
+        posture_weights.get(item.get('posture_name', 'upright'), 0.5)
+        for item in items
+    )
+    score = (total_weighted / len(items)) * 100
+    
+    # Store daily score
+    scores_table.put_item(Item={
+        'user_id': items[0].get('user_id', 'unknown'),
+        'date': yesterday.strftime('%Y-%m-%d'),
+        'score': Decimal(str(round(score, 1))),
+        'total_readings': len(items),
+        'device_id': event.get('device_id', 'chair_001'),
+    })
+    
+    return {
+        'statusCode': 200,
+        'body': json.dumps({'date': yesterday.strftime('%Y-%m-%d'), 'score': round(score, 1)})
+    }
+'''

smart_chair/config/settings.py

@@ -0,0 +1,122 @@
+"""
+SmartChair Configuration — All system constants and hardware parameters.
+Based on literature: SitPose (arxiv:2412.12216), FusionActNet (arxiv:2310.02011),
+MLSTM-FCN (arxiv:1801.04503), TinyNav (arxiv:2603.11071)
+"""
+
+# ─── Sensor Hardware ───────────────────────────────────────────────────────────
+IMU_SENSOR = "MPU6050"             # or ICM-42688 for better accuracy
+IMU_SAMPLE_RATE_HZ = 50           # matches UCI-HAR standard
+IMU_AXES = 6                       # 3 accel + 3 gyro
+
+LOAD_CELL_COUNT = 4                # FL, FR, RL, RR corners
+LOAD_CELL_CAPACITY_KG = 200       # per cell, HX711 ADC
+LOAD_CELL_SAMPLE_RATE_HZ = 10     # HX711 @ 10 SPS mode
+
+THERMAL_SENSOR = "AMG8833"         # 8x8 IR grid array
+THERMAL_GRID_SIZE = (8, 8)
+THERMAL_SAMPLE_RATE_HZ = 1        # presence detection only
+THERMAL_PRESENCE_THRESHOLD_C = 28.0  # above ambient = human detected
+
+# ─── Posture Classes ───────────────────────────────────────────────────────────
+POSTURE_CLASSES = {
+    0: "upright",
+    1: "forward_lean",
+    2: "backward_lean",
+    3: "left_lean",
+    4: "right_lean",
+    5: "slouch",
+    6: "absent"
+}
+NUM_POSTURE_CLASSES = len(POSTURE_CLASSES)
+
+# ─── ML Model Parameters ──────────────────────────────────────────────────────
+# Sliding window for temporal models (from MLSTM-FCN paper)
+WINDOW_SIZE = 128                  # 128 samples @ 50Hz = 2.56 seconds
+WINDOW_STRIDE = 64                 # 50% overlap
+INPUT_CHANNELS = 14                # 6 IMU + 4 load cells + 2 computed angles + 2 CoP
+
+# Ensemble voting classifier (from SitPose: F1=98.2%)
+ENSEMBLE_SVM_C = 10.0
+ENSEMBLE_SVM_KERNEL = "rbf"
+ENSEMBLE_DT_MAX_DEPTH = 10
+ENSEMBLE_MLP_HIDDEN = (64, 32)
+ENSEMBLE_MLP_MAX_ITER = 500
+
+# MLSTM-FCN architecture (from arxiv:1801.04503)
+MLSTM_FCN_FILTERS = [128, 256, 128]
+MLSTM_FCN_KERNELS = [8, 5, 3]
+MLSTM_FCN_LSTM_UNITS = 8
+MLSTM_FCN_DROPOUT = 0.8
+MLSTM_FCN_SE_RATIO = 16
+
+# Training
+TRAIN_EPOCHS = 100
+TRAIN_BATCH_SIZE = 64
+TRAIN_LR = 1e-3
+TRAIN_VAL_SPLIT = 0.2
+EARLY_STOPPING_PATIENCE = 10
+
+# ─── Fatigue Detection ─────────────────────────────────────────────────────────
+FATIGUE_WINDOW_MINUTES = 30        # rolling window for fatigue analysis
+FATIGUE_COP_VARIANCE_THRESHOLD = 0.15  # high CoP variance = restlessness/fatigue
+FATIGUE_MICRO_MOVEMENT_THRESHOLD = 0.02  # below = fatigue
+DROWSINESS_STILLNESS_SECONDS = 120  # 2 min stillness = possible drowsiness
+
+# ─── Spine Risk (RULA-based, from arxiv:2205.03491) ───────────────────────────
+RULA_TRUNK_ANGLES = [10, 20, 60]   # degree thresholds
+RULA_LATERAL_THRESHOLD = 15        # degrees
+RISK_LEVELS = {1: "negligible", 2: "low", 3: "medium", 4: "high",
+               5: "high", 6: "very_high", 7: "critical"}
+
+# ─── Break Recommendation ─────────────────────────────────────────────────────
+MIN_BREAK_INTERVAL_MINUTES = 20
+MAX_SITTING_MINUTES = 50
+BREAK_DURATION_SECONDS = 120       # 2-minute micro-break
+BREAK_URGENCY_LEVELS = ["gentle", "moderate", "urgent"]
+
+# ─── Multi-User Recognition ───────────────────────────────────────────────────
+USER_ENROLLMENT_SAMPLES = 5        # sit-down events for enrollment
+USER_WEIGHT_TOLERANCE_KG = 3.0     # weight matching tolerance
+USER_COP_TOLERANCE = 0.1           # CoP ratio matching tolerance
+MAX_REGISTERED_USERS = 10
+
+# ─── Gamification ──────────────────────────────────────────────────────────────
+POINTS_PER_GOOD_POSTURE_MINUTE = 10
+POINTS_PER_BREAK_TAKEN = 50
+POINTS_PER_EXERCISE_DONE = 100
+STREAK_BONUS_MULTIPLIER = 1.5
+BADGE_THRESHOLDS = {
+    "posture_novice": 500,
+    "posture_pro": 2000,
+    "posture_master": 5000,
+    "break_champion": 1000,
+    "streak_warrior": 3000,
+    "iron_spine": 10000
+}
+
+# ─── Cloud / AWS IoT Core ─────────────────────────────────────────────────────
+AWS_IOT_ENDPOINT = ""              # set via env var
+AWS_IOT_TOPIC_TELEMETRY = "smartchair/{device_id}/telemetry"
+AWS_IOT_TOPIC_ALERTS = "smartchair/{device_id}/alerts"
+AWS_IOT_TOPIC_COMMANDS = "smartchair/{device_id}/commands"
+MQTT_QOS = 1
+TELEMETRY_PUBLISH_INTERVAL_S = 5   # publish every 5 seconds
+
+# ─── Edge Deployment ──────────────────────────────────────────────────────────
+MICROCONTROLLER = "ESP32-S3"       # Xtensa LX7 dual-core, PSRAM
+TFLITE_ARENA_SIZE_KB = 50          # tensor arena for TFLite Micro
+TARGET_INFERENCE_LATENCY_MS = 30   # from TinyNav benchmarks
+QUANTIZATION = "INT8"              # post-training quantization
+
+# ─── Dashboard ─────────────────────────────────────────────────────────────────
+DASHBOARD_REFRESH_INTERVAL_S = 5
+POSTURE_SCORE_WEIGHTS = {
+    "upright": 1.0,
+    "forward_lean": 0.4,
+    "backward_lean": 0.5,
+    "left_lean": 0.6,
+    "right_lean": 0.6,
+    "slouch": 0.2,
+    "absent": 0.0
+}

smart_chair/data_collection/protocol.py

@@ -0,0 +1,258 @@
+"""
+SmartChair Data Collection Protocol.
+
+Standardized procedure for collecting real sensor data to train production models.
+Based on UCI-HAR and SitPose collection methodology.
+
+Equipment needed:
+- SmartChair hardware (ESP32-S3 + IMU + 4 load cells + thermal)
+- Laptop running this script (USB serial connection to ESP32)
+- Printed posture instruction cards for participants
+- Consent forms
+
+Protocol:
+1. Participant sits on chair
+2. System captures 5 seconds of baseline (upright)
+3. Researcher instructs posture via visual cards
+4. Each posture held for 60 seconds
+5. 10-second rest between postures
+6. Repeat all 6 postures (excluding absent)
+7. Total per participant: ~8 minutes
+8. Target: 20+ participants for 95%+ accuracy
+"""
+
+import json
+import time
+import os
+import numpy as np
+from datetime import datetime
+from typing import Optional
+
+
+class DataCollectionSession:
+    """Manages a single data collection session."""
+    
+    POSTURES_TO_COLLECT = [
+        {"id": 0, "name": "upright", "instruction": "Sit with back straight, feet flat, shoulders relaxed."},
+        {"id": 1, "name": "forward_lean", "instruction": "Lean forward ~15° as if reading something close."},
+        {"id": 2, "name": "backward_lean", "instruction": "Lean back against the backrest, relaxed."},
+        {"id": 3, "name": "left_lean", "instruction": "Lean to the left, resting on left armrest."},
+        {"id": 4, "name": "right_lean", "instruction": "Lean to the right, resting on right armrest."},
+        {"id": 5, "name": "slouch", "instruction": "Slouch forward with rounded shoulders, C-spine."},
+    ]
+    
+    def __init__(self, participant_id: str, participant_weight_kg: float,
+                 output_dir: str = "./collected_data"):
+        self.participant_id = participant_id
+        self.participant_weight = participant_weight_kg
+        self.output_dir = output_dir
+        self.session_id = datetime.now().strftime("%Y%m%d_%H%M%S")
+        self.data = {
+            "metadata": {
+                "participant_id": participant_id,
+                "weight_kg": participant_weight_kg,
+                "session_id": self.session_id,
+                "collection_date": datetime.now().isoformat(),
+                "protocol_version": "1.0",
+                "imu_hz": 50,
+                "load_cell_hz": 10,
+                "thermal_hz": 1,
+            },
+            "recordings": [],
+        }
+        
+        os.makedirs(output_dir, exist_ok=True)
+    
+    def run_collection(self, serial_port: Optional[str] = None):
+        """
+        Run the full data collection protocol.
+        
+        Args:
+            serial_port: Serial port to read from ESP32 (e.g., '/dev/ttyUSB0')
+                        If None, generates synthetic data for testing.
+        """
+        print(f"\n{'='*60}")
+        print(f"DATA COLLECTION SESSION")
+        print(f"Participant: {self.participant_id} ({self.participant_weight} kg)")
+        print(f"Session ID: {self.session_id}")
+        print(f"{'='*60}\n")
+        
+        for posture in self.POSTURES_TO_COLLECT:
+            print(f"\n📌 POSTURE: {posture['name'].upper()}")
+            print(f"   Instruction: {posture['instruction']}")
+            print(f"   Recording for 60 seconds...")
+            
+            input("   Press ENTER when participant is in position...")
+            
+            # Countdown
+            for i in range(3, 0, -1):
+                print(f"   Starting in {i}...")
+                time.sleep(1)
+            
+            # Record data
+            recording = self._record_posture(posture, duration_seconds=60, serial_port=serial_port)
+            self.data["recordings"].append(recording)
+            
+            print(f"   ✅ Recorded {recording['n_imu_samples']} IMU + {recording['n_load_samples']} load samples")
+            
+            print("   Rest for 10 seconds...")
+            time.sleep(2)  # Shortened for demo
+        
+        # Also record absent (empty chair)
+        print(f"\n📌 POSTURE: ABSENT")
+        print(f"   Instruction: Participant stands up. Chair must be empty.")
+        input("   Press ENTER when chair is empty...")
+        
+        recording = self._record_posture(
+            {"id": 6, "name": "absent", "instruction": "Empty chair"},
+            duration_seconds=30, serial_port=serial_port
+        )
+        self.data["recordings"].append(recording)
+        
+        # Save
+        self._save()
+        
+        print(f"\n{'='*60}")
+        print(f"✅ SESSION COMPLETE")
+        print(f"   Total recordings: {len(self.data['recordings'])}")
+        print(f"   Saved to: {self.output_dir}/{self.participant_id}_{self.session_id}.json")
+        print(f"{'='*60}\n")
+    
+    def _record_posture(self, posture: dict, duration_seconds: int,
+                        serial_port: Optional[str] = None) -> dict:
+        """Record sensor data for one posture hold."""
+        start_time = time.time()
+        imu_samples = []
+        load_samples = []
+        
+        if serial_port:
+            # Real hardware — read from ESP32 UART
+            import serial
+            ser = serial.Serial(serial_port, 115200, timeout=0.1)
+            
+            while time.time() - start_time < duration_seconds:
+                line = ser.readline().decode().strip()
+                if line:
+                    try:
+                        data = json.loads(line)
+                        if "imu" in data:
+                            imu_samples.append(data["imu"])
+                        if "load" in data:
+                            load_samples.append(data["load"])
+                    except json.JSONDecodeError:
+                        pass
+            
+            ser.close()
+        else:
+            # Synthetic data for protocol testing
+            from smart_chair.data_collection.synthetic_data_generator import (
+                generate_imu_data, generate_load_cell_data
+            )
+            
+            n_imu = duration_seconds * 50  # 50 Hz
+            n_load = duration_seconds * 10  # 10 Hz
+            
+            imu_data = generate_imu_data(posture["id"], n_imu, self.participant_weight)
+            load_data = generate_load_cell_data(posture["id"], n_load, self.participant_weight)
+            
+            imu_samples = imu_data.tolist()
+            load_samples = load_data.tolist()
+        
+        return {
+            "posture_id": posture["id"],
+            "posture_name": posture["name"],
+            "duration_seconds": duration_seconds,
+            "n_imu_samples": len(imu_samples),
+            "n_load_samples": len(load_samples),
+            "imu_data": imu_samples,
+            "load_data": load_samples,
+            "timestamp_start": datetime.fromtimestamp(start_time).isoformat(),
+        }
+    
+    def _save(self):
+        """Save collected data to JSON."""
+        filename = f"{self.participant_id}_{self.session_id}.json"
+        filepath = os.path.join(self.output_dir, filename)
+        
+        with open(filepath, 'w') as f:
+            json.dump(self.data, f)
+        
+        # Also save as numpy arrays for direct ML training
+        for rec in self.data["recordings"]:
+            npy_dir = os.path.join(self.output_dir, "numpy", self.participant_id)
+            os.makedirs(npy_dir, exist_ok=True)
+            
+            np.save(os.path.join(npy_dir, f"{rec['posture_name']}_imu.npy"), 
+                    np.array(rec['imu_data'], dtype=np.float32))
+            np.save(os.path.join(npy_dir, f"{rec['posture_name']}_load.npy"),
+                    np.array(rec['load_data'], dtype=np.float32))
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# DATASET PREPARATION
+# ═══════════════════════════════════════════════════════════════════════════════
+
+def prepare_training_dataset(data_dir: str = "./collected_data") -> dict:
+    """
+    Load all collected data and prepare for model training.
+    Applies subject-based train/test split.
+    
+    Returns:
+        dict with train/test arrays + metadata
+    """
+    import glob
+    
+    all_imu = []
+    all_load = []
+    all_labels = []
+    all_subjects = []
+    subject_map = {}
+    
+    json_files = glob.glob(os.path.join(data_dir, "*.json"))
+    
+    for fpath in sorted(json_files):
+        with open(fpath) as f:
+            session = json.load(f)
+        
+        pid = session["metadata"]["participant_id"]
+        if pid not in subject_map:
+            subject_map[pid] = len(subject_map)
+        sid = subject_map[pid]
+        
+        for rec in session["recordings"]:
+            imu = np.array(rec["imu_data"], dtype=np.float32)
+            load = np.array(rec["load_data"], dtype=np.float32)
+            
+            # Align lengths (IMU at 50Hz, load at 10Hz — upsample load)
+            n = min(len(imu), len(load) * 5)
+            imu = imu[:n]
+            
+            # Repeat load cells to match IMU rate
+            load_upsampled = np.repeat(load, 5, axis=0)[:n]
+            
+            labels = np.full(n, rec["posture_id"], dtype=np.int32)
+            subjects = np.full(n, sid, dtype=np.int32)
+            
+            all_imu.append(imu)
+            all_load.append(load_upsampled)
+            all_labels.append(labels)
+            all_subjects.append(subjects)
+    
+    if not all_imu:
+        print("⚠️ No data found. Run data collection first.")
+        return None
+    
+    dataset = {
+        "imu_data": np.concatenate(all_imu),
+        "load_data": np.concatenate(all_load),
+        "labels": np.concatenate(all_labels),
+        "subject_ids": np.concatenate(all_subjects),
+        "n_subjects": len(subject_map),
+        "subject_map": subject_map,
+    }
+    
+    print(f"Loaded {len(json_files)} sessions, {len(subject_map)} participants")
+    print(f"Total samples: {len(dataset['labels'])}")
+    print(f"Class distribution: {np.bincount(dataset['labels'])}")
+    
+    return dataset

smart_chair/data_collection/synthetic_data_generator.py

@@ -0,0 +1,327 @@
+"""
+Synthetic Data Generator for SmartChair Development & Testing.
+Generates realistic IMU + Load Cell + Thermal sensor data for each posture class.
+
+Physics-based: Each posture has characteristic sensor signatures derived from
+biomechanical models of seated humans. Noise levels match real MPU6050 + HX711 specs.
+
+Used for: model architecture validation, pipeline testing, and pre-training before
+real data collection. Real data collection protocol is in data_collection/protocol.py
+"""
+
+import numpy as np
+from typing import Dict, Tuple, Optional
+
+
+# ─── Posture Sensor Signatures ─────────────────────────────────────────────────
+# Based on biomechanics literature and SitPose angular distributions
+# Format: (accel_mean_xyz, gyro_mean_xyz, load_ratios_FLFRRLRR)
+POSTURE_SIGNATURES = {
+    0: {  # Upright (good posture)
+        "name": "upright",
+        "accel_mean": [0.0, 0.0, 9.81],      # gravity along z
+        "accel_std": [0.05, 0.05, 0.05],
+        "gyro_mean": [0.0, 0.0, 0.0],
+        "gyro_std": [0.02, 0.02, 0.02],
+        "load_ratios": [0.25, 0.25, 0.25, 0.25],  # balanced
+        "load_std": [0.02, 0.02, 0.02, 0.02],
+        "thermal_center": (4, 4),              # centered on 8x8 grid
+        "thermal_spread": 2.0,
+    },
+    1: {  # Forward lean
+        "name": "forward_lean",
+        "accel_mean": [2.5, 0.0, 9.5],        # tilted forward ~15°
+        "accel_std": [0.08, 0.05, 0.08],
+        "gyro_mean": [0.0, 0.3, 0.0],         # slow forward rotation
+        "gyro_std": [0.03, 0.05, 0.03],
+        "load_ratios": [0.35, 0.35, 0.15, 0.15],  # front-heavy
+        "load_std": [0.03, 0.03, 0.02, 0.02],
+        "thermal_center": (3, 4),
+        "thermal_spread": 2.5,
+    },
+    2: {  # Backward lean
+        "name": "backward_lean",
+        "accel_mean": [-1.8, 0.0, 9.6],       # tilted backward ~10°
+        "accel_std": [0.06, 0.05, 0.06],
+        "gyro_mean": [0.0, -0.2, 0.0],
+        "gyro_std": [0.03, 0.04, 0.03],
+        "load_ratios": [0.15, 0.15, 0.35, 0.35],  # rear-heavy
+        "load_std": [0.02, 0.02, 0.03, 0.03],
+        "thermal_center": (5, 4),
+        "thermal_spread": 2.0,
+    },
+    3: {  # Left lean
+        "name": "left_lean",
+        "accel_mean": [0.0, -2.0, 9.6],       # tilted left ~12°
+        "accel_std": [0.05, 0.07, 0.06],
+        "gyro_mean": [0.2, 0.0, 0.0],
+        "gyro_std": [0.04, 0.03, 0.03],
+        "load_ratios": [0.35, 0.15, 0.35, 0.15],  # left-heavy
+        "load_std": [0.03, 0.02, 0.03, 0.02],
+        "thermal_center": (4, 3),
+        "thermal_spread": 2.0,
+    },
+    4: {  # Right lean
+        "name": "right_lean",
+        "accel_mean": [0.0, 2.0, 9.6],        # tilted right ~12°
+        "accel_std": [0.05, 0.07, 0.06],
+        "gyro_mean": [-0.2, 0.0, 0.0],
+        "gyro_std": [0.04, 0.03, 0.03],
+        "load_ratios": [0.15, 0.35, 0.15, 0.35],  # right-heavy
+        "load_std": [0.02, 0.03, 0.02, 0.03],
+        "thermal_center": (4, 5),
+        "thermal_spread": 2.0,
+    },
+    5: {  # Slouch (worst posture — spine C-curve)
+        "name": "slouch",
+        "accel_mean": [3.2, 0.0, 9.2],        # deep forward tilt ~20°
+        "accel_std": [0.1, 0.06, 0.1],
+        "gyro_mean": [0.0, 0.5, 0.0],         # slow drift
+        "gyro_std": [0.04, 0.06, 0.04],
+        "load_ratios": [0.30, 0.30, 0.20, 0.20],  # front-heavy + reclined
+        "load_std": [0.04, 0.04, 0.03, 0.03],
+        "thermal_center": (3, 4),
+        "thermal_spread": 3.0,
+    },
+    6: {  # Absent (empty chair)
+        "name": "absent",
+        "accel_mean": [0.0, 0.0, 9.81],       # pure gravity
+        "accel_std": [0.01, 0.01, 0.01],       # very low noise
+        "gyro_mean": [0.0, 0.0, 0.0],
+        "gyro_std": [0.01, 0.01, 0.01],
+        "load_ratios": [0.0, 0.0, 0.0, 0.0],  # no weight
+        "load_std": [0.005, 0.005, 0.005, 0.005],
+        "thermal_center": (4, 4),
+        "thermal_spread": 0.5,
+    },
+}
+
+
+def generate_imu_data(posture_id: int, n_samples: int, 
+                       user_weight_kg: float = 70.0,
+                       noise_scale: float = 1.0,
+                       rng: Optional[np.random.Generator] = None) -> np.ndarray:
+    """
+    Generate synthetic IMU data for a given posture.
+    
+    Args:
+        posture_id: 0-6 posture class
+        n_samples: number of time steps
+        user_weight_kg: affects micro-movement amplitude
+        noise_scale: multiplier for sensor noise (1.0 = realistic MPU6050)
+        rng: random generator for reproducibility
+    
+    Returns:
+        imu_data: shape (n_samples, 6) — [ax, ay, az, gx, gy, gz]
+    """
+    if rng is None:
+        rng = np.random.default_rng(42)
+    
+    sig = POSTURE_SIGNATURES[posture_id]
+    
+    # Base signal + Gaussian noise + slow drift (realistic sensor behavior)
+    accel = np.tile(sig["accel_mean"], (n_samples, 1))
+    accel += rng.normal(0, sig["accel_std"], (n_samples, 3)) * noise_scale
+    
+    # Add micro-movements (breathing, fidgeting) — frequency ~0.3Hz
+    t = np.arange(n_samples) / 50.0
+    breathing = 0.02 * np.sin(2 * np.pi * 0.3 * t)
+    accel[:, 0] += breathing * (user_weight_kg / 70.0)
+    accel[:, 2] += breathing * 0.5
+    
+    # Gyroscope
+    gyro = np.tile(sig["gyro_mean"], (n_samples, 1))
+    gyro += rng.normal(0, sig["gyro_std"], (n_samples, 3)) * noise_scale
+    
+    # Add slow drift (realistic IMU behavior)
+    drift = np.cumsum(rng.normal(0, 0.0005, (n_samples, 3)), axis=0)
+    gyro += drift
+    
+    return np.concatenate([accel, gyro], axis=1).astype(np.float32)
+
+
+def generate_load_cell_data(posture_id: int, n_samples: int,
+                             user_weight_kg: float = 70.0,
+                             noise_scale: float = 1.0,
+                             rng: Optional[np.random.Generator] = None) -> np.ndarray:
+    """
+    Generate synthetic load cell data for a given posture.
+    
+    Args:
+        posture_id: 0-6 posture class
+        n_samples: number of time steps
+        user_weight_kg: total body weight
+        noise_scale: HX711 noise multiplier
+        rng: random generator
+    
+    Returns:
+        load_data: shape (n_samples, 4) — [FL, FR, RL, RR] in kg
+    """
+    if rng is None:
+        rng = np.random.default_rng(42)
+    
+    sig = POSTURE_SIGNATURES[posture_id]
+    ratios = np.array(sig["load_ratios"])
+    
+    # Base weight distribution
+    base_loads = ratios * user_weight_kg
+    
+    # Temporal variation + noise
+    loads = np.tile(base_loads, (n_samples, 1))
+    loads += rng.normal(0, sig["load_std"], (n_samples, 4)) * user_weight_kg * noise_scale
+    
+    # Add slow weight shifting (postural micro-adjustments ~0.1Hz)
+    t = np.arange(n_samples) / 10.0  # load cells at 10 Hz
+    shift = 0.5 * np.sin(2 * np.pi * 0.05 * t)
+    loads[:, 0] += shift
+    loads[:, 1] -= shift
+    
+    # Ensure non-negative
+    loads = np.maximum(loads, 0)
+    
+    return loads.astype(np.float32)
+
+
+def generate_thermal_data(posture_id: int, n_samples: int,
+                           ambient_temp: float = 22.0,
+                           body_temp: float = 34.0,
+                           rng: Optional[np.random.Generator] = None) -> np.ndarray:
+    """
+    Generate synthetic AMG8833 thermal grid data.
+    
+    Args:
+        posture_id: 0-6 posture class
+        n_samples: number of frames (at 1 Hz)
+        ambient_temp: room temperature
+        body_temp: skin surface temperature
+        rng: random generator
+    
+    Returns:
+        thermal_data: shape (n_samples, 8, 8) — temperature grid in °C
+    """
+    if rng is None:
+        rng = np.random.default_rng(42)
+    
+    sig = POSTURE_SIGNATURES[posture_id]
+    cy, cx = sig["thermal_center"]
+    spread = sig["thermal_spread"]
+    
+    # Create 2D Gaussian heat map (person's thermal signature)
+    yy, xx = np.meshgrid(np.arange(8), np.arange(8), indexing='ij')
+    
+    frames = []
+    for _ in range(n_samples):
+        if posture_id == 6:  # absent — ambient only
+            frame = ambient_temp + rng.normal(0, 0.3, (8, 8))
+        else:
+            # Gaussian blob centered at posture-specific position
+            dist = np.sqrt((xx - cx)**2 + (yy - cy)**2)
+            heat = (body_temp - ambient_temp) * np.exp(-dist**2 / (2 * spread**2))
+            frame = ambient_temp + heat + rng.normal(0, 0.5, (8, 8))
+        
+        frames.append(frame)
+    
+    return np.array(frames, dtype=np.float32)
+
+
+def generate_dataset(n_subjects: int = 20,
+                     samples_per_posture_per_subject: int = 500,
+                     posture_classes: int = 7,
+                     seed: int = 42) -> Dict:
+    """
+    Generate a complete synthetic dataset with multiple virtual subjects.
+    Each subject has a unique weight and sitting style.
+    
+    Returns:
+        dict with keys: imu_data, load_data, thermal_data, labels, subject_ids, 
+                        subject_weights, feature_names
+    """
+    rng = np.random.default_rng(seed)
+    
+    all_imu = []
+    all_load = []
+    all_thermal = []
+    all_labels = []
+    all_subjects = []
+    all_weights = []
+    
+    for subj_id in range(n_subjects):
+        # Each subject has unique characteristics
+        weight = rng.normal(70, 15)  # kg, mean=70, std=15
+        weight = np.clip(weight, 40, 120)
+        noise_scale = rng.uniform(0.8, 1.2)  # individual sensor noise variation
+        
+        for posture_id in range(posture_classes):
+            n = samples_per_posture_per_subject
+            
+            imu = generate_imu_data(posture_id, n, weight, noise_scale, rng)
+            load = generate_load_cell_data(posture_id, n, weight, noise_scale, rng)
+            thermal = generate_thermal_data(posture_id, max(1, n // 50), rng=rng)
+            
+            all_imu.append(imu)
+            all_load.append(load)
+            all_thermal.append(thermal)
+            all_labels.append(np.full(n, posture_id, dtype=np.int32))
+            all_subjects.append(np.full(n, subj_id, dtype=np.int32))
+            all_weights.append(weight)
+    
+    return {
+        "imu_data": np.concatenate(all_imu, axis=0),
+        "load_data": np.concatenate(all_load, axis=0),
+        "thermal_data": np.concatenate(all_thermal, axis=0),
+        "labels": np.concatenate(all_labels, axis=0),
+        "subject_ids": np.concatenate(all_subjects, axis=0),
+        "subject_weights": np.array(all_weights),
+        "n_subjects": n_subjects,
+        "n_postures": posture_classes,
+    }
+
+
+def subject_based_split(dataset: Dict, train_ratio: float = 0.7, seed: int = 42):
+    """
+    Split dataset by subject (NOT by sample) to prevent data leakage.
+    This is critical — per SSL-Wearables paper, random splits inflate accuracy 5-10%.
+    
+    Returns:
+        train_dataset, test_dataset (same dict structure)
+    """
+    rng = np.random.default_rng(seed)
+    n_subjects = dataset["n_subjects"]
+    
+    subject_ids = np.arange(n_subjects)
+    rng.shuffle(subject_ids)
+    
+    n_train = int(n_subjects * train_ratio)
+    train_subjects = set(subject_ids[:n_train])
+    test_subjects = set(subject_ids[n_train:])
+    
+    train_mask = np.isin(dataset["subject_ids"], list(train_subjects))
+    test_mask = np.isin(dataset["subject_ids"], list(test_subjects))
+    
+    def apply_mask(d, mask):
+        return {
+            "imu_data": d["imu_data"][mask],
+            "load_data": d["load_data"][mask],
+            "labels": d["labels"][mask],
+            "subject_ids": d["subject_ids"][mask],
+        }
+    
+    print(f"Subject-based split: {len(train_subjects)} train / {len(test_subjects)} test subjects")
+    print(f"Samples: {train_mask.sum()} train / {test_mask.sum()} test")
+    
+    return apply_mask(dataset, train_mask), apply_mask(dataset, test_mask)
+
+
+if __name__ == "__main__":
+    print("Generating synthetic SmartChair dataset...")
+    dataset = generate_dataset(n_subjects=20, samples_per_posture_per_subject=500)
+    
+    print(f"IMU shape: {dataset['imu_data'].shape}")
+    print(f"Load shape: {dataset['load_data'].shape}")
+    print(f"Labels shape: {dataset['labels'].shape}")
+    print(f"Subjects shape: {dataset['subject_ids'].shape}")
+    print(f"Class distribution: {np.bincount(dataset['labels'])}")
+    
+    train, test = subject_based_split(dataset)
+    print(f"\nTrain: {train['imu_data'].shape[0]} samples")
+    print(f"Test:  {test['imu_data'].shape[0]} samples")

smart_chair/firmware/esp32_firmware.ino

@@ -0,0 +1,563 @@
+/*
+ * SmartChair ESP32-S3 Firmware
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 
+ * Hardware:
+ *   - ESP32-S3 (Xtensa LX7 dual-core, 240MHz, 8MB PSRAM)
+ *   - MPU6050 IMU (I2C, 50Hz sampling)
+ *   - 4× HX711 Load Cell Amplifiers (10 SPS each)
+ *   - AMG8833 8×8 Thermal Grid (I2C, 1Hz)
+ *   - WS2812B Status LED
+ *   - Vibration Motor (GPIO PWM)
+ * 
+ * ML Inference:
+ *   - TFLite Micro INT8 posture classifier (<50KB, <30ms inference)
+ *   - OR: micromlgen Random Forest (~5KB, <5ms inference)
+ * 
+ * Communication:
+ *   - UART to Raspberry Pi (for complex inference + cloud)
+ *   - WiFi for direct MQTT (optional, if no RPi)
+ *   - BLE for mobile app connection
+ * 
+ * Based on: TinyNav ESP32 deployment (arxiv:2603.11071)
+ */
+
+#include <Wire.h>
+#include <WiFi.h>
+#include <PubSubClient.h>
+#include <ArduinoJson.h>
+
+// ─── TFLite Micro (uncomment if using neural network) ────────────────────────
+// #include "tensorflow/lite/micro/all_ops_resolver.h"
+// #include "tensorflow/lite/micro/micro_interpreter.h"
+// #include "tensorflow/lite/micro/micro_error_reporter.h"
+// #include "model_data.h"  // Generated: xxd -i posture_model.tflite > model_data.h
+
+// ─── micromlgen (uncomment if using Random Forest) ───────────────────────────
+// #include "posture_classifier.h"  // Generated by micromlgen
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CONFIGURATION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+// WiFi
+const char* WIFI_SSID = "YOUR_WIFI_SSID";
+const char* WIFI_PASS = "YOUR_WIFI_PASSWORD";
+
+// MQTT (AWS IoT Core or local Mosquitto)
+const char* MQTT_BROKER = "YOUR_AWS_IOT_ENDPOINT.iot.region.amazonaws.com";
+const int MQTT_PORT = 8883;
+const char* DEVICE_ID = "chair_001";
+
+// Pin assignments
+#define IMU_SDA 21
+#define IMU_SCL 22
+#define HX711_DOUT_FL 32
+#define HX711_SCK_FL  33
+#define HX711_DOUT_FR 25
+#define HX711_SCK_FR  26
+#define HX711_DOUT_RL 27
+#define HX711_SCK_RL  14
+#define HX711_DOUT_RR 12
+#define HX711_SCK_RR  13
+#define LED_PIN 48         // WS2812B
+#define VIBRATION_PIN 4    // PWM motor
+#define THERMAL_SDA 21     // shared I2C bus
+#define THERMAL_SCL 22
+
+// Sensor sampling
+#define IMU_SAMPLE_HZ 50
+#define LOAD_SAMPLE_HZ 10
+#define THERMAL_SAMPLE_HZ 1
+#define INFERENCE_INTERVAL_MS 2560  // 2.56s window (128 samples @ 50Hz)
+
+// ML Model
+#define WINDOW_SIZE 128
+#define NUM_FEATURES 11       // 6 IMU + 4 load + 1 total_weight (for tabular)
+#define NUM_CLASSES 7
+#define TFLITE_ARENA_KB 50
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// GLOBAL STATE
+// ═══════════════════════════════════════════════════════════════════════════════
+
+// Sensor buffers
+float imu_buffer[WINDOW_SIZE][6];      // [ax, ay, az, gx, gy, gz]
+float load_buffer[WINDOW_SIZE][4];     // [FL, FR, RL, RR]
+int buffer_idx = 0;
+bool buffer_full = false;
+
+// Current readings
+float accel[3] = {0, 0, 9.81};
+float gyro[3] = {0, 0, 0};
+float load_cells[4] = {0, 0, 0, 0};
+float thermal_max = 22.0;
+
+// Inference state
+int current_posture = 0;              // 0-6
+float posture_confidence = 0.0;
+unsigned long last_inference_ms = 0;
+unsigned long session_start_ms = 0;
+
+// Posture names
+const char* POSTURE_NAMES[] = {
+    "upright", "forward_lean", "backward_lean",
+    "left_lean", "right_lean", "slouch", "absent"
+};
+
+// MQTT
+WiFiClient espClient;
+PubSubClient mqtt(espClient);
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// SENSOR READING
+// ═══════════════════════════════════════════════════════════════════════════════
+
+void initMPU6050() {
+    Wire.begin(IMU_SDA, IMU_SCL);
+    Wire.beginTransmission(0x68);  // MPU6050 address
+    Wire.write(0x6B);              // PWR_MGMT_1 register
+    Wire.write(0x00);              // Wake up
+    Wire.endTransmission(true);
+    
+    // Set accelerometer range to ±4g
+    Wire.beginTransmission(0x68);
+    Wire.write(0x1C);
+    Wire.write(0x08);  // ±4g
+    Wire.endTransmission(true);
+    
+    // Set gyroscope range to ±500°/s
+    Wire.beginTransmission(0x68);
+    Wire.write(0x1B);
+    Wire.write(0x08);  // ±500°/s
+    Wire.endTransmission(true);
+    
+    // Set sample rate to 50Hz
+    Wire.beginTransmission(0x68);
+    Wire.write(0x19);
+    Wire.write(0x09);  // 1000/(1+9) = 100Hz internal, DLPF = 50Hz
+    Wire.endTransmission(true);
+    
+    Serial.println("[IMU] MPU6050 initialized @ 50Hz, ±4g, ±500°/s");
+}
+
+void readMPU6050() {
+    Wire.beginTransmission(0x68);
+    Wire.write(0x3B);  // Starting register
+    Wire.endTransmission(false);
+    Wire.requestFrom(0x68, 14, true);
+    
+    // Accelerometer (m/s²)
+    accel[0] = (Wire.read() << 8 | Wire.read()) / 8192.0 * 9.81;  // ±4g
+    accel[1] = (Wire.read() << 8 | Wire.read()) / 8192.0 * 9.81;
+    accel[2] = (Wire.read() << 8 | Wire.read()) / 8192.0 * 9.81;
+    
+    // Temperature (skip)
+    Wire.read(); Wire.read();
+    
+    // Gyroscope (rad/s)
+    gyro[0] = (Wire.read() << 8 | Wire.read()) / 65.5 * (M_PI / 180.0);  // ±500°/s
+    gyro[1] = (Wire.read() << 8 | Wire.read()) / 65.5 * (M_PI / 180.0);
+    gyro[2] = (Wire.read() << 8 | Wire.read()) / 65.5 * (M_PI / 180.0);
+}
+
+// ─── HX711 Load Cell Reading ─────────────────────────────────────────────────
+
+long readHX711(int dout_pin, int sck_pin) {
+    // Wait for HX711 to be ready
+    while (digitalRead(dout_pin));
+    
+    long value = 0;
+    for (int i = 0; i < 24; i++) {
+        digitalWrite(sck_pin, HIGH);
+        delayMicroseconds(1);
+        value = (value << 1) | digitalRead(dout_pin);
+        digitalWrite(sck_pin, LOW);
+        delayMicroseconds(1);
+    }
+    
+    // 25th pulse: gain = 128 (channel A)
+    digitalWrite(sck_pin, HIGH);
+    delayMicroseconds(1);
+    digitalWrite(sck_pin, LOW);
+    delayMicroseconds(1);
+    
+    // Sign extend
+    if (value & 0x800000) value |= 0xFF000000;
+    
+    return value;
+}
+
+void readLoadCells() {
+    static float calibration[4] = {420.0, 420.0, 420.0, 420.0};  // calibration factors
+    static long tare[4] = {0, 0, 0, 0};
+    
+    long raw_fl = readHX711(HX711_DOUT_FL, HX711_SCK_FL);
+    long raw_fr = readHX711(HX711_DOUT_FR, HX711_SCK_FR);
+    long raw_rl = readHX711(HX711_DOUT_RL, HX711_SCK_RL);
+    long raw_rr = readHX711(HX711_DOUT_RR, HX711_SCK_RR);
+    
+    load_cells[0] = (raw_fl - tare[0]) / calibration[0];  // FL in kg
+    load_cells[1] = (raw_fr - tare[1]) / calibration[1];  // FR in kg
+    load_cells[2] = (raw_rl - tare[2]) / calibration[2];  // RL in kg
+    load_cells[3] = (raw_rr - tare[3]) / calibration[3];  // RR in kg
+    
+    // Clamp to reasonable range
+    for (int i = 0; i < 4; i++) {
+        load_cells[i] = max(0.0f, min(200.0f, load_cells[i]));
+    }
+}
+
+// ─── Thermal Presence Detection ──────────────────────────────────────────────
+
+bool readThermalPresence() {
+    // AMG8833 at I2C address 0x69
+    Wire.beginTransmission(0x69);
+    Wire.write(0x80);  // Pixel data start register
+    Wire.endTransmission(false);
+    
+    float max_temp = 0;
+    for (int i = 0; i < 64; i++) {
+        Wire.requestFrom(0x69, 2);
+        int16_t raw = Wire.read() | (Wire.read() << 8);
+        float temp = raw * 0.25;  // 0.25°C resolution
+        if (temp > max_temp) max_temp = temp;
+    }
+    
+    thermal_max = max_temp;
+    return max_temp > 28.0;  // Human presence threshold
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// FEATURE EXTRACTION (on-device)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+void extractFeatures(float* features) {
+    // Tabular features for Random Forest / ensemble classifier
+    // 11 features: 6 IMU stats + 4 load cell ratios + 1 total weight
+    
+    float acc_mean[3] = {0}, gyro_mean[3] = {0};
+    float total_weight_sum = 0;
+    
+    for (int i = 0; i < WINDOW_SIZE; i++) {
+        for (int j = 0; j < 3; j++) {
+            acc_mean[j] += imu_buffer[i][j];
+            gyro_mean[j] += imu_buffer[i][j + 3];
+        }
+        for (int j = 0; j < 4; j++) {
+            total_weight_sum += load_buffer[i][j];
+        }
+    }
+    
+    for (int j = 0; j < 3; j++) {
+        acc_mean[j] /= WINDOW_SIZE;
+        gyro_mean[j] /= WINDOW_SIZE;
+    }
+    
+    float total_weight = total_weight_sum / WINDOW_SIZE;
+    
+    // Compute pitch and roll (degrees)
+    float pitch = atan2(acc_mean[0], sqrt(acc_mean[1]*acc_mean[1] + acc_mean[2]*acc_mean[2])) * 180.0 / M_PI;
+    float roll = atan2(acc_mean[1], sqrt(acc_mean[0]*acc_mean[0] + acc_mean[2]*acc_mean[2])) * 180.0 / M_PI;
+    
+    // Load cell ratios (last reading)
+    float lc_total = load_cells[0] + load_cells[1] + load_cells[2] + load_cells[3] + 0.001;
+    
+    // Pack features
+    features[0] = pitch;
+    features[1] = roll;
+    features[2] = acc_mean[2];         // vertical acceleration
+    features[3] = gyro_mean[0];        // roll rate
+    features[4] = gyro_mean[1];        // pitch rate  
+    features[5] = gyro_mean[2];        // yaw rate
+    features[6] = load_cells[0] / lc_total;  // FL ratio
+    features[7] = load_cells[1] / lc_total;  // FR ratio
+    features[8] = load_cells[2] / lc_total;  // RL ratio
+    features[9] = load_cells[3] / lc_total;  // RR ratio
+    features[10] = total_weight;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ML INFERENCE
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/* 
+ * Option A: TFLite Micro (neural network)
+ * Uncomment the TFLite includes above and this function
+ */
+/*
+static uint8_t tensor_arena[TFLITE_ARENA_KB * 1024];
+
+void runTFLiteInference(float* features) {
+    static bool initialized = false;
+    static tflite::MicroInterpreter* interpreter = nullptr;
+    
+    if (!initialized) {
+        static tflite::AllOpsResolver resolver;
+        const tflite::Model* model = tflite::GetModel(g_model);
+        static tflite::MicroInterpreter static_interpreter(
+            model, resolver, tensor_arena, TFLITE_ARENA_KB * 1024);
+        interpreter = &static_interpreter;
+        interpreter->AllocateTensors();
+        initialized = true;
+    }
+    
+    // Copy features to input tensor
+    TfLiteTensor* input = interpreter->input(0);
+    for (int i = 0; i < NUM_FEATURES; i++) {
+        input->data.f[i] = features[i];  // or quantize for INT8
+    }
+    
+    // Run inference
+    interpreter->Invoke();
+    
+    // Get output
+    TfLiteTensor* output = interpreter->output(0);
+    float max_prob = -1;
+    for (int i = 0; i < NUM_CLASSES; i++) {
+        float prob = output->data.f[i];
+        if (prob > max_prob) {
+            max_prob = prob;
+            current_posture = i;
+        }
+    }
+    posture_confidence = max_prob;
+}
+*/
+
+/*
+ * Option B: micromlgen Random Forest (lighter, no framework needed)
+ * Uncomment posture_classifier.h include and this function
+ */
+/*
+void runRFInference(float* features) {
+    current_posture = posture_classifier_predict(features);
+    posture_confidence = 0.95;  // RF doesn't provide per-sample probabilities
+}
+*/
+
+// Rule-based fallback (works without ML model, for testing)
+void runRuleBasedInference(float* features) {
+    float pitch = features[0];
+    float roll = features[1];
+    float total_weight = features[10];
+    
+    // No one sitting
+    if (total_weight < 5.0 || !readThermalPresence()) {
+        current_posture = 6;  // absent
+        posture_confidence = 0.99;
+        return;
+    }
+    
+    // Rule-based posture detection from angles
+    if (abs(pitch) < 10 && abs(roll) < 10) {
+        current_posture = 0;  // upright
+        posture_confidence = 0.85;
+    } else if (pitch > 20) {
+        current_posture = 5;  // slouch (deep forward)
+        posture_confidence = 0.80;
+    } else if (pitch > 10) {
+        current_posture = 1;  // forward lean
+        posture_confidence = 0.75;
+    } else if (pitch < -10) {
+        current_posture = 2;  // backward lean
+        posture_confidence = 0.75;
+    } else if (roll < -10) {
+        current_posture = 3;  // left lean
+        posture_confidence = 0.70;
+    } else if (roll > 10) {
+        current_posture = 4;  // right lean
+        posture_confidence = 0.70;
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MQTT PUBLISHING
+// ═══════════════════════════════════════════════════════════════════════════════
+
+void publishTelemetry() {
+    StaticJsonDocument<512> doc;
+    
+    doc["device_id"] = DEVICE_ID;
+    doc["timestamp"] = millis();
+    doc["posture"] = current_posture;
+    doc["posture_name"] = POSTURE_NAMES[current_posture];
+    doc["confidence"] = posture_confidence;
+    
+    float lc_total = load_cells[0] + load_cells[1] + load_cells[2] + load_cells[3];
+    float cop_x = (load_cells[1] + load_cells[3] - load_cells[0] - load_cells[2]) / (lc_total + 0.001);
+    float cop_y = (load_cells[0] + load_cells[1] - load_cells[2] - load_cells[3]) / (lc_total + 0.001);
+    
+    doc["cop_x"] = cop_x;
+    doc["cop_y"] = cop_y;
+    doc["weight_kg"] = lc_total;
+    doc["thermal_present"] = thermal_max > 28.0;
+    doc["session_min"] = (millis() - session_start_ms) / 60000.0;
+    
+    char buffer[512];
+    serializeJson(doc, buffer);
+    
+    // Publish to MQTT or send via UART to RPi
+    if (mqtt.connected()) {
+        char topic[64];
+        snprintf(topic, sizeof(topic), "smartchair/%s/telemetry", DEVICE_ID);
+        mqtt.publish(topic, buffer);
+    }
+    
+    // Always send to RPi via UART for complex processing
+    Serial.println(buffer);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// HAPTIC & VISUAL FEEDBACK
+// ═══════════════════════════════════════════════════════════════════════════════
+
+void updateFeedback() {
+    // LED color based on posture quality
+    // Green = good, Yellow = moderate, Red = bad
+    switch(current_posture) {
+        case 0:  // upright
+            // setLED(0, 255, 0);  // green
+            break;
+        case 1:  // forward lean
+        case 2:  // backward lean
+            // setLED(255, 165, 0);  // orange
+            break;
+        case 3:  // left lean
+        case 4:  // right lean
+            // setLED(255, 255, 0);  // yellow
+            break;
+        case 5:  // slouch
+            // setLED(255, 0, 0);  // red
+            // Gentle vibration alert
+            analogWrite(VIBRATION_PIN, 128);
+            delay(200);
+            analogWrite(VIBRATION_PIN, 0);
+            break;
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MAIN SETUP & LOOP
+// ═══════════════════════════════════════════════════════════════════════════════
+
+void setup() {
+    Serial.begin(115200);
+    Serial.println("\n╔══════════════════════════════════╗");
+    Serial.println("║  SmartChair ESP32-S3 Firmware    ║");
+    Serial.println("║  v1.0 — Posture Intelligence     ║");
+    Serial.println("╚══════════════════════════════════╝\n");
+    
+    // Initialize I2C
+    Wire.begin(IMU_SDA, IMU_SCL);
+    Wire.setClock(400000);  // 400kHz I2C
+    
+    // Initialize sensors
+    initMPU6050();
+    
+    // HX711 pins
+    pinMode(HX711_DOUT_FL, INPUT);
+    pinMode(HX711_SCK_FL, OUTPUT);
+    pinMode(HX711_DOUT_FR, INPUT);
+    pinMode(HX711_SCK_FR, OUTPUT);
+    pinMode(HX711_DOUT_RL, INPUT);
+    pinMode(HX711_SCK_RL, OUTPUT);
+    pinMode(HX711_DOUT_RR, INPUT);
+    pinMode(HX711_SCK_RR, OUTPUT);
+    
+    // Feedback pins
+    pinMode(VIBRATION_PIN, OUTPUT);
+    
+    // WiFi
+    WiFi.begin(WIFI_SSID, WIFI_PASS);
+    int wifi_attempts = 0;
+    while (WiFi.status() != WL_CONNECTED && wifi_attempts < 20) {
+        delay(500);
+        Serial.print(".");
+        wifi_attempts++;
+    }
+    
+    if (WiFi.status() == WL_CONNECTED) {
+        Serial.printf("\n[WiFi] Connected: %s\n", WiFi.localIP().toString().c_str());
+        
+        // MQTT setup
+        mqtt.setServer(MQTT_BROKER, MQTT_PORT);
+        if (mqtt.connect(DEVICE_ID)) {
+            Serial.println("[MQTT] Connected to broker");
+        }
+    } else {
+        Serial.println("\n[WiFi] Offline mode — data sent via UART only");
+    }
+    
+    session_start_ms = millis();
+    Serial.println("[Ready] SmartChair sensor fusion active\n");
+}
+
+void loop() {
+    unsigned long now = millis();
+    
+    // ── IMU Sampling (50 Hz) ─────────────────────────────────────────────
+    static unsigned long last_imu = 0;
+    if (now - last_imu >= 20) {  // 20ms = 50Hz
+        readMPU6050();
+        
+        imu_buffer[buffer_idx][0] = accel[0];
+        imu_buffer[buffer_idx][1] = accel[1];
+        imu_buffer[buffer_idx][2] = accel[2];
+        imu_buffer[buffer_idx][3] = gyro[0];
+        imu_buffer[buffer_idx][4] = gyro[1];
+        imu_buffer[buffer_idx][5] = gyro[2];
+        
+        last_imu = now;
+    }
+    
+    // ── Load Cell Sampling (10 Hz) ───────────────────────────────────────
+    static unsigned long last_load = 0;
+    if (now - last_load >= 100) {  // 100ms = 10Hz
+        readLoadCells();
+        
+        load_buffer[buffer_idx][0] = load_cells[0];
+        load_buffer[buffer_idx][1] = load_cells[1];
+        load_buffer[buffer_idx][2] = load_cells[2];
+        load_buffer[buffer_idx][3] = load_cells[3];
+        
+        last_load = now;
+    }
+    
+    // ── Buffer Management ────────────────────────────────────────────────
+    buffer_idx++;
+    if (buffer_idx >= WINDOW_SIZE) {
+        buffer_idx = 0;
+        buffer_full = true;
+    }
+    
+    // ── ML Inference (every 2.56 seconds) ────────────────────────────────
+    if (buffer_full && (now - last_inference_ms >= INFERENCE_INTERVAL_MS)) {
+        float features[NUM_FEATURES];
+        extractFeatures(features);
+        
+        // Choose inference method:
+        // runTFLiteInference(features);   // Option A: Neural network
+        // runRFInference(features);       // Option B: Random Forest
+        runRuleBasedInference(features);   // Option C: Rule-based fallback
+        
+        updateFeedback();
+        
+        last_inference_ms = now;
+    }
+    
+    // ── Telemetry Publishing (every 5 seconds) ───────────────────────────
+    static unsigned long last_publish = 0;
+    if (now - last_publish >= 5000) {
+        publishTelemetry();
+        last_publish = now;
+    }
+    
+    // ── MQTT Maintenance ─────────────────────────────────────────────────
+    if (mqtt.connected()) {
+        mqtt.loop();
+    }
+    
+    // Small delay to prevent watchdog timeout
+    delay(1);
+}

smart_chair/main.py

@@ -0,0 +1,416 @@
+"""
+SmartChair Main Orchestrator — Integrates all subsystems.
+
+This is the Raspberry Pi main loop that:
+1. Receives sensor data from ESP32 via UART
+2. Runs posture classification (ensemble or MLSTM-FCN)
+3. Computes RULA risk score
+4. Detects fatigue and drowsiness
+5. Recognizes the current user
+6. Manages break recommendations
+7. Suggests exercises
+8. Updates gamification scores
+9. Publishes to AWS IoT Core
+10. Feeds the dashboard
+
+Architecture:
+  ESP32 → UART (115200) → RPi Main Loop → AWS IoT Core
+                                         → Local Dashboard (Flask/Streamlit)
+                                         → SQLite (local history)
+"""
+
+import json
+import time
+import numpy as np
+from datetime import datetime
+from typing import Dict, Optional
+
+# SmartChair modules
+import sys
+sys.path.insert(0, '/app/smart_chair')
+sys.path.insert(0, '/app')
+
+from config.settings import *
+from utils.feature_engineering import compute_imu_angles, compute_center_of_pressure
+from ml_models.posture_classifier import EnsemblePostureClassifier
+from ml_models.spine_risk_predictor import RULAScorer, SpineRiskPredictor, FatigueDetector, InjuryRiskAlertSystem
+from ml_models.user_recognition import MultiUserRecognizer, PersonalizedSittingModel
+from ml_models.break_recommendation import AdaptiveBreakEngine, ExerciseSuggestionEngine
+from ml_models.gamification import PostureScorer, GamificationEngine
+from cloud.aws_iot_integration import AWSIoTClient, TelemetryPayload, AlertPayload
+
+
+class SmartChairSystem:
+    """
+    Main system orchestrator. Coordinates all subsystems in real-time.
+    """
+    
+    def __init__(self, device_id: str = "chair_001"):
+        print("╔══════════════════════════════════════════════╗")
+        print("║  SmartChair AI System — Initializing...      ║")
+        print("╚══════════════════════════════════════════════╝")
+        
+        self.device_id = device_id
+        self.current_user = "unknown"
+        self.session_start = datetime.now()
+        self.current_posture = "upright"
+        self.current_posture_id = 0
+        self.posture_start_time = datetime.now()
+        
+        # ── Initialize Subsystems ──────────────────────────────────────
+        print("[1/8] Loading posture classifier...")
+        self.classifier = EnsemblePostureClassifier()
+        
+        print("[2/8] Initializing RULA scorer...")
+        self.rula_scorer = RULAScorer()
+        
+        print("[3/8] Initializing spine risk predictor...")
+        self.risk_predictor = SpineRiskPredictor()
+        
+        print("[4/8] Initializing fatigue detector...")
+        self.fatigue_detector = FatigueDetector()
+        
+        print("[5/8] Initializing user recognizer...")
+        self.user_recognizer = MultiUserRecognizer()
+        self.user_models = {}  # user_id → PersonalizedSittingModel
+        
+        print("[6/8] Initializing break engine...")
+        self.break_engine = AdaptiveBreakEngine()
+        self.exercise_engine = ExerciseSuggestionEngine()
+        
+        print("[7/8] Initializing gamification...")
+        self.posture_scorer = PostureScorer()
+        self.gamification = {}  # user_id → GamificationEngine
+        
+        print("[8/8] Initializing injury alert system...")
+        self.alert_system = InjuryRiskAlertSystem()
+        
+        # AWS IoT (optional)
+        self.iot_client = AWSIoTClient(device_id)
+        
+        print("\n✅ SmartChair AI System ready!\n")
+    
+    def process_sensor_reading(self, imu_data: np.ndarray, load_data: np.ndarray,
+                                thermal_present: bool = True) -> Dict:
+        """
+        Process a single sensor reading through the full pipeline.
+        Called at the inference rate (every ~2.56 seconds).
+        
+        Args:
+            imu_data: shape (128, 6) — window of IMU readings
+            load_data: shape (128, 4) — window of load cell readings
+            thermal_present: whether thermal sensor detects a person
+        
+        Returns:
+            Full system state dict with all subsystem outputs
+        """
+        now = datetime.now()
+        result = {"timestamp": now.isoformat(), "device_id": self.device_id}
+        
+        # ── 1. Human Presence Detection ───────────────────────────────
+        total_weight = np.mean(np.sum(load_data, axis=1))
+        if not thermal_present or total_weight < 5.0:
+            self.current_posture = "absent"
+            self.current_posture_id = 6
+            result["posture"] = {"class": 6, "name": "absent", "confidence": 0.99}
+            return result
+        
+        # ── 2. Posture Classification ──────────��──────────────────────
+        if self.classifier.is_trained:
+            posture_id = self.classifier.predict(imu_data, load_data)
+            proba = self.classifier.predict_proba(imu_data, load_data)
+            confidence = float(np.max(proba))
+        else:
+            # Rule-based fallback
+            pitch, roll = compute_imu_angles(imu_data[:, :3])
+            avg_pitch = np.mean(pitch)
+            avg_roll = np.mean(roll)
+            posture_id, confidence = self._rule_based_classify(avg_pitch, avg_roll, total_weight)
+            proba = np.zeros(NUM_POSTURE_CLASSES)
+            proba[posture_id] = confidence
+        
+        posture_name = POSTURE_CLASSES[posture_id]
+        
+        # Track posture change timing
+        if posture_id != self.current_posture_id:
+            self.posture_start_time = now
+        
+        self.current_posture_id = posture_id
+        self.current_posture = posture_name
+        
+        posture_duration_min = (now - self.posture_start_time).total_seconds() / 60
+        
+        result["posture"] = {
+            "class": int(posture_id),
+            "name": posture_name,
+            "confidence": round(confidence, 3),
+            "duration_minutes": round(posture_duration_min, 1),
+            "probabilities": {POSTURE_CLASSES[i]: round(float(p), 3) for i, p in enumerate(proba)},
+        }
+        
+        # ── 3. RULA Ergonomic Risk Score ──────────────────────────────
+        pitch, roll = compute_imu_angles(imu_data[:, :3])
+        avg_pitch = float(np.mean(pitch))
+        avg_roll = float(np.mean(roll))
+        avg_yaw_rate = float(np.mean(imu_data[:, 5]))
+        
+        rula = self.rula_scorer.compute_rula_score(
+            avg_pitch, avg_roll, avg_yaw_rate,
+            posture_duration_min, is_static=True
+        )
+        result["rula"] = rula
+        
+        # ── 4. Spine Risk Prediction ──────────────────────────────────
+        self.risk_predictor.record_posture(posture_name, rula["rula_score"])
+        session_risk = self.risk_predictor.compute_session_risk(lookback_minutes=60)
+        result["spine_risk"] = session_risk
+        
+        # ── 5. Fatigue & Drowsiness Detection ─────────────────────────
+        for i in range(min(10, len(load_data))):
+            self.fatigue_detector.update(load_data[i], imu_data[i * 5] if i * 5 < len(imu_data) else imu_data[-1])
+        
+        fatigue = self.fatigue_detector.analyze_fatigue()
+        result["fatigue"] = fatigue
+        
+        # ── 6. User Recognition ───────────────────────────────────────
+        if self.user_recognizer.is_trained:
+            user_result = self.user_recognizer.recognize(load_data[:50])
+            self.current_user = user_result["user_id"]
+            result["user"] = user_result
+        else:
+            result["user"] = {"user_id": "unknown", "confidence": 0}
+        
+        # ── 7. Break Recommendation ───────────────────────────────────
+        self.break_engine.update_posture(posture_name, rula["rula_score"])
+        
+        personal_interval = None
+        if self.current_user in self.user_models:
+            personal_interval = self.user_models[self.current_user].get_optimal_break_interval()
+        
+        break_rec = self.break_engine.compute_urgency(
+            fatigue_level=fatigue["fatigue_level"],
+            current_rula=rula["rula_score"],
+            personal_interval=personal_interval,
+        )
+        result["break_recommendation"] = break_rec
+        
+        # ── 8. Exercise Suggestions (when break is needed) ────────────
+        if break_rec["urgency_level"] in ["moderate", "urgent"]:
+            session_min = (now - self.session_start).total_seconds() / 60
+            exercises = self.exercise_engine.suggest_exercises(
+                dominant_posture=posture_name,
+                rula_score=rula["rula_score"],
+                session_duration_min=session_min,
+                break_type="micro" if break_rec["urgency_level"] == "moderate" else "full",
+            )
+            result["exercise_suggestions"] = exercises
+        
+        # ── 9. Gamification Update ────────────────────────────────────
+        self.posture_scorer.record_posture(posture_name, 2.56 / 60)  # ~2.56s per reading
+        
+        if self.current_user != "unknown" and self.current_user in self.gamification:
+            if posture_name == "upright":
+                self.gamification[self.current_user].award_posture_points(2.56 / 60)
+        
+        daily_score = self.posture_scorer.compute_daily_score()
+        result["posture_score"] = daily_score
+        
+        # ── 10. Injury Risk Alerts ────────────────────────────────────
+        acute_alert = self.alert_system.check_acute_risk(
+            rula["rula_score"], posture_name, posture_duration_min
+        )
+        if acute_alert:
+            result["alert"] = acute_alert
+            # Publish alert to cloud
+            self._publish_alert(acute_alert)
+        
+        # ── 11. Publish to Cloud ──────────────────────────────────────
+        self._publish_telemetry(result)
+        
+        return result
+    
+    def _rule_based_classify(self, pitch: float, roll: float, weight: float):
+        """Fallback rule-based classification when ML model not loaded."""
+        if weight < 5.0:
+            return 6, 0.99  # absent
+        if abs(pitch) < 10 and abs(roll) < 10:
+            return 0, 0.85  # upright
+        if pitch > 20:
+            return 5, 0.80  # slouch
+        if pitch > 10:
+            return 1, 0.75  # forward lean
+        if pitch < -10:
+            return 2, 0.75  # backward lean
+        if roll < -10:
+            return 3, 0.70  # left lean
+        if roll > 10:
+            return 4, 0.70  # right lean
+        return 0, 0.60  # default upright
+    
+    def _publish_telemetry(self, result: Dict):
+        """Publish processed data to AWS IoT Core."""
+        payload = TelemetryPayload(
+            device_id=self.device_id,
+            timestamp=int(time.time() * 1000),
+            user_id=self.current_user,
+            posture_class=result["posture"]["class"],
+            posture_name=result["posture"]["name"],
+            posture_confidence=result["posture"]["confidence"],
+            rula_score=result["rula"]["rula_score"],
+            risk_level=result["rula"]["risk_level"],
+            fatigue_level=result["fatigue"]["fatigue_level"],
+            session_duration_min=result["break_recommendation"]["session_duration_min"],
+        )
+        self.iot_client.publish_telemetry(payload)
+    
+    def _publish_alert(self, alert: Dict):
+        """Publish alert to AWS IoT Core."""
+        payload = AlertPayload(
+            device_id=self.device_id,
+            timestamp=int(time.time() * 1000),
+            alert_type=alert["type"],
+            severity=alert["severity"],
+            message=alert["message"],
+            action=alert.get("action", ""),
+            user_id=self.current_user,
+        )
+        self.iot_client.publish_alert(payload)
+    
+    def enroll_user(self, user_id: str, sit_events: list):
+        """Enroll a new user for recognition."""
+        result = self.user_recognizer.enroll_user(user_id, sit_events)
+        if result["status"] == "enrolled":
+            self.user_models[user_id] = PersonalizedSittingModel(user_id)
+            self.gamification[user_id] = GamificationEngine(user_id)
+        return result
+    
+    def get_dashboard_data(self) -> Dict:
+        """Get all data needed for the dashboard."""
+        return {
+            "device_id": self.device_id,
+            "current_user": self.current_user,
+            "current_posture": self.current_posture,
+            "session_start": self.session_start.isoformat(),
+            "session_duration_min": (datetime.now() - self.session_start).total_seconds() / 60,
+            "daily_score": self.posture_scorer.compute_daily_score(),
+            "weekly_score": self.posture_scorer.compute_weekly_score(),
+            "trend_data": self.posture_scorer.get_trend_data(days=30),
+            "fatigue": self.fatigue_detector.analyze_fatigue(),
+            "spine_risk": self.risk_predictor.compute_session_risk(),
+            "active_alerts": self.alert_system.get_active_alerts(),
+            "gamification": {
+                uid: engine.get_profile()
+                for uid, engine in self.gamification.items()
+            },
+        }
+
+
+def run_demo():
+    """
+    Demo: Run SmartChair system with synthetic data.
+    Shows all 12 features working together.
+    """
+    from data_collection.synthetic_data_generator import (
+        generate_imu_data, generate_load_cell_data, generate_dataset, subject_based_split
+    )
+    
+    print("\n" + "=" * 70)
+    print("SMARTCHAIR AI SYSTEM — FULL PIPELINE DEMO")
+    print("=" * 70)
+    
+    # Initialize system
+    system = SmartChairSystem(device_id="demo_chair")
+    
+    # ── Step 1: Train posture classifier ──────────────────────────────
+    print("\n📊 STEP 1: Training posture classifier...")
+    dataset = generate_dataset(n_subjects=15, samples_per_posture_per_subject=300)
+    train, test = subject_based_split(dataset)
+    
+    results = system.classifier.train(
+        train["imu_data"], train["load_data"], train["labels"],
+        test["imu_data"], test["load_data"], test["labels"]
+    )
+    
+    # ── Step 2: Enroll users ──��───────────────────────────────────────
+    print("\n👤 STEP 2: Enrolling users...")
+    rng = np.random.default_rng(123)
+    
+    for user_name, weight in [("Alice", 55), ("Bob", 85), ("Charlie", 70)]:
+        sit_events = []
+        for _ in range(5):
+            load = generate_load_cell_data(0, 100, weight, rng=rng)
+            sit_events.append(load)
+        
+        result = system.enroll_user(user_name, sit_events)
+        print(f"   {user_name}: {result['status']} ({result.get('avg_weight_kg', 0)} kg)")
+    
+    # ── Step 3: Simulate a sitting session ────────────────────────────
+    print("\n🪑 STEP 3: Simulating sitting session...")
+    
+    # Simulate 10 readings with different postures
+    posture_sequence = [0, 0, 0, 1, 1, 5, 5, 5, 0, 0]  # upright → forward → slouch → upright
+    posture_names_seq = [POSTURE_CLASSES[p] for p in posture_sequence]
+    
+    print(f"\n   Simulated posture sequence: {posture_names_seq}")
+    print("-" * 70)
+    
+    for i, posture_id in enumerate(posture_sequence):
+        # Generate sensor data for this posture
+        imu = generate_imu_data(posture_id, WINDOW_SIZE, user_weight_kg=70, rng=rng)
+        load = generate_load_cell_data(posture_id, WINDOW_SIZE, user_weight_kg=70, rng=rng)
+        
+        # Process through full pipeline
+        result = system.process_sensor_reading(imu, load, thermal_present=True)
+        
+        # Print summary
+        print(f"\n   Reading {i+1}/{len(posture_sequence)}:")
+        print(f"   ├─ Posture: {result['posture']['name']} (confidence: {result['posture']['confidence']:.2%})")
+        print(f"   ├─ RULA Score: {result['rula']['rula_score']}/7 ({result['rula']['risk_level']})")
+        print(f"   ├─ Fatigue: {result['fatigue']['fatigue_level']}")
+        print(f"   ├─ Break: {result['break_recommendation']['urgency_level']} (score: {result['break_recommendation']['urgency_score']:.0f}/100)")
+        
+        if "exercise_suggestions" in result:
+            exercises = [e["name"] for e in result["exercise_suggestions"]]
+            print(f"   ├─ Exercises: {exercises}")
+        
+        if "alert" in result:
+            print(f"   └─ 🚨 ALERT: {result['alert']['message']}")
+    
+    # ── Step 4: Show dashboard data ───────────────────────────────────
+    print("\n\n📈 STEP 4: Dashboard Summary")
+    print("-" * 70)
+    dashboard = system.get_dashboard_data()
+    
+    print(f"   Current User: {dashboard['current_user']}")
+    print(f"   Session Duration: {dashboard['session_duration_min']:.1f} min")
+    print(f"   Daily Score: {dashboard['daily_score']}")
+    print(f"   Active Alerts: {len(dashboard['active_alerts'])}")
+    print(f"   Spine Risk: {dashboard['spine_risk']}")
+    
+    print("\n" + "=" * 70)
+    print("✅ DEMO COMPLETE — All 12 features operational!")
+    print("=" * 70)
+    
+    # Summary of all features
+    print("""
+    ┌────────────────────────────────────────────────────────────┐
+    │              SMARTCHAIR FEATURE STATUS                      │
+    ├────────────────────────────────────────────────────────────┤
+    │ ✅ 1.  Real-time posture classification (ML)              │
+    │ ✅ 2.  Long-term spine risk prediction                    │
+    │ ✅ 3.  Personalized sitting behaviour model               │
+    │ ✅ 4.  Smart micro-break recommendations (adaptive)       │
+    │ ✅ 5.  Exercise suggestion system                         │
+    │ ✅ 6.  Hybrid sensor fusion (IMU + Load Cell + Thermal)   │
+    │ ✅ 7.  Fatigue & drowsiness detection                     │
+    │ ✅ 8.  Daily/weekly posture score dashboard                │
+    │ ✅ 9.  Injury risk alert system                           │
+    │ ✅ 10. Cloud integration (AWS IoT Core)                   │
+    │ ✅ 11. Multi-user recognition (weight signature)          │
+    │ ✅ 12. Gamification system                                │
+    └────────────────────────────────────────────────────────────┘
+    """)
+
+
+if __name__ == "__main__":
+    run_demo()

smart_chair/ml_models/break_recommendation.py

@@ -0,0 +1,489 @@
+"""
+SmartChair Smart Break Recommendation & Exercise Suggestion Engine.
+
+1. Adaptive Micro-Break Recommendation
+   → NOT a fixed timer — adapts based on:
+     * Current posture quality
+     * Cumulative risk score
+     * User's personal fatigue pattern
+     * Time since last break
+     * Current fatigue level
+   
+2. Exercise Suggestion System
+   → Based on detected posture issues
+   → Maps specific postural problems to targeted exercises
+   → Progressive difficulty based on user fitness level
+"""
+
+import numpy as np
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
+from collections import deque
+
+import sys
+sys.path.insert(0, '/app/smart_chair')
+from config.settings import *
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 1. ADAPTIVE MICRO-BREAK RECOMMENDATION ENGINE
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class AdaptiveBreakEngine:
+    """
+    Smart break recommendation that adapts to the user's real-time state.
+    
+    Unlike fixed timers (e.g., "break every 30 min"), this engine:
+    - Triggers earlier when posture is bad
+    - Delays when user is in flow state with good posture
+    - Escalates urgency as risk accumulates
+    - Learns optimal timing from user's fatigue patterns
+    
+    Algorithm: Score-based urgency calculator
+        urgency = Σ(weighted_factors) → {gentle, moderate, urgent}
+    """
+    
+    def __init__(self, base_interval_min: float = 30.0):
+        self.base_interval = base_interval_min
+        self.last_break_time = None
+        self.break_history = deque(maxlen=100)
+        self.current_session_start = datetime.now()
+        self.posture_quality_buffer = deque(maxlen=300)  # 5 min at 1 Hz
+        
+        # Adaptive weights (tune these based on user feedback)
+        self.weights = {
+            'time_since_break': 0.3,
+            'posture_quality': 0.25,
+            'fatigue_level': 0.2,
+            'rula_score': 0.15,
+            'session_duration': 0.1,
+        }
+    
+    def update_posture(self, posture_name: str, rula_score: int):
+        """Feed current posture for continuous monitoring."""
+        score = POSTURE_SCORE_WEIGHTS.get(posture_name, 0.5)
+        self.posture_quality_buffer.append({
+            'timestamp': datetime.now(),
+            'quality': score,
+            'rula': rula_score,
+        })
+    
+    def record_break(self, break_type: str = "micro", duration_seconds: int = 120):
+        """Record that user took a break."""
+        now = datetime.now()
+        self.break_history.append({
+            'timestamp': now,
+            'type': break_type,
+            'duration': duration_seconds,
+        })
+        self.last_break_time = now
+    
+    def compute_urgency(self, fatigue_level: str = "none",
+                         current_rula: int = 1,
+                         personal_interval: Optional[float] = None) -> Dict:
+        """
+        Compute break urgency score (0-100) and recommendation.
+        
+        Args:
+            fatigue_level: from FatigueDetector ("none", "low", "moderate", "high")
+            current_rula: current RULA score (1-7)
+            personal_interval: user's personalized break interval (from PersonalizedSittingModel)
+        
+        Returns:
+            dict with urgency_score, level, recommendation, optimal_break_time
+        """
+        now = datetime.now()
+        effective_interval = personal_interval or self.base_interval
+        
+        # ── Factor 1: Time since last break ───────────────────────────────
+        if self.last_break_time:
+            minutes_since_break = (now - self.last_break_time).total_seconds() / 60
+        else:
+            minutes_since_break = (now - self.current_session_start).total_seconds() / 60
+        
+        time_factor = min(100, (minutes_since_break / effective_interval) * 60)
+        
+        # ── Factor 2: Recent posture quality ──────────────────────────────
+        if self.posture_quality_buffer:
+            recent_quality = np.mean([p['quality'] for p in self.posture_quality_buffer])
+            posture_factor = (1 - recent_quality) * 100  # bad posture → high urgency
+        else:
+            posture_factor = 30  # neutral default
+        
+        # ── Factor 3: Fatigue level ───────────────────────────────────────
+        fatigue_map = {"none": 0, "low": 25, "moderate": 60, "high": 95}
+        fatigue_factor = fatigue_map.get(fatigue_level, 30)
+        
+        # ── Factor 4: RULA score ──────────────────────────────────────────
+        rula_factor = (current_rula - 1) / 6 * 100  # normalize 1-7 to 0-100
+        
+        # ── Factor 5: Total session duration ──────────────────────────────
+        session_min = (now - self.current_session_start).total_seconds() / 60
+        session_factor = min(100, (session_min / MAX_SITTING_MINUTES) * 60)
+        
+        # ── Weighted sum ──────────────────────────────────────────────────
+        urgency = (
+            self.weights['time_since_break'] * time_factor +
+            self.weights['posture_quality'] * posture_factor +
+            self.weights['fatigue_level'] * fatigue_factor +
+            self.weights['rula_score'] * rula_factor +
+            self.weights['session_duration'] * session_factor
+        )
+        
+        urgency = min(100, max(0, urgency))
+        
+        # ── Decision ──────────────────────────────────────────────────────
+        if urgency >= 70:
+            level = "urgent"
+            recommendation = "🚨 Take a break NOW. Stand up and move for 2 minutes."
+            optimal_time = now  # immediate
+        elif urgency >= 40:
+            level = "moderate"
+            remaining_min = max(5, effective_interval - minutes_since_break)
+            recommendation = f"⚡ Break recommended in ~{remaining_min:.0f} minutes. Start planning a pause."
+            optimal_time = now + timedelta(minutes=remaining_min)
+        else:
+            level = "gentle"
+            remaining_min = max(10, effective_interval - minutes_since_break)
+            recommendation = f"✅ Good for now. Next break in ~{remaining_min:.0f} minutes."
+            optimal_time = now + timedelta(minutes=remaining_min)
+        
+        return {
+            "urgency_score": round(urgency, 1),
+            "urgency_level": level,
+            "recommendation": recommendation,
+            "optimal_break_time": optimal_time.isoformat(),
+            "minutes_since_break": round(minutes_since_break, 1),
+            "session_duration_min": round(session_min, 1),
+            "factors": {
+                "time": round(time_factor, 1),
+                "posture": round(posture_factor, 1),
+                "fatigue": round(fatigue_factor, 1),
+                "rula": round(rula_factor, 1),
+                "session": round(session_factor, 1),
+            }
+        }
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 2. EXERCISE SUGGESTION SYSTEM
+# ═══════════════════════════════════════════════════════════════════════════════
+
+# Exercises mapped to specific posture problems
+EXERCISE_DATABASE = {
+    # ── For Forward Lean / Slouch (tight hip flexors, weak upper back) ────
+    "forward_lean": [
+        {
+            "name": "Chin Tucks",
+            "description": "Sit tall, pull chin straight back (making a double chin). Hold 5 seconds.",
+            "duration_seconds": 30,
+            "reps": 10,
+            "difficulty": "easy",
+            "target_muscles": ["deep neck flexors", "upper cervical extensors"],
+            "benefit": "Corrects forward head posture, reduces neck strain",
+        },
+        {
+            "name": "Seated Cat-Cow",
+            "description": "Sit on edge of chair. Arch back (cow), then round back (cat). Slow and controlled.",
+            "duration_seconds": 45,
+            "reps": 8,
+            "difficulty": "easy",
+            "target_muscles": ["erector spinae", "rectus abdominis"],
+            "benefit": "Mobilizes thoracic spine, releases compressed discs",
+        },
+        {
+            "name": "Chest Opener Stretch",
+            "description": "Clasp hands behind back, squeeze shoulder blades together, lift hands slightly.",
+            "duration_seconds": 30,
+            "reps": 3,
+            "difficulty": "easy",
+            "target_muscles": ["pectoralis major", "anterior deltoid"],
+            "benefit": "Opens chest, counteracts hunched posture",
+        },
+        {
+            "name": "Standing Hip Flexor Stretch",
+            "description": "Step one foot forward into lunge. Push hips forward, keep back straight.",
+            "duration_seconds": 60,
+            "reps": 2,
+            "difficulty": "moderate",
+            "target_muscles": ["iliopsoas", "rectus femoris"],
+            "benefit": "Releases tight hip flexors from prolonged sitting",
+        },
+    ],
+    
+    # ── For Slouch (weak core, posterior chain) ────────────────────────────
+    "slouch": [
+        {
+            "name": "Seated Pelvic Tilts",
+            "description": "Sit tall. Tilt pelvis forward (arch lower back), then backward (flatten). Slowly alternate.",
+            "duration_seconds": 30,
+            "reps": 10,
+            "difficulty": "easy",
+            "target_muscles": ["transverse abdominis", "multifidus"],
+            "benefit": "Activates deep core stabilizers, corrects lumbar lordosis",
+        },
+        {
+            "name": "Bracing Drill",
+            "description": "Brace your core as if someone is about to punch your stomach. Hold 10 seconds, breathe normally.",
+            "duration_seconds": 40,
+            "reps": 5,
+            "difficulty": "easy",
+            "target_muscles": ["transverse abdominis", "obliques"],
+            "benefit": "Builds endurance in spinal stabilizers",
+        },
+        {
+            "name": "Wall Angels",
+            "description": "Stand with back flat against wall. Raise arms to 'goal post' position, slide up and down.",
+            "duration_seconds": 60,
+            "reps": 10,
+            "difficulty": "moderate",
+            "target_muscles": ["lower trapezius", "serratus anterior", "rotator cuff"],
+            "benefit": "Strengthens mid-back, improves scapular control",
+        },
+        {
+            "name": "Glute Bridge",
+            "description": "Lie on back, knees bent. Squeeze glutes and lift hips. Hold 3 seconds at top.",
+            "duration_seconds": 60,
+            "reps": 12,
+            "difficulty": "moderate",
+            "target_muscles": ["gluteus maximus", "hamstrings"],
+            "benefit": "Activates posterior chain, counteracts hip flexor dominance",
+        },
+    ],
+    
+    # ── For Left/Right Lean (lateral imbalance) ───────────────────────────
+    "lateral_lean": [
+        {
+            "name": "Seated Side Stretch",
+            "description": "Raise one arm overhead, lean to the opposite side. Hold 15 seconds each side.",
+            "duration_seconds": 60,
+            "reps": 3,
+            "difficulty": "easy",
+            "target_muscles": ["quadratus lumborum", "obliques", "latissimus dorsi"],
+            "benefit": "Releases lateral spine compression, improves symmetry",
+        },
+        {
+            "name": "Single-Leg Balance",
+            "description": "Stand on one leg for 30 seconds. Switch legs. Close eyes for challenge.",
+            "duration_seconds": 60,
+            "reps": 2,
+            "difficulty": "moderate",
+            "target_muscles": ["gluteus medius", "core stabilizers"],
+            "benefit": "Corrects lateral pelvic tilt, improves proprioception",
+        },
+        {
+            "name": "Thread the Needle",
+            "description": "On all fours, reach one arm under body and rotate. Follow with reaching to sky.",
+            "duration_seconds": 45,
+            "reps": 6,
+            "difficulty": "moderate",
+            "target_muscles": ["thoracic rotators", "obliques"],
+            "benefit": "Improves thoracic rotation, reduces asymmetric loading",
+        },
+    ],
+    
+    # ── For Backward Lean (weak anterior core, tight hamstrings) ──────────
+    "backward_lean": [
+        {
+            "name": "Seated Hamstring Stretch",
+            "description": "Extend one leg, flex foot. Lean forward from hips with straight back.",
+            "duration_seconds": 30,
+            "reps": 3,
+            "difficulty": "easy",
+            "target_muscles": ["hamstrings", "gastrocnemius"],
+            "benefit": "Releases posterior chain tension causing backward pelvic tilt",
+        },
+        {
+            "name": "Dead Bug",
+            "description": "Lie on back, arms up. Extend opposite arm and leg slowly. Return and switch.",
+            "duration_seconds": 60,
+            "reps": 10,
+            "difficulty": "moderate",
+            "target_muscles": ["transverse abdominis", "rectus abdominis"],
+            "benefit": "Strengthens anterior core without spinal compression",
+        },
+    ],
+    
+    # ── General / Break Exercises ─────────────────────────────────────────
+    "general": [
+        {
+            "name": "Standing Desk Stretch",
+            "description": "Stand up. Reach arms overhead, interlace fingers, stretch upward. Hold 10 seconds.",
+            "duration_seconds": 20,
+            "reps": 3,
+            "difficulty": "easy",
+            "target_muscles": ["full spine extensors", "shoulders"],
+            "benefit": "Decompresses spine after sitting, increases blood flow",
+        },
+        {
+            "name": "Neck Rolls",
+            "description": "Slowly roll head in a circle. 5 clockwise, 5 counter-clockwise.",
+            "duration_seconds": 30,
+            "reps": 10,
+            "difficulty": "easy",
+            "target_muscles": ["sternocleidomastoid", "upper trapezius"],
+            "benefit": "Releases neck tension from screen viewing",
+        },
+        {
+            "name": "Eye 20-20-20 Rule",
+            "description": "Look at something 20 feet away for 20 seconds. Blink frequently.",
+            "duration_seconds": 20,
+            "reps": 1,
+            "difficulty": "easy",
+            "target_muscles": ["ciliary muscle", "extraocular muscles"],
+            "benefit": "Reduces eye strain and digital fatigue",
+        },
+        {
+            "name": "Calf Raises",
+            "description": "Stand behind chair for balance. Rise onto toes, hold 2 seconds, lower.",
+            "duration_seconds": 30,
+            "reps": 15,
+            "difficulty": "easy",
+            "target_muscles": ["gastrocnemius", "soleus"],
+            "benefit": "Promotes blood circulation, prevents deep vein thrombosis",
+        },
+        {
+            "name": "Desk Push-ups",
+            "description": "Place hands on desk edge. Step back. Do push-ups at an angle.",
+            "duration_seconds": 30,
+            "reps": 10,
+            "difficulty": "moderate",
+            "target_muscles": ["pectoralis major", "triceps", "core"],
+            "benefit": "Full body activation, increases alertness",
+        },
+    ],
+}
+
+
+class ExerciseSuggestionEngine:
+    """
+    Suggests targeted exercises based on detected posture issues.
+    
+    Logic:
+    1. Analyze recent posture history to identify dominant problems
+    2. Map problems to specific corrective exercises
+    3. Adjust difficulty based on user fitness level
+    4. Track exercise compliance and effectiveness
+    """
+    
+    def __init__(self):
+        self.exercise_log = deque(maxlen=500)
+        self.user_fitness_level = "easy"  # easy, moderate, hard
+        self.completed_exercises = {}  # exercise_name → count
+    
+    def suggest_exercises(self, 
+                          dominant_posture: str,
+                          rula_score: int,
+                          session_duration_min: float,
+                          break_type: str = "micro",
+                          max_exercises: int = 3) -> List[Dict]:
+        """
+        Generate exercise recommendations.
+        
+        Args:
+            dominant_posture: most common bad posture in recent window
+            rula_score: current risk level
+            session_duration_min: how long user has been sitting
+            break_type: "micro" (2 min) or "full" (5+ min)
+            max_exercises: maximum exercises to suggest
+        
+        Returns:
+            list of exercise dicts
+        """
+        suggestions = []
+        
+        # Map posture to exercise category
+        posture_map = {
+            "forward_lean": "forward_lean",
+            "slouch": "slouch",
+            "backward_lean": "backward_lean",
+            "left_lean": "lateral_lean",
+            "right_lean": "lateral_lean",
+        }
+        
+        category = posture_map.get(dominant_posture, "general")
+        
+        # Get exercises for this category + general
+        targeted = EXERCISE_DATABASE.get(category, [])
+        general = EXERCISE_DATABASE.get("general", [])
+        
+        # Filter by fitness level
+        available = [e for e in targeted if self._difficulty_matches(e["difficulty"])]
+        available_general = [e for e in general if self._difficulty_matches(e["difficulty"])]
+        
+        # Select exercises based on break duration
+        if break_type == "micro":
+            max_duration = 120  # 2 minutes
+        else:
+            max_duration = 300  # 5 minutes
+        
+        # Prioritize targeted exercises
+        total_duration = 0
+        for ex in available:
+            if total_duration + ex["duration_seconds"] <= max_duration:
+                suggestions.append(ex)
+                total_duration += ex["duration_seconds"]
+            if len(suggestions) >= max_exercises:
+                break
+        
+        # Fill remaining time with general exercises
+        if len(suggestions) < max_exercises:
+            for ex in available_general:
+                if ex not in suggestions and total_duration + ex["duration_seconds"] <= max_duration:
+                    suggestions.append(ex)
+                    total_duration += ex["duration_seconds"]
+                if len(suggestions) >= max_exercises:
+                    break
+        
+        # Add context
+        for i, ex in enumerate(suggestions):
+            ex = ex.copy()
+            ex["priority"] = i + 1
+            ex["reason"] = f"Targets {dominant_posture} posture correction" if i < len(available) else "General wellness"
+            suggestions[i] = ex
+        
+        return suggestions
+    
+    def record_exercise_completed(self, exercise_name: str, rating: int = 3):
+        """Record that user completed an exercise. Rating 1-5."""
+        self.exercise_log.append({
+            'timestamp': datetime.now(),
+            'exercise': exercise_name,
+            'rating': rating,
+        })
+        self.completed_exercises[exercise_name] = \
+            self.completed_exercises.get(exercise_name, 0) + 1
+        
+        # Auto-adjust fitness level
+        total_completed = sum(self.completed_exercises.values())
+        if total_completed > 50 and self.user_fitness_level == "easy":
+            self.user_fitness_level = "moderate"
+        elif total_completed > 200 and self.user_fitness_level == "moderate":
+            self.user_fitness_level = "hard"
+    
+    def _difficulty_matches(self, exercise_difficulty: str) -> bool:
+        """Check if exercise difficulty matches user level."""
+        levels = ["easy", "moderate", "hard"]
+        user_idx = levels.index(self.user_fitness_level)
+        ex_idx = levels.index(exercise_difficulty)
+        return ex_idx <= user_idx + 1  # allow one level above
+    
+    def get_exercise_stats(self) -> Dict:
+        """Get exercise compliance statistics."""
+        if not self.exercise_log:
+            return {"total_exercises": 0, "compliance_rate": 0}
+        
+        total = len(self.exercise_log)
+        avg_rating = np.mean([e['rating'] for e in self.exercise_log])
+        
+        # Favorite exercise
+        favorite = max(self.completed_exercises, key=self.completed_exercises.get) \
+            if self.completed_exercises else None
+        
+        return {
+            "total_exercises_completed": total,
+            "avg_rating": round(avg_rating, 1),
+            "favorite_exercise": favorite,
+            "fitness_level": self.user_fitness_level,
+            "exercise_counts": dict(self.completed_exercises),
+        }

smart_chair/ml_models/gamification.py

@@ -0,0 +1,315 @@
+"""
+SmartChair Gamification & Posture Scoring System.
+
+Engagement mechanics:
+- Points: Earned for good posture, breaks taken, exercises completed
+- Streaks: Consecutive days meeting posture goals
+- Badges: Achievement milestones
+- Daily/Weekly scores: Aggregate posture quality metrics
+- Leaderboard: Multi-user competition (family/office)
+
+Based on health behavior change literature:
+- HealthGuru (arxiv:2502.13920): contextual engagement
+- PhysioLLM (arxiv:2406.19283): personalized health coaching
+"""
+
+import numpy as np
+from datetime import datetime, timedelta, date
+from typing import Dict, List, Optional
+from collections import defaultdict
+
+import sys
+sys.path.insert(0, '/app/smart_chair')
+from config.settings import *
+
+
+class PostureScorer:
+    """
+    Computes daily and weekly posture scores (0-100).
+    
+    Score = weighted average of time spent in each posture class.
+    upright = 100%, mild lean = 60%, slouch = 20%, absent = excluded
+    """
+    
+    def __init__(self):
+        self.daily_records = defaultdict(list)  # date → list of (posture, duration_min)
+        self.weekly_scores = []
+    
+    def record_posture(self, posture_name: str, duration_minutes: float,
+                       timestamp: Optional[datetime] = None):
+        """Record posture observation."""
+        if timestamp is None:
+            timestamp = datetime.now()
+        
+        day = timestamp.date()
+        self.daily_records[day].append({
+            'posture': posture_name,
+            'duration': duration_minutes,
+            'hour': timestamp.hour,
+        })
+    
+    def compute_daily_score(self, target_date: Optional[date] = None) -> Dict:
+        """
+        Compute posture score for a specific day.
+        
+        Score formula: Σ(duration_i × weight_i) / Σ(duration_i) × 100
+        """
+        if target_date is None:
+            target_date = datetime.now().date()
+        
+        records = self.daily_records.get(target_date, [])
+        if not records:
+            return {"date": str(target_date), "score": 0, "total_minutes": 0, "status": "no_data"}
+        
+        total_weighted = 0
+        total_minutes = 0
+        posture_breakdown = defaultdict(float)
+        hourly_quality = defaultdict(list)
+        
+        for r in records:
+            weight = POSTURE_SCORE_WEIGHTS.get(r['posture'], 0.5)
+            if r['posture'] == 'absent':
+                continue  # don't count absent time
+            
+            total_weighted += r['duration'] * weight
+            total_minutes += r['duration']
+            posture_breakdown[r['posture']] += r['duration']
+            hourly_quality[r['hour']].append(weight)
+        
+        score = (total_weighted / total_minutes * 100) if total_minutes > 0 else 0
+        
+        # Best and worst hours
+        hourly_avg = {h: np.mean(q) * 100 for h, q in hourly_quality.items()}
+        best_hour = max(hourly_avg, key=hourly_avg.get) if hourly_avg else None
+        worst_hour = min(hourly_avg, key=hourly_avg.get) if hourly_avg else None
+        
+        return {
+            "date": str(target_date),
+            "score": round(score, 1),
+            "total_sitting_minutes": round(total_minutes, 1),
+            "posture_breakdown_minutes": dict(posture_breakdown),
+            "best_hour": best_hour,
+            "worst_hour": worst_hour,
+            "hourly_scores": {str(h): round(s, 1) for h, s in sorted(hourly_avg.items())},
+        }
+    
+    def compute_weekly_score(self) -> Dict:
+        """Compute average score for the past 7 days."""
+        today = datetime.now().date()
+        daily_scores = []
+        
+        for i in range(7):
+            day = today - timedelta(days=i)
+            result = self.compute_daily_score(day)
+            if result["score"] > 0:
+                daily_scores.append(result)
+        
+        if not daily_scores:
+            return {"week_score": 0, "days_with_data": 0}
+        
+        avg_score = np.mean([d["score"] for d in daily_scores])
+        
+        # Trend analysis
+        if len(daily_scores) >= 3:
+            recent = np.mean([d["score"] for d in daily_scores[:3]])
+            older = np.mean([d["score"] for d in daily_scores[3:]])
+            trend = "improving" if recent > older + 3 else "declining" if recent < older - 3 else "stable"
+        else:
+            trend = "insufficient_data"
+        
+        return {
+            "week_score": round(avg_score, 1),
+            "days_with_data": len(daily_scores),
+            "trend": trend,
+            "daily_scores": daily_scores,
+            "best_day": max(daily_scores, key=lambda x: x["score"]),
+            "worst_day": min(daily_scores, key=lambda x: x["score"]),
+        }
+    
+    def get_trend_data(self, days: int = 30) -> Dict:
+        """Get score trend data for dashboard graphs."""
+        today = datetime.now().date()
+        scores = []
+        
+        for i in range(days):
+            day = today - timedelta(days=days - 1 - i)
+            result = self.compute_daily_score(day)
+            scores.append({
+                "date": str(day),
+                "score": result["score"],
+                "minutes": result.get("total_sitting_minutes", 0),
+            })
+        
+        return {
+            "period_days": days,
+            "scores": scores,
+            "avg_score": round(np.mean([s["score"] for s in scores if s["score"] > 0]) if any(s["score"] > 0 for s in scores) else 0, 1),
+            "max_score": round(max(s["score"] for s in scores), 1) if scores else 0,
+            "min_score": round(min(s["score"] for s in scores if s["score"] > 0), 1) if any(s["score"] > 0 for s in scores) else 0,
+        }
+
+
+class GamificationEngine:
+    """
+    Full gamification system for engagement and posture improvement.
+    
+    Points: 10/min good posture, 50/break taken, 100/exercise done
+    Streaks: Consecutive days with score > 70
+    Badges: Milestone achievements
+    Level: Based on total points
+    """
+    
+    def __init__(self, user_id: str):
+        self.user_id = user_id
+        self.total_points = 0
+        self.daily_points = defaultdict(int)
+        self.streak_days = 0
+        self.longest_streak = 0
+        self.badges = set()
+        self.level = 1
+        self.history = []
+        
+        # Daily goals
+        self.daily_goals = {
+            "good_posture_minutes": 240,  # 4 hours
+            "breaks_taken": 8,
+            "exercises_completed": 3,
+            "target_score": 70,
+        }
+    
+    def award_posture_points(self, good_posture_minutes: float):
+        """Award points for good posture time."""
+        points = int(good_posture_minutes * POINTS_PER_GOOD_POSTURE_MINUTE)
+        self._add_points(points, "good_posture")
+    
+    def award_break_points(self):
+        """Award points for taking a break."""
+        self._add_points(POINTS_PER_BREAK_TAKEN, "break_taken")
+    
+    def award_exercise_points(self, exercise_name: str):
+        """Award points for completing an exercise."""
+        self._add_points(POINTS_PER_EXERCISE_DONE, "exercise_completed")
+    
+    def _add_points(self, points: int, reason: str):
+        """Add points and check for level-up and badges."""
+        # Streak bonus
+        if self.streak_days >= 3:
+            bonus = int(points * (STREAK_BONUS_MULTIPLIER - 1))
+            points += bonus
+        
+        self.total_points += points
+        today = datetime.now().date()
+        self.daily_points[today] += points
+        
+        self.history.append({
+            'timestamp': datetime.now().isoformat(),
+            'points': points,
+            'reason': reason,
+            'total': self.total_points,
+        })
+        
+        # Check level up (every 1000 points)
+        new_level = 1 + self.total_points // 1000
+        if new_level > self.level:
+            self.level = new_level
+        
+        # Check badges
+        self._check_badges()
+    
+    def update_streak(self, daily_score: float):
+        """Update streak based on daily score."""
+        if daily_score >= self.daily_goals["target_score"]:
+            self.streak_days += 1
+            self.longest_streak = max(self.longest_streak, self.streak_days)
+        else:
+            self.streak_days = 0
+    
+    def _check_badges(self):
+        """Check and award badges based on thresholds."""
+        for badge_name, threshold in BADGE_THRESHOLDS.items():
+            if badge_name not in self.badges and self.total_points >= threshold:
+                self.badges.add(badge_name)
+    
+    def get_daily_progress(self, posture_score: float, breaks_taken: int,
+                            exercises_done: int, good_posture_min: float) -> Dict:
+        """Get progress toward daily goals."""
+        return {
+            "posture_score": {
+                "current": round(posture_score, 1),
+                "goal": self.daily_goals["target_score"],
+                "met": posture_score >= self.daily_goals["target_score"],
+                "pct": round(min(100, posture_score / self.daily_goals["target_score"] * 100), 1),
+            },
+            "good_posture_minutes": {
+                "current": round(good_posture_min, 1),
+                "goal": self.daily_goals["good_posture_minutes"],
+                "met": good_posture_min >= self.daily_goals["good_posture_minutes"],
+                "pct": round(min(100, good_posture_min / self.daily_goals["good_posture_minutes"] * 100), 1),
+            },
+            "breaks": {
+                "current": breaks_taken,
+                "goal": self.daily_goals["breaks_taken"],
+                "met": breaks_taken >= self.daily_goals["breaks_taken"],
+                "pct": round(min(100, breaks_taken / self.daily_goals["breaks_taken"] * 100), 1),
+            },
+            "exercises": {
+                "current": exercises_done,
+                "goal": self.daily_goals["exercises_completed"],
+                "met": exercises_done >= self.daily_goals["exercises_completed"],
+                "pct": round(min(100, exercises_done / self.daily_goals["exercises_completed"] * 100), 1),
+            },
+        }
+    
+    def get_profile(self) -> Dict:
+        """Get complete gamification profile."""
+        return {
+            "user_id": self.user_id,
+            "level": self.level,
+            "total_points": self.total_points,
+            "streak_days": self.streak_days,
+            "longest_streak": self.longest_streak,
+            "badges": sorted(list(self.badges)),
+            "badges_remaining": [
+                {"name": b, "points_needed": t - self.total_points}
+                for b, t in sorted(BADGE_THRESHOLDS.items(), key=lambda x: x[1])
+                if b not in self.badges
+            ],
+            "points_to_next_level": 1000 - (self.total_points % 1000),
+            "recent_activity": self.history[-10:] if self.history else [],
+        }
+    
+    def get_leaderboard_entry(self) -> Dict:
+        """Get this user's leaderboard entry."""
+        return {
+            "user_id": self.user_id,
+            "total_points": self.total_points,
+            "level": self.level,
+            "streak": self.streak_days,
+            "badges_count": len(self.badges),
+        }
+
+
+class Leaderboard:
+    """Multi-user leaderboard for family/office competition."""
+    
+    def __init__(self):
+        self.users = {}  # user_id → GamificationEngine
+    
+    def add_user(self, engine: GamificationEngine):
+        self.users[engine.user_id] = engine
+    
+    def get_rankings(self, sort_by: str = "total_points") -> List[Dict]:
+        """Get ranked list of all users."""
+        entries = [engine.get_leaderboard_entry() for engine in self.users.values()]
+        entries.sort(key=lambda x: x[sort_by], reverse=True)
+        
+        for i, entry in enumerate(entries):
+            entry["rank"] = i + 1
+        
+        return entries
+    
+    def get_weekly_winner(self) -> Optional[str]:
+        """Determine this week's posture champion."""
+        if not self.users:
+            return None
+        return max(self.users.values(), key=lambda e: e.total_points).user_id

smart_chair/ml_models/posture_classifier.py

@@ -0,0 +1,350 @@
+"""
+SmartChair Posture Classification — Dual-path architecture.
+
+Path 1: Ensemble Voting (SVM + DT + MLP + XGBoost) on tabular features
+  → Based on SitPose (arxiv:2412.12216), F1=98.2%
+  → Runs on ESP32 via micromlgen C export
+
+Path 2: MLSTM-FCN on sequential windowed data
+  → Based on arxiv:1801.04503 + FusionActNet (arxiv:2310.02011)
+  → Runs on ESP32-S3 via TFLite INT8
+
+Both paths are trained and the best is selected for deployment.
+"""
+
+import numpy as np
+import joblib
+from sklearn.ensemble import VotingClassifier, RandomForestClassifier
+from sklearn.svm import SVC
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.neural_network import MLPClassifier
+from sklearn.metrics import classification_report, confusion_matrix, f1_score
+from sklearn.preprocessing import StandardScaler
+import xgboost as xgb
+
+import sys
+sys.path.insert(0, '/app/smart_chair')
+from utils.feature_engineering import (
+    extract_tabular_features, extract_sequential_features,
+    create_sliding_windows, normalize_sensors
+)
+from config.settings import *
+
+
+class EnsemblePostureClassifier:
+    """
+    Soft-voting ensemble: SVM + DecisionTree + MLP + XGBoost.
+    Best for tabular features extracted from sensor windows.
+    Target: 95.48%+ accuracy (user requirement).
+    
+    Based on SitPose recipe: SVM(C=10,rbf) + DT(depth=10) + MLP(64,32).
+    Added XGBoost as 4th learner for additional improvement.
+    """
+    
+    def __init__(self):
+        self.scaler = StandardScaler()
+        self.model = VotingClassifier(
+            estimators=[
+                ('svm', SVC(
+                    probability=True,
+                    kernel=ENSEMBLE_SVM_KERNEL,
+                    C=ENSEMBLE_SVM_C,
+                    gamma='scale',
+                    class_weight='balanced'
+                )),
+                ('dt', DecisionTreeClassifier(
+                    max_depth=ENSEMBLE_DT_MAX_DEPTH,
+                    class_weight='balanced'
+                )),
+                ('mlp', MLPClassifier(
+                    hidden_layer_sizes=ENSEMBLE_MLP_HIDDEN,
+                    max_iter=ENSEMBLE_MLP_MAX_ITER,
+                    early_stopping=True,
+                    validation_fraction=0.1,
+                    random_state=42
+                )),
+                ('xgb', xgb.XGBClassifier(
+                    n_estimators=100,
+                    max_depth=6,
+                    learning_rate=0.1,
+                    eval_metric='mlogloss',
+                    random_state=42
+                )),
+                ('rf', RandomForestClassifier(
+                    n_estimators=100,
+                    max_depth=12,
+                    class_weight='balanced',
+                    random_state=42
+                )),
+            ],
+            voting='soft',
+            n_jobs=-1
+        )
+        self.is_trained = False
+        self.feature_names = None
+    
+    def prepare_features(self, imu_data, load_data, window_size=WINDOW_SIZE, stride=WINDOW_STRIDE):
+        """
+        Extract tabular features from sliding windows of sensor data.
+        
+        Args:
+            imu_data: shape (N, 6)
+            load_data: shape (N, 4)
+            window_size: samples per window
+            stride: window step
+        
+        Returns:
+            features: shape (num_windows, n_features)
+        """
+        n_windows = (len(imu_data) - window_size) // stride
+        features_list = []
+        
+        for i in range(0, len(imu_data) - window_size, stride):
+            imu_window = imu_data[i:i + window_size]
+            load_window = load_data[i:i + window_size]
+            feat = extract_tabular_features(imu_window, load_window, window_size)
+            features_list.append(feat)
+        
+        return np.array(features_list)
+    
+    def train(self, imu_train, load_train, labels_train,
+              imu_val=None, load_val=None, labels_val=None):
+        """
+        Train the ensemble classifier.
+        
+        Args:
+            imu_train: shape (N, 6) — continuous IMU data
+            load_train: shape (N, 4) — continuous load cell data
+            labels_train: shape (N,) — per-sample labels
+        """
+        print("=" * 60)
+        print("ENSEMBLE POSTURE CLASSIFIER — TRAINING")
+        print("=" * 60)
+        
+        # Create windows and extract features
+        print("\n[1/4] Extracting tabular features from training windows...")
+        X_windows, y_windows = create_sliding_windows(
+            np.concatenate([imu_train, load_train], axis=1),
+            labels_train,
+            window_size=WINDOW_SIZE, stride=WINDOW_STRIDE
+        )
+        
+        X_features = []
+        for w in X_windows:
+            imu_w = w[:, :6]
+            load_w = w[:, 6:10]
+            X_features.append(extract_tabular_features(imu_w, load_w))
+        X_features = np.array(X_features)
+        
+        print(f"   Training samples: {len(X_features)}, Features: {X_features.shape[1]}")
+        print(f"   Class distribution: {np.bincount(y_windows)}")
+        
+        # Handle NaN/Inf
+        X_features = np.nan_to_num(X_features, nan=0, posinf=0, neginf=0)
+        
+        # Scale features
+        print("\n[2/4] Scaling features...")
+        X_scaled = self.scaler.fit_transform(X_features)
+        
+        # Train ensemble
+        print("\n[3/4] Training ensemble (SVM + DT + MLP + XGBoost + RF)...")
+        self.model.fit(X_scaled, y_windows)
+        self.is_trained = True
+        
+        # Evaluate on training set
+        train_pred = self.model.predict(X_scaled)
+        train_f1 = f1_score(y_windows, train_pred, average='weighted')
+        print(f"\n   Training F1 (weighted): {train_f1:.4f}")
+        
+        # Evaluate on validation set if provided
+        if imu_val is not None:
+            print("\n[4/4] Evaluating on validation set...")
+            X_val_windows, y_val_windows = create_sliding_windows(
+                np.concatenate([imu_val, load_val], axis=1),
+                labels_val,
+                window_size=WINDOW_SIZE, stride=WINDOW_STRIDE
+            )
+            
+            X_val_features = []
+            for w in X_val_windows:
+                X_val_features.append(extract_tabular_features(w[:, :6], w[:, 6:10]))
+            X_val_features = np.nan_to_num(np.array(X_val_features), nan=0, posinf=0, neginf=0)
+            X_val_scaled = self.scaler.transform(X_val_features)
+            
+            val_pred = self.model.predict(X_val_scaled)
+            val_f1 = f1_score(y_val_windows, val_pred, average='weighted')
+            
+            print(f"\n   Validation F1 (weighted): {val_f1:.4f}")
+            print(f"\n   Classification Report:")
+            print(classification_report(
+                y_val_windows, val_pred,
+                target_names=[POSTURE_CLASSES[i] for i in sorted(POSTURE_CLASSES.keys())]
+            ))
+            print(f"\n   Confusion Matrix:")
+            print(confusion_matrix(y_val_windows, val_pred))
+            
+            return {"train_f1": train_f1, "val_f1": val_f1}
+        
+        return {"train_f1": train_f1}
+    
+    def predict(self, imu_window, load_window):
+        """Single window inference."""
+        feat = extract_tabular_features(imu_window, load_window)
+        feat = np.nan_to_num(feat.reshape(1, -1), nan=0, posinf=0, neginf=0)
+        feat_scaled = self.scaler.transform(feat)
+        return self.model.predict(feat_scaled)[0]
+    
+    def predict_proba(self, imu_window, load_window):
+        """Single window inference with probability."""
+        feat = extract_tabular_features(imu_window, load_window)
+        feat = np.nan_to_num(feat.reshape(1, -1), nan=0, posinf=0, neginf=0)
+        feat_scaled = self.scaler.transform(feat)
+        return self.model.predict_proba(feat_scaled)[0]
+    
+    def save(self, path):
+        """Save model + scaler."""
+        joblib.dump({
+            'model': self.model,
+            'scaler': self.scaler,
+            'posture_classes': POSTURE_CLASSES,
+        }, path)
+        print(f"Model saved to {path}")
+    
+    def load(self, path):
+        """Load model + scaler."""
+        data = joblib.load(path)
+        self.model = data['model']
+        self.scaler = data['scaler']
+        self.is_trained = True
+        print(f"Model loaded from {path}")
+
+
+def build_mlstm_fcn(n_timesteps=WINDOW_SIZE, n_channels=INPUT_CHANNELS, 
+                     n_classes=NUM_POSTURE_CLASSES):
+    """
+    Build MLSTM-FCN model for sequential sensor data.
+    Architecture from arxiv:1801.04503 with Squeeze-Excite blocks.
+    
+    Input: (batch, timesteps, channels) — windowed sensor data
+    Output: (batch, n_classes) — posture probabilities
+    """
+    import tensorflow as tf
+    from tensorflow.keras import layers, Model
+    
+    inputs = layers.Input(shape=(n_timesteps, n_channels), name='sensor_input')
+    
+    # ── FCN Branch with Squeeze-Excite ────────────────────────────────────
+    x = inputs
+    for filters, kernel in zip(MLSTM_FCN_FILTERS, MLSTM_FCN_KERNELS):
+        x = layers.Conv1D(filters, kernel, padding='same')(x)
+        x = layers.BatchNormalization(momentum=0.99, epsilon=0.001)(x)
+        x = layers.ReLU()(x)
+        
+        # Squeeze-Excite block (channel attention)
+        se = layers.GlobalAveragePooling1D()(x)
+        se = layers.Dense(filters // MLSTM_FCN_SE_RATIO, activation='relu')(se)
+        se = layers.Dense(filters, activation='sigmoid')(se)
+        se = layers.Reshape((1, filters))(se)
+        x = layers.Multiply()([x, se])
+    
+    fcn_out = layers.GlobalAveragePooling1D(name='fcn_features')(x)
+    
+    # ── LSTM Branch (dimension shuffle) ───────────────────────────────────
+    # Permute: (batch, timesteps, channels) → (batch, channels, timesteps)
+    # LSTM sees each channel as a "timestep" over all time positions
+    shuffled = layers.Permute((2, 1))(inputs)
+    lstm_out = layers.LSTM(MLSTM_FCN_LSTM_UNITS, name='lstm_features')(shuffled)
+    lstm_out = layers.Dropout(MLSTM_FCN_DROPOUT)(lstm_out)
+    
+    # ── Merge ─────────────────────────────────────────────────────────────
+    merged = layers.Concatenate(name='fused_features')([fcn_out, lstm_out])
+    
+    # Classification head
+    output = layers.Dense(n_classes, activation='softmax', name='posture_output')(merged)
+    
+    model = Model(inputs, output, name='MLSTM_FCN_Posture')
+    model.compile(
+        optimizer=tf.keras.optimizers.Adam(learning_rate=TRAIN_LR),
+        loss='sparse_categorical_crossentropy',
+        metrics=['accuracy']
+    )
+    
+    return model
+
+
+def train_mlstm_fcn(model, X_train, y_train, X_val, y_val):
+    """
+    Train MLSTM-FCN with early stopping and learning rate reduction.
+    """
+    import tensorflow as tf
+    
+    callbacks = [
+        tf.keras.callbacks.EarlyStopping(
+            monitor='val_accuracy', patience=EARLY_STOPPING_PATIENCE,
+            restore_best_weights=True, mode='max'
+        ),
+        tf.keras.callbacks.ReduceLROnPlateau(
+            monitor='val_loss', factor=0.5, patience=5, min_lr=1e-6
+        ),
+    ]
+    
+    history = model.fit(
+        X_train, y_train,
+        validation_data=(X_val, y_val),
+        epochs=TRAIN_EPOCHS,
+        batch_size=TRAIN_BATCH_SIZE,
+        callbacks=callbacks,
+        verbose=1
+    )
+    
+    return history
+
+
+def convert_to_tflite(model, representative_data, output_path='posture_model.tflite'):
+    """
+    Convert Keras model to INT8 TFLite for ESP32-S3 deployment.
+    Based on TinyNav (arxiv:2603.11071) quantization recipe.
+    """
+    import tensorflow as tf
+    
+    def representative_dataset():
+        for sample in representative_data[:200]:
+            yield [sample[np.newaxis].astype(np.float32)]
+    
+    converter = tf.lite.TFLiteConverter.from_keras_model(model)
+    converter.optimizations = [tf.lite.Optimize.DEFAULT]
+    converter.representative_dataset = representative_dataset
+    converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
+    converter.inference_input_type = tf.int8
+    converter.inference_output_type = tf.int8
+    
+    tflite_model = converter.convert()
+    
+    with open(output_path, 'wb') as f:
+        f.write(tflite_model)
+    
+    print(f"TFLite model saved: {output_path} ({len(tflite_model)/1024:.1f} KB)")
+    return tflite_model
+
+
+if __name__ == "__main__":
+    from data_collection.synthetic_data_generator import generate_dataset, subject_based_split
+    
+    # Generate synthetic data
+    print("Generating synthetic dataset...")
+    dataset = generate_dataset(n_subjects=20, samples_per_posture_per_subject=500)
+    train, test = subject_based_split(dataset)
+    
+    # Train Ensemble Classifier
+    print("\n" + "=" * 60)
+    print("TRAINING ENSEMBLE CLASSIFIER")
+    print("=" * 60)
+    
+    clf = EnsemblePostureClassifier()
+    results = clf.train(
+        train["imu_data"], train["load_data"], train["labels"],
+        test["imu_data"], test["load_data"], test["labels"]
+    )
+    
+    print(f"\nFinal Results — Ensemble: {results}")
+    clf.save("/app/smart_chair/models/ensemble_posture.joblib")

smart_chair/ml_models/spine_risk_predictor.py

@@ -0,0 +1,555 @@
+"""
+SmartChair Spine Risk Prediction & Fatigue Detection.
+
+1. RULA-based Ergonomic Risk Score (real-time)
+   → Based on DULA/DEBA (arxiv:2205.03491): differentiable RULA scoring
+   → Maps IMU angles to 1-7 risk scale per RULA standard
+
+2. Cumulative Spine Risk Prediction (long-term)
+   → Accumulates posture history → predicts injury risk trajectory
+   → Uses exponential decay weighting (recent bad posture = higher risk)
+
+3. Fatigue & Drowsiness Detection (pressure patterns)
+   → Based on CoP variance trends over 30-min windows
+   → Increasing variability = restlessness → fatigue
+   → Decreasing micro-movement = drowsiness/falling asleep
+"""
+
+import numpy as np
+from collections import deque
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
+
+import sys
+sys.path.insert(0, '/app/smart_chair')
+from utils.feature_engineering import compute_imu_angles, compute_center_of_pressure
+from config.settings import *
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 1. RULA-BASED REAL-TIME ERGONOMIC RISK SCORE
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class RULAScorer:
+    """
+    Rapid Upper Limb Assessment (RULA) adapted for seated posture.
+    Maps trunk pitch/roll angles to a 1-7 risk score.
+    
+    Score interpretation (EN ISO 11226 + RULA):
+        1-2: Acceptable posture
+        3-4: Investigate further, possible intervention needed
+        5-6: Investigate and implement changes soon
+        7:   Investigate and implement changes immediately
+    """
+    
+    def __init__(self):
+        self.trunk_angle_thresholds = RULA_TRUNK_ANGLES  # [10, 20, 60] degrees
+        self.lateral_threshold = RULA_LATERAL_THRESHOLD   # 15 degrees
+    
+    def score_trunk(self, pitch_deg: float) -> int:
+        """Score trunk forward/backward flexion (1-4 base score)."""
+        deviation = abs(pitch_deg)
+        if deviation < self.trunk_angle_thresholds[0]:      # < 10°
+            return 1
+        elif deviation < self.trunk_angle_thresholds[1]:     # 10-20°
+            return 2
+        elif deviation < self.trunk_angle_thresholds[2]:     # 20-60°
+            return 3
+        else:                                                 # > 60°
+            return 4
+    
+    def score_lateral(self, roll_deg: float) -> int:
+        """Score lateral trunk deviation (0-1 modifier)."""
+        return 1 if abs(roll_deg) > self.lateral_threshold else 0
+    
+    def score_twist(self, yaw_rate: float) -> int:
+        """Score trunk twist from gyroscope yaw rate (0-1 modifier)."""
+        return 1 if abs(yaw_rate) > 0.5 else 0  # rad/s threshold
+    
+    def compute_rula_score(self, pitch_deg: float, roll_deg: float,
+                           yaw_rate: float = 0.0,
+                           duration_minutes: float = 0.0,
+                           is_static: bool = True) -> Dict:
+        """
+        Compute full RULA score for seated posture.
+        
+        Args:
+            pitch_deg: trunk forward/backward angle (from IMU)
+            roll_deg: trunk lateral angle (from IMU)
+            yaw_rate: trunk rotation rate (from gyroscope z-axis)
+            duration_minutes: how long in this posture
+            is_static: True if posture held > 1 minute
+        
+        Returns:
+            dict with score, risk_level, recommendations
+        """
+        # Base trunk score
+        trunk_score = self.score_trunk(pitch_deg)
+        trunk_score += self.score_lateral(roll_deg)
+        trunk_score += self.score_twist(yaw_rate)
+        
+        # Static posture modifier (held > 1 min adds +1)
+        if is_static and duration_minutes > 1:
+            trunk_score += 1
+        
+        # Duration escalation (long-held bad posture is worse)
+        if duration_minutes > 30:
+            trunk_score += 1
+        if duration_minutes > 60:
+            trunk_score += 1
+        
+        # Clamp to 1-7
+        final_score = max(1, min(7, trunk_score))
+        
+        return {
+            "rula_score": final_score,
+            "risk_level": RISK_LEVELS.get(final_score, "unknown"),
+            "trunk_base": self.score_trunk(pitch_deg),
+            "lateral_mod": self.score_lateral(roll_deg),
+            "twist_mod": self.score_twist(yaw_rate),
+            "duration_minutes": duration_minutes,
+            "pitch_deg": pitch_deg,
+            "roll_deg": roll_deg,
+            "recommendations": self._get_recommendations(final_score, pitch_deg, roll_deg)
+        }
+    
+    def _get_recommendations(self, score: int, pitch: float, roll: float) -> List[str]:
+        """Generate actionable recommendations based on risk score."""
+        recs = []
+        if score <= 2:
+            recs.append("Good posture! Keep it up.")
+        if score >= 3:
+            recs.append("Adjust your sitting position — try moving back in the chair.")
+        if abs(pitch) > 20:
+            recs.append(f"Forward lean detected ({abs(pitch):.0f}°). Sit upright and engage core.")
+        if abs(roll) > 15:
+            side = "left" if roll < 0 else "right"
+            recs.append(f"Leaning {side} ({abs(roll):.0f}°). Center your weight evenly.")
+        if score >= 5:
+            recs.append("⚠️ HIGH RISK: Take a break immediately and do spine stretches.")
+        if score >= 7:
+            recs.append("🚨 CRITICAL: Prolonged poor posture detected. Stand up NOW.")
+        return recs
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 2. CUMULATIVE SPINE RISK PREDICTOR
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class SpineRiskPredictor:
+    """
+    Long-term spine risk prediction using accumulated session data.
+    
+    Model: Exponential decay weighted accumulator.
+    Recent bad posture has more impact than historical bad posture.
+    
+    Risk score = Σ (posture_penalty × decay^(time_elapsed)) / normalization
+    
+    Outputs:
+        - Daily risk score (0-100)
+        - Weekly trend (improving / stable / deteriorating)
+        - Predicted injury risk category
+    """
+    
+    def __init__(self, decay_rate: float = 0.95):
+        self.decay_rate = decay_rate
+        self.history = deque(maxlen=7 * 24 * 60)  # 1 week of per-minute records
+        self.daily_scores = deque(maxlen=30)       # 30 days of daily scores
+        
+        # Posture penalty weights (higher = worse for spine)
+        self.posture_penalties = {
+            "upright": 0.0,
+            "forward_lean": 0.6,
+            "backward_lean": 0.3,
+            "left_lean": 0.4,
+            "right_lean": 0.4,
+            "slouch": 1.0,      # worst posture for spine
+            "absent": 0.0,
+        }
+    
+    def record_posture(self, posture_name: str, rula_score: int,
+                       duration_minutes: float = 1.0, timestamp: Optional[datetime] = None):
+        """Record a posture observation."""
+        if timestamp is None:
+            timestamp = datetime.now()
+        
+        self.history.append({
+            "timestamp": timestamp,
+            "posture": posture_name,
+            "rula_score": rula_score,
+            "duration": duration_minutes,
+            "penalty": self.posture_penalties.get(posture_name, 0.5),
+        })
+    
+    def compute_session_risk(self, lookback_minutes: int = 60) -> Dict:
+        """
+        Compute risk score for the current session.
+        
+        Returns:
+            dict with risk_score (0-100), trend, breakdown
+        """
+        now = datetime.now()
+        cutoff = now - timedelta(minutes=lookback_minutes)
+        
+        recent = [r for r in self.history if r["timestamp"] >= cutoff]
+        
+        if not recent:
+            return {"risk_score": 0, "trend": "no_data", "minutes_analyzed": 0}
+        
+        # Weighted risk accumulation
+        total_risk = 0
+        total_weight = 0
+        posture_breakdown = {}
+        
+        for record in recent:
+            elapsed = (now - record["timestamp"]).total_seconds() / 60
+            weight = self.decay_rate ** elapsed  # exponential decay
+            risk = record["penalty"] * record["rula_score"] * record["duration"]
+            
+            total_risk += risk * weight
+            total_weight += weight * record["duration"]
+            
+            p = record["posture"]
+            posture_breakdown[p] = posture_breakdown.get(p, 0) + record["duration"]
+        
+        # Normalize to 0-100 scale
+        max_possible_risk = 7 * 1.0 * lookback_minutes  # max RULA × max penalty × all minutes
+        risk_score = min(100, (total_risk / (total_weight + 1e-6)) * 100 / 7)
+        
+        return {
+            "risk_score": round(risk_score, 1),
+            "risk_category": self._categorize_risk(risk_score),
+            "minutes_analyzed": sum(r["duration"] for r in recent),
+            "posture_breakdown": posture_breakdown,
+            "dominant_posture": max(posture_breakdown, key=posture_breakdown.get) if posture_breakdown else "unknown",
+        }
+    
+    def compute_daily_score(self) -> float:
+        """Compute and store daily posture score (0-100, higher = better)."""
+        session = self.compute_session_risk(lookback_minutes=24*60)
+        # Invert: low risk = high score
+        daily_score = max(0, 100 - session["risk_score"])
+        self.daily_scores.append({
+            "date": datetime.now().date(),
+            "score": daily_score,
+        })
+        return daily_score
+    
+    def get_weekly_trend(self) -> Dict:
+        """Analyze 7-day trend."""
+        if len(self.daily_scores) < 2:
+            return {"trend": "insufficient_data", "scores": []}
+        
+        scores = [s["score"] for s in self.daily_scores]
+        recent_3 = np.mean(scores[-3:]) if len(scores) >= 3 else scores[-1]
+        older_3 = np.mean(scores[-6:-3]) if len(scores) >= 6 else scores[0]
+        
+        if recent_3 > older_3 + 5:
+            trend = "improving"
+        elif recent_3 < older_3 - 5:
+            trend = "deteriorating"
+        else:
+            trend = "stable"
+        
+        return {
+            "trend": trend,
+            "current_avg": round(recent_3, 1),
+            "previous_avg": round(older_3, 1),
+            "scores": [{"date": str(s["date"]), "score": s["score"]} for s in self.daily_scores],
+        }
+    
+    def predict_injury_risk(self, weeks_ahead: int = 4) -> Dict:
+        """
+        Predict future injury risk based on current trajectory.
+        
+        Uses linear extrapolation of daily scores to estimate
+        when risk crosses critical thresholds.
+        """
+        if len(self.daily_scores) < 7:
+            return {"prediction": "need_more_data", "days_collected": len(self.daily_scores)}
+        
+        scores = [s["score"] for s in self.daily_scores]
+        x = np.arange(len(scores))
+        slope, intercept = np.polyfit(x, scores, 1)
+        
+        # Project forward
+        future_x = np.arange(len(scores), len(scores) + weeks_ahead * 7)
+        projected = slope * future_x + intercept
+        
+        # Find when score drops below thresholds
+        alerts = []
+        if slope < -0.5:  # declining at > 0.5 points/day
+            days_to_danger = int((40 - intercept) / slope) if slope != 0 else None
+            if days_to_danger and 0 < days_to_danger < weeks_ahead * 7:
+                alerts.append(f"⚠️ At current rate, posture score will reach DANGER zone in {days_to_danger} days")
+        
+        return {
+            "slope": round(slope, 3),  # points per day
+            "direction": "improving" if slope > 0 else "declining",
+            "projected_4week_score": round(projected[-1], 1),
+            "current_score": round(scores[-1], 1),
+            "alerts": alerts,
+            "recommendation": "Maintain current habits" if slope >= 0 else
+                            "Increase break frequency and do corrective exercises"
+        }
+    
+    def _categorize_risk(self, risk_score: float) -> str:
+        if risk_score < 20: return "low"
+        elif risk_score < 40: return "moderate"
+        elif risk_score < 60: return "elevated"
+        elif risk_score < 80: return "high"
+        else: return "critical"
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 3. FATIGUE & DROWSINESS DETECTION
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class FatigueDetector:
+    """
+    Detects physical fatigue and drowsiness from pressure/load cell patterns.
+    
+    Fatigue indicators (from literature):
+        1. Increasing CoP variance (restlessness, frequent shifting)
+        2. Decreasing micro-movement amplitude (stillness = drowsiness)
+        3. Gradual forward lean (torso muscle fatigue → slouch)
+        4. Weight redistribution pattern changes
+    
+    Uses rolling window analysis over 30 minutes.
+    """
+    
+    def __init__(self, window_minutes: int = FATIGUE_WINDOW_MINUTES):
+        self.window_minutes = window_minutes
+        self.cop_history = deque(maxlen=window_minutes * 60 * 10)  # 10 Hz
+        self.movement_history = deque(maxlen=window_minutes * 60 * 50)  # 50 Hz IMU
+        self.posture_sequence = deque(maxlen=window_minutes)  # per-minute
+        self.alert_cooldown_seconds = 300  # 5 min between alerts
+        self.last_alert_time = None
+    
+    def update(self, load_cells: np.ndarray, imu_data: np.ndarray,
+               timestamp: Optional[datetime] = None):
+        """
+        Add new sensor readings. Call at sensor sampling rate.
+        
+        Args:
+            load_cells: shape (4,) — [FL, FR, RL, RR]
+            imu_data: shape (6,) — [ax, ay, az, gx, gy, gz]
+        """
+        if timestamp is None:
+            timestamp = datetime.now()
+        
+        # Compute CoP
+        total = np.sum(load_cells) + 1e-6
+        cop_x = (load_cells[1] + load_cells[3] - load_cells[0] - load_cells[2]) / total
+        cop_y = (load_cells[0] + load_cells[1] - load_cells[2] - load_cells[3]) / total
+        
+        self.cop_history.append({
+            "timestamp": timestamp,
+            "cop_x": cop_x,
+            "cop_y": cop_y,
+            "total_weight": total,
+        })
+        
+        # Compute acceleration magnitude (micro-movement indicator)
+        accel_mag = np.linalg.norm(imu_data[:3])
+        self.movement_history.append({
+            "timestamp": timestamp,
+            "accel_mag": accel_mag,
+            "gyro_mag": np.linalg.norm(imu_data[3:]),
+        })
+    
+    def analyze_fatigue(self) -> Dict:
+        """
+        Analyze current fatigue state from accumulated sensor history.
+        
+        Returns:
+            dict with fatigue_level, drowsiness_risk, indicators
+        """
+        if len(self.cop_history) < 100:
+            return {"fatigue_level": "unknown", "drowsiness_risk": "unknown",
+                    "reason": "insufficient_data"}
+        
+        # ── CoP Variance Analysis (restlessness) ──────────────────────────
+        cop_x_values = [r["cop_x"] for r in self.cop_history]
+        cop_y_values = [r["cop_y"] for r in self.cop_history]
+        
+        # Split into 5-minute windows
+        n = len(cop_x_values)
+        window_5min = min(3000, n // 3)  # ~5 min at 10 Hz
+        
+        early_cop_var = np.var(cop_x_values[:window_5min]) + np.var(cop_y_values[:window_5min])
+        recent_cop_var = np.var(cop_x_values[-window_5min:]) + np.var(cop_y_values[-window_5min:])
+        
+        cop_trend = recent_cop_var / (early_cop_var + 1e-6)
+        
+        # ── Micro-Movement Analysis (drowsiness) ─────────────────────────
+        accel_values = [r["accel_mag"] for r in self.movement_history]
+        n_mov = len(accel_values)
+        window_2min = min(6000, n_mov // 3)  # ~2 min at 50 Hz
+        
+        recent_movement = np.std(accel_values[-window_2min:])
+        early_movement = np.std(accel_values[:window_2min])
+        
+        movement_decline = recent_movement / (early_movement + 1e-6)
+        
+        # ── Weight Shift Analysis ─────────────────────────────────────────
+        weights = [r["total_weight"] for r in self.cop_history]
+        weight_stability = np.std(weights[-window_5min:])
+        
+        # ── Fatigue Classification ────────────────────────────────────────
+        fatigue_score = 0
+        indicators = []
+        
+        # Restlessness (high CoP variance trend)
+        if cop_trend > 2.0:
+            fatigue_score += 3
+            indicators.append(f"Restlessness: CoP variance increased {cop_trend:.1f}x")
+        elif cop_trend > 1.5:
+            fatigue_score += 1
+            indicators.append(f"Mild restlessness: CoP variance increased {cop_trend:.1f}x")
+        
+        # Drowsiness (decreasing movement)
+        if movement_decline < 0.3:
+            fatigue_score += 4
+            indicators.append(f"⚠️ Possible drowsiness: movement dropped to {movement_decline:.1%} of baseline")
+        elif movement_decline < 0.6:
+            fatigue_score += 2
+            indicators.append(f"Reduced activity: movement at {movement_decline:.1%} of baseline")
+        
+        # Weight instability
+        if weight_stability > 2.0:
+            fatigue_score += 1
+            indicators.append("Frequent weight shifting detected")
+        
+        # Classify
+        if fatigue_score >= 5:
+            fatigue_level = "high"
+        elif fatigue_score >= 3:
+            fatigue_level = "moderate"
+        elif fatigue_score >= 1:
+            fatigue_level = "low"
+        else:
+            fatigue_level = "none"
+        
+        # Drowsiness specifically
+        drowsiness_risk = "high" if movement_decline < 0.3 else \
+                         "moderate" if movement_decline < 0.5 else "low"
+        
+        return {
+            "fatigue_level": fatigue_level,
+            "fatigue_score": fatigue_score,
+            "drowsiness_risk": drowsiness_risk,
+            "cop_variance_trend": round(cop_trend, 2),
+            "movement_decline_ratio": round(movement_decline, 3),
+            "indicators": indicators,
+            "recommendation": self._get_fatigue_recommendation(fatigue_level, drowsiness_risk),
+            "minutes_analyzed": len(self.cop_history) / 600,  # at 10 Hz
+        }
+    
+    def _get_fatigue_recommendation(self, fatigue: str, drowsiness: str) -> str:
+        if drowsiness == "high":
+            return "🚨 DROWSINESS ALERT: Stand up, walk, and get fresh air immediately!"
+        if fatigue == "high":
+            return "⚠️ High fatigue detected. Take a 5-minute active break with stretching."
+        if fatigue == "moderate":
+            return "Moderate fatigue. Consider a micro-break in the next 10 minutes."
+        return "Looking good! No fatigue issues detected."
+    
+    def should_alert(self) -> bool:
+        """Check if enough time has passed since last alert."""
+        if self.last_alert_time is None:
+            return True
+        elapsed = (datetime.now() - self.last_alert_time).total_seconds()
+        return elapsed > self.alert_cooldown_seconds
+    
+    def send_alert(self):
+        """Mark alert as sent."""
+        self.last_alert_time = datetime.now()
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 4. INJURY RISK ALERT SYSTEM
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class InjuryRiskAlertSystem:
+    """
+    Monitors long-term postural habits and generates injury risk alerts.
+    
+    Alert types:
+        - Acute: Dangerous posture held too long (immediate)
+        - Chronic: Pattern of bad posture over days/weeks
+        - Trend: Deteriorating posture score trajectory
+    """
+    
+    def __init__(self):
+        self.alerts = deque(maxlen=1000)
+        self.acknowledged = set()
+    
+    def check_acute_risk(self, rula_score: int, posture_name: str,
+                          duration_minutes: float) -> Optional[Dict]:
+        """Check for immediate dangerous posture."""
+        alert = None
+        
+        if rula_score >= 6 and duration_minutes > 5:
+            alert = {
+                "type": "acute",
+                "severity": "critical",
+                "message": f"🚨 CRITICAL: {posture_name} posture (RULA={rula_score}) "
+                          f"held for {duration_minutes:.0f} min. Risk of acute back strain.",
+                "action": "Stand up and do gentle back extension stretches immediately.",
+                "timestamp": datetime.now().isoformat(),
+            }
+        elif rula_score >= 4 and duration_minutes > 20:
+            alert = {
+                "type": "acute", 
+                "severity": "warning",
+                "message": f"⚠️ WARNING: {posture_name} posture (RULA={rula_score}) "
+                          f"for {duration_minutes:.0f} min. Spine compression accumulating.",
+                "action": "Adjust posture and take a micro-break within 10 minutes.",
+                "timestamp": datetime.now().isoformat(),
+            }
+        
+        if alert:
+            self.alerts.append(alert)
+        return alert
+    
+    def check_chronic_risk(self, daily_scores: List[float]) -> Optional[Dict]:
+        """Check for chronic poor posture patterns."""
+        if len(daily_scores) < 7:
+            return None
+        
+        week_avg = np.mean(daily_scores[-7:])
+        
+        if week_avg < 30:
+            alert = {
+                "type": "chronic",
+                "severity": "critical",
+                "message": f"🚨 CHRONIC RISK: Weekly posture score = {week_avg:.0f}/100. "
+                          f"Persistent poor posture increases herniated disc risk by 4x.",
+                "action": "Schedule ergonomic assessment. Consider standing desk alternation.",
+                "timestamp": datetime.now().isoformat(),
+            }
+            self.alerts.append(alert)
+            return alert
+        
+        if week_avg < 50:
+            alert = {
+                "type": "chronic",
+                "severity": "warning",
+                "message": f"⚠️ CONCERN: Weekly posture score = {week_avg:.0f}/100. "
+                          f"Consistent moderate risk detected.",
+                "action": "Increase break frequency and add core strengthening exercises.",
+                "timestamp": datetime.now().isoformat(),
+            }
+            self.alerts.append(alert)
+            return alert
+        
+        return None
+    
+    def get_active_alerts(self) -> List[Dict]:
+        """Get all unacknowledged alerts."""
+        return [a for i, a in enumerate(self.alerts) if i not in self.acknowledged]
+    
+    def acknowledge_alert(self, alert_index: int):
+        """Mark alert as acknowledged."""
+        self.acknowledged.add(alert_index)

smart_chair/ml_models/user_recognition.py

@@ -0,0 +1,409 @@
+"""
+SmartChair Multi-User Recognition via Weight Signature Patterns.
+
+Based on pressure biometrics literature + AuthentiSense (arxiv:2302.02740):
+- Uses load cell weight distribution as biometric signature
+- Few-shot learning: 5 sit-down events per user for enrollment
+- k-NN matching with Mahalanobis distance for robustness
+- Siamese network option for improved accuracy with more data
+
+Weight signature features:
+- Total weight (strongest discriminator, ±3kg tolerance)
+- Front/back weight ratio (sitting style)
+- Left/right weight ratio (postural asymmetry)
+- CoP pattern during sit-down transition (unique to individual)
+"""
+
+import numpy as np
+from collections import defaultdict
+from typing import Dict, List, Optional, Tuple
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.preprocessing import StandardScaler
+import joblib
+
+import sys
+sys.path.insert(0, '/app/smart_chair')
+from utils.feature_engineering import compute_center_of_pressure
+from config.settings import *
+
+
+class WeightSignature:
+    """Represents a user's unique weight distribution pattern."""
+    
+    def __init__(self, load_readings: np.ndarray):
+        """
+        Extract weight signature from a sequence of load cell readings.
+        
+        Args:
+            load_readings: shape (N, 4) — [FL, FR, RL, RR] over ~10 seconds of sitting
+        """
+        total = np.sum(load_readings, axis=1, keepdims=True) + 1e-6
+        normalized = load_readings / total
+        
+        self.total_weight = np.mean(total)
+        self.total_weight_std = np.std(total)
+        
+        # Per-cell ratios (unique to how a person sits)
+        self.fl_ratio = np.mean(normalized[:, 0])
+        self.fr_ratio = np.mean(normalized[:, 1])
+        self.rl_ratio = np.mean(normalized[:, 2])
+        self.rr_ratio = np.mean(normalized[:, 3])
+        
+        # Ratio variabilities (how stable their sitting is)
+        self.fl_std = np.std(normalized[:, 0])
+        self.fr_std = np.std(normalized[:, 1])
+        self.rl_std = np.std(normalized[:, 2])
+        self.rr_std = np.std(normalized[:, 3])
+        
+        # Derived ratios
+        front = normalized[:, 0] + normalized[:, 1]
+        back = normalized[:, 2] + normalized[:, 3]
+        left = normalized[:, 0] + normalized[:, 2]
+        right = normalized[:, 1] + normalized[:, 3]
+        
+        self.front_back_ratio = np.mean(front / (back + 1e-6))
+        self.left_right_ratio = np.mean(left / (right + 1e-6))
+        
+        # CoP signature
+        cop_x, cop_y = compute_center_of_pressure(load_readings)
+        self.cop_x_mean = np.mean(cop_x)
+        self.cop_y_mean = np.mean(cop_y)
+        self.cop_x_std = np.std(cop_x)
+        self.cop_y_std = np.std(cop_y)
+        
+        # Sit-down dynamics (how quickly weight stabilizes)
+        if len(load_readings) > 20:
+            weight_diff = np.diff(total.flatten())
+            self.sitdown_speed = np.mean(np.abs(weight_diff[:20]))
+            self.stability_time = np.argmax(np.abs(weight_diff) < 0.5) if np.any(np.abs(weight_diff) < 0.5) else len(weight_diff)
+        else:
+            self.sitdown_speed = 0
+            self.stability_time = 0
+    
+    def to_vector(self) -> np.ndarray:
+        """Convert to feature vector for ML models."""
+        return np.array([
+            self.total_weight,
+            self.fl_ratio, self.fr_ratio, self.rl_ratio, self.rr_ratio,
+            self.fl_std, self.fr_std, self.rl_std, self.rr_std,
+            self.front_back_ratio, self.left_right_ratio,
+            self.cop_x_mean, self.cop_y_mean,
+            self.cop_x_std, self.cop_y_std,
+            self.sitdown_speed, self.stability_time,
+        ], dtype=np.float32)
+    
+    @staticmethod
+    def feature_names() -> List[str]:
+        return [
+            "total_weight",
+            "fl_ratio", "fr_ratio", "rl_ratio", "rr_ratio",
+            "fl_std", "fr_std", "rl_std", "rr_std",
+            "front_back_ratio", "left_right_ratio",
+            "cop_x_mean", "cop_y_mean",
+            "cop_x_std", "cop_y_std",
+            "sitdown_speed", "stability_time",
+        ]
+
+
+class MultiUserRecognizer:
+    """
+    Recognizes seated users from load cell weight distribution patterns.
+    
+    Enrollment: User sits down 5 times, system captures weight signatures.
+    Recognition: Compare new sitting event to enrolled profiles.
+    
+    Uses k-NN with k=3 (from AuthentiSense recipe for few-shot biometrics).
+    Falls back to weight-based nearest-neighbor if k-NN confidence is low.
+    """
+    
+    def __init__(self, n_enrollment_samples: int = USER_ENROLLMENT_SAMPLES):
+        self.n_enrollment_samples = n_enrollment_samples
+        self.enrolled_users = {}  # user_id → list of WeightSignatures
+        self.knn_model = None
+        self.scaler = StandardScaler()
+        self.is_trained = False
+        self.confidence_threshold = 0.6  # minimum confidence for recognition
+    
+    def enroll_user(self, user_id: str, load_readings_list: List[np.ndarray]) -> Dict:
+        """
+        Enroll a new user with multiple sit-down events.
+        
+        Args:
+            user_id: unique identifier (e.g., "user_alice")
+            load_readings_list: list of (N, 4) arrays, one per sit-down event
+        
+        Returns:
+            enrollment status dict
+        """
+        if len(load_readings_list) < self.n_enrollment_samples:
+            return {
+                "status": "incomplete",
+                "message": f"Need {self.n_enrollment_samples} sit-down samples, "
+                          f"got {len(load_readings_list)}",
+                "user_id": user_id,
+            }
+        
+        signatures = [WeightSignature(readings) for readings in load_readings_list]
+        self.enrolled_users[user_id] = signatures
+        
+        # Retrain classifier
+        self._train_knn()
+        
+        avg_weight = np.mean([s.total_weight for s in signatures])
+        return {
+            "status": "enrolled",
+            "user_id": user_id,
+            "n_samples": len(signatures),
+            "avg_weight_kg": round(float(avg_weight), 1),
+            "total_enrolled": len(self.enrolled_users),
+        }
+    
+    def recognize(self, load_readings: np.ndarray) -> Dict:
+        """
+        Identify which enrolled user is sitting.
+        
+        Args:
+            load_readings: shape (N, 4) — recent load cell data (~10 sec)
+        
+        Returns:
+            dict with recognized user_id, confidence, and top candidates
+        """
+        if not self.is_trained:
+            return {"user_id": "unknown", "confidence": 0, "reason": "no_enrolled_users"}
+        
+        sig = WeightSignature(load_readings)
+        features = sig.to_vector().reshape(1, -1)
+        features_scaled = self.scaler.transform(features)
+        
+        # k-NN prediction with probability
+        proba = self.knn_model.predict_proba(features_scaled)[0]
+        predicted_class = self.knn_model.classes_[np.argmax(proba)]
+        confidence = np.max(proba)
+        
+        # Weight-based sanity check
+        weight_match = self._weight_based_match(sig.total_weight)
+        
+        # Final decision
+        if confidence >= self.confidence_threshold:
+            user_id = predicted_class
+            method = "knn"
+        elif weight_match["confidence"] > confidence:
+            user_id = weight_match["user_id"]
+            confidence = weight_match["confidence"]
+            method = "weight_fallback"
+        else:
+            user_id = "unknown"
+            method = "below_threshold"
+        
+        # Top candidates
+        top_k = sorted(zip(self.knn_model.classes_, proba), key=lambda x: -x[1])[:3]
+        
+        return {
+            "user_id": user_id,
+            "confidence": round(float(confidence), 3),
+            "method": method,
+            "top_candidates": [{"id": uid, "probability": round(float(p), 3)} for uid, p in top_k],
+            "detected_weight_kg": round(float(sig.total_weight), 1),
+        }
+    
+    def _weight_based_match(self, weight: float) -> Dict:
+        """Simple weight-based user matching as fallback."""
+        best_match = "unknown"
+        best_diff = float('inf')
+        
+        for user_id, signatures in self.enrolled_users.items():
+            avg_weight = np.mean([s.total_weight for s in signatures])
+            diff = abs(weight - avg_weight)
+            
+            if diff < best_diff:
+                best_diff = diff
+                best_match = user_id
+        
+        # Confidence based on weight difference (3kg tolerance)
+        if best_diff < USER_WEIGHT_TOLERANCE_KG:
+            confidence = 1.0 - (best_diff / USER_WEIGHT_TOLERANCE_KG) * 0.5
+        else:
+            confidence = max(0, 0.5 - (best_diff - USER_WEIGHT_TOLERANCE_KG) / 20)
+        
+        return {"user_id": best_match, "confidence": confidence, "weight_diff_kg": best_diff}
+    
+    def _train_knn(self):
+        """Train k-NN model on all enrolled user signatures."""
+        if len(self.enrolled_users) < 2:
+            # Need at least 2 users for classification
+            if len(self.enrolled_users) == 1:
+                # Single user mode
+                self.is_trained = False
+                return
+            return
+        
+        X, y = [], []
+        for user_id, signatures in self.enrolled_users.items():
+            for sig in signatures:
+                X.append(sig.to_vector())
+                y.append(user_id)
+        
+        X = np.array(X)
+        y = np.array(y)
+        
+        # Scale features
+        X_scaled = self.scaler.fit_transform(X)
+        
+        # Train k-NN (k=3, as per AuthentiSense for few-shot)
+        k = min(3, len(X) // len(self.enrolled_users))
+        k = max(1, k)
+        
+        self.knn_model = KNeighborsClassifier(
+            n_neighbors=k,
+            metric='mahalanobis' if len(X) > X.shape[1] else 'euclidean',
+            metric_params={'V': np.cov(X_scaled.T)} if len(X) > X.shape[1] else None,
+            weights='distance',
+        )
+        self.knn_model.fit(X_scaled, y)
+        self.is_trained = True
+    
+    def remove_user(self, user_id: str) -> bool:
+        """Remove a user from the system."""
+        if user_id in self.enrolled_users:
+            del self.enrolled_users[user_id]
+            if len(self.enrolled_users) >= 2:
+                self._train_knn()
+            else:
+                self.is_trained = False
+            return True
+        return False
+    
+    def save(self, path: str):
+        """Save recognizer state."""
+        joblib.dump({
+            'enrolled_users': self.enrolled_users,
+            'scaler': self.scaler,
+            'knn_model': self.knn_model,
+            'is_trained': self.is_trained,
+        }, path)
+    
+    def load(self, path: str):
+        """Load recognizer state."""
+        data = joblib.load(path)
+        self.enrolled_users = data['enrolled_users']
+        self.scaler = data['scaler']
+        self.knn_model = data['knn_model']
+        self.is_trained = data['is_trained']
+
+
+class PersonalizedSittingModel:
+    """
+    Learns individual user's sitting patterns over time.
+    
+    Tracks:
+    - Preferred postures by time of day
+    - Typical session duration
+    - Break compliance patterns
+    - Fatigue onset timing
+    - Posture quality trends
+    
+    Used for: personalized break timing, adaptive alerts, trend analysis.
+    """
+    
+    def __init__(self, user_id: str):
+        self.user_id = user_id
+        self.sessions = []  # list of session records
+        self.hourly_posture_dist = defaultdict(lambda: defaultdict(float))  # hour → posture → minutes
+        self.break_compliance = []  # (recommended, taken) booleans
+        self.fatigue_onsets = []  # minutes into session when fatigue detected
+    
+    def record_session(self, start_time, end_time, posture_timeline: List[Dict],
+                       breaks_taken: int, fatigue_onset_min: Optional[float] = None):
+        """
+        Record a complete sitting session.
+        
+        Args:
+            posture_timeline: list of {"posture": str, "duration_min": float, "rula_score": int}
+        """
+        duration = (end_time - start_time).total_seconds() / 60
+        
+        # Session summary
+        good_posture_min = sum(
+            p["duration_min"] for p in posture_timeline 
+            if p["posture"] in ["upright"]
+        )
+        
+        session = {
+            "start": start_time,
+            "end": end_time,
+            "duration_min": duration,
+            "good_posture_pct": good_posture_min / duration * 100 if duration > 0 else 0,
+            "breaks_taken": breaks_taken,
+            "posture_timeline": posture_timeline,
+        }
+        self.sessions.append(session)
+        
+        # Update hourly distribution
+        for p in posture_timeline:
+            hour = start_time.hour  # simplified — could interpolate
+            self.hourly_posture_dist[hour][p["posture"]] += p["duration_min"]
+        
+        # Fatigue timing
+        if fatigue_onset_min is not None:
+            self.fatigue_onsets.append(fatigue_onset_min)
+    
+    def get_typical_fatigue_onset(self) -> Optional[float]:
+        """Predict when this user typically gets fatigued."""
+        if len(self.fatigue_onsets) < 3:
+            return None
+        return np.median(self.fatigue_onsets)
+    
+    def get_optimal_break_interval(self) -> float:
+        """
+        Calculate personalized break interval based on user's fatigue patterns.
+        
+        Returns: recommended minutes between breaks
+        """
+        typical_fatigue = self.get_typical_fatigue_onset()
+        
+        if typical_fatigue is not None:
+            # Break should come BEFORE fatigue (80% of fatigue onset time)
+            return max(MIN_BREAK_INTERVAL_MINUTES, min(MAX_SITTING_MINUTES, typical_fatigue * 0.8))
+        
+        # Default: start conservative, adjust as data accumulates
+        return 30.0
+    
+    def get_worst_time_of_day(self) -> Optional[int]:
+        """Find the hour of day when posture is typically worst."""
+        if not self.hourly_posture_dist:
+            return None
+        
+        worst_hour = None
+        worst_score = float('inf')
+        
+        for hour, postures in self.hourly_posture_dist.items():
+            total = sum(postures.values())
+            if total < 10:
+                continue
+            good = postures.get("upright", 0)
+            score = good / total
+            if score < worst_score:
+                worst_score = score
+                worst_hour = hour
+        
+        return worst_hour
+    
+    def get_profile_summary(self) -> Dict:
+        """Get comprehensive user profile summary."""
+        if not self.sessions:
+            return {"status": "no_data", "user_id": self.user_id}
+        
+        total_sessions = len(self.sessions)
+        avg_duration = np.mean([s["duration_min"] for s in self.sessions])
+        avg_good_pct = np.mean([s["good_posture_pct"] for s in self.sessions])
+        
+        return {
+            "user_id": self.user_id,
+            "total_sessions": total_sessions,
+            "avg_session_duration_min": round(avg_duration, 1),
+            "avg_good_posture_pct": round(avg_good_pct, 1),
+            "typical_fatigue_onset_min": round(self.get_typical_fatigue_onset() or 0, 1),
+            "recommended_break_interval_min": round(self.get_optimal_break_interval(), 1),
+            "worst_time_of_day": self.get_worst_time_of_day(),
+            "total_sitting_hours": round(sum(s["duration_min"] for s in self.sessions) / 60, 1),
+        }

smart_chair/utils/feature_engineering.py

@@ -0,0 +1,226 @@
+"""
+Feature Engineering Pipeline for SmartChair Sensor Fusion.
+Extracts features from IMU (6-axis), Load Cells (4), and Thermal (8x8) sensors.
+
+References:
+- SitPose (arxiv:2412.12216): Joint angle features → 98.2% F1
+- SSL-Wearables (arxiv:2206.02909): Hand-crafted features for RF baseline
+- FusionActNet (arxiv:2310.02011): Separable temporal features
+"""
+
+import numpy as np
+from itertools import combinations
+from scipy import stats as scipy_stats
+from scipy.fft import rfft, rfftfreq
+
+
+def compute_imu_angles(accel_xyz):
+    """
+    Compute pitch and roll from accelerometer data.
+    Pitch = rotation around Y-axis (forward/backward lean)
+    Roll = rotation around X-axis (left/right lean)
+    
+    Args:
+        accel_xyz: array of shape (N, 3) — [ax, ay, az] in m/s²
+    
+    Returns:
+        pitch, roll in degrees, each shape (N,)
+    """
+    ax, ay, az = accel_xyz[:, 0], accel_xyz[:, 1], accel_xyz[:, 2]
+    pitch = np.degrees(np.arctan2(ax, np.sqrt(ay**2 + az**2)))
+    roll = np.degrees(np.arctan2(ay, np.sqrt(ax**2 + az**2)))
+    return pitch, roll
+
+
+def compute_center_of_pressure(load_cells):
+    """
+    Compute Center of Pressure (CoP) from 4 load cells at chair corners.
+    
+    Args:
+        load_cells: array shape (N, 4) — [FL, FR, RL, RR] in kg
+    
+    Returns:
+        cop_x, cop_y — normalized CoP coordinates in [-1, 1]
+    """
+    fl, fr, rl, rr = load_cells[:, 0], load_cells[:, 1], load_cells[:, 2], load_cells[:, 3]
+    total = fl + fr + rl + rr + 1e-6  # avoid division by zero
+    
+    # CoP_x: positive = right, negative = left
+    cop_x = (fr + rr - fl - rl) / total
+    # CoP_y: positive = front, negative = rear
+    cop_y = (fl + fr - rl - rr) / total
+    
+    return cop_x, cop_y
+
+
+def extract_tabular_features(imu_data, load_data, window_size=128):
+    """
+    Extract hand-crafted features for ensemble classifier (SitPose recipe).
+    Operates on a single window of data.
+    
+    Args:
+        imu_data: shape (window_size, 6) — [ax, ay, az, gx, gy, gz]
+        load_data: shape (window_size, 4) — [FL, FR, RL, RR]
+    
+    Returns:
+        feature_vector: 1D numpy array of extracted features
+    """
+    features = []
+    
+    # ── IMU Features ──────────────────────────────────────────────────────
+    # Per-axis statistics (from SSL-Wearables paper)
+    for ch in range(imu_data.shape[1]):
+        sig = imu_data[:, ch]
+        features.extend([
+            np.mean(sig),
+            np.std(sig),
+            np.ptp(sig),                    # range (peak-to-peak)
+            np.median(sig),
+            scipy_stats.kurtosis(sig),
+            scipy_stats.skew(sig),
+        ])
+        # Percentiles
+        features.extend(np.percentile(sig, [10, 25, 50, 75, 90]).tolist())
+    
+    # Euclidean norm of acceleration
+    accel_norm = np.linalg.norm(imu_data[:, :3], axis=1)
+    features.extend([
+        np.mean(accel_norm),
+        np.std(accel_norm),
+        np.ptp(accel_norm),
+        np.median(np.abs(accel_norm - np.median(accel_norm))),  # MAD
+        scipy_stats.kurtosis(accel_norm),
+        scipy_stats.skew(accel_norm),
+    ])
+    
+    # FFT features (top 2 frequency components + spectral power in 4 bands)
+    fft_vals = np.abs(rfft(accel_norm))
+    freqs = rfftfreq(len(accel_norm), d=1.0/50)  # 50 Hz
+    sorted_idx = np.argsort(fft_vals)[::-1]
+    features.extend([
+        freqs[sorted_idx[0]] if len(sorted_idx) > 0 else 0,
+        fft_vals[sorted_idx[0]] if len(sorted_idx) > 0 else 0,
+        freqs[sorted_idx[1]] if len(sorted_idx) > 1 else 0,
+        fft_vals[sorted_idx[1]] if len(sorted_idx) > 1 else 0,
+    ])
+    # Spectral power in 4 bands: [0-3Hz], [3-6Hz], [6-12Hz], [12-25Hz]
+    band_edges = [0, 3, 6, 12, 25]
+    for i in range(len(band_edges) - 1):
+        mask = (freqs >= band_edges[i]) & (freqs < band_edges[i+1])
+        features.append(np.sum(fft_vals[mask]**2) if np.any(mask) else 0)
+    
+    # Cross-axis correlations
+    for i, j in combinations(range(imu_data.shape[1]), 2):
+        corr = np.corrcoef(imu_data[:, i], imu_data[:, j])[0, 1]
+        features.append(corr if not np.isnan(corr) else 0)
+    
+    # IMU angles (pitch, roll)
+    pitch, roll = compute_imu_angles(imu_data[:, :3])
+    features.extend([
+        np.mean(pitch), np.std(pitch), np.mean(roll), np.std(roll),
+        np.max(np.abs(pitch)), np.max(np.abs(roll)),
+    ])
+    
+    # ── Load Cell Features ────────────────────────────────────────────────
+    total_weight = np.sum(load_data, axis=1)
+    features.append(np.mean(total_weight))
+    
+    # Normalized per-cell percentages
+    norm_load = load_data / (total_weight[:, np.newaxis] + 1e-6)
+    for ch in range(4):
+        features.extend([
+            np.mean(norm_load[:, ch]),
+            np.std(norm_load[:, ch]),
+        ])
+    
+    # Center of Pressure
+    cop_x, cop_y = compute_center_of_pressure(load_data)
+    features.extend([
+        np.mean(cop_x), np.std(cop_x),
+        np.mean(cop_y), np.std(cop_y),
+        np.ptp(cop_x), np.ptp(cop_y),       # CoP sway range
+    ])
+    
+    # Weight distribution variance (asymmetry indicator)
+    features.append(np.mean(np.var(norm_load, axis=1)))
+    
+    # Front/back and left/right ratios
+    front = norm_load[:, 0] + norm_load[:, 1]
+    back = norm_load[:, 2] + norm_load[:, 3]
+    left = norm_load[:, 0] + norm_load[:, 2]
+    right = norm_load[:, 1] + norm_load[:, 3]
+    features.extend([
+        np.mean(front / (back + 1e-6)),
+        np.mean(left / (right + 1e-6)),
+    ])
+    
+    return np.array(features, dtype=np.float32)
+
+
+def extract_sequential_features(imu_data, load_data):
+    """
+    Prepare sequential (windowed) data for MLSTM-FCN / 1D-CNN.
+    Combines all sensor channels into a unified time-series tensor.
+    
+    Args:
+        imu_data: shape (window_size, 6) — raw IMU
+        load_data: shape (window_size, 4) — raw load cells
+    
+    Returns:
+        tensor: shape (window_size, 14) — all channels concatenated
+            Channels: [ax, ay, az, gx, gy, gz, pitch, roll, FL, FR, RL, RR, cop_x, cop_y]
+    """
+    # Compute derived channels
+    pitch, roll = compute_imu_angles(imu_data[:, :3])
+    cop_x, cop_y = compute_center_of_pressure(load_data)
+    
+    # Stack all channels
+    derived = np.column_stack([pitch, roll, cop_x, cop_y])
+    tensor = np.concatenate([imu_data, load_data, derived], axis=1)
+    
+    return tensor.astype(np.float32)
+
+
+def create_sliding_windows(data, labels, window_size=128, stride=64):
+    """
+    Create sliding windows from continuous sensor data.
+    Label is assigned by majority vote within window.
+    
+    Args:
+        data: shape (N, channels) — continuous sensor data
+        labels: shape (N,) — per-sample labels
+        window_size: samples per window
+        stride: step between windows
+    
+    Returns:
+        X: shape (num_windows, window_size, channels)
+        y: shape (num_windows,)
+    """
+    X, y = [], []
+    for i in range(0, len(data) - window_size, stride):
+        window_data = data[i:i + window_size]
+        window_labels = labels[i:i + window_size]
+        
+        X.append(window_data)
+        y.append(np.bincount(window_labels.astype(int)).argmax())
+    
+    return np.array(X), np.array(y)
+
+
+def normalize_sensors(data, scaler=None):
+    """
+    Per-channel z-score normalization.
+    Returns normalized data and fitted scaler.
+    """
+    from sklearn.preprocessing import StandardScaler
+    
+    original_shape = data.shape
+    flat = data.reshape(-1, data.shape[-1])
+    
+    if scaler is None:
+        scaler = StandardScaler()
+        flat_norm = scaler.fit_transform(flat)
+    else:
+        flat_norm = scaler.transform(flat)
+    
+    return flat_norm.reshape(original_shape), scaler