Generating Multi-Table Time Series EHR from Latent Space with Minimal Preprocessing

The paper introduces RawMed, a novel framework that generates high-fidelity, multi-table time-series synthetic Electronic Health Records (EHRs) with minimal preprocessing by leveraging text-based representations, while also proposing a comprehensive evaluation framework that demonstrates its superiority over existing baselines in distributional similarity, temporal dynamics, and utility.

The Gist

Imagine you are a doctor trying to train a new AI assistant to predict heart attacks or suggest better treatments. You have a massive library of patient records (Electronic Health Records, or EHRs) that contain everything: blood test results, medication lists, vital signs, and notes from every day a patient was in the hospital.

The problem? You can't share these records. They contain sensitive private information. If you leak them, it's a privacy disaster. If you try to hide the names, smart hackers can often figure out who the patients are just by looking at the unique patterns of their data.

So, scientists need to create fake patient records that look and act exactly like the real ones, but belong to no one. This is called "synthetic data."

However, most previous attempts to create this fake data were like making a "cartoon" version of a patient. They would:

1. Pick only a few features: Like only recording heart rate and temperature, ignoring thousands of other details.
2. Simplify the data: Instead of saying a patient's blood sugar was "98.4 mg/dL," they might just say "Normal" or "High."
3. Mess up the timeline: They often forgot that medical events happen in a specific order (you get a blood test before you get the results).

This paper introduces RawMed, a new tool that creates a hyper-realistic, high-definition "digital twin" of patient records.

Here is how RawMed works, explained with some analogies:

1. The "Raw" Approach: No More Cooking the Books

Imagine you are trying to teach a student to cook.

• Old Methods: You give them a recipe that says "Add a pinch of salt" and "Cook until done." You've removed the specific measurements and times. The student learns a vague idea, but they can't recreate the dish perfectly.
• RawMed: You give the student the exact raw ingredients, the precise temperature of the oven, and the exact second to flip the steak. It keeps the data in its original, messy, complex form (the "raw" state) without simplifying it. This means the fake data is useful for any future research question, not just the ones the scientists thought of today.

2. The "Text" Trick: Speaking the Patient's Language

Medical records are stored in complex databases with many different tables (like a spreadsheet for labs, another for drugs, another for vitals).

• The Problem: Computers usually struggle to read these messy, multi-table databases all at once.
• The RawMed Solution: It treats the entire patient record like a story. It converts every lab result, every pill, and every vital sign into a sentence of text.
  • Example: Instead of a database row, it writes: "Lab test: Glucose, Value: 95, Unit: mg/dL."
  • By turning data into text, RawMed can use powerful language models (like the AI behind this explanation) to understand the relationships between different medical events.

3. The "Compression" Magic: Fitting a Novel into a Postcard

