Equilibrium Window of Health: Early-Drift Monitoring Core (Stage-Locked, Deterministic, Event-Aware)

CASE STUDY

Snapshot

Field: Longitudinal health monitoring · decision-support analytics
Model type: Event-aware latent state-space model with uncertainty (EKF-based; smoothing optional)
Method2Model stage: Stage 1 (spec) → Stage 2 (formula + I/O contract) → reviewable core engine
Core aim: Detect chronic drift before overt abnormality, separate it from recorded acute events, and report outputs with auditable uncertainty across “cheap / mixed / full” measurement regimes.

The problem addressed

Real-world monitoring pipelines often fail not because the science is wrong, but because their assumptions are brittle. Patient timelines are typically multi-rate (daily wearables vs. intermittent labs), incomplete, and affected by acute events that can masquerade as long-term deterioration. A practical monitoring engine must therefore do three things simultaneously:

Infer a patient-specific equilibrium baseline even when the patient is not “healthy at t=0,”
Quantify change as drift with uncertainty, rather than as a single-point “risk score,”
Explain whether a deviation is likely acute-driven (recorded event) or chronic drift (persistent trend).

What we built (deliverables)

1) Stage-locked specification (Method2Model — Stage 1)

A locked scope and success criteria, with explicit acceptance tests and an assumption log. The specification formalizes the measurement regimes (cheap/mixed/full), defines how missingness must inflate uncertainty, and sets minimal interpretability requirements (tags and attribution) so the implementation remains testable and defensible.

2) Official I/O contract (Method2Model — Stage 2)

A schema-first patient-package contract that defines exactly which inputs the engine consumes and which outputs it must produce. The contract removes ambiguity around week-binning, time zones, measurement units, and version pinning—so implementation becomes deterministic and auditable.

3) Reviewable core engine (single-file implementation)

A “reviewable” core implementation that declares version and traceability identifiers (architecture/formula pack/code IDs), validates schemas and units, and writes standardized outputs (posterior states, drift signals, interpretability tags, QC report, and parameter stamps).

Model overview (client-readable)

A) Latent equilibrium state (“Equilibrium Window”)

The engine tracks a weekly latent health state vector:

Z_t = (I_t, M_t, R_t, C_t, Mt_t)

The intent is to represent a multidimensional equilibrium window rather than a single scalar “health score.” The system is decision-support: it estimates trajectories and uncertainty without making clinical recommendations.

B) Drift as the primary product output

Drift is computed per axis as an uncertainty-aware, standardized change signal (velocity scaled by uncertainty), and elevated states are promoted to alerts only if they persist for L consecutive weeks. This persistence rule is central: it reduces false alarms from transient fluctuations and measurement noise.

C) Regime-aware uncertainty under missingness

The observation model is regime-dependent (cheap/mixed/full). When measurement coverage drops, posterior uncertainty is required to increase in a controlled manner rather than silently producing overconfident estimates. In other words: less data must produce wider credible intervals, not brittle point estimates.

D) Event-aware separation using recorded events

When acute events are present (e.g., infection/flare/medication change recorded in events.csv), the engine computes an attribution ratio:

ρ_t = ‖B·g(E_t)‖ / (‖Ẑ_t − Ẑ_t−1‖ + ε)

and tags a week as acute-driven if the event contribution dominates the observed state change beyond a policy threshold. This mechanism is intentionally transparent: the tag explains “why this changed” in a way that can be audited.

Implementation note (consistency patch): Acute attribution is aligned with the shock that actually drives the transition from t−1 → t, preventing off-by-one misattribution in weekly tagging.

Data contract (inputs)

The engine expects a standardized patient-package folder:

meta.json (timezone, units_version, optional cohort metadata)
timeline_weekly.csv (week index and timeline anchors)
biomarkers_long.csv (long-format biomarkers: timestamp, name, value, unit, week_index)
wearables_daily.csv (optional daily wearables)
events.csv (optional but recommended; recorded events and timing)

Time-zone rule: If event timestamps are naive, they are interpreted in the meta.json timezone to guarantee consistent week-binning across datasets.

Outputs (what the engine produces)

At minimum, the standardized outputs include:

Posterior latent state by week: means and uncertainty (SD/CI) for each axis
Drift signals by week: per-axis drift scores + persistence-based alerts
Interpretability tags: acute_driven, missingness_driven_uncertainty, top_axis, top2_axis
QC report: schema validation, unit/version checks, approximation flags (when allowed)
Stamped parameters: params_estimated.json storing baselines, guardrails, and version identifiers for reproducibility

These outputs are intentionally contracted: predictable, exportable, and stable under refactoring.

Determinism & governance (why this is defensible)

Schema-first inputs prevent silent misuse of units, time, or column meanings.
Version pinning ensures outputs can be traced back to a specific architecture/formula pack.
QC artifacts externalize uncertainty and data quality rather than hiding it.
Policy-controlled thresholds allow deployments to tune sensitivity without modifying the scientific core.

Limitations (explicit by design)

This system is not a diagnostic device and does not output medical recommendations.
“Unknown shock detection” (unrecorded acute events inferred from residuals) is intentionally out of scope in the MVP and can be added as a controlled extension once acceptance tests are met.

Why this belongs in the Case Studies section

Equilibrium Window of Health demonstrates the Method2Model approach end-to-end: turning a monitoring intent into a stage-locked specification, a formal I/O contract, and a deterministic core implementation that produces uncertainty-aware outputs with clear interpretability tags—ready for integration into a product, a study pipeline, or an internal decision-support workflow.

Code availability: The Python code for this case study is available on GitHub at https://github.com/RamyarAzar/Equilibrium_Window_of_Health .

License note: Please contact the author to obtain explicit permission prior to reuse or redistribution.