EHR2Path: Scalable Modeling of Longitudinal Patient Pathways from Multimodal Electronic Health Records

The paper introduces EHR2Path, a scalable multimodal framework that utilizes a Masked Summarization Bottleneck to compress diverse, longitudinal electronic health records into unified temporal representations, enabling the accurate forecasting and simulation of complete in-hospital patient pathways for proactive clinical decision-making.

The Gist

Imagine you are trying to predict the plot of a very complicated, chaotic movie about a patient's stay in a hospital.

Currently, most medical AI tools are like movie critics who only watch the last 10 minutes of the film and try to guess the ending. They might tell you, "This patient will likely die" or "They will stay for 3 days." But they miss the whole story: the drama in the Emergency Room, the quiet moments in the ward, the sudden changes in the ICU, and the messy notes doctors scribble down.

EHR2Path is a new tool that acts more like a super-intelligent showrunner. Instead of just guessing the ending, it tries to write the entire script of the patient's hospital journey, hour by hour, from the moment they walk in until they leave.

Here is how it works, broken down into simple concepts:

1. The "Universal Translator" (Multimodal Data)

Hospitals generate data in a million different languages:

• Numbers: Heart rates, blood pressure.
• Codes: Diagnosis codes (like "ICD-10").
• Text: Doctors' handwritten notes, radiology reports, nursing logs.

Older AI models were like people who only spoke "Numbers." If a doctor wrote a note saying, "Patient looks pale and confused," the old AI ignored it.
EHR2Path is like a polyglot translator. It takes all these different formats—numbers, codes, and messy text—and turns them all into a single, unified story. It reads the doctor's note just as easily as it reads a blood test result, creating a complete picture of the patient.

2. The "Giant Library" Problem (Long Context)

A patient's hospital stay can last days or weeks. If you try to feed a computer every single page of a patient's history (which could be thousands of pages long), the computer's brain (its "context window") explodes. It gets overwhelmed and forgets the beginning of the story.

The Solution: The "Highlighter" (Masked Summarization Bottleneck)
This is the paper's coolest invention. Imagine you have a 500-page book about a patient. You can't read all 500 pages to the AI at once.

• The Trick: EHR2Path uses a special "Summarizer" that reads the whole book and writes a one-page cheat sheet (a summary) of the most important plot points.
• The "Recent" Focus: It keeps the last 24 hours of the story in high definition (full text) because that's what matters most right now.
• The Result: The AI gets the "cheat sheet" for the old stuff and the "full script" for the recent stuff. This allows it to remember the entire hospital stay without getting a headache, making it incredibly efficient.

3. The "Time Traveler" (Simulation)

Most AI tools are like fortune tellers: they look at the past and say, "You will get sick tomorrow."
EHR2Path is like a time traveler.

• It predicts what happens in the next hour (e.g., "The heart rate will drop to 60").
• Then, it takes that prediction, adds it to the patient's record, and asks, "Okay, given that new fact, what happens in the hour after that?"
• It repeats this over and over, simulating the entire future journey of the patient.

This allows doctors to run "What if?" scenarios. What if we give this medication now? How does the patient's path change? It helps them plan proactively rather than just reacting to emergencies.

4. Why This Matters

Think of a doctor as a pilot flying a plane through a storm.

• Old AI: Tells the pilot, "You might crash in 2 hours." (Too late, and not helpful).
• EHR2Path: Gives the pilot a flight simulator. It says, "If you turn left, you hit turbulence. If you turn right, the weather clears. Here is the map of the next 24 hours."

The Bottom Line

EHR2Path is a scalable, smart system that reads every type of hospital record, remembers the whole story using a clever "cheat sheet" method, and simulates the patient's future journey. It moves medicine from "guessing the outcome" to "planning the path," helping doctors give better, more personalized care before things go wrong.

The authors have even made the code open-source, so other researchers can use this "flight simulator" to build even better tools for the future of healthcare.

Technical Summary

1. Problem Statement

Current machine learning approaches for Electronic Health Records (EHR) face three primary limitations when modeling patient trajectories:

• Narrow Scope: Most models focus on isolated outcome predictions (e.g., mortality, length of stay) rather than modeling the full evolution of a patient's state.
• Limited Context: Existing methods often operate on restricted feature spaces (e.g., only structured codes) or short context windows, failing to capture the full multimodal history (vitals, notes, labs, imaging) required for holistic pathway modeling.
• Scalability Issues: Directly applying Large Language Models (LLMs) to full hospital trajectories is computationally prohibitive due to the length, density, and irregularity of clinical histories, which quickly exceed practical token limits.

The goal is to create a scalable framework that can forecast and simulate full in-hospital patient pathways (from Emergency Department admission to discharge) by integrating heterogeneous, longitudinal data.

2. Methodology: EHR2Path

EHR2Path is a multimodal framework that converts diverse clinical inputs into a unified temporal representation to predict the next hour of a patient's EHR state.

A. Data Representation

• Unified Textual Format: The model avoids heavy preprocessing or feature-specific adjustments. Instead, it structures heterogeneous data (static demographics, continuous vitals, categorical events, free-text notes) into a natural language format.
• Hierarchical Organization: Data is organized into three levels:
  1. Clinical Units: ED, Hospital Ward, ICU.
  2. Categories: Vitals, Medications, Labs, Procedures, Reports, etc.
  3. Features: Events (e.g., "Admission") and Values (e.g., "Heart Rate: 82").
• Temporal Modeling: Data is represented as sparse sequences where time is relative to the current step (e.g., "Heart Rate: 1: 80" for the previous hour). Missing data is handled by the absence of an entry.

B. Core Architecture

The system utilizes a Transformer-based LLM backbone with three specific variants:

1. E2P-T (Text-only): Processes the most recent $w$ hours (e.g., 24h) of raw text.
2. E2P-S (Summary-only): Relies on compressed embeddings of the entire patient history.
3. E2P-S+T (Hybrid): Combines recent raw text (24h) with the full history summary.

C. Key Innovation: Masked Summarization Bottleneck

To handle long clinical histories without exceeding context limits, the authors introduce a Masked Summarization Bottleneck:

• Mechanism: A dedicated "Summary Model" compresses the entire history of a specific data section (e.g., all past vitals) into a small set of learned summary tokens ($S$).
• Masking Strategy: A custom attention mask ensures that the "Output" tokens (predicting the next state) can only attend to the summary tokens and previous outputs, not the raw historical input tokens.
• Objective: This forces the model to learn a compact representation that maximizes mutual information with the next state ($I(S; z_{t+1})$) while minimizing redundancy from the full history.
• Efficiency: This allows the model to incorporate up to 20x more historical context (e.g., full hospital stay) while keeping the input token count low (e.g., ~1,500 tokens vs. ~86,000 raw tokens).

D. Training and Inference

• Training Objective: Next-step prediction. The model predicts the sparse EHR state (events and values) for time $t+1$ given data up to $t$.
• Length-of-Stay (LOS) Indicator: To prevent the model from failing to terminate (e.g., never predicting discharge), a countdown token for remaining hours is added. During inference, the model predicts its own LOS, allowing for iterative simulation.
• Iterative Simulation: The model can be rolled out step-by-step. The predicted state at $t+1$ is fed back as input to predict $t+2$, simulating complete future trajectories until a termination condition (discharge/death) is met.

3. Key Contributions

1. Pathway-Level Modeling: Shifts focus from single-outcome prediction to forecasting the entire patient state evolution, including vital signs, treatments, and care transitions.
2. Multimodal Integration: Successfully unifies structured codes, continuous physiological signals, and unstructured free-text notes (radiology reports, physician notes) into a single trajectory model.
3. Masked Summarization Bottleneck: A novel architectural component that enables efficient modeling of long-term dependencies by compressing history into task-optimized tokens, solving the context-length bottleneck of LLMs in healthcare.
4. Scalable Framework: Demonstrates that full in-hospital trajectories can be modeled and simulated iteratively with high token efficiency.

4. Experimental Results

The model was evaluated on the MIMIC-IV dataset (approx. 300,000 patients) across 9 clinical tasks (ED, Ward, ICU).

• Next-Step Prediction:
  • EHR2Path significantly outperformed baselines (ETHOS, REMed, MEME) and statistical baselines.
  • E2P-S (Summary-only) achieved the highest macro F1 scores, proving the efficacy of the summarization bottleneck in extracting predictive signals from long histories.
  • Context Efficiency: E2P-S and E2P-S+T utilized ~20x more historical context than text-only models while using fewer input tokens.
• Longitudinal Simulation:
  • The model successfully simulated multi-day trajectories. Performance degradation was gradual rather than catastrophic as the prediction horizon increased.
  • E2P-S+T provided the most robust performance across diverse tasks, balancing short-term detail with long-term context.
• Outcome Prediction (Fine-Tuning):
  • When fine-tuned for specific outcomes (e.g., mortality, discharge diagnosis), EHR2Path outperformed specialized baselines (MEME, REMed) in 3 out of 4 tasks, demonstrating its potential as a foundation model.
• Ablation Studies:
  • Removing the LOS indicator significantly reduced the model's ability to converge on discharge events.
  • An 8-token bottleneck size was found to offer the best trade-off between validation loss and computational efficiency.

5. Significance

• Clinical Decision Support: By forecasting the full patient pathway (including deterioration, treatment needs, and transitions), EHR2Path supports proactive and personalized care rather than reactive decision-making.
• Foundation for AI in Healthcare: It establishes a scalable paradigm for modeling heterogeneous EHR data, moving beyond narrow tasks to holistic patient state representation.
• Efficiency: The Masked Summarization Bottleneck provides a blueprint for applying LLMs to other domains with long, dense, and irregular historical data where context limits are a barrier.
• Open Science: The code is publicly available, facilitating reproducibility and further research into anticipatory clinical modeling.

In summary, EHR2Path represents a significant leap forward in medical AI by enabling the simulation of complete patient journeys through efficient, multimodal, and long-context modeling.