Deploy cardiac monitor FastAPI backend

- FastAPI with JWT auth, health profiles, vitals, ML predictions
- ECGFounder + XGBoost ensemble for cardiac risk assessment
- Dockerfile downloads models from GitHub LFS during build
- CPU-only PyTorch for optimized container size

.dockerignore

@@ -0,0 +1,9 @@
+__pycache__
+*.pyc
+.env
+.env.*
+.git
+.gitignore
+*.md
+.venv
+venv

Dockerfile

@@ -0,0 +1,28 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install CPU-only PyTorch first (saves ~1.5GB vs full torch)
+RUN pip install --no-cache-dir torch --index-url https://download.pytorch.org/whl/cpu
+
+# Install remaining dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY app/ app/
+COPY ml_src/ ml_src/
+
+# Download ML models from GitHub LFS (avoids LFS issues on HF Spaces)
+RUN mkdir -p ml_models && \
+    apt-get update && apt-get install -y --no-install-recommends curl && \
+    curl -L -o ml_models/ecgfounder_best.pt \
+      "https://media.githubusercontent.com/media/Sanuka23/cardiac-monitor/main/backend/ml_models/ecgfounder_best.pt" && \
+    curl -L -o ml_models/xgboost_cardiac.joblib \
+      "https://media.githubusercontent.com/media/Sanuka23/cardiac-monitor/main/backend/ml_models/xgboost_cardiac.joblib" && \
+    apt-get purge -y curl && apt-get autoremove -y && rm -rf /var/lib/apt/lists/* && \
+    echo "Model sizes:" && ls -lh ml_models/
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,12 +1,23 @@
 ---
 title: Cardiac Monitor API
-emoji: 💻
+emoji: ❤️
 colorFrom: red
-colorTo: yellow
+colorTo: blue
 sdk: docker
 pinned: false
 license: mit
-short_description: FastAPI backend for ESP32 Heart Rate, SpO2 & ECG cardiac mon
+app_port: 7860
+short_description: Cardiac monitoring API with ML risk prediction
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Cardiac Monitor API
+
+FastAPI backend for ESP32 Heart Rate, SpO2 & ECG cardiac monitoring system with ML-based risk prediction.
+
+## Endpoints
+
+- `GET /api/v1/health` — Health check
+- `POST /api/v1/auth/register` — Register
+- `POST /api/v1/auth/login` — Login (JWT)
+- `GET /api/v1/vitals/{device_id}` — Vitals history
+- `GET /api/v1/predictions/{device_id}` — Risk predictions

app/config.py

@@ -0,0 +1,16 @@
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    MONGODB_URI: str = "mongodb://localhost:27017"
+    DATABASE_NAME: str = "cardiac_monitor"
+    JWT_SECRET: str = "changeme"
+    JWT_ALGORITHM: str = "HS256"
+    JWT_EXPIRY_HOURS: int = 24
+    API_KEY: str = "dev-api-key"
+
+    class Config:
+        env_file = ".env"
+
+
+settings = Settings()

app/database.py

@@ -0,0 +1,31 @@
+from motor.motor_asyncio import AsyncIOMotorClient
+
+client: AsyncIOMotorClient = None
+db = None
+
+
+async def connect_db(uri: str, db_name: str):
+    global client, db
+    client = AsyncIOMotorClient(uri, serverSelectionTimeoutMS=5000)
+    db = client[db_name]
+
+    # Create indexes (non-blocking — if DB is unreachable, server still starts)
+    try:
+        await db.users.create_index("email", unique=True)
+        await db.devices.create_index("device_id", unique=True)
+        await db.vitals.create_index([("device_id", 1), ("timestamp", -1)])
+        await db.predictions.create_index([("device_id", 1), ("created_at", -1)])
+        print("[DB] Connected and indexes created.")
+    except Exception as e:
+        print(f"[DB] Warning: Could not create indexes: {e}")
+        print("[DB] Server will start but DB operations may fail until MongoDB is available.")
+
+
+async def close_db():
+    global client
+    if client:
+        client.close()
+
+
+def get_db():
+    return db

app/main.py

@@ -0,0 +1,46 @@
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from app.config import settings
+from app.database import connect_db, close_db
+from app.routes import vitals, auth, devices, health, predictions
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await connect_db(settings.MONGODB_URI, settings.DATABASE_NAME)
+
+    # Load ML models (non-blocking — server starts even if models aren't ready)
+    try:
+        from app.services.ml_service import load_models
+        load_models()
+    except Exception as e:
+        print(f"[ML] Could not load models: {e}")
+        print("[ML] Server will run without predictions until models are available.")
+
+    yield
+    await close_db()
+
+
+app = FastAPI(
+    title="Cardiac Monitor API",
+    version="1.0.0",
+    description="Backend for ESP32 Heart Rate, SpO2 & ECG Monitor",
+    lifespan=lifespan,
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(health.router, prefix="/api/v1", tags=["health"])
+app.include_router(auth.router, prefix="/api/v1/auth", tags=["auth"])
+app.include_router(vitals.router, prefix="/api/v1/vitals", tags=["vitals"])
+app.include_router(predictions.router, prefix="/api/v1/predictions", tags=["predictions"])
+app.include_router(devices.router, prefix="/api/v1/devices", tags=["devices"])

app/middleware/auth.py

@@ -0,0 +1,54 @@
+from datetime import datetime, timedelta
+
+import bcrypt
+from bson import ObjectId
+from fastapi import Depends, HTTPException, Header
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from jose import jwt, JWTError
+
+from app.config import settings
+from app.database import get_db
+
+security = HTTPBearer()
+
+
+def hash_password(password: str) -> str:
+    return bcrypt.hashpw(password.encode("utf-8"), bcrypt.gensalt()).decode("utf-8")
+
+
+def verify_password(plain: str, hashed: str) -> bool:
+    return bcrypt.checkpw(plain.encode("utf-8"), hashed.encode("utf-8"))
+
+
+def create_access_token(user_id: str) -> str:
+    expire = datetime.utcnow() + timedelta(hours=settings.JWT_EXPIRY_HOURS)
+    payload = {"sub": user_id, "exp": expire}
+    return jwt.encode(payload, settings.JWT_SECRET, algorithm=settings.JWT_ALGORITHM)
+
+
+async def verify_api_key(x_api_key: str = Header(...)):
+    if x_api_key != settings.API_KEY:
+        raise HTTPException(status_code=401, detail="Invalid API key")
+    return x_api_key
+
+
+async def get_current_user(
+    credentials: HTTPAuthorizationCredentials = Depends(security),
+):
+    try:
+        payload = jwt.decode(
+            credentials.credentials,
+            settings.JWT_SECRET,
+            algorithms=[settings.JWT_ALGORITHM],
+        )
+        user_id = payload.get("sub")
+        if user_id is None:
+            raise HTTPException(status_code=401, detail="Invalid token")
+    except JWTError:
+        raise HTTPException(status_code=401, detail="Invalid token")
+
+    db = get_db()
+    user = await db.users.find_one({"_id": ObjectId(user_id)})
+    if user is None:
+        raise HTTPException(status_code=401, detail="User not found")
+    return user

app/models/device.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel, Field
+from typing import Optional
+from datetime import datetime
+
+
+class DeviceRegister(BaseModel):
+    device_id: str = Field(..., min_length=1, max_length=50)
+    name: Optional[str] = Field(None, max_length=100)
+
+
+class DeviceResponse(BaseModel):
+    device_id: str
+    name: Optional[str] = None
+    owner_user_id: Optional[str] = None
+    last_seen: Optional[datetime] = None
+    registered_at: datetime

app/models/prediction.py

@@ -0,0 +1,15 @@
+from pydantic import BaseModel, Field
+from typing import Optional
+from datetime import datetime
+
+
+class PredictionResponse(BaseModel):
+    id: str
+    vitals_id: str
+    device_id: str
+    risk_score: float = Field(..., ge=0.0, le=1.0)
+    risk_label: str
+    confidence: float = Field(..., ge=0.0, le=1.0)
+    features: dict
+    model_version: str
+    created_at: datetime

app/models/user.py

@@ -0,0 +1,41 @@
+from pydantic import BaseModel, EmailStr, Field
+from typing import List, Optional
+from datetime import datetime
+
+
+class HealthProfile(BaseModel):
+    age: Optional[int] = Field(None, ge=1, le=120)
+    sex: Optional[str] = Field(None, pattern="^(male|female|other)$")
+    height_cm: Optional[float] = Field(None, ge=50, le=300)
+    weight_kg: Optional[float] = Field(None, ge=10, le=500)
+    is_diabetic: bool = False
+    is_hypertensive: bool = False
+    is_smoker: bool = False
+    family_history: bool = False
+    known_conditions: List[str] = Field(default_factory=list)
+    medications: List[str] = Field(default_factory=list)
+
+
+class UserRegister(BaseModel):
+    email: str = Field(..., min_length=5, max_length=100)
+    password: str = Field(..., min_length=6, max_length=100)
+    name: str = Field(..., min_length=1, max_length=100)
+
+
+class UserLogin(BaseModel):
+    email: str
+    password: str
+
+
+class UserResponse(BaseModel):
+    id: str
+    email: str
+    name: str
+    device_ids: List[str] = Field(default_factory=list)
+    profile: Optional[HealthProfile] = None
+    created_at: datetime
+
+
+class TokenResponse(BaseModel):
+    access_token: str
+    token_type: str = "bearer"

app/models/vitals.py

@@ -0,0 +1,32 @@
+from pydantic import BaseModel, Field
+from typing import List, Optional
+from datetime import datetime
+
+
+class VitalsCreate(BaseModel):
+    device_id: str = Field(..., min_length=1, max_length=50)
+    timestamp: int = Field(..., description="Unix epoch seconds from ESP32")
+    window_ms: int = Field(default=10000, ge=1000, le=60000)
+    sample_rate_hz: int = Field(default=100, ge=50, le=1000)
+    heart_rate_bpm: float = Field(..., ge=0, le=300)
+    spo2_percent: int = Field(..., ge=0, le=100)
+    ecg_lead_off: bool = Field(default=False)
+    ecg_samples: List[int] = Field(..., min_length=100, max_length=6000)
+    beat_timestamps_ms: List[int] = Field(default_factory=list)
+
+
+class VitalsResponse(BaseModel):
+    id: str
+    device_id: str
+    timestamp: datetime
+    heart_rate_bpm: float
+    spo2_percent: int
+    ecg_lead_off: bool
+    sample_count: int
+    prediction: Optional[dict] = None
+    created_at: datetime
+
+
+class VitalsListResponse(BaseModel):
+    vitals: List[VitalsResponse]
+    total: int

app/routes/auth.py

@@ -0,0 +1,85 @@
+from datetime import datetime
+
+from fastapi import APIRouter, Depends, HTTPException
+
+from app.database import get_db
+from app.middleware.auth import (
+    hash_password,
+    verify_password,
+    create_access_token,
+    get_current_user,
+)
+from app.models.user import (
+    UserRegister,
+    UserLogin,
+    UserResponse,
+    TokenResponse,
+    HealthProfile,
+)
+
+router = APIRouter()
+
+
+@router.post("/register", response_model=TokenResponse)
+async def register(data: UserRegister):
+    db = get_db()
+
+    existing = await db.users.find_one({"email": data.email})
+    if existing:
+        raise HTTPException(status_code=400, detail="Email already registered")
+
+    user_doc = {
+        "email": data.email,
+        "password_hash": hash_password(data.password),
+        "name": data.name,
+        "device_ids": [],
+        "profile": None,
+        "created_at": datetime.utcnow(),
+    }
+    result = await db.users.insert_one(user_doc)
+    token = create_access_token(str(result.inserted_id))
+    return TokenResponse(access_token=token)
+
+
+@router.post("/login", response_model=TokenResponse)
+async def login(data: UserLogin):
+    db = get_db()
+
+    user = await db.users.find_one({"email": data.email})
+    if not user or not verify_password(data.password, user["password_hash"]):
+        raise HTTPException(status_code=401, detail="Invalid email or password")
+
+    token = create_access_token(str(user["_id"]))
+    return TokenResponse(access_token=token)
+
+
+@router.get("/me", response_model=UserResponse)
+async def get_me(user=Depends(get_current_user)):
+    return UserResponse(
+        id=str(user["_id"]),
+        email=user["email"],
+        name=user["name"],
+        device_ids=user.get("device_ids", []),
+        profile=user.get("profile"),
+        created_at=user["created_at"],
+    )
+
+
+@router.put("/profile", response_model=UserResponse)
+async def update_profile(profile: HealthProfile, user=Depends(get_current_user)):
+    db = get_db()
+
+    await db.users.update_one(
+        {"_id": user["_id"]},
+        {"$set": {"profile": profile.model_dump()}},
+    )
+
+    user["profile"] = profile.model_dump()
+    return UserResponse(
+        id=str(user["_id"]),
+        email=user["email"],
+        name=user["name"],
+        device_ids=user.get("device_ids", []),
+        profile=user["profile"],
+        created_at=user["created_at"],
+    )

app/routes/devices.py

@@ -0,0 +1,83 @@
+from datetime import datetime
+
+from fastapi import APIRouter, Depends, HTTPException
+
+from app.database import get_db
+from app.middleware.auth import get_current_user
+from app.models.device import DeviceRegister, DeviceResponse
+
+router = APIRouter()
+
+
+@router.post("/register", response_model=DeviceResponse)
+async def register_device(data: DeviceRegister, user=Depends(get_current_user)):
+    db = get_db()
+
+    existing = await db.devices.find_one({"device_id": data.device_id})
+    if existing:
+        # If device already exists, link to this user if not already linked
+        if existing.get("owner_user_id") and str(existing["owner_user_id"]) != str(
+            user["_id"]
+        ):
+            raise HTTPException(
+                status_code=400, detail="Device already registered to another user"
+            )
+        await db.devices.update_one(
+            {"device_id": data.device_id},
+            {
+                "$set": {
+                    "owner_user_id": str(user["_id"]),
+                    "name": data.name or existing.get("name"),
+                }
+            },
+        )
+        existing["owner_user_id"] = str(user["_id"])
+        if data.name:
+            existing["name"] = data.name
+        doc = existing
+    else:
+        doc = {
+            "device_id": data.device_id,
+            "name": data.name,
+            "owner_user_id": str(user["_id"]),
+            "last_seen": None,
+            "registered_at": datetime.utcnow(),
+        }
+        await db.devices.insert_one(doc)
+
+    # Add device_id to user's device list
+    await db.users.update_one(
+        {"_id": user["_id"]},
+        {"$addToSet": {"device_ids": data.device_id}},
+    )
+
+    return DeviceResponse(
+        device_id=doc["device_id"],
+        name=doc.get("name"),
+        owner_user_id=doc.get("owner_user_id"),
+        last_seen=doc.get("last_seen"),
+        registered_at=doc.get("registered_at", datetime.utcnow()),
+    )
+
+
+@router.get("", response_model=list[DeviceResponse])
+async def list_devices(user=Depends(get_current_user)):
+    db = get_db()
+
+    device_ids = user.get("device_ids", [])
+    if not device_ids:
+        return []
+
+    cursor = db.devices.find({"device_id": {"$in": device_ids}})
+    docs = await cursor.to_list(length=100)
+
+    return [
+        DeviceResponse(
+            device_id=doc["device_id"],
+            name=doc.get("name"),
+            owner_user_id=doc.get("owner_user_id"),
+            last_seen=doc.get("last_seen"),
+            registered_at=doc.get("registered_at", datetime.utcnow()),
+        )
+        for doc in docs
+    ]

app/routes/health.py

@@ -0,0 +1,17 @@
+from fastapi import APIRouter
+
+from app.database import get_db
+
+router = APIRouter()
+
+
+@router.get("/health")
+async def health_check():
+    db = get_db()
+    try:
+        await db.command("ping")
+        db_status = "connected"
+    except Exception:
+        db_status = "disconnected"
+
+    return {"status": "ok", "db": db_status, "version": "1.0.0"}

app/routes/predictions.py

@@ -0,0 +1,69 @@
+from fastapi import APIRouter, Depends, HTTPException, Query
+
+from app.database import get_db
+from app.middleware.auth import get_current_user
+from app.models.prediction import PredictionResponse
+
+router = APIRouter()
+
+
+@router.get("/{device_id}/latest", response_model=PredictionResponse)
+async def get_latest_prediction(device_id: str, _=Depends(get_current_user)):
+    db = get_db()
+
+    doc = await db.predictions.find_one(
+        {"device_id": device_id},
+        sort=[("created_at", -1)],
+    )
+    if not doc:
+        raise HTTPException(
+            status_code=404, detail="No predictions found for this device"
+        )
+
+    return PredictionResponse(
+        id=str(doc["_id"]),
+        vitals_id=doc["vitals_id"],
+        device_id=doc["device_id"],
+        risk_score=doc["risk_score"],
+        risk_label=doc["risk_label"],
+        confidence=doc["confidence"],
+        features=doc.get("features", {}),
+        model_version=doc.get("model_version", "none"),
+        created_at=doc["created_at"],
+    )
+
+
+@router.get("/{device_id}")
+async def get_prediction_history(
+    device_id: str,
+    limit: int = Query(default=50, ge=1, le=500),
+    offset: int = Query(default=0, ge=0),
+    _=Depends(get_current_user),
+):
+    db = get_db()
+
+    cursor = (
+        db.predictions.find({"device_id": device_id})
+        .sort("created_at", -1)
+        .skip(offset)
+        .limit(limit)
+    )
+    docs = await cursor.to_list(length=limit)
+
+    results = [
+        PredictionResponse(
+            id=str(doc["_id"]),
+            vitals_id=doc["vitals_id"],
+            device_id=doc["device_id"],
+            risk_score=doc["risk_score"],
+            risk_label=doc["risk_label"],
+            confidence=doc["confidence"],
+            features=doc.get("features", {}),
+            model_version=doc.get("model_version", "none"),
+            created_at=doc["created_at"],
+        )
+        for doc in docs
+    ]
+
+    total = await db.predictions.count_documents({"device_id": device_id})
+    return {"predictions": results, "total": total}

app/routes/vitals.py

@@ -0,0 +1,197 @@
+from datetime import datetime
+
+from bson import ObjectId
+from fastapi import APIRouter, Depends, HTTPException, Query
+
+from app.database import get_db
+from app.middleware.auth import verify_api_key, get_current_user
+from app.models.vitals import VitalsCreate, VitalsResponse, VitalsListResponse
+
+router = APIRouter()
+
+
+def _vitals_doc_to_response(doc: dict, prediction: dict = None) -> VitalsResponse:
+    return VitalsResponse(
+        id=str(doc["_id"]),
+        device_id=doc["device_id"],
+        timestamp=doc["timestamp"],
+        heart_rate_bpm=doc["heart_rate_bpm"],
+        spo2_percent=doc["spo2_percent"],
+        ecg_lead_off=doc["ecg_lead_off"],
+        sample_count=len(doc.get("ecg_samples", [])),
+        prediction=prediction,
+        created_at=doc["created_at"],
+    )
+
+
+@router.post("", response_model=VitalsResponse)
+async def upload_vitals(data: VitalsCreate, _=Depends(verify_api_key)):
+    db = get_db()
+
+    vitals_doc = {
+        "device_id": data.device_id,
+        "timestamp": datetime.utcfromtimestamp(data.timestamp),
+        "window_ms": data.window_ms,
+        "sample_rate_hz": data.sample_rate_hz,
+        "heart_rate_bpm": data.heart_rate_bpm,
+        "spo2_percent": data.spo2_percent,
+        "ecg_lead_off": data.ecg_lead_off,
+        "ecg_samples": data.ecg_samples,
+        "beat_timestamps_ms": data.beat_timestamps_ms,
+        "created_at": datetime.utcnow(),
+    }
+    result = await db.vitals.insert_one(vitals_doc)
+    vitals_doc["_id"] = result.inserted_id
+
+    # Update device last_seen
+    await db.devices.update_one(
+        {"device_id": data.device_id},
+        {"$set": {"last_seen": datetime.utcnow()}},
+    )
+
+    # Run ML prediction if models are available
+    prediction = None
+    try:
+        from app.services.ml_service import predict, _models_loaded, load_models
+
+        if not _models_loaded:
+            load_models()
+
+        if not data.ecg_lead_off and len(data.ecg_samples) >= 100:
+            # Get user profile for personalized prediction
+            device_doc = await db.devices.find_one({"device_id": data.device_id})
+            user_profile = None
+            history_features = None
+
+            if device_doc and device_doc.get("owner_user_id"):
+                user = await db.users.find_one({"_id": ObjectId(device_doc["owner_user_id"])})
+                if user and user.get("profile"):
+                    user_profile = user["profile"]
+
+                # Compute historical baselines
+                from datetime import timedelta
+                now = datetime.utcnow()
+                pipeline_24h = [
+                    {"$match": {"device_id": data.device_id,
+                                "created_at": {"$gte": now - timedelta(hours=24)}}},
+                    {"$group": {
+                        "_id": None,
+                        "avg_hr": {"$avg": "$heart_rate_bpm"},
+                        "std_hr": {"$stdDevPop": "$heart_rate_bpm"},
+                        "avg_spo2": {"$avg": "$spo2_percent"},
+                        "std_spo2": {"$stdDevPop": "$spo2_percent"},
+                        "count": {"$sum": 1},
+                    }},
+                ]
+                pipeline_7d = [
+                    {"$match": {"device_id": data.device_id,
+                                "created_at": {"$gte": now - timedelta(days=7)}}},
+                    {"$group": {
+                        "_id": None,
+                        "avg_hr": {"$avg": "$heart_rate_bpm"},
+                        "avg_spo2": {"$avg": "$spo2_percent"},
+                    }},
+                ]
+
+                stats_24h = await db.vitals.aggregate(pipeline_24h).to_list(1)
+                stats_7d = await db.vitals.aggregate(pipeline_7d).to_list(1)
+
+                if stats_24h:
+                    s = stats_24h[0]
+                    hr_std = s.get("std_hr", 1) or 1
+                    spo2_std = s.get("std_spo2", 1) or 1
+                    history_features = {
+                        "hr_baseline_24h": s.get("avg_hr", 0),
+                        "spo2_baseline_24h": s.get("avg_spo2", 0),
+                        "hr_deviation": abs(data.heart_rate_bpm - s.get("avg_hr", data.heart_rate_bpm)) / hr_std,
+                        "spo2_deviation": abs(data.spo2_percent - s.get("avg_spo2", data.spo2_percent)) / spo2_std,
+                        "readings_count_24h": s.get("count", 0),
+                    }
+                if stats_7d:
+                    if history_features is None:
+                        history_features = {}
+                    history_features["hr_baseline_7d"] = stats_7d[0].get("avg_hr", 0)
+
+            ml_result = predict(
+                ecg_samples=data.ecg_samples,
+                sample_rate_hz=data.sample_rate_hz,
+                heart_rate_bpm=data.heart_rate_bpm,
+                spo2_percent=data.spo2_percent,
+                user_profile=user_profile,
+                history_features=history_features,
+            )
+
+            if ml_result["risk_label"] != "unknown":
+                pred_doc = {
+                    "vitals_id": str(result.inserted_id),
+                    "device_id": data.device_id,
+                    "risk_score": ml_result["risk_score"],
+                    "risk_label": ml_result["risk_label"],
+                    "confidence": ml_result["confidence"],
+                    "features": ml_result["features"],
+                    "model_version": ml_result["model_version"],
+                    "created_at": datetime.utcnow(),
+                }
+                await db.predictions.insert_one(pred_doc)
+                prediction = {
+                    "risk_score": ml_result["risk_score"],
+                    "risk_label": ml_result["risk_label"],
+                    "confidence": ml_result["confidence"],
+                }
+    except ImportError:
+        pass  # ML dependencies not installed, skip prediction
+    except Exception as e:
+        print(f"[ML] Prediction error: {e}")
+
+    return _vitals_doc_to_response(vitals_doc, prediction)
+
+
+@router.get("/{device_id}/latest", response_model=VitalsResponse)
+async def get_latest_vitals(device_id: str, _=Depends(get_current_user)):
+    db = get_db()
+
+    doc = await db.vitals.find_one(
+        {"device_id": device_id},
+        sort=[("timestamp", -1)],
+    )
+    if not doc:
+        raise HTTPException(status_code=404, detail="No vitals found for this device")
+
+    # Attach latest prediction if exists
+    pred = await db.predictions.find_one(
+        {"vitals_id": str(doc["_id"])},
+    )
+    pred_dict = None
+    if pred:
+        pred_dict = {
+            "risk_score": pred["risk_score"],
+            "risk_label": pred["risk_label"],
+            "confidence": pred["confidence"],
+        }
+
+    return _vitals_doc_to_response(doc, pred_dict)
+
+
+@router.get("/{device_id}", response_model=VitalsListResponse)
+async def get_vitals_history(
+    device_id: str,
+    limit: int = Query(default=50, ge=1, le=500),
+    offset: int = Query(default=0, ge=0),
+    _=Depends(get_current_user),
+):
+    db = get_db()
+
+    total = await db.vitals.count_documents({"device_id": device_id})
+    cursor = (
+        db.vitals.find(
+            {"device_id": device_id},
+            {"ecg_samples": 0},  # Exclude raw samples from list view
+        )
+        .sort("timestamp", -1)
+        .skip(offset)
+        .limit(limit)
+    )
+    docs = await cursor.to_list(length=limit)
+
+    vitals_list = [_vitals_doc_to_response(doc) for doc in docs]
+    return VitalsListResponse(vitals=vitals_list, total=total)

app/services/feature_extractor.py

@@ -0,0 +1,29 @@
+"""
+ECG Feature Extraction for backend inference.
+Thin wrapper that imports from ml/src/feature_extractor.py to stay in sync.
+"""
+
+import os
+import sys
+
+# Import from the bundled ML source
+ML_SRC = os.path.join(os.path.dirname(__file__), "..", "..", "ml_src")
+sys.path.insert(0, ML_SRC)
+
+from feature_extractor import (
+    extract_ecg_features,
+    features_to_array,
+    FEATURE_NAMES,
+    PROFILE_FEATURE_NAMES,
+    HISTORY_FEATURE_NAMES,
+    ALL_FEATURE_NAMES,
+)
+
+__all__ = [
+    "extract_ecg_features",
+    "features_to_array",
+    "FEATURE_NAMES",
+    "PROFILE_FEATURE_NAMES",
+    "HISTORY_FEATURE_NAMES",
+    "ALL_FEATURE_NAMES",
+]

app/services/ml_service.py

@@ -0,0 +1,232 @@
+"""
+ML inference service for cardiac risk prediction.
+Loads ECGFounder + XGBoost ensemble and runs prediction on incoming vitals.
+"""
+
+import os
+import sys
+import numpy as np
+from scipy.signal import resample
+import torch
+import joblib
+
+# Import model architecture from bundled ml_src/
+BACKEND_ROOT = os.path.join(os.path.dirname(__file__), "..", "..")
+ML_SRC = os.path.join(BACKEND_ROOT, "ml_src")
+sys.path.insert(0, ML_SRC)
+
+from net1d import Net1D
+from feature_extractor import extract_ecg_features, features_to_array, FEATURE_NAMES
+
+# Model paths — bundled in backend/ml_models/
+MODEL_DIR = os.path.join(BACKEND_ROOT, "ml_models")
+
+# Ensemble weights
+ECG_WEIGHT = 0.60
+XGB_WEIGHT = 0.40
+
+# Risk labels
+RISK_LABELS = {
+    (0.0, 0.2): "normal",
+    (0.2, 0.4): "low",
+    (0.4, 0.6): "moderate",
+    (0.6, 0.8): "elevated",
+    (0.8, 1.01): "high",
+}
+
+# Global model instances
+_ecg_model = None
+_xgb_model = None
+_device = None
+_models_loaded = False
+
+
+def get_risk_label(score: float) -> str:
+    for (low, high), label in RISK_LABELS.items():
+        if low <= score < high:
+            return label
+    return "high"
+
+
+def load_models():
+    """Load both models into memory. Called once at startup."""
+    global _ecg_model, _xgb_model, _device, _models_loaded
+
+    if _models_loaded:
+        return True
+
+    # Select device
+    if torch.cuda.is_available():
+        _device = torch.device("cuda:0")
+    elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+        _device = torch.device("mps")
+    else:
+        _device = torch.device("cpu")
+
+    ecg_path = os.path.join(MODEL_DIR, "ecgfounder_best.pt")
+    xgb_path = os.path.join(MODEL_DIR, "xgboost_cardiac.joblib")
+
+    # Load ECGFounder
+    if os.path.exists(ecg_path):
+        try:
+            _ecg_model = Net1D(
+                in_channels=1,
+                base_filters=64,
+                ratio=1,
+                filter_list=[64, 160, 160, 400, 400, 1024, 1024],
+                m_blocks_list=[2, 2, 2, 3, 3, 4, 4],
+                kernel_size=16,
+                stride=2,
+                groups_width=16,
+                verbose=False,
+                use_bn=False,
+                use_do=False,
+                n_classes=1,
+            )
+            state_dict = torch.load(ecg_path, map_location=_device, weights_only=False)
+            _ecg_model.load_state_dict(state_dict)
+            _ecg_model.to(_device)
+            _ecg_model.eval()
+            print(f"[ML] ECGFounder loaded on {_device}")
+        except Exception as e:
+            print(f"[ML] Failed to load ECGFounder: {e}")
+            _ecg_model = None
+    else:
+        print(f"[ML] ECGFounder not found at {ecg_path}")
+
+    # Load XGBoost
+    if os.path.exists(xgb_path):
+        try:
+            _xgb_model = joblib.load(xgb_path)
+            print("[ML] XGBoost loaded")
+        except Exception as e:
+            print(f"[ML] Failed to load XGBoost: {e}")
+            _xgb_model = None
+    else:
+        print(f"[ML] XGBoost not found at {xgb_path}")
+
+    _models_loaded = True
+    return _ecg_model is not None or _xgb_model is not None
+
+
+def predict(ecg_samples: list, sample_rate_hz: int = 100,
+            heart_rate_bpm: float = None, spo2_percent: float = None,
+            user_profile: dict = None, history_features: dict = None) -> dict:
+    """
+    Run ensemble prediction on ECG data.
+
+    Args:
+        ecg_samples: list of ECG ADC values from ESP32
+        sample_rate_hz: device sample rate (100Hz for ESP32)
+        heart_rate_bpm: HR from MAX30100
+        spo2_percent: SpO2 from MAX30100
+        user_profile: dict with age, sex, bmi, is_diabetic, etc.
+        history_features: dict with hr_baseline_24h, etc.
+
+    Returns:
+        dict with risk_score, risk_label, confidence, features, model_version
+    """
+    if not _models_loaded:
+        load_models()
+
+    ecg = np.array(ecg_samples, dtype=np.float32)
+    result = {
+        "risk_score": 0.0,
+        "risk_label": "unknown",
+        "confidence": 0.0,
+        "features": {},
+        "model_version": "v1.0-ensemble",
+    }
+
+    prob_ecg = None
+    prob_xgb = None
+
+    # --- ECGFounder Prediction ---
+    if _ecg_model is not None:
+        try:
+            # Upsample from device rate to 500Hz (5000 samples for 10s)
+            target_length = 5000
+            if len(ecg) != target_length:
+                ecg_500hz = resample(ecg, target_length)
+            else:
+                ecg_500hz = ecg.copy()
+
+            # Z-score normalize
+            mean = np.mean(ecg_500hz)
+            std = np.std(ecg_500hz) + 1e-8
+            ecg_500hz = (ecg_500hz - mean) / std
+            ecg_500hz = np.nan_to_num(ecg_500hz, nan=0.0)
+
+            # Shape: (1, 1, 5000)
+            tensor = torch.FloatTensor(ecg_500hz).reshape(1, 1, -1).to(_device)
+
+            with torch.no_grad():
+                logit = _ecg_model(tensor)
+                prob_ecg = float(torch.sigmoid(logit).cpu().item())
+
+        except Exception as e:
+            print(f"[ML] ECGFounder inference error: {e}")
+            prob_ecg = None
+
+    # --- XGBoost Prediction ---
+    if _xgb_model is not None:
+        try:
+            # Extract features at device sample rate
+            features = extract_ecg_features(
+                ecg, sample_rate=sample_rate_hz,
+                heart_rate_sensor=heart_rate_bpm,
+                spo2=spo2_percent,
+            )
+
+            # Add user profile features
+            if user_profile:
+                features["age"] = user_profile.get("age", 50)
+                features["sex"] = 1 if user_profile.get("sex") == "male" else 0
+                h = user_profile.get("height_cm", 170) / 100
+                w = user_profile.get("weight_kg", 70)
+                features["bmi"] = w / (h * h) if h > 0 else 25.0
+                features["is_diabetic"] = 1 if user_profile.get("is_diabetic") else 0
+                features["is_hypertensive"] = 1 if user_profile.get("is_hypertensive") else 0
+                features["is_smoker"] = 1 if user_profile.get("is_smoker") else 0
+                features["family_history"] = 1 if user_profile.get("family_history") else 0
+
+            # Add historical baseline features
+            if history_features:
+                for key in ["hr_baseline_24h", "hr_baseline_7d", "spo2_baseline_24h",
+                            "hr_deviation", "spo2_deviation", "resting_hr_trend",
+                            "readings_count_24h"]:
+                    features[key] = history_features.get(key, 0.0)
+
+            # Convert to array (25 ECG features only for base model)
+            feat_array = features_to_array(features, include_profile=False).reshape(1, -1)
+            prob_xgb = float(_xgb_model.predict_proba(feat_array)[0, 1])
+
+            # Store features in result
+            result["features"] = {k: round(v, 4) for k, v in features.items()
+                                  if k in FEATURE_NAMES[:10]}  # Top 10 for response size
+
+        except Exception as e:
+            print(f"[ML] XGBoost inference error: {e}")
+            prob_xgb = None
+
+    # --- Ensemble ---
+    if prob_ecg is not None and prob_xgb is not None:
+        risk_score = ECG_WEIGHT * prob_ecg + XGB_WEIGHT * prob_xgb
+        confidence = 1.0 - abs(prob_ecg - prob_xgb)  # Higher when models agree
+        result["model_version"] = "v1.0-ensemble"
+    elif prob_ecg is not None:
+        risk_score = prob_ecg
+        confidence = 0.7
+        result["model_version"] = "v1.0-ecgfounder-only"
+    elif prob_xgb is not None:
+        risk_score = prob_xgb
+        confidence = 0.6
+        result["model_version"] = "v1.0-xgboost-only"
+    else:
+        return result  # No models available
+
+    result["risk_score"] = round(float(risk_score), 4)
+    result["risk_label"] = get_risk_label(risk_score)
+    result["confidence"] = round(float(confidence), 4)
+
+    return result

ml_src/feature_extractor.py

@@ -0,0 +1,248 @@
+"""
+ECG Feature Extraction for XGBoost model.
+Extracts 26 signal features from single-lead ECG using NeuroKit2.
+This module is shared between ml/ training and backend/ inference.
+"""
+
+import numpy as np
+import neurokit2 as nk
+from scipy.stats import kurtosis, skew
+
+
+def extract_ecg_features(ecg_signal: np.ndarray, sample_rate: int = 100,
+                         heart_rate_sensor: float = None,
+                         spo2: float = None) -> dict:
+    """
+    Extract 26 features from single-lead ECG signal.
+
+    Args:
+        ecg_signal: 1D numpy array of ECG samples
+        sample_rate: Sampling rate in Hz (100 for ESP32, 500 for PTB-XL)
+        heart_rate_sensor: HR from MAX30100 (optional, for device features)
+        spo2: SpO2 from MAX30100 (optional, for device features)
+
+    Returns:
+        dict of 26 features (keys match XGBoost training feature names)
+    """
+    features = {}
+
+    try:
+        # Clean the ECG signal
+        ecg_cleaned = nk.ecg_clean(ecg_signal, sampling_rate=sample_rate)
+
+        # Detect R-peaks
+        _, rpeaks = nk.ecg_peaks(ecg_cleaned, sampling_rate=sample_rate)
+        r_peak_indices = rpeaks.get("ECG_R_Peaks", np.array([]))
+
+        if len(r_peak_indices) < 3:
+            return _fallback_features(ecg_signal, heart_rate_sensor, spo2)
+
+        # --- HRV Time-Domain Features (7) ---
+        rr_intervals = np.diff(r_peak_indices) / sample_rate * 1000  # ms
+
+        features["mean_rr"] = float(np.mean(rr_intervals))
+        features["sdnn"] = float(np.std(rr_intervals, ddof=1)) if len(rr_intervals) > 1 else 0.0
+        features["rmssd"] = float(np.sqrt(np.mean(np.diff(rr_intervals) ** 2))) if len(rr_intervals) > 1 else 0.0
+
+        nn_diff = np.abs(np.diff(rr_intervals))
+        features["pnn50"] = float(np.sum(nn_diff > 50) / len(nn_diff) * 100) if len(nn_diff) > 0 else 0.0
+
+        hr_from_rr = 60000.0 / rr_intervals
+        features["mean_hr_ecg"] = float(np.mean(hr_from_rr))
+        features["hr_std"] = float(np.std(hr_from_rr))
+        features["rr_range"] = float(np.max(rr_intervals) - np.min(rr_intervals))
+
+        # --- ECG Morphology Features (9) ---
+        try:
+            # Delineate ECG waves
+            _, waves = nk.ecg_delineate(ecg_cleaned, rpeaks, sampling_rate=sample_rate, method="dwt")
+
+            # QRS duration
+            qrs_onsets = [x for x in waves.get("ECG_Q_Peaks", []) if isinstance(x, (int, float)) and not np.isnan(x)]
+            qrs_offsets = [x for x in waves.get("ECG_S_Peaks", []) if isinstance(x, (int, float)) and not np.isnan(x)]
+            if qrs_onsets and qrs_offsets:
+                qrs_durations = []
+                for q, s in zip(qrs_onsets[:len(qrs_offsets)], qrs_offsets[:len(qrs_onsets)]):
+                    qrs_durations.append(abs(s - q) / sample_rate * 1000)
+                features["qrs_duration"] = float(np.mean(qrs_durations)) if qrs_durations else 100.0
+            else:
+                features["qrs_duration"] = 100.0
+
+            # R amplitude
+            r_amplitudes = ecg_cleaned[r_peak_indices.astype(int)]
+            features["r_amplitude"] = float(np.mean(r_amplitudes))
+            features["r_amplitude_std"] = float(np.std(r_amplitudes))
+
+            # QT interval
+            t_offsets = [x for x in waves.get("ECG_T_Offsets", []) if isinstance(x, (int, float)) and not np.isnan(x)]
+            if qrs_onsets and t_offsets:
+                qt_intervals = []
+                for q, t in zip(qrs_onsets[:len(t_offsets)], t_offsets[:len(qrs_onsets)]):
+                    qt_intervals.append(abs(t - q) / sample_rate * 1000)
+                features["qt_interval"] = float(np.mean(qt_intervals)) if qt_intervals else 400.0
+                # Bazett's QTc
+                mean_rr_sec = features["mean_rr"] / 1000
+                features["qtc"] = float(features["qt_interval"] / np.sqrt(mean_rr_sec)) if mean_rr_sec > 0 else 440.0
+            else:
+                features["qt_interval"] = 400.0
+                features["qtc"] = 440.0
+
+            # ST level (amplitude at J-point, ~40ms after R-peak)
+            j_offset = int(0.04 * sample_rate)
+            st_levels = []
+            for rp in r_peak_indices.astype(int):
+                j_idx = rp + j_offset
+                if j_idx < len(ecg_cleaned):
+                    st_levels.append(ecg_cleaned[j_idx])
+            features["st_level"] = float(np.mean(st_levels)) if st_levels else 0.0
+
+            # T-wave amplitude
+            t_peaks = [x for x in waves.get("ECG_T_Peaks", []) if isinstance(x, (int, float)) and not np.isnan(x)]
+            if t_peaks:
+                t_amps = [ecg_cleaned[int(t)] for t in t_peaks if int(t) < len(ecg_cleaned)]
+                features["t_amplitude"] = float(np.mean(t_amps)) if t_amps else 0.0
+            else:
+                features["t_amplitude"] = 0.0
+
+            # P-wave ratio (P amplitude / R amplitude)
+            p_peaks = [x for x in waves.get("ECG_P_Peaks", []) if isinstance(x, (int, float)) and not np.isnan(x)]
+            if p_peaks and features["r_amplitude"] != 0:
+                p_amps = [ecg_cleaned[int(p)] for p in p_peaks if int(p) < len(ecg_cleaned)]
+                features["p_wave_ratio"] = float(np.mean(p_amps) / features["r_amplitude"]) if p_amps else 0.1
+            else:
+                features["p_wave_ratio"] = 0.1
+
+        except Exception:
+            features.setdefault("qrs_duration", 100.0)
+            features.setdefault("r_amplitude", float(np.max(ecg_cleaned) - np.min(ecg_cleaned)))
+            features.setdefault("r_amplitude_std", 0.0)
+            features.setdefault("qt_interval", 400.0)
+            features.setdefault("qtc", 440.0)
+            features.setdefault("st_level", 0.0)
+            features.setdefault("t_amplitude", 0.0)
+            features.setdefault("p_wave_ratio", 0.1)
+
+        # --- Signal Statistics (6) ---
+        features["rms"] = float(np.sqrt(np.mean(ecg_cleaned ** 2)))
+        features["entropy"] = float(_sample_entropy(ecg_cleaned))
+        features["zero_crossing_rate"] = float(
+            np.sum(np.diff(np.sign(ecg_cleaned - np.mean(ecg_cleaned))) != 0) / len(ecg_cleaned)
+        )
+        features["kurtosis"] = float(kurtosis(ecg_cleaned))
+        features["skewness"] = float(skew(ecg_cleaned))
+        features["snr"] = float(_estimate_snr(ecg_cleaned, sample_rate))
+
+        # --- Device Sensor Features (4) ---
+        features["heart_rate_sensor"] = float(heart_rate_sensor) if heart_rate_sensor else features["mean_hr_ecg"]
+        features["spo2"] = float(spo2) if spo2 else 97.0
+
+        hr_diff = abs(features["heart_rate_sensor"] - features["mean_hr_ecg"])
+        features["hr_sensor_ecg_diff"] = float(hr_diff)
+
+        # ECG quality score (based on peak regularity)
+        if len(rr_intervals) > 1:
+            cv = np.std(rr_intervals) / np.mean(rr_intervals)
+            features["ecg_quality"] = float(max(0, 1 - cv))
+        else:
+            features["ecg_quality"] = 0.5
+
+    except Exception:
+        return _fallback_features(ecg_signal, heart_rate_sensor, spo2)
+
+    return features
+
+
+def _sample_entropy(signal, m=2, r_factor=0.2):
+    """Approximate sample entropy."""
+    try:
+        r = r_factor * np.std(signal)
+        N = len(signal)
+        if N < m + 2 or r == 0:
+            return 0.0
+
+        # Use simplified approach for speed
+        templates_m = np.array([signal[i:i + m] for i in range(N - m)])
+        templates_m1 = np.array([signal[i:i + m + 1] for i in range(N - m - 1)])
+
+        count_m = 0
+        count_m1 = 0
+
+        # Sample subset for speed
+        n_check = min(200, len(templates_m))
+        indices = np.random.choice(len(templates_m), n_check, replace=False) if len(templates_m) > n_check else range(len(templates_m))
+
+        for i in indices:
+            dist_m = np.max(np.abs(templates_m - templates_m[i]), axis=1)
+            count_m += np.sum(dist_m < r) - 1
+
+            if i < len(templates_m1):
+                dist_m1 = np.max(np.abs(templates_m1 - templates_m1[i]), axis=1)
+                count_m1 += np.sum(dist_m1 < r) - 1
+
+        if count_m == 0 or count_m1 == 0:
+            return 0.0
+
+        return -np.log(count_m1 / count_m)
+    except Exception:
+        return 0.0
+
+
+def _estimate_snr(signal, sample_rate):
+    """Estimate signal-to-noise ratio."""
+    try:
+        cleaned = nk.ecg_clean(signal, sampling_rate=sample_rate)
+        noise = signal - cleaned
+        signal_power = np.mean(cleaned ** 2)
+        noise_power = np.mean(noise ** 2)
+        if noise_power == 0:
+            return 30.0
+        return float(10 * np.log10(signal_power / noise_power))
+    except Exception:
+        return 10.0
+
+
+def _fallback_features(ecg_signal, heart_rate_sensor=None, spo2=None) -> dict:
+    """Return default features when ECG processing fails."""
+    return {
+        "mean_rr": 800.0, "sdnn": 50.0, "rmssd": 30.0, "pnn50": 10.0,
+        "mean_hr_ecg": 75.0, "hr_std": 5.0, "rr_range": 200.0,
+        "qrs_duration": 100.0, "r_amplitude": 1.0, "r_amplitude_std": 0.1,
+        "qt_interval": 400.0, "qtc": 440.0, "st_level": 0.0,
+        "t_amplitude": 0.3, "p_wave_ratio": 0.1,
+        "rms": float(np.sqrt(np.mean(ecg_signal ** 2))) if len(ecg_signal) > 0 else 0.5,
+        "entropy": 0.5, "zero_crossing_rate": 0.1,
+        "kurtosis": 0.0, "skewness": 0.0, "snr": 10.0,
+        "heart_rate_sensor": float(heart_rate_sensor) if heart_rate_sensor else 75.0,
+        "spo2": float(spo2) if spo2 else 97.0,
+        "hr_sensor_ecg_diff": 0.0, "ecg_quality": 0.5,
+    }
+
+
+# Ordered feature names for XGBoost (must match training order)
+FEATURE_NAMES = [
+    "mean_rr", "sdnn", "rmssd", "pnn50", "mean_hr_ecg", "hr_std", "rr_range",
+    "qrs_duration", "r_amplitude", "r_amplitude_std", "qt_interval", "qtc",
+    "st_level", "t_amplitude", "p_wave_ratio",
+    "rms", "entropy", "zero_crossing_rate", "kurtosis", "skewness", "snr",
+    "heart_rate_sensor", "spo2", "hr_sensor_ecg_diff", "ecg_quality",
+]
+
+# User profile feature names (appended after ECG features)
+PROFILE_FEATURE_NAMES = [
+    "age", "sex", "bmi", "is_diabetic", "is_hypertensive",
+    "is_smoker", "family_history",
+]
+
+# Historical baseline feature names
+HISTORY_FEATURE_NAMES = [
+    "hr_baseline_24h", "hr_baseline_7d", "spo2_baseline_24h",
+    "hr_deviation", "spo2_deviation", "resting_hr_trend", "readings_count_24h",
+]
+
+ALL_FEATURE_NAMES = FEATURE_NAMES + PROFILE_FEATURE_NAMES + HISTORY_FEATURE_NAMES
+
+
+def features_to_array(features: dict, include_profile: bool = False) -> np.ndarray:
+    """Convert feature dict to numpy array in correct order for XGBoost."""
+    names = ALL_FEATURE_NAMES if include_profile else FEATURE_NAMES
+    return np.array([features.get(name, 0.0) for name in names], dtype=np.float32)

ml_src/net1d.py

@@ -0,0 +1,198 @@
+"""
+Net1D: 1D CNN with Squeeze-and-Excitation for ECG classification.
+From PKUDigitalHealth/ECGFounder (MIT License).
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class MyConv1dPadSame(nn.Module):
+    def __init__(self, in_channels, out_channels, kernel_size, stride, groups=1):
+        super().__init__()
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.kernel_size = kernel_size
+        self.stride = stride
+        self.conv = nn.Conv1d(in_channels, out_channels, kernel_size, stride, groups=groups)
+
+    def forward(self, x):
+        in_dim = x.shape[-1]
+        out_dim = (in_dim + self.stride - 1) // self.stride
+        p = max(0, (out_dim - 1) * self.stride + self.kernel_size - in_dim)
+        pad_left = p // 2
+        pad_right = p - pad_left
+        x = F.pad(x, (pad_left, pad_right), "constant", 0)
+        return self.conv(x)
+
+
+class MyMaxPool1dPadSame(nn.Module):
+    def __init__(self, kernel_size):
+        super().__init__()
+        self.kernel_size = kernel_size
+        self.max_pool = nn.MaxPool1d(kernel_size=kernel_size)
+
+    def forward(self, x):
+        p = max(0, self.kernel_size - 1)
+        pad_left = p // 2
+        pad_right = p - pad_left
+        x = F.pad(x, (pad_left, pad_right), "constant", 0)
+        return self.max_pool(x)
+
+
+class Swish(nn.Module):
+    def forward(self, x):
+        return x * torch.sigmoid(x)
+
+
+class BasicBlock(nn.Module):
+    def __init__(self, in_channels, out_channels, ratio, kernel_size, stride,
+                 groups, downsample, is_first_block=False, use_bn=True, use_do=True):
+        super().__init__()
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.downsample = downsample
+        self.stride = stride if downsample else 1
+        self.is_first_block = is_first_block
+        self.use_bn = use_bn
+        self.use_do = use_do
+        middle = int(out_channels * ratio)
+
+        self.bn1 = nn.BatchNorm1d(in_channels)
+        self.activation1 = Swish()
+        self.do1 = nn.Dropout(p=0.5)
+        self.conv1 = MyConv1dPadSame(in_channels, middle, 1, 1, 1)
+
+        self.bn2 = nn.BatchNorm1d(middle)
+        self.activation2 = Swish()
+        self.do2 = nn.Dropout(p=0.5)
+        self.conv2 = MyConv1dPadSame(middle, middle, kernel_size, self.stride, groups)
+
+        self.bn3 = nn.BatchNorm1d(middle)
+        self.activation3 = Swish()
+        self.do3 = nn.Dropout(p=0.5)
+        self.conv3 = MyConv1dPadSame(middle, out_channels, 1, 1, 1)
+
+        # Squeeze-and-Excitation
+        r = 2
+        self.se_fc1 = nn.Linear(out_channels, out_channels // r)
+        self.se_fc2 = nn.Linear(out_channels // r, out_channels)
+        self.se_activation = Swish()
+
+        if self.downsample:
+            self.max_pool = MyMaxPool1dPadSame(kernel_size=self.stride)
+
+    def forward(self, x):
+        identity = x
+        out = x
+
+        if not self.is_first_block:
+            if self.use_bn:
+                out = self.bn1(out)
+            out = self.activation1(out)
+            if self.use_do:
+                out = self.do1(out)
+        out = self.conv1(out)
+
+        if self.use_bn:
+            out = self.bn2(out)
+        out = self.activation2(out)
+        if self.use_do:
+            out = self.do2(out)
+        out = self.conv2(out)
+
+        if self.use_bn:
+            out = self.bn3(out)
+        out = self.activation3(out)
+        if self.use_do:
+            out = self.do3(out)
+        out = self.conv3(out)
+
+        # SE attention
+        se = out.mean(-1)
+        se = self.se_fc1(se)
+        se = self.se_activation(se)
+        se = self.se_fc2(se)
+        se = torch.sigmoid(se)
+        out = torch.einsum('abc,ab->abc', out, se)
+
+        if self.downsample:
+            identity = self.max_pool(identity)
+        if self.out_channels != self.in_channels:
+            identity = identity.transpose(-1, -2)
+            ch1 = (self.out_channels - self.in_channels) // 2
+            ch2 = self.out_channels - self.in_channels - ch1
+            identity = F.pad(identity, (ch1, ch2), "constant", 0)
+            identity = identity.transpose(-1, -2)
+
+        out += identity
+        return out
+
+
+class BasicStage(nn.Module):
+    def __init__(self, in_channels, out_channels, ratio, kernel_size, stride,
+                 groups, i_stage, m_blocks, use_bn=True, use_do=True):
+        super().__init__()
+        self.block_list = nn.ModuleList()
+        for i_block in range(m_blocks):
+            is_first = (i_stage == 0 and i_block == 0)
+            if i_block == 0:
+                tmp_block = BasicBlock(
+                    in_channels, out_channels, ratio, kernel_size,
+                    stride, groups, downsample=True,
+                    is_first_block=is_first, use_bn=use_bn, use_do=use_do)
+            else:
+                tmp_block = BasicBlock(
+                    out_channels, out_channels, ratio, kernel_size,
+                    1, groups, downsample=False,
+                    is_first_block=False, use_bn=use_bn, use_do=use_do)
+            self.block_list.append(tmp_block)
+
+    def forward(self, x):
+        for block in self.block_list:
+            x = block(x)
+        return x
+
+
+class Net1D(nn.Module):
+    """
+    1D CNN for ECG classification.
+    Input:  (batch, in_channels, length)
+    Output: (batch, n_classes)
+    """
+    def __init__(self, in_channels, base_filters, ratio, filter_list,
+                 m_blocks_list, kernel_size, stride, groups_width,
+                 n_classes, use_bn=True, use_do=True, verbose=False):
+        super().__init__()
+        self.n_stages = len(filter_list)
+        self.use_bn = use_bn
+
+        self.first_conv = MyConv1dPadSame(in_channels, base_filters, kernel_size, stride=2)
+        self.first_bn = nn.BatchNorm1d(base_filters)
+        self.first_activation = Swish()
+
+        self.stage_list = nn.ModuleList()
+        in_ch = base_filters
+        for i_stage in range(self.n_stages):
+            out_ch = filter_list[i_stage]
+            self.stage_list.append(BasicStage(
+                in_ch, out_ch, ratio, kernel_size, stride,
+                out_ch // groups_width, i_stage, m_blocks_list[i_stage],
+                use_bn=use_bn, use_do=use_do))
+            in_ch = out_ch
+
+        self.dense = nn.Linear(in_ch, n_classes)
+
+    def forward(self, x):
+        out = self.first_conv(x)
+        if self.use_bn:
+            out = self.first_bn(out)
+        out = self.first_activation(out)
+
+        for stage in self.stage_list:
+            out = stage(out)
+
+        features = out.mean(-1)  # Global Average Pooling
+        out = self.dense(features)
+        return out

requirements.txt

@@ -0,0 +1,15 @@
+fastapi==0.115.6
+uvicorn[standard]==0.34.0
+motor==3.6.0
+pymongo==4.10.1
+pydantic==2.10.0
+pydantic-settings==2.7.0
+python-jose[cryptography]==3.3.0
+bcrypt==4.2.0
+python-multipart==0.0.18
+numpy==1.26.4
+scipy==1.14.1
+httpx==0.28.1
+xgboost>=2.0.0
+neurokit2>=0.2.7
+joblib>=1.3.0