If you turn a whole hospital stay into text, it becomes a massive novel. If you try to feed a novel into a computer model, it chokes (it's too long and expensive to process).

• The Analogy: Imagine trying to memorize a 500-page book word-for-word. It's impossible. But if you could summarize the book into a few key symbols that still hold the essence of the story, you could memorize it easily.
• The Tech: RawMed uses a technique called Residual Quantization. Think of this as a "lossy" compression, but a very smart one. It takes the long text story and compresses it into a short, secret code (a "latent space").
  • It's like turning a high-definition 4K movie into a tiny, encrypted file that still looks perfect when you play it back.
  • This allows the AI to learn the complex patterns of thousands of patients without getting overwhelmed by the data size.

4. The "Time Travel" Engine

Medical data is all about time. A fever today might mean something different than a fever tomorrow.

• The Innovation: RawMed doesn't just look at the data; it looks at the sequence. It learns that "Event A" usually happens 2 hours before "Event B."
• It uses a special "Time Transformer" (a type of AI) that predicts the next event in the story based on what happened before. It's like a detective who can predict the next clue in a mystery because they understand the pattern of the crime.

5. The "Quality Control" Check

When you generate fake data, sometimes the AI gets creative in weird ways. It might invent a drug name that doesn't exist or say a patient had a heart attack before they were born.

• The Fix: RawMed has a strict "Editor" step at the end. It checks every generated record to make sure:
  • The drug names are real.
  • The numbers are within realistic ranges (no one has a heart rate of 500).
  • The timeline makes sense (you can't get a test result before the test is ordered).
  • If a record fails, it gets thrown out and regenerated.

Why Does This Matter?

• Privacy: Hospitals can share these "fake" records with researchers anywhere in the world without worrying about patient privacy.
• Better AI: Because the fake data is so realistic and includes all the details (not just the easy ones), AI models trained on it are much smarter and more accurate.
• Future-Proof: Since RawMed keeps all the original data columns, researchers can ask new questions years from now without needing new data.

In short: RawMed is like a master forger who can create a perfect, undetectable replica of a patient's medical history. It keeps all the tiny details, respects the timeline, and protects the patient's identity, allowing doctors and scientists to train better AI to save lives.

Technical Summary

1. Problem Statement

Electronic Health Records (EHR) are complex, multi-table, time-series relational databases containing heterogeneous data (categorical, numerical, text) that are critical for medical AI research. However, their utility is severely limited by privacy regulations and data sharing restrictions.

Existing synthetic EHR generation methods suffer from three primary limitations:

1. Feature Selection Bias: Most methods generate only a pre-selected subset of features (columns) based on domain knowledge. This limits the utility of the synthetic data for new research questions requiring excluded features.
2. Lossy Preprocessing: Current approaches rely on complex transformations like numeric binning, term normalization, and temporal aggregation. These steps distort original data distributions, obscure subtle trends, and reduce fidelity for predictive modeling.
3. Lack of Temporal/Relational Modeling: Few methods simultaneously capture the complex temporal dynamics of time-series data and the inter-table relationships inherent in relational EHR structures.

2. Methodology: RawMed Framework

RawMed is a framework designed to synthesize raw multi-table time-series EHR data, preserving all original columns and values with minimal preprocessing. It employs a text-based representation combined with latent space compression.

A. Data Representation

• Serialization: Instead of converting data into fixed features, RawMed treats EHR events as text. Each clinical event (e.g., a lab test) is serialized into a string (e.g., "lab item Glucose value 95 uom mg/dL").
• Structure: A patient's trajectory is represented as a sequence of events $S_p = [(t_i, x_i)]$, where $t_i$ is the timestamp and $x_i$ is the serialized text string.
• Tokenization: Text is tokenized and padded to a fixed length. Timestamps are tokenized into digit sequences (e.g., 720 minutes $\to$ [7, 2]) to provide explicit temporal context.

B. Event Compression (Latent Space)

To handle the computational complexity of long text sequences, RawMed compresses event embeddings into a discrete latent space:

• Encoder: A 1D Convolutional Neural Network (CNN) encodes the text embedding.
• Residual Quantization (RQ): Unlike standard Vector Quantization (VQ), RawMed uses Residual Quantization. It decomposes the latent vector into multiple quantized components (depth $D$), allowing for a more expressive representation of independent column distributions (e.g., patient weight) without the distortion common in single-stage VQ.
• Output: The event is compressed into a sequence of discrete indices $k_i$.

C. Temporal Modeling

• Model Architecture: A TempoTransformer (a Transformer-based model) is used for autoregressive modeling.
• Input Sequence: The model processes a unified sequence of time tokens and compressed event tokens: $[\tau_1, k_1, \tau_2, k_2, \dots]$.
• Training: The model is trained to predict the next token in the sequence using a negative log-likelihood objective, effectively learning the joint distribution of temporal intervals and clinical events.

D. Generation and Post-processing

• Sampling: Synthetic patient trajectories are generated via autoregressive sampling (Top-k).
• Post-processing: To ensure structural integrity, a two-stage validation is applied:
  1. Event-level: Corrects misspelled table/column names (using Levenshtein distance) and removes extraneous characters from numeric fields.
  2. Patient-level: Discards sequences with invalid events or temporal inconsistencies (non-chronological order).
  3. Constraint Enforcement: Values are filtered to match observed ranges in real data.

3. Key Contributions

1. First Raw Multi-Table EHR Synthesis: RawMed is the first framework to generate raw EHR data preserving all columns and original values across multiple tables, eliminating the need for domain-specific feature engineering.
2. Novel Evaluation Framework: The authors propose a comprehensive evaluation suite for synthetic raw EHRs, including:
   • Distributional Similarity: Column-wise Density Estimation (CDE) and Item-specific CDE (I-CDE).
   • Inter-Table/Column Relationships: Pairwise Column Correlation (PCC) and Item-specific PCC.
   • Temporal Fidelity: Time Gap distribution, Event Count distribution, and Next Event Prediction (F1 score).
   • Clinical Utility: Downstream predictive performance (AUROC) on 11 clinical tasks.
   • Privacy: Membership Inference Attack (MIA) resistance.
3. Scalability via Compression: By utilizing Residual Quantization, RawMed significantly reduces sequence length (up to 84% reduction) compared to non-compressed text models, enabling the generation of large-scale datasets with thousands of features.

4. Experimental Results

The framework was validated on two large-scale open-source datasets: MIMIC-IV (ICU) and eICU.

• Fidelity: RawMed outperformed baselines (SDV, RC-TGAN, ClavaDDPM, and a non-compressed RealTabFormer) across all metrics.
  • CDE/PCC: Achieved the lowest error rates, indicating superior distributional and correlation matching.
  • Item-Specific Metrics: Significantly outperformed ClavaDDPM in I-CDE and I-PCC, proving it preserves the unique characteristics of specific clinical items (e.g., specific drugs or lab tests).
• Temporal Dynamics:
  • Time Gap: RawMed achieved near-perfect similarity (KS statistic ~0.01–0.03) compared to baselines (0.41–0.76).
  • Next Event Prediction: RawMed achieved the highest F1 scores, demonstrating superior ability to model event sequence patterns.
• Clinical Utility: In downstream prediction tasks (e.g., predicting creatinine levels or medication administration), models trained on RawMed data achieved AUROC scores (0.87 for MIMIC-IV) nearly identical to models trained on real data, significantly outperforming all baselines.
• Privacy: RawMed demonstrated robust privacy protection, with Membership Inference Attack accuracy near random guessing (0.497–0.498).
• Ablation Studies: Removing Residual Quantization or Time Tokenization significantly degraded performance, confirming the necessity of these components for handling independent distributions and temporal patterns.

5. Significance

• Paradigm Shift: RawMed moves EHR synthesis away from "feature engineering" toward "raw data generation," allowing researchers to use synthetic data for any downstream task without re-engineering features.
• Privacy-Preserving Research: It provides a viable solution for sharing sensitive medical data, enabling collaborative research while mitigating re-identification risks.
• Generalizability: The text-based approach makes the framework adaptable to various EHR database schemas without retraining on specific feature sets.
• Open Science: The authors released the code and validated the framework on public datasets, setting a new standard for reproducibility and evaluation in synthetic health data generation.

In conclusion, RawMed represents a significant advancement in medical AI by generating high-fidelity, privacy-preserving, multi-table time-series EHR data that closely mirrors the complexity and utility of real-world clinical records.