Upload 4 files

Dockerfile

@@ -1,20 +1,27 @@
-FROM python:3.13.5-slim
+# Hugging Face Spaces - Docker (Streamlit) for Sundew Diabetes Watch
+FROM python:3.11-slim
 
-WORKDIR /app
+# Avoid prompt
+ENV PIP_NO_INPUT=1         PYTHONDONTWRITEBYTECODE=1         PYTHONUNBUFFERED=1         # Streamlit defaults for HF
+    PORT=7860
+
+# System deps (build tools if needed by some wheel)
+RUN apt-get update && apt-get install -y --no-install-recommends         build-essential         && rm -rf /var/lib/apt/lists/*
 
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    git \
-    && rm -rf /var/lib/apt/lists/*
+WORKDIR /app
 
-COPY requirements.txt ./
-COPY src/ ./src/
+COPY requirements.txt /app/requirements.txt
+RUN pip install --upgrade pip && pip install -r /app/requirements.txt
 
-RUN pip3 install -r requirements.txt
+# Copy app code
+COPY app.py /app/app.py
+COPY .streamlit/config.toml /app/.streamlit/config.toml
+COPY README.md /app/README.md
 
-EXPOSE 8501
+EXPOSE 7860
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+# HEALTHCHECK so Spaces knows the app is up
+HEALTHCHECK --interval=30s --timeout=5s --start-period=30s CMD python -c "import socket; s=socket.socket(); s.settimeout(3); s.connect(('127.0.0.1', 7860)); s.close()" || exit 1
 
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+# Streamlit entrypoint
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]

README.md

@@ -1,19 +1,24 @@
----
-title: Sundew Diabetes Watch
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Diabetes Watch
----
+# 🌿 Sundew Diabetes Watch (Hugging Face Space: Docker + Streamlit)
 
-# Welcome to Streamlit!
+**Mission:** Low-cost, energy-aware diabetes risk monitoring for everyone — especially communities across Africa.
+This app uses the *Sundew* selective-activation algorithm to run heavier models **only when needed**, saving compute and making
+always-on monitoring practical on affordable hardware.
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+## How it works
+- Upload a CSV with columns: `timestamp, glucose_mgdl, carbs_g, insulin_units, steps, hr` (optional extras allowed).
+- A lightweight **risk score** runs on each event.
+- **Sundew** decides when to open the gate and run a heavier model for near-term risk.
+- You control the target activation rate to meet power/latency budgets.
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+> **Disclaimer:** Research prototype. Not medical advice.
+
+## Developing locally
+```bash
+python -m venv .venv && source .venv/bin/activate  # Windows: .venv\Scripts\activate
+pip install -r requirements.txt
+streamlit run app.py
+```
+
+## Deploying as a Hugging Face Space (Docker)
+- Create a new **Docker** Space and push these files.
+- The Dockerfile exposes port 7860 and launches `streamlit run app.py`.

app.py

@@ -0,0 +1,217 @@
+import math
+from dataclasses import dataclass
+from typing import Optional
+
+import numpy as np
+import pandas as pd
+import streamlit as st
+
+# ---- Try Sundew; fallback if missing ----
+try:
+    from sundew import SundewAlgorithm  # provided by sundew-algorithms
+    _HAS_SUNDEW = True
+except Exception:
+    SundewAlgorithm = None  # type: ignore
+    _HAS_SUNDEW = False
+
+st.set_page_config(page_title="Sundew Diabetes Watch", layout="wide")
+st.title("🌿 Sundew Diabetes Watch")
+st.caption("Energy-aware selective activation for diabetes monitoring — research demo (not medical advice).")
+
+# ---------------- Sundew Gate wrapper ----------------
+@dataclass
+class SundewGate:
+    target_activation: float = 0.25
+    temperature: float = 0.08
+    mode: str = "tuned_v2"
+
+    def __post_init__(self):
+        if _HAS_SUNDEW and SundewAlgorithm is not None:
+            try:
+                self.sd = SundewAlgorithm(
+                    target_activation=self.target_activation,
+                    temperature=self.temperature,
+                    mode=self.mode,
+                )
+            except TypeError:
+                self.sd = SundewAlgorithm()
+        else:
+            self.sd = None
+        # fallback state
+        self._tau = 0.5
+        self._ema = 0.0
+        self._alpha = 0.02
+
+    def decide(self, score: float) -> bool:
+        score = float(max(0.0, min(1.0, score)))
+        if self.sd is not None:
+            for name in ("decide", "step", "open"):
+                if hasattr(self.sd, name):
+                    try:
+                        return bool(getattr(self.sd, name)(score))
+                    except Exception:
+                        pass
+        # stochastic logistic fallback
+        p_open = 1 / (1 + math.exp(-(score - self._tau) / max(1e-6, self.temperature)))
+        fired = np.random.rand() < p_open
+        self._ema = (1 - self._alpha) * self._ema + self._alpha * (1.0 if fired else 0.0)
+        self._tau += 0.01 * (self.target_activation - self._ema)
+        self._tau = min(0.95, max(0.05, self._tau))
+        return fired
+
+# ---------------- Lightweight risk scoring ----------------
+def compute_lightweight_score(row: pd.Series) -> float:
+    g = float(row.get("glucose_mgdl", np.nan))
+    roc = float(row.get("roc_mgdl_min", 0.0))
+    insulin = float(row.get("insulin_units", 0.0))
+    carbs = float(row.get("carbs_g", 0.0))
+    hr = float(row.get("hr", 0.0))
+
+    low_gap = max(0.0, 80 - g)
+    high_gap = max(0.0, g - 140)
+    base = (low_gap + high_gap) / 120.0
+
+    roc_term = min(1.0, abs(roc) / 3.0)
+    insulin_term = min(1.0, insulin / 6.0) * (1.0 if roc < -0.5 else 0.3)
+    carbs_term = min(1.0, carbs / 50.0) * (1.0 if roc > 0.5 else 0.3)
+    activity_term = min(1.0, max(0.0, hr - 100) / 60.0) * (1.0 if insulin > 0.5 else 0.2)
+
+    score = base + 0.7 * roc_term + 0.5 * insulin_term + 0.4 * carbs_term + 0.3 * activity_term
+    return float(max(0.0, min(1.0, score)))
+
+# ---------------- Heavy model (simple logreg) ----------------
+from sklearn.linear_model import LogisticRegression
+from sklearn.preprocessing import StandardScaler
+from sklearn.pipeline import Pipeline
+
+def make_heavy_model() -> Pipeline:
+    return Pipeline([("scaler", StandardScaler()), ("clf", LogisticRegression(max_iter=1000))])
+
+def train_heavy_model(df: pd.DataFrame) -> Pipeline:
+    df = df.copy()
+    # predict 30-min ahead risk: hypo<70 or hyper>180
+    df["future_glucose"] = df["glucose_mgdl"].shift(-6)  # assuming 5-min cadence
+    df["label"] = ((df["future_glucose"] < 70) | (df["future_glucose"] > 180)).astype(int)
+    df = df.dropna(subset=["label"]).copy()
+
+    X = df[["glucose_mgdl", "roc_mgdl_min", "insulin_units", "carbs_g", "hr"]].fillna(0.0).values
+    y = df["label"].values
+    if len(np.unique(y)) < 2:
+        # ensure fit works even with monotone data
+        y = np.array([0, 1] * (len(X) // 2 + 1))[: len(X)]
+    model = make_heavy_model()
+    model.fit(X, y)
+    return model
+
+# ---------------- UI ----------------
+left, right = st.columns([2, 1])
+with left:
+    uploaded = st.file_uploader("Upload CGM CSV (timestamp, glucose_mgdl, carbs_g, insulin_units, steps, hr)", type=["csv"])
+    use_synth = st.checkbox("Use synthetic example if no file uploaded", value=True)
+with right:
+    target_activation = st.slider("Target heavy-activation rate", 0.05, 0.9, 0.25, 0.01)
+    temperature = st.slider("Gate temperature", 0.02, 0.5, 0.08, 0.01)
+    mode = st.selectbox("Sundew mode", ["tuned_v2", "conservative", "aggressive", "auto_tuned"], index=0)
+
+# ---------------- Load or synthesize data ----------------
+if uploaded is not None:
+    df = pd.read_csv(uploaded)
+else:
+    if not use_synth:
+        st.stop()
+    rng = np.random.default_rng(7)
+    n = 600
+    t0 = pd.Timestamp.utcnow().floor("min")
+    times = [t0 + pd.Timedelta(minutes=5 * i) for i in range(n)]
+    base = 120 + 25 * np.sin(np.linspace(0, 10 * np.pi, n))
+    noise = rng.normal(0, 10, n)
+    meals = (rng.random(n) < 0.04).astype(float) * rng.normal(45, 15, n).clip(0, 120)
+    insulin = (rng.random(n) < 0.03).astype(float) * rng.normal(4, 1.2, n).clip(0, 8)
+    steps = rng.integers(0, 150, size=n)
+    hr = 70 + (steps > 80) * rng.integers(30, 60, size=n)
+    glucose = base + noise + 0.3 * meals - 0.8 * insulin
+    df = pd.DataFrame({
+        "timestamp": times,
+        "glucose_mgdl": np.round(glucose, 1),
+        "carbs_g": np.round(meals, 1),
+        "insulin_units": np.round(insulin, 1),
+        "steps": steps,
+        "hr": hr,
+    })
+
+# ---- Robust timestamp parsing (handles tz-aware) ----
+from pandas.api.types import is_datetime64_any_dtype
+if "timestamp" not in df.columns:
+    st.error("CSV must include a 'timestamp' column.")
+    st.stop()
+
+if not is_datetime64_any_dtype(df["timestamp"]):
+    df["timestamp"] = pd.to_datetime(df["timestamp"], utc=True, errors="coerce")
+
+# localize to UTC if naive
+if getattr(df["timestamp"].dt, "tz", None) is None:
+    df["timestamp"] = df["timestamp"].dt.tz_localize("UTC")
+
+df = df.sort_values("timestamp").reset_index(drop=True)
+df["dt_min"] = df["timestamp"].diff().dt.total_seconds() / 60.0
+df["glucose_prev"] = df["glucose_mgdl"].shift(1)
+df["roc_mgdl_min"] = (df["glucose_mgdl"] - df["glucose_prev"]) / df["dt_min"]
+df["roc_mgdl_min"] = df["roc_mgdl_min"].replace([np.inf, -np.inf], 0.0).fillna(0.0)
+
+# Train model
+model = train_heavy_model(df)
+
+# Run stream
+gate = SundewGate(target_activation=target_activation, temperature=temperature, mode=mode)
+records = []
+alerts = []
+
+for _, row in df.iterrows():
+    score = compute_lightweight_score(row)
+    open_gate = gate.decide(score)
+    decision = "SKIP"
+    proba = None
+    if open_gate:
+        X = np.array([[row.get("glucose_mgdl", 0.0), row.get("roc_mgdl_min", 0.0),
+                       row.get("insulin_units", 0.0), row.get("carbs_g", 0.0), row.get("hr", 0.0)]])
+        try:
+            proba = float(model.predict_proba(X)[0, 1])
+        except Exception:
+            proba = float(model.predict(X)[0])
+        decision = "RUN"
+        if proba >= 0.6:
+            alerts.append({
+                "timestamp": row["timestamp"],
+                "glucose": row["glucose_mgdl"],
+                "risk_proba": proba,
+                "note": "⚠ Elevated 30-min risk — please check CGM and plan carbs/insulin."
+            })
+    records.append({
+        "timestamp": row["timestamp"], "glucose": row["glucose_mgdl"], "roc": row["roc_mgdl_min"],
+        "score": score, "gate": decision, "risk_proba": proba
+    })
+
+out = pd.DataFrame(records)
+events = len(out)
+activations = int((out["gate"] == "RUN").sum())
+rate = activations / max(events, 1)
+
+c1, c2, c3 = st.columns(3)
+c1.metric("Events", f"{events}")
+c2.metric("Heavy activations", f"{activations}")
+c3.metric("Activation rate", f"{rate:.2%}")
+
+st.line_chart(out.set_index("timestamp")["glucose"], height=220)
+st.line_chart(out.set_index("timestamp")["score"], height=220)
+
+st.subheader("Decisions (tail)")
+st.dataframe(out.tail(50))
+
+st.subheader("Alerts")
+if alerts:
+    st.dataframe(pd.DataFrame(alerts))
+else:
+    st.info("No high-risk alerts triggered in this window.")
+
+st.caption("Engine: {}"
+           .format("sundew-algorithms active" if _HAS_SUNDEW else "fallback gate (install sundew-algorithms)"))

requirements.txt

@@ -1,3 +1,6 @@
-altair
-pandas
-streamlit
+streamlit==1.37.1
+scikit-learn==1.5.1
+numpy==1.26.4
+pandas==2.2.2
+# Sundew adaptive gating algorithm (PyPI)
+sundew-algorithms