Chapter 8: Time Series Analysis for Clinical Data
Learning Objectives
By the end of this chapter, readers will be able to understand the unique characteristics of clinical time series data and how they differ from time series in other domains, implement methods for handling irregularly sampled observations that are common in real-world healthcare settings, develop models that appropriately handle missing data mechanisms that correlate with patient characteristics and access to care, build clinical deterioration prediction systems using recurrent neural networks and temporal convolutional networks, apply attention mechanisms to create interpretable temporal predictions that clinicians can trust, and critically evaluate how observation patterns systematically differ across patient populations and care settings. Readers will gain expertise in constructing fairness-aware temporal models that maintain performance for patients with sparse observations, implementing early warning systems with explicit fairness constraints, and deploying production systems that account for structural inequities in data collection patterns. The chapter emphasizes that temporal modeling choices have direct implications for health equity, as naïve approaches often penalize patients who receive less frequent monitoring due to insurance status, geographic location, or systemic barriers to care access.
Introduction: The Temporal Nature of Clinical Data
Healthcare is fundamentally a temporal process. Clinical conditions evolve over hours, days, and years. Interventions have time-dependent effects. Patient states change in response to treatments, disease progression, and external factors. Understanding these temporal dynamics is essential for effective clinical decision-making, yet the temporal data available for analysis reflects not just biological processes but also the structural organization of healthcare delivery and the systematic inequities embedded within it.
Consider two patients admitted to a hospital with similar pneumonia severity scores. The first patient, insured through a comprehensive health plan and admitted to a well-resourced intensive care unit, may have vital signs recorded every fifteen minutes, laboratory tests drawn every four hours, and continuous pulse oximetry monitoring. The second patient, uninsured and admitted to a general ward in an under-resourced hospital, might have vital signs recorded only every four hours, laboratory tests drawn once daily, and intermittent pulse oximetry checks. Both patients generate temporal data, but the frequency, completeness, and quality of observations differ systematically based on factors unrelated to their underlying clinical condition.
Traditional time series analysis methods assume regular sampling intervals and treat missing data as random noise. Clinical time series violate both assumptions. Observations are irregularly sampled, driven by clinical concern, staffing patterns, insurance authorization requirements, and resource availability rather than predetermined schedules. Missing data is rarely missing at random but instead correlates with patient acuity, socioeconomic status, care setting, and systemic access barriers. A model trained on data from well-resourced settings may implicitly learn that frequent observations indicate higher quality care and better outcomes, then penalize patients in under-resourced settings whose sparse observations reflect resource constraints rather than lower clinical need.
The temporal dimension amplifies existing inequities through multiple mechanisms. Early warning systems trained predominantly on frequently sampled ICU data may fail to detect deterioration in patients with sparse ward-level monitoring. Forecasting models may achieve high performance on patients with complete temporal coverage while performing poorly on patients with intermittent observations characteristic of safety-net hospitals or rural clinics. Attention mechanisms may learn to focus on observation frequency as a proxy for risk, creating a pernicious feedback loop where patients receiving less frequent monitoring are systematically under-triaged by algorithmic systems.
This chapter develops methods for temporal analysis of clinical data that explicitly address these challenges. We begin with mathematical foundations for handling irregularly sampled time series and non-random missingness mechanisms. We then implement recurrent neural networks and temporal convolutional networks adapted for clinical sequences with varying observation patterns. We develop attention mechanisms that provide interpretable temporal predictions while avoiding spurious correlations with observation frequency. Throughout, we integrate fairness constraints and equity considerations, ensuring that temporal models maintain performance across diverse patient populations and care settings. The production systems we build demonstrate how to operationalize these principles in real-world deployment, creating early warning systems that work reliably for all patients regardless of how frequently they are observed.
Mathematical Foundations for Clinical Time Series
Clinical time series present unique mathematical challenges that require careful formulation. We denote a clinical time series for patient $i$ as $\mathbf{X}_i = \{(\mathbf{x}_{i,j}, t_{i,j})\}_{j=1}^{n_i}$ where $\mathbf{x}_{i,j} \in \mathbb{R}^d$ represents a $d$-dimensional observation at time $t_{i,j}$. Unlike traditional time series where observations occur at regular intervals $t_j = j\Delta t$, clinical observations arrive at irregular times driven by clinical workflows, with $t_{i,j+1} - t_{i,j}$ varying unpredictably both within and across patients.
The irregularity extends beyond timing to the observations themselves. At time $t_{i,j}$, we may observe only a subset of the $d$ possible features, creating a missing data pattern $\mathbf{M}_{i,j} \in \{0,1\}^d$ where $M_{i,j,k} = 1$ indicates feature $k$ was observed. The observed values can be represented as $\tilde{\mathbf{x}}_{i,j} = \mathbf{M}_{i,j} \odot \mathbf{x}_{i,j}$ where $\odot$ denotes element-wise multiplication. Importantly, the missingness pattern $\mathbf{M}_{i,j}$ is itself informative, correlating with patient severity, care setting, and socioeconomic factors.
To formalize the missingness mechanism, we consider three categories building on the framework of Rubin (1976) and Little and Rubin (2019), adapted for the temporal clinical context. Under Missing Completely At Random (MCAR), the probability of missingness is independent of both observed and unobserved values: $P(\mathbf{M}_{i,j} \mid \mathbf{x}_{i,j}, \mathbf{X}_{i,\lt j}, \mathbf{Z}_i) = P(\mathbf{M}_{i,j})$ where $\mathbf{X}_{i,\lt j}$ denotes all prior observations and $\mathbf{Z}_i$ represents time-invariant patient characteristics. MCAR rarely holds in clinical settings, as the decision to order a laboratory test or record a vital sign depends on clinical judgment, patient condition, and care protocols.
Under Missing At Random (MAR), missingness depends on observed data but not on the unobserved values themselves: $P(\mathbf{M}_{i,j} \mid \mathbf{x}_{i,j}, \mathbf{X}_{i,\lt j}, \mathbf{Z}_i) = P(\mathbf{M}_{i,j} \mid \tilde{\mathbf{X}}_{i,\lt j}, \mathbf{Z}_i)$ where $\tilde{\mathbf{X}}_{i,\lt j}$ contains only observed portions of prior time points. MAR allows missingness to correlate with previously observed values, such as ordering more frequent laboratory tests for patients with previously abnormal results. Many clinical models assume MAR, but this assumption is violated when missingness correlates with unobserved disease severity or socioeconomic factors not captured in the electronic health record.
Under Missing Not At Random (MNAR), missingness depends on the unobserved values themselves or on unobserved confounders: $P(\mathbf{M}_{i,j} \mid \mathbf{x}_{i,j}, \mathbf{X}_{i,\lt j}, \mathbf{Z}_i)$ depends on the full $\mathbf{x}_{i,j}$ including unobserved components. MNAR is common in clinical settings where observation patterns reflect insurance authorization requirements, resource constraints, or implicit bias in clinical decision-making. A patient may receive less frequent monitoring not because their condition is stable but because their insurance requires pre-authorization for certain tests, or because implicit bias leads clinicians to take symptoms less seriously.
For temporal prediction tasks, we aim to learn a function $f: \mathcal{H} \rightarrow \mathcal{Y}$ mapping from history $\mathcal{H}_i = \{(\tilde{\mathbf{x}}_{i,j}, \mathbf{M}_{i,j}, t_{i,j})\}_{j=1}^{n_i}$ to outcomes $y_i \in \mathcal{Y}$. The outcome might be binary deterioration within the next 24 hours, continuous vital sign values at future time points, or time-to-event outcomes like length of stay or time to discharge. The challenge lies in learning $f$ that performs well across populations with systematically different observation patterns, avoiding spurious correlations between observation frequency and outcomes.
To address irregularly sampled data, we can employ several mathematical approaches. Forward filling or last observation carried forward (LOCF) assumes values remain constant until the next observation: $\hat{x}_{i,k}(t) = x_{i,j,k}$ for $t_{i,j} \leq t \lt t_{i,j+1}$ where $M_{i,j,k} = 1$. While simple, LOCF introduces bias by assuming stability that may not reflect true clinical trajectories, particularly for patients with sparse observations where inter-observation intervals can be lengthy.
Linear or spline interpolation provides smoothing between observations: $\hat{x}_{i,k}(t) = \alpha x_{i,j,k} + (1-\alpha)x_{i,j+1,k}$ for $t_{i,j} \lt t \lt t_{i,j+1}$ where $\alpha = (t_{i,j+1} - t)/(t_{i,j+1} - t_{i,j})$. Interpolation assumes smooth transitions appropriate for some variables like weight or blood pressure but inappropriate for discrete events like medication administration. Higher-order splines can capture more complex dynamics but require more observations, disadvantaging patients with sparse monitoring.
Gaussian process models provide a principled probabilistic approach to irregular sampling. We model the underlying continuous-time process as $x_{i,k}(t) \sim \mathcal{GP}(\mu_k(t), \kappa_k(t,t'))$ with mean function $\mu_k(t)$ and covariance kernel $\kappa_k(t,t')$. Popular kernels include the squared exponential $\kappa(t,t') = \sigma^2\exp(-\frac{(t-t')^2}{2\ell^2})$ with length-scale $\ell$ controlling temporal smoothness, and the Matérn kernel $\kappa(t,t') = \frac{2^{1-\nu}}{\Gamma(\nu)}(\sqrt{2\nu}\frac{\lvert t-t' \rvert}{\ell})^\nu K_\nu(\sqrt{2\nu}\frac{\lvert t-t' \rvert}{\ell})$ allowing control over differentiability through parameter $\nu$. Gaussian processes naturally handle irregular sampling and provide uncertainty quantification, but computational costs scale as $\mathcal{O}(n^3)$ limiting their application to long sequences unless sparse approximations are employed.
For sequences with both irregularly spaced observations and missing features, we can factor the joint distribution as $p(\mathbf{X}_i, \mathbf{M}_i) = p(\mathbf{X}_i \mid \mathbf{M}_i)p(\mathbf{M}_i)$. If we believe MAR holds, we can model $p(\mathbf{X}_i \mid \mathbf{M}_i)$ ignoring the missingness mechanism. However, when MNAR is suspected, we must jointly model observations and missingness. Pattern mixture models stratify by missingness patterns: $p(\mathbf{X}_i) = \sum_{\mathbf{M}} p(\mathbf{X}_i \mid \mathbf{M}_i = \mathbf{M})p(\mathbf{M}_i = \mathbf{M})$, allowing different temporal dynamics for different observation patterns. Selection models explicitly model the missingness mechanism: $p(\mathbf{M}_{i,j} \mid \mathbf{x}_{i,j}, \mathbf{X}_{i,\lt j})$, enabling adjustment for informative missingness but requiring careful specification of the missingness model to avoid bias.
From an equity perspective, we must consider that observation patterns themselves reflect structural inequities. Let $S_i \in \mathcal{S}$ denote sensitive attributes like race, insurance status, or geographic location that we seek to ensure fair treatment. If observation frequency $\lambda_i = \frac{n_i}{t_{i,n_i} - t_{i,1}}$ differs systematically across groups $\mathbb{E}[\lambda_i \mid S_i = s] \neq \mathbb{E}[\lambda_i \mid S_i = s']$, then models that implicitly or explicitly use observation frequency as a feature will exhibit disparate performance across groups. We can formalize fairness requirements through various metrics adapted to the temporal setting, as developed by Obermeyer et al. (2019) and Chen et al. (2020).
Demographic parity requires that predictions are independent of sensitive attributes conditional on clinically relevant history: $P(\hat{y}_i = 1 \mid S_i = s, \mathcal{H}_i^{\text{clinical}}) = P(\hat{y}_i = 1 \mid S_i = s', \mathcal{H}_i^{\text{clinical}})$ where $\mathcal{H}_i^{\text{clinical}}$ includes only clinically meaningful features excluding proxies for socioeconomic status or access barriers. Equalized odds requires that true positive and false positive rates are equal across groups: $P(\hat{y}_i = 1 \mid y_i = k, S_i = s) = P(\hat{y}_i = 1 \mid y_i = k, S_i = s')$ for $k \in \{0,1\}$. Calibration requires that predicted probabilities match observed frequencies across groups: $P(y_i = 1 \mid \hat{p}_i = p, S_i = s) = p$ for all $p$ and $s$.
These fairness definitions are not always simultaneously achievable, particularly when base rates differ across groups due to social determinants of health rather than biological differences. Chouldechova (2017) proved that demographic parity and equalized odds cannot both hold when prevalence differs across groups, forcing difficult tradeoffs. For temporal clinical prediction, these challenges are compounded by the fact that observation patterns themselves are both informative about outcomes and correlated with sensitive attributes, creating a complex landscape requiring careful navigation.
Recurrent Neural Networks for Clinical Sequences
Recurrent neural networks provide a natural framework for modeling sequential clinical data through their ability to maintain hidden states that summarize relevant history. The basic RNN architecture updates a hidden state $\mathbf{h}_t \in \mathbb{R}^h$ at each time step based on the current input $\mathbf{x}_t$ and previous hidden state: $\mathbf{h}_t = \sigma(\mathbf{W}_h\mathbf{h}_{t-1} + \mathbf{W}_x\mathbf{x}_t + \mathbf{b}_h)$ where $\sigma$ is a nonlinear activation function, $\mathbf{W}_h \in \mathbb{R}^{h \times h}$ governs the evolution of hidden states, $\mathbf{W}_x \in \mathbb{R}^{h \times d}$ maps inputs to the hidden space, and $\mathbf{b}_h$ is a bias term. Predictions are generated from the hidden state through $\hat{y}_t = g(\mathbf{W}_y\mathbf{h}_t + \mathbf{b}_y)$ where $g$ is an appropriate output activation such as sigmoid for binary classification or softmax for multi-class problems.
While elegant in formulation, basic RNNs suffer from vanishing and exploding gradient problems when processing long sequences, as gradients must propagate back through many time steps during training. Gradients can decay exponentially with sequence length, making it difficult to learn long-range dependencies essential for clinical prediction where relevant information may be separated by many hours or days. Hochreiter and Schmidhuber (1997) introduced Long Short-Term Memory (LSTM) networks to address these limitations through a sophisticated gating mechanism that enables selective information retention and forgetting.
The LSTM architecture maintains both a hidden state $\mathbf{h}_t$ and a cell state $\mathbf{c}_t$ that serves as a pathway for information flow across time steps. Three gates control information flow: the forget gate $\mathbf{f}_t = \sigma(\mathbf{W}_f[\mathbf{h}_{t-1}, \mathbf{x}_t] + \mathbf{b}_f)$ determines what information to discard from the cell state, the input gate $\mathbf{i}_t = \sigma(\mathbf{W}_i[\mathbf{h}_{t-1}, \mathbf{x}_t] + \mathbf{b}_i)$ controls what new information to store, and the output gate $\mathbf{o}_t = \sigma(\mathbf{W}_o[\mathbf{h}_{t-1}, \mathbf{x}_t] + \mathbf{b}_o)$ determines what to output based on the cell state. The cell state updates through $\tilde{\mathbf{c}}_t = \tanh(\mathbf{W}_c[\mathbf{h}_{t-1}, \mathbf{x}_t] + \mathbf{b}_c)$ as a candidate update, then $\mathbf{c}_t = \mathbf{f}_t \odot \mathbf{c}_{t-1} + \mathbf{i}_t \odot \tilde{\mathbf{c}}_t$ combining selective forgetting and addition. The hidden state becomes $\mathbf{h}_t = \mathbf{o}_t \odot \tanh(\mathbf{c}_t)$.
The LSTM gating mechanism enables learning which information is relevant over different time scales, crucial for clinical applications where some variables like daily weights inform long-term fluid status while others like minute-to-minute heart rate changes indicate acute deterioration. However, standard LSTM implementations assume regularly spaced observations and do not explicitly account for time intervals between observations or missing data patterns common in clinical settings.
To handle irregular sampling, we can incorporate time intervals directly into the model architecture. The time-aware LSTM proposed by Baytas et al. (2017) modifies the forget gate to account for elapsed time: $\mathbf{f}_t = \sigma(\mathbf{W}_f[\mathbf{h}_{t-1}, \mathbf{x}_t] + \mathbf{W}_{\delta}\delta_t + \mathbf{b}_f)$ where $\delta_t = t_t - t_{t-1}$ is the time gap. This allows the model to discount information more heavily when longer intervals have elapsed, capturing the intuition that observations become less relevant over time. More sophisticated approaches introduce decay functions: $\mathbf{c}_t = \mathbf{f}_t \odot \mathbf{c}_{t-1} \odot \exp(-\delta_t/\tau) + \mathbf{i}_t \odot \tilde{\mathbf{c}}_t$ where $\tau$ controls the decay rate, enabling continuous-time modeling of information relevance.
For missing data, several strategies exist. Simple approaches use indicator variables: augmenting the input $[\mathbf{x}_t, \mathbf{m}_t]$ where $\mathbf{m}_t$ is a missingness mask allows the model to learn separate representations for observed and missing values. GRU-D developed by Che et al. (2018) takes a more principled approach, incorporating trainable decay parameters: $\mathbf{x}_t' = \mathbf{m}_t \odot \mathbf{x}_t + (1 - \mathbf{m}_t) \odot (\mathbf{x}_{t-1}' \odot \exp(-\delta_t \mathbf{W}_{\gamma}) + \mathbf{\mu})$ where $\mathbf{W}_{\gamma}$ are learned decay weights and $\mathbf{\mu}$ are empirical means. This formulation combines last observation carried forward with learned decay toward population means, allowing the model to adapt to different missingness patterns during training.
Phased LSTM introduced by Neil et al. (2016) provides another approach through learnable periodic gates: $k_t = \frac{\text{mod}(t, \tau_k)}{\tau_k}$ where $\tau_k$ is a period parameter, then $\phi_t = \begin{cases} \frac{2k_t}{r_k} & \text{if } k_t \lt \frac{r_k}{2} \\ 2 - \frac{2k_t}{r_k} & \text{if } \frac{r_k}{2} \leq k_t \lt r_k \\ \alpha_k & \text{otherwise} \end{cases}$ with parameters $r_k$ controlling gate openness duration and $\alpha_k$ controlling leak. The phased LSTM output becomes $\mathbf{h}_t = \phi_t \odot \mathbf{h}_{\text{LSTM},t} + (1-\phi_t) \odot \mathbf{h}_{t-1}$ enabling the model to learn when to update based on input timing, useful for clinical data where physiological processes have intrinsic periodicities.
From an equity perspective, RNN architectures risk learning spurious correlations between observation frequency and outcomes. A model trained predominantly on ICU data where deteriorating patients receive more frequent monitoring may learn that observation frequency itself predicts outcomes, then generalize poorly to ward settings where baseline monitoring is less frequent. This creates a form of shortcut learning where the model exploits dataset biases rather than learning true causal relationships between patient states and outcomes.
To mitigate these risks, we can employ several strategies. First, we can explicitly model the observation process separately from patient state evolution through dual-pathway architectures. One pathway models patient clinical trajectory: $\mathbf{h}_t^{\text{clinical}} = \text{LSTM}(\mathbf{x}_t, \mathbf{h}_{t-1}^{\text{clinical}})$ while another models observation patterns: $\mathbf{h}_t^{\text{obs}} = \text{LSTM}(\mathbf{m}_t, \delta_t, \mathbf{h}_{t-1}^{\text{obs}})$. Predictions combine both pathways through $\hat{y}_t = g([\mathbf{h}_t^{\text{clinical}}, \mathbf{h}_t^{\text{obs}}])$ but we can apply regularization encouraging the model to rely primarily on clinical features while using observation patterns only for calibration purposes.
Second, we can use adversarial debiasing techniques adapted to temporal settings. We train a primary LSTM predictor while simultaneously training an adversary that attempts to predict sensitive attributes from the hidden states: $\hat{s}_t = f_{\text{adv}}(\mathbf{h}_t)$. The primary model is trained to minimize prediction loss while maximizing adversary loss through a gradient reversal layer, encouraging representations that are informative for the clinical task but uninformative about protected attributes. This approach, built on work by Zhang et al. (2018) and Madras et al. (2018), helps prevent the model from exploiting correlations between observation patterns and sensitive attributes.
Third, we can implement fairness constraints directly in the loss function. For a binary classification task, we can add a term penalizing disparate false negative rates across groups: $\mathcal{L} = \mathcal{L}_{\text{task}} + \lambda\sum_{s,s' \in \mathcal{S}} \lvert \text{FNR}_s - \text{FNR}_{s'} \rvert$ where $\text{FNR}_s = \frac{\sum_{i:S_i=s,y_i=1}\mathbb{1}[\hat{y}_i=0]}{\sum_{i:S_i=s}y_i}$ is the false negative rate for group $s$. This formulation directly optimizes for equalized false negative rates, crucial for early warning systems where missing deterioration events (false negatives) can have severe consequences. However, computing group-wise metrics requires access to sensitive attributes during training, raising privacy concerns that must be carefully addressed through techniques like differential privacy.
Implementation: Production RNN for Clinical Deterioration
We now implement a production-quality RNN system for predicting clinical deterioration that explicitly handles irregularly sampled data, missing values, and fairness constraints. Our implementation draws on principles from successful systems like the Modified Early Warning Score (MEWS) but leverages deep learning to learn complex temporal patterns from data while maintaining interpretability and fairness properties.
from typing import Dict, List, Optional, Tuple
import numpy as np
import torch
import torch.nn as nn
from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence
from dataclasses import dataclass
import warnings
@dataclass
class ClinicalSequenceConfig:
"""Configuration for clinical sequence modeling."""
input_dim: int
hidden_dim: int
num_layers: int
dropout: float = 0.2
bidirectional: bool = False
use_time_aware: bool = True
use_missingness_indicators: bool = True
fairness_weight: float = 0.1
class TimeAwareLSTMCell(nn.Module):
"""
LSTM cell with time-aware decay mechanism for irregularly sampled clinical data.
This cell incorporates elapsed time between observations into the forget gate,
allowing the model to appropriately discount information as time passes. This
is crucial for clinical applications where observation intervals vary from
minutes to days based on care setting and patient acuity.
"""
def __init__(
self,
input_dim: int,
hidden_dim: int,
use_time_aware: bool = True
) -> None:
super().__init__()
self.input_dim = input_dim
self.hidden_dim = hidden_dim
self.use_time_aware = use_time_aware
# Standard LSTM gates with additional time dimension if time-aware
time_dim = 1 if use_time_aware else 0
self.Wf = nn.Linear(input_dim + hidden_dim + time_dim, hidden_dim)
self.Wi = nn.Linear(input_dim + hidden_dim + time_dim, hidden_dim)
self.Wc = nn.Linear(input_dim + hidden_dim + time_dim, hidden_dim)
self.Wo = nn.Linear(input_dim + hidden_dim + time_dim, hidden_dim)
def forward(
self,
x: torch.Tensor,
h_prev: torch.Tensor,
c_prev: torch.Tensor,
delta_t: Optional[torch.Tensor] = None
) -> Tuple[torch.Tensor, torch.Tensor]:
"""
Forward pass incorporating time intervals.
Args:
x: Input features [batch_size, input_dim]
h_prev: Previous hidden state [batch_size, hidden_dim]
c_prev: Previous cell state [batch_size, hidden_dim]
delta_t: Time since last observation [batch_size, 1]
Returns:
Tuple of new hidden state and cell state
"""
if self.use_time_aware and delta_t is not None:
# Concatenate time interval with input and hidden state
combined = torch.cat([x, h_prev, delta_t], dim=1)
else:
combined = torch.cat([x, h_prev], dim=1)
# Compute gates with time-dependent forgetting
f = torch.sigmoid(self.Wf(combined))
i = torch.sigmoid(self.Wi(combined))
c_tilde = torch.tanh(self.Wc(combined))
o = torch.sigmoid(self.Wo(combined))
# Update cell state with time-aware decay
if self.use_time_aware and delta_t is not None:
# Exponential decay of cell state based on elapsed time
# Longer intervals lead to more aggressive forgetting
decay = torch.exp(-delta_t)
c = f * c_prev * decay + i * c_tilde
else:
c = f * c_prev + i * c_tilde
h = o * torch.tanh(c)
return h, c
class ClinicalLSTM(nn.Module):
"""
LSTM network for clinical time series with equity considerations.
This model handles irregularly sampled observations, missing data, and
includes provisions for fairness constraints. The architecture explicitly
models both clinical state evolution and observation patterns to avoid
learning spurious correlations between monitoring frequency and outcomes.
"""
def __init__(self, config: ClinicalSequenceConfig) -> None:
super().__init__()
self.config = config
# Adjust input dimension if using missingness indicators
effective_input_dim = config.input_dim
if config.use_missingness_indicators:
# Double input dimension to include missingness masks
effective_input_dim = config.input_dim * 2
# Clinical state pathway - learns patient condition dynamics
self.clinical_lstm = nn.LSTM(
input_size=effective_input_dim,
hidden_size=config.hidden_dim,
num_layers=config.num_layers,
dropout=config.dropout if config.num_layers > 1 else 0,
bidirectional=config.bidirectional,
batch_first=True
)
# Observation pattern pathway - learns monitoring patterns
# This helps separate clinical state from access-related observation patterns
self.observation_lstm = nn.LSTM(
input_size=config.input_dim, # Just missingness indicators
hidden_size=config.hidden_dim // 2,
num_layers=1,
batch_first=True
)
# Time-aware cells for handling irregular sampling
if config.use_time_aware:
self.time_cells = nn.ModuleList([
TimeAwareLSTMCell(
effective_input_dim if i == 0 else config.hidden_dim,
config.hidden_dim,
use_time_aware=True
) for i in range(config.num_layers)
])
# Prediction head combines both pathways
lstm_output_dim = config.hidden_dim * (2 if config.bidirectional else 1)
combined_dim = lstm_output_dim + config.hidden_dim // 2
self.predictor = nn.Sequential(
nn.Linear(combined_dim, config.hidden_dim),
nn.ReLU(),
nn.Dropout(config.dropout),
nn.Linear(config.hidden_dim, 1),
nn.Sigmoid()
)
# Adversarial head for fairness - tries to predict sensitive attributes
# from learned representations. Gradient reversal during training
# encourages representations uninformative about protected attributes
self.adversary = nn.Sequential(
nn.Linear(lstm_output_dim, config.hidden_dim // 2),
nn.ReLU(),
nn.Dropout(config.dropout),
nn.Linear(config.hidden_dim // 2, 1),
nn.Sigmoid()
)
def forward(
self,
x: torch.Tensor,
mask: torch.Tensor,
delta_t: torch.Tensor,
lengths: torch.Tensor,
sensitive_attr: Optional[torch.Tensor] = None
) -> Dict[str, torch.Tensor]:
"""
Forward pass through the network.
Args:
x: Input features [batch_size, seq_len, input_dim]
mask: Missingness indicators [batch_size, seq_len, input_dim]
delta_t: Time since last observation [batch_size, seq_len, 1]
lengths: Actual sequence lengths for each sample [batch_size]
sensitive_attr: Protected attributes for fairness [batch_size, 1]
Returns:
Dictionary with predictions and auxiliary outputs
"""
batch_size, seq_len, _ = x.shape
# Prepare input with missingness indicators
if self.config.use_missingness_indicators:
# Concatenate observations with missingness masks
# This allows model to learn different representations for
# observed vs. missing values
x_input = torch.cat([x, mask], dim=-1)
else:
x_input = x
# Pack sequences for efficient processing of variable-length sequences
x_packed = pack_padded_sequence(
x_input,
lengths.cpu(),
batch_first=True,
enforce_sorted=False
)
# Clinical pathway - processes actual measurements
clinical_output, (h_clinical, c_clinical) = self.clinical_lstm(x_packed)
clinical_output, _ = pad_packed_sequence(
clinical_output,
batch_first=True,
total_length=seq_len
)
# Observation pathway - processes missingness patterns
# This helps separate clinical deterioration signals from
# observation frequency patterns that may reflect access barriers
mask_packed = pack_padded_sequence(
mask,
lengths.cpu(),
batch_first=True,
enforce_sorted=False
)
obs_output, (h_obs, c_obs) = self.observation_lstm(mask_packed)
obs_output, _ = pad_packed_sequence(
obs_output,
batch_first=True,
total_length=seq_len
)
# Use last valid output from each sequence
idx = (lengths - 1).view(-1, 1, 1).expand(-1, 1, clinical_output.size(2))
last_clinical = clinical_output.gather(1, idx).squeeze(1)
idx_obs = (lengths - 1).view(-1, 1, 1).expand(-1, 1, obs_output.size(2))
last_obs = obs_output.gather(1, idx_obs).squeeze(1)
# Combine both pathways for final prediction
combined = torch.cat([last_clinical, last_obs], dim=-1)
predictions = self.predictor(combined)
outputs = {
'predictions': predictions,
'clinical_hidden': last_clinical,
'obs_hidden': last_obs
}
# If sensitive attributes provided, compute adversary predictions
# for fairness regularization during training
if sensitive_attr is not None:
# Apply gradient reversal layer conceptually
# (actual implementation would use custom autograd function)
adv_pred = self.adversary(last_clinical.detach())
outputs['adversary_pred'] = adv_pred
return outputs
class FairClinicalDeterioration:
"""
Complete system for clinical deterioration prediction with fairness constraints.
This class implements the full training and inference pipeline including
data preprocessing, model training with fairness constraints, and evaluation
with equity metrics. Designed for production deployment in diverse clinical
environments.
"""
def __init__(self, config: ClinicalSequenceConfig) -> None:
self.config = config
self.model = ClinicalLSTM(config)
self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
self.model.to(self.device)
def preprocess_sequence(
self,
observations: List[Dict[str, float]],
timestamps: List[float],
features: List[str]
) -> Dict[str, np.ndarray]:
"""
Preprocess clinical time series handling irregular sampling and missing data.
Args:
observations: List of observation dictionaries
timestamps: Corresponding timestamps
features: Feature names to extract
Returns:
Dictionary with processed arrays
"""
seq_len = len(observations)
n_features = len(features)
# Initialize arrays
x = np.zeros((seq_len, n_features), dtype=np.float32)
mask = np.zeros((seq_len, n_features), dtype=np.float32)
delta_t = np.zeros((seq_len, 1), dtype=np.float32)
# Fill in observed values and create missingness indicators
for t, obs in enumerate(observations):
for i, feat in enumerate(features):
if feat in obs and obs[feat] is not None:
x[t, i] = obs[feat]
mask[t, i] = 1.0
# If missing, x[t,i] remains 0, mask[t,i] remains 0
# Compute time since last observation
if t > 0:
delta_t[t, 0] = timestamps[t] - timestamps[t-1]
# Forward fill missing values for numerical stability
# while preserving missingness indicators for the model
for i in range(n_features):
last_valid = None
for t in range(seq_len):
if mask[t, i] == 1.0:
last_valid = x[t, i]
elif last_valid is not None:
x[t, i] = last_valid
# If never observed, remains 0
# Normalize time intervals to reasonable scale (hours)
delta_t = delta_t / 3600.0
return {
'x': x,
'mask': mask,
'delta_t': delta_t,
'length': seq_len
}
def compute_fairness_loss(
self,
predictions: torch.Tensor,
labels: torch.Tensor,
sensitive_attr: torch.Tensor
) -> torch.Tensor:
"""
Compute fairness loss penalizing disparate false negative rates.
For early warning systems, false negatives (missed deterioration) can
have severe consequences. We ensure the model doesn't systematically
miss deterioration events in certain patient populations.
Args:
predictions: Model predictions [batch_size, 1]
labels: True labels [batch_size, 1]
sensitive_attr: Protected attributes [batch_size, 1]
Returns:
Fairness loss term
"""
# Identify unique groups
unique_groups = torch.unique(sensitive_attr)
if len(unique_groups) < 2:
# No fairness constraint needed if only one group present
return torch.tensor(0.0, device=predictions.device)
# Compute false negative rate for each group
fnr_by_group = []
for group in unique_groups:
group_mask = (sensitive_attr == group).squeeze()
group_labels = labels[group_mask]
group_preds = predictions[group_mask]
# Count false negatives: actual positive but predicted negative
positives = (group_labels == 1).sum().float()
if positives > 0:
false_negatives = ((group_labels == 1) & (group_preds < 0.5)).sum().float()
fnr = false_negatives / positives
else:
fnr = torch.tensor(0.0, device=predictions.device)
fnr_by_group.append(fnr)
# Compute pairwise FNR differences
fnr_tensor = torch.stack(fnr_by_group)
fairness_loss = torch.tensor(0.0, device=predictions.device)
for i in range(len(fnr_by_group)):
for j in range(i + 1, len(fnr_by_group)):
fairness_loss += torch.abs(fnr_tensor[i] - fnr_tensor[j])
return fairness_loss
def train(
self,
train_loader: torch.utils.data.DataLoader,
val_loader: torch.utils.data.DataLoader,
num_epochs: int = 50,
learning_rate: float = 0.001
) -> Dict[str, List[float]]:
"""
Train the model with fairness constraints.
Args:
train_loader: Training data loader
val_loader: Validation data loader
num_epochs: Number of training epochs
learning_rate: Learning rate for optimizer
Returns:
Dictionary with training history
"""
optimizer = torch.optim.Adam(self.model.parameters(), lr=learning_rate)
criterion = nn.BCELoss()
history = {
'train_loss': [],
'val_loss': [],
'train_fairness': [],
'val_fairness': []
}
for epoch in range(num_epochs):
# Training phase
self.model.train()
train_loss = 0.0
train_fairness = 0.0
for batch in train_loader:
x = batch['x'].to(self.device)
mask = batch['mask'].to(self.device)
delta_t = batch['delta_t'].to(self.device)
lengths = batch['length']
labels = batch['label'].to(self.device)
sensitive = batch.get('sensitive_attr')
if sensitive is not None:
sensitive = sensitive.to(self.device)
optimizer.zero_grad()
# Forward pass
outputs = self.model(x, mask, delta_t, lengths, sensitive)
predictions = outputs['predictions']
# Compute task loss
task_loss = criterion(predictions, labels)
# Compute fairness loss if sensitive attributes available
if sensitive is not None:
fairness_loss = self.compute_fairness_loss(
predictions,
labels,
sensitive
)
total_loss = task_loss + self.config.fairness_weight * fairness_loss
train_fairness += fairness_loss.item()
else:
total_loss = task_loss
# Backward pass
total_loss.backward()
# Gradient clipping for stability
torch.nn.utils.clip_grad_norm_(self.model.parameters(), max_norm=1.0)
optimizer.step()
train_loss += task_loss.item()
# Validation phase
self.model.eval()
val_loss = 0.0
val_fairness = 0.0
with torch.no_grad():
for batch in val_loader:
x = batch['x'].to(self.device)
mask = batch['mask'].to(self.device)
delta_t = batch['delta_t'].to(self.device)
lengths = batch['length']
labels = batch['label'].to(self.device)
sensitive = batch.get('sensitive_attr')
if sensitive is not None:
sensitive = sensitive.to(self.device)
outputs = self.model(x, mask, delta_t, lengths, sensitive)
predictions = outputs['predictions']
task_loss = criterion(predictions, labels)
val_loss += task_loss.item()
if sensitive is not None:
fairness_loss = self.compute_fairness_loss(
predictions,
labels,
sensitive
)
val_fairness += fairness_loss.item()
# Record history
history['train_loss'].append(train_loss / len(train_loader))
history['val_loss'].append(val_loss / len(val_loader))
history['train_fairness'].append(train_fairness / len(train_loader))
history['val_fairness'].append(val_fairness / len(val_loader))
if (epoch + 1) % 10 == 0:
print(f"Epoch {epoch+1}/{num_epochs}")
print(f" Train Loss: {history['train_loss'][-1]:.4f}, "
f"Fairness: {history['train_fairness'][-1]:.4f}")
print(f" Val Loss: {history['val_loss'][-1]:.4f}, "
f"Fairness: {history['val_fairness'][-1]:.4f}")
return history
def evaluate_equity_metrics(
self,
test_loader: torch.utils.data.DataLoader
) -> Dict[str, Dict[str, float]]:
"""
Evaluate model with stratified equity metrics.
Computes performance metrics separately for different patient groups
to identify potential disparities in model performance across populations.
Args:
test_loader: Test data loader
Returns:
Dictionary of metrics by group
"""
self.model.eval()
# Collect predictions and labels by group
results_by_group: Dict[int, Dict[str, List]] = {}
with torch.no_grad():
for batch in test_loader:
x = batch['x'].to(self.device)
mask = batch['mask'].to(self.device)
delta_t = batch['delta_t'].to(self.device)
lengths = batch['length']
labels = batch['label'].cpu().numpy()
sensitive = batch.get('sensitive_attr')
if sensitive is None:
warnings.warn("No sensitive attributes provided for equity evaluation")
continue
sensitive = sensitive.cpu().numpy()
outputs = self.model(x, mask, delta_t, lengths, None)
predictions = outputs['predictions'].cpu().numpy()
# Organize by group
for group in np.unique(sensitive):
if group not in results_by_group:
results_by_group[group] = {
'predictions': [],
'labels': []
}
group_mask = sensitive.flatten() == group
results_by_group[group]['predictions'].extend(
predictions[group_mask].flatten()
)
results_by_group[group]['labels'].extend(
labels[group_mask].flatten()
)
# Compute metrics for each group
metrics_by_group = {}
for group, data in results_by_group.items():
preds = np.array(data['predictions'])
labels = np.array(data['labels'])
# Binarize predictions
binary_preds = (preds >= 0.5).astype(int)
# Compute confusion matrix elements
tp = np.sum((binary_preds == 1) & (labels == 1))
tn = np.sum((binary_preds == 0) & (labels == 0))
fp = np.sum((binary_preds == 1) & (labels == 0))
fn = np.sum((binary_preds == 0) & (labels == 1))
# Compute metrics with safe division
sensitivity = tp / (tp + fn) if (tp + fn) > 0 else 0.0
specificity = tn / (tn + fp) if (tn + fp) > 0 else 0.0
ppv = tp / (tp + fp) if (tp + fp) > 0 else 0.0
npv = tn / (tn + fn) if (tn + fn) > 0 else 0.0
metrics_by_group[f'group_{int(group)}'] = {
'sensitivity': float(sensitivity),
'specificity': float(specificity),
'ppv': float(ppv),
'npv': float(npv),
'n_samples': len(labels)
}
return metrics_by_group
This implementation provides a production-ready system that handles the key challenges of clinical time series: irregular sampling through time-aware LSTM cells, missing data through explicit missingness indicators and dual-pathway architecture, and fairness through adversarial debiasing and explicit false negative rate constraints. The system can be trained end-to-end and deployed for real-time clinical deterioration prediction while maintaining equity across patient populations.
Temporal Convolutional Networks for Clinical Applications
While recurrent architectures like LSTMs are natural for sequential modeling, temporal convolutional networks (TCNs) offer compelling alternatives with distinct advantages for clinical applications. TCNs apply causal convolutions across the temporal dimension, enabling parallel processing of sequences and capturing long-range dependencies through dilated convolutions rather than recurrent connections. The absence of recurrent connections eliminates vanishing gradient problems and enables more efficient training on modern hardware architectures optimized for convolutional operations.
A temporal convolutional layer applies one-dimensional convolution across time while preserving temporal ordering through causal padding. For input sequence $\mathbf{x} = [\mathbf{x}_1, ..., \mathbf{x}_T]$ with $\mathbf{x}_t \in \mathbb{R}^d$, the convolution at time $t$ with kernel $\mathbf{W} \in \mathbb{R}^{k \times d \times d'}$ of size $k$ produces $\mathbf{h}_t = \sum_{i=0}^{k-1}\mathbf{W}_i \mathbf{x}_{t-i}$, where we set $\mathbf{x}_j = \mathbf{0}$ for $j \lt 1$. This formulation ensures that predictions at time $t$ depend only on current and past observations, never future ones, maintaining causality essential for real-time clinical prediction.
To capture long-range dependencies without excessive parameters, TCNs employ dilated convolutions introduced by Yu and Koltun (2016) and van den Oord et al. (2016). A dilated convolution with dilation factor $r$ skips $r-1$ time steps between kernel applications: $\mathbf{h}_t = \sum_{i=0}^{k-1}\mathbf{W}_i \mathbf{x}_{t-r \cdot i}$. Stacking layers with exponentially increasing dilation factors creates a receptive field that grows exponentially with depth. A network with $L$ layers, kernel size $k$, and dilation factors $r_\ell = 2^\ell$ achieves receptive field size $\text{RF} = 1 + \sum_{\ell=0}^{L-1}2(k-1)2^\ell = 1 + 2(k-1)(2^L - 1)$, enabling modeling of dependencies spanning hundreds of time steps with modest network depth.
For clinical applications, TCNs offer several advantages over RNNs. First, the parallel architecture enables efficient processing of long sequences common in hospitalization records spanning days or weeks. Training throughput can be orders of magnitude faster than sequential RNN processing. Second, the fixed receptive field provides more interpretable influence of past observations on current predictions. Third, TCNs naturally handle variable-length sequences through masking without the need for sequence packing and unpacking required by RNNs. Fourth, the hierarchical feature learning through layers mirrors clinical reasoning where short-term changes in vital signs combine to indicate evolving patient states.
However, TCNs also present challenges for clinical deployment. The fixed receptive field means the network cannot adapt its temporal horizon dynamically based on patient state, unlike LSTMs whose gating mechanisms enable flexible information retention. For irregularly sampled clinical data, applying convolutions with fixed kernel spacing requires careful preprocessing. Missing data patterns that correlate with patient characteristics can be more difficult to model without explicit recurrent state. From an equity perspective, TCNs risk learning shortcuts based on observation frequency if preprocessing aggregates data into fixed time windows, as patients with more frequent monitoring will have denser representations.
To address irregular sampling in TCNs, we can employ several strategies. Time-aware TCNs incorporate elapsed time as an additional channel: $\tilde{\mathbf{x}}_t = [\mathbf{x}_t, \delta_t, \mathbf{m}_t]$ where $\delta_t$ is time since the last observation and $\mathbf{m}_t$ indicates missingness. The convolution then operates on this augmented representation, allowing learned kernels to account for varying time intervals. Alternatively, we can use continuous convolutions that explicitly parameterize kernel weights as functions of time: $\mathbf{h}_t = \sum_{j:t_j \lt t}\mathbf{W}(t - t_j)\mathbf{x}_j$, where $\mathbf{W}(\cdot)$ is a neural network mapping time differences to kernel weights, enabling adaptation to irregular sampling patterns.
For fairness in TCNs, we can implement techniques parallel to those used for RNNs. Dual-pathway architectures can separate clinical features from observation patterns, training one TCN on observed values and another on missingness indicators. Adversarial training can encourage learned representations that are predictive of outcomes but uninformative about sensitive attributes. Group-specific batch normalization can adapt feature distributions across populations while sharing convolutional filters, helping the model maintain performance across groups with different baseline characteristics.
The architectural choice between RNNs and TCNs often depends on specific application requirements. For real-time predictions where computational efficiency is critical and sequences are long, TCNs may be preferable. For applications requiring explicit modeling of information flow and adaptive temporal horizons, LSTMs may be more appropriate. In practice, hybrid architectures combining both approaches can leverage complementary strengths, using TCNs for efficient feature extraction from long sequences followed by LSTM layers for final prediction integrating learned temporal features with explicit state tracking.
Attention Mechanisms for Interpretable Temporal Predictions
Attention mechanisms have revolutionized sequence modeling by enabling models to dynamically focus on relevant portions of the input when making predictions. Introduced by Bahdanau et al. (2015) for machine translation and extended broadly by Vaswani et al. (2017) in the Transformer architecture, attention provides both performance improvements and interpretability crucial for clinical deployment. For temporal clinical prediction, attention can identify which past observations most influence current predictions, helping clinicians understand model reasoning and enabling detection of spurious patterns.
The attention mechanism computes a weighted sum of sequence elements where weights reflect relevance to the current prediction. Given a sequence of hidden states $\mathbf{H} = [\mathbf{h}_1, ..., \mathbf{h}_T]$ with $\mathbf{h}_t \in \mathbb{R}^d$ from an encoder, we compute attention weights $\alpha_t$ and a context vector $\mathbf{c}$. The additive attention mechanism computes $e_t = \mathbf{v}^\top\tanh(\mathbf{W}_h\mathbf{h}_t + \mathbf{W}_s\mathbf{s} + \mathbf{b})$, where $\mathbf{s}$ is a query vector (such as a decoder state), $\mathbf{W}_h$ and $\mathbf{W}_s$ are weight matrices, $\mathbf{v}$ is a learned vector, and $\mathbf{b}$ is a bias. Attention weights normalize energies through softmax: $\alpha_t = \frac{\exp(e_t)}{\sum_{j=1}^T \exp(e_j)}$, yielding the context vector $\mathbf{c} = \sum_{t=1}^T \alpha_t \mathbf{h}_t$ as a weighted combination of all hidden states.
Scaled dot-product attention, used in Transformers, offers computational advantages. For query $\mathbf{q} \in \mathbb{R}^{d_k}$, keys $\mathbf{K} = [\mathbf{k}_1, ..., \mathbf{k}_T] \in \mathbb{R}^{T \times d_k}$, and values $\mathbf{V} = [\mathbf{v}_1, ..., \mathbf{v}_T] \in \mathbb{R}^{T \times d_v}$, attention computes $\text{Attention}(\mathbf{q}, \mathbf{K}, \mathbf{V}) = \text{softmax}\left(\frac{\mathbf{q}\mathbf{K}^\top}{\sqrt{d_k}}\right)\mathbf{V}$. The scaling factor $1/\sqrt{d_k}$ prevents softmax saturation for large $d_k$. Multi-head attention applies this operation with different learned projections in parallel: $\text{MultiHead}(\mathbf{q}, \mathbf{K}, \mathbf{V}) = \text{Concat}(\text{head}_1, ..., \text{head}_h)\mathbf{W}^O$, where $\text{head}_i = \text{Attention}(\mathbf{q}\mathbf{W}_i^Q, \mathbf{K}\mathbf{W}_i^K, \mathbf{V}\mathbf{W}_i^V)$ and $\mathbf{W}_i^Q$, $\mathbf{W}_i^K$, $\mathbf{W}_i^V$, $\mathbf{W}^O$ are learned projection matrices.
For clinical time series, attention patterns can reveal which past observations most influence predictions. Attention weights $\alpha_t$ indicate the relative importance of time $t$ for the current prediction, enabling clinicians to inspect which historical measurements the model deemed relevant. This interpretability is crucial for clinical trust and can help identify when models rely on spurious correlations. For example, if a deterioration prediction model consistently places high attention on time points with frequent observations rather than abnormal values, this suggests the model may be exploiting observation frequency rather than clinical state.
However, attention mechanisms also introduce equity challenges. If training data contains systematic differences in observation patterns across populations, attention may learn to focus on features correlated with sensitive attributes rather than clinically relevant patterns. A model trained predominantly on well-resourced ICU data may learn that high-frequency monitoring itself predicts good outcomes, then assign high attention weights to observation frequency. When deployed in under-resourced settings with less frequent monitoring, the model may systematically underestimate risk for patients who are inadequately monitored due to resource constraints.
To address these challenges, we can implement fairness-aware attention mechanisms. Constrained attention restricts which features attention can focus on, explicitly preventing attention over observation frequency or other proxies for access to care. We can define a mask $\mathbf{M}_{\text{clinical}} \in \{0,1\}^T$ indicating clinically appropriate features, then modify attention to $\alpha_t = \frac{\exp(e_t) \cdot M_{\text{clinical},t}}{\sum_{j=1}^T \exp(e_j) \cdot M_{\text{clinical},j}}$, ensuring attention focuses only on valid clinical features. Adversarial attention training can encourage attention patterns that are similar across population groups. We train an adversary that attempts to predict sensitive attributes from attention weights $\boldsymbol{\alpha}$, using gradient reversal to encourage attention patterns uninformative about protected attributes while maintaining predictive accuracy.
Group-normalized attention adapts attention computation for different populations while maintaining shared representations. We compute group-specific parameters: $e_{t,s} = \mathbf{v}_s^\top\tanh(\mathbf{W}_h\mathbf{h}_t + \mathbf{W}_s\mathbf{s} + \mathbf{b}_s)$ where $\mathbf{v}_s, \mathbf{b}_s$ are group-specific while $\mathbf{W}_h, \mathbf{W}_s$ are shared. This allows attention patterns to adapt to different baseline observation patterns across groups while maintaining consistent clinical reasoning in the shared encoder.
For temporal clinical prediction, self-attention enables the model to integrate information across all time points simultaneously rather than sequentially. Each position can attend to all others, creating rich representations that capture complex temporal dependencies. The Transformer architecture stacks multiple self-attention layers with position-wise feed-forward networks, enabling deep hierarchical temporal reasoning. For clinical sequences, we augment standard positional encoding with clinical time information. Rather than just position index $t$, we encode actual elapsed time $\tau_t$ using learned embeddings: $\text{PE}(\tau_t, 2i) = \sin(\omega_i \tau_t)$ and $\text{PE}(\tau_t, 2i+1) = \cos(\omega_i \tau_t)$ where $\omega_i = 1/10000^{2i/d}$ are learned frequencies, enabling the model to capture temporal patterns at multiple scales.
Case Study: Equity-Aware Early Warning System Implementation
We now implement a complete early warning system for clinical deterioration that integrates attention mechanisms with explicit fairness constraints. This system builds on the Modified Early Warning Score (MEWS) clinical framework but learns temporal patterns from data while ensuring equitable performance across patient populations. The implementation demonstrates production-ready code suitable for deployment in diverse clinical settings.
from typing import Dict, List, Optional, Tuple, Union
import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
from dataclasses import dataclass
import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
@dataclass
class TransformerConfig:
"""Configuration for clinical Transformer model."""
d_model: int = 256
n_heads: int = 8
n_layers: int = 4
d_ff: int = 1024
dropout: float = 0.1
max_seq_length: int = 168 # 1 week at hourly resolution
fairness_weight: float = 0.15
attention_fairness_weight: float = 0.05
class TemporalPositionalEncoding(nn.Module):
"""
Positional encoding that incorporates actual elapsed time rather than
just sequence position. This is crucial for irregularly sampled clinical
data where position in sequence doesn't reflect actual temporal relationships.
"""
def __init__(self, d_model: int, max_length: int = 5000) -> None:
super().__init__()
self.d_model = d_model
# Create learnable time embeddings
self.time_embedding = nn.Linear(1, d_model)
# Also maintain standard positional encodings as backup
position = torch.arange(max_length).unsqueeze(1)
div_term = torch.exp(
torch.arange(0, d_model, 2) * (-np.log(10000.0) / d_model)
)
pe = torch.zeros(max_length, d_model)
pe[:, 0::2] = torch.sin(position * div_term)
pe[:, 1::2] = torch.cos(position * div_term)
self.register_buffer('pe', pe)
def forward(
self,
x: torch.Tensor,
timestamps: torch.Tensor
) -> torch.Tensor:
"""
Args:
x: Input tensor [batch_size, seq_len, d_model]
timestamps: Actual timestamps [batch_size, seq_len, 1] in hours
Returns:
Position-encoded tensor
"""
# Combine learned time embeddings with positional encodings
time_emb = self.time_embedding(timestamps)
pos_emb = self.pe[:x.size(1), :].unsqueeze(0)
return x + time_emb + pos_emb
class FairnessAwareMultiHeadAttention(nn.Module):
"""
Multi-head attention with fairness constraints to prevent learning
spurious correlations between observation frequency and outcomes.
"""
def __init__(
self,
d_model: int,
n_heads: int,
dropout: float = 0.1,
fairness_aware: bool = True
) -> None:
super().__init__()
assert d_model % n_heads == 0, "d_model must be divisible by n_heads"
self.d_model = d_model
self.n_heads = n_heads
self.d_k = d_model // n_heads
self.fairness_aware = fairness_aware
# Projection matrices
self.W_q = nn.Linear(d_model, d_model)
self.W_k = nn.Linear(d_model, d_model)
self.W_v = nn.Linear(d_model, d_model)
self.W_o = nn.Linear(d_model, d_model)
self.dropout = nn.Dropout(dropout)
# If fairness-aware, add adversary to predict observation patterns
# from attention weights to discourage focusing on monitoring frequency
if fairness_aware:
self.attention_adversary = nn.Sequential(
nn.Linear(n_heads, 32),
nn.ReLU(),
nn.Dropout(dropout),
nn.Linear(32, 1),
nn.Sigmoid()
)
def forward(
self,
x: torch.Tensor,
mask: Optional[torch.Tensor] = None,
obs_frequency: Optional[torch.Tensor] = None
) -> Tuple[torch.Tensor, torch.Tensor, Optional[torch.Tensor]]:
"""
Forward pass with fairness-aware attention.
Args:
x: Input [batch_size, seq_len, d_model]
mask: Attention mask [batch_size, 1, 1, seq_len]
obs_frequency: Observation frequency for fairness loss [batch_size, seq_len]
Returns:
Tuple of (output, attention_weights, adversary_loss)
"""
batch_size, seq_len, _ = x.shape
# Project and split into heads
Q = self.W_q(x).view(batch_size, seq_len, self.n_heads, self.d_k)
K = self.W_k(x).view(batch_size, seq_len, self.n_heads, self.d_k)
V = self.W_v(x).view(batch_size, seq_len, self.n_heads, self.d_k)
# Transpose for attention: [batch, n_heads, seq_len, d_k]
Q = Q.transpose(1, 2)
K = K.transpose(1, 2)
V = V.transpose(1, 2)
# Scaled dot-product attention
scores = torch.matmul(Q, K.transpose(-2, -1)) / np.sqrt(self.d_k)
# Apply mask if provided
if mask is not None:
scores = scores.masked_fill(mask == 0, -1e9)
attention_weights = F.softmax(scores, dim=-1)
attention_weights = self.dropout(attention_weights)
# Apply attention to values
context = torch.matmul(attention_weights, V)
# Concatenate heads and project
context = context.transpose(1, 2).contiguous().view(
batch_size, seq_len, self.d_model
)
output = self.W_o(context)
# Compute adversarial loss if fairness-aware and obs_frequency provided
adv_loss = None
if self.fairness_aware and obs_frequency is not None:
# Average attention weights across sequence for each head
# Shape: [batch_size, n_heads, seq_len, seq_len] -> [batch_size, n_heads]
avg_attention = attention_weights.mean(dim=[2, 3])
# Try to predict observation frequency from attention patterns
# If adversary succeeds, attention is encoding observation patterns
obs_pred = self.attention_adversary(avg_attention)
# Compute adversarial loss (we want to maximize this during training
# through gradient reversal to prevent attention from encoding obs patterns)
target_obs = (obs_frequency.mean(dim=1, keepdim=True) > obs_frequency.median()).float()
adv_loss = F.binary_cross_entropy(obs_pred, target_obs)
# Average attention weights across heads for interpretability
attention_weights_avg = attention_weights.mean(dim=1)
return output, attention_weights_avg, adv_loss
class TransformerEncoderLayer(nn.Module):
"""Transformer encoder layer with fairness-aware attention."""
def __init__(self, config: TransformerConfig) -> None:
super().__init__()
self.attention = FairnessAwareMultiHeadAttention(
d_model=config.d_model,
n_heads=config.n_heads,
dropout=config.dropout,
fairness_aware=True
)
self.feed_forward = nn.Sequential(
nn.Linear(config.d_model, config.d_ff),
nn.ReLU(),
nn.Dropout(config.dropout),
nn.Linear(config.d_ff, config.d_model)
)
self.norm1 = nn.LayerNorm(config.d_model)
self.norm2 = nn.LayerNorm(config.d_model)
self.dropout = nn.Dropout(config.dropout)
def forward(
self,
x: torch.Tensor,
mask: Optional[torch.Tensor] = None,
obs_frequency: Optional[torch.Tensor] = None
) -> Tuple[torch.Tensor, torch.Tensor, Optional[torch.Tensor]]:
"""Forward pass through encoder layer."""
# Multi-head attention with residual connection
attn_output, attention_weights, adv_loss = self.attention(
x, mask, obs_frequency
)
x = self.norm1(x + self.dropout(attn_output))
# Feed-forward with residual connection
ff_output = self.feed_forward(x)
x = self.norm2(x + self.dropout(ff_output))
return x, attention_weights, adv_loss
class ClinicalTransformer(nn.Module):
"""
Complete Transformer model for clinical deterioration prediction
with integrated fairness constraints and interpretable attention.
"""
def __init__(self, config: TransformerConfig, input_dim: int) -> None:
super().__init__()
self.config = config
# Input embedding projects clinical features to model dimension
self.input_embedding = nn.Linear(input_dim * 2, config.d_model) # *2 for missingness indicators
# Temporal positional encoding
self.pos_encoder = TemporalPositionalEncoding(
config.d_model,
config.max_seq_length
)
# Transformer encoder layers
self.encoder_layers = nn.ModuleList([
TransformerEncoderLayer(config)
for _ in range(config.n_layers)
])
# Prediction head
self.predictor = nn.Sequential(
nn.Linear(config.d_model, config.d_model // 2),
nn.ReLU(),
nn.Dropout(config.dropout),
nn.Linear(config.d_model // 2, 1),
nn.Sigmoid()
)
# Risk score head for interpretability (similar to MEWS)
self.risk_score = nn.Sequential(
nn.Linear(config.d_model, config.d_model // 4),
nn.ReLU(),
nn.Linear(config.d_model // 4, 1),
nn.Softplus() # Ensures positive scores
)
def create_attention_mask(
self,
seq_len: int,
batch_size: int
) -> torch.Tensor:
"""Create causal mask preventing attention to future time points."""
mask = torch.tril(torch.ones(seq_len, seq_len))
mask = mask.unsqueeze(0).unsqueeze(0) # [1, 1, seq_len, seq_len]
mask = mask.expand(batch_size, 1, seq_len, seq_len)
return mask
def forward(
self,
x: torch.Tensor,
mask: torch.Tensor,
timestamps: torch.Tensor,
obs_frequency: Optional[torch.Tensor] = None
) -> Dict[str, torch.Tensor]:
"""
Forward pass through the clinical Transformer.
Args:
x: Clinical features [batch_size, seq_len, input_dim]
mask: Missingness indicators [batch_size, seq_len, input_dim]
timestamps: Actual timestamps [batch_size, seq_len, 1]
obs_frequency: Observation frequency [batch_size, seq_len]
Returns:
Dictionary with predictions, risk scores, and attention weights
"""
batch_size, seq_len, _ = x.shape
# Combine features with missingness indicators
x_combined = torch.cat([x, mask], dim=-1)
# Embed input
x_embedded = self.input_embedding(x_combined)
# Add positional encoding
x_encoded = self.pos_encoder(x_embedded, timestamps)
# Create causal attention mask
attn_mask = self.create_attention_mask(seq_len, batch_size).to(x.device)
# Pass through encoder layers
attention_weights_list = []
total_adv_loss = 0.0
for layer in self.encoder_layers:
x_encoded, attn_weights, adv_loss = layer(
x_encoded,
attn_mask,
obs_frequency
)
attention_weights_list.append(attn_weights)
if adv_loss is not None:
total_adv_loss += adv_loss
# Average adversarial loss across layers
if obs_frequency is not None:
avg_adv_loss = total_adv_loss / len(self.encoder_layers)
else:
avg_adv_loss = None
# Use final time step for prediction (or can use pooling)
final_repr = x_encoded[:, -1, :]
# Generate predictions and risk scores
predictions = self.predictor(final_repr)
risk_scores = self.risk_score(final_repr)
outputs = {
'predictions': predictions,
'risk_scores': risk_scores,
'attention_weights': attention_weights_list[-1], # Last layer attention
'all_attention': torch.stack(attention_weights_list),
'hidden_repr': final_repr
}
if avg_adv_loss is not None:
outputs['adversary_loss'] = avg_adv_loss
return outputs
class EquityAwareEarlyWarning:
"""
Complete early warning system with equity considerations built in.
This system predicts clinical deterioration while ensuring:
1. Performance parity across patient populations
2. Attention patterns not biased by observation frequency
3. Interpretable predictions clinicians can trust
4. Robust performance in diverse care settings
"""
def __init__(
self,
config: TransformerConfig,
input_dim: int,
feature_names: List[str]
) -> None:
self.config = config
self.feature_names = feature_names
self.model = ClinicalTransformer(config, input_dim)
self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
self.model.to(self.device)
logger.info(f"Initialized early warning system on {self.device}")
logger.info(f"Model parameters: {sum(p.numel() for p in self.model.parameters()):,}")
def compute_observation_frequency(
self,
mask: torch.Tensor,
timestamps: torch.Tensor
) -> torch.Tensor:
"""
Compute observation frequency at each time point.
This metric quantifies monitoring intensity, which may correlate
with both patient acuity and access to care resources.
Args:
mask: Missingness indicators [batch_size, seq_len, input_dim]
timestamps: Timestamps [batch_size, seq_len, 1]
Returns:
Observation frequency [batch_size, seq_len]
"""
# Count observations per time point
obs_count = mask.sum(dim=-1) # [batch_size, seq_len]
# Compute time intervals
time_diffs = timestamps[:, 1:, :] - timestamps[:, :-1, :]
time_diffs = torch.cat([
torch.ones_like(time_diffs[:, :1, :]),
time_diffs
], dim=1)
# Frequency = observations / time interval
frequency = obs_count / (time_diffs.squeeze(-1) + 1e-6)
return frequency
def train_step(
self,
batch: Dict[str, torch.Tensor],
optimizer: torch.optim.Optimizer
) -> Dict[str, float]:
"""Single training step with fairness constraints."""
self.model.train()
x = batch['x'].to(self.device)
mask = batch['mask'].to(self.device)
timestamps = batch['timestamps'].to(self.device)
labels = batch['label'].to(self.device)
sensitive = batch.get('sensitive_attr')
# Compute observation frequency
obs_freq = self.compute_observation_frequency(mask, timestamps)
optimizer.zero_grad()
# Forward pass
outputs = self.model(x, mask, timestamps, obs_freq)
predictions = outputs['predictions']
# Task loss (binary cross-entropy)
task_loss = F.binary_cross_entropy(predictions, labels)
# Fairness loss (equalized false negative rates)
fairness_loss = torch.tensor(0.0, device=self.device)
if sensitive is not None:
sensitive = sensitive.to(self.device)
unique_groups = torch.unique(sensitive)
if len(unique_groups) > 1:
fnr_by_group = []
for group in unique_groups:
group_mask = (sensitive == group).squeeze()
if group_mask.sum() > 0:
group_labels = labels[group_mask]
group_preds = predictions[group_mask]
positives = (group_labels == 1).sum().float()
if positives > 0:
false_negs = ((group_labels == 1) & (group_preds < 0.5)).sum().float()
fnr = false_negs / positives
fnr_by_group.append(fnr)
if len(fnr_by_group) > 1:
fnr_tensor = torch.stack(fnr_by_group)
for i in range(len(fnr_by_group)):
for j in range(i + 1, len(fnr_by_group)):
fairness_loss += torch.abs(fnr_tensor[i] - fnr_tensor[j])
# Attention fairness loss (prevent attention from encoding obs frequency)
attention_loss = outputs.get('adversary_loss', torch.tensor(0.0, device=self.device))
# Combined loss with weights
total_loss = (
task_loss +
self.config.fairness_weight * fairness_loss +
self.config.attention_fairness_weight * attention_loss
)
# Backward pass
total_loss.backward()
torch.nn.utils.clip_grad_norm_(self.model.parameters(), max_norm=1.0)
optimizer.step()
return {
'total_loss': total_loss.item(),
'task_loss': task_loss.item(),
'fairness_loss': fairness_loss.item(),
'attention_loss': attention_loss.item()
}
def interpret_prediction(
self,
x: torch.Tensor,
mask: torch.Tensor,
timestamps: torch.Tensor,
feature_names: List[str]
) -> Dict[str, Union[float, List[Tuple[str, float]]]]:
"""
Generate interpretable explanation for a prediction.
Returns attention-weighted feature importance and high-risk time periods.
"""
self.model.eval()
with torch.no_grad():
obs_freq = self.compute_observation_frequency(mask, timestamps)
outputs = self.model(
x.unsqueeze(0).to(self.device),
mask.unsqueeze(0).to(self.device),
timestamps.unsqueeze(0).to(self.device),
obs_freq.unsqueeze(0)
)
prediction = outputs['predictions'].item()
risk_score = outputs['risk_scores'].item()
attention = outputs['attention_weights'][0, -1, :].cpu().numpy() # Last time step
# Identify high-attention time periods
threshold = attention.mean() + attention.std()
high_attention_times = [
(i, timestamps[0, i, 0].item(), attention[i])
for i in range(len(attention))
if attention[i] > threshold
]
# Feature importance at high-attention times
feature_importance: Dict[str, float] = {feat: 0.0 for feat in feature_names}
for idx, _, att_weight in high_attention_times:
for f_idx, feat in enumerate(feature_names):
if mask[idx, f_idx] > 0: # Only if observed
feature_importance[feat] += att_weight * abs(x[idx, f_idx].item())
# Normalize
total = sum(feature_importance.values())
if total > 0:
feature_importance = {
k: v/total for k, v in feature_importance.items()
}
# Sort by importance
sorted_features = sorted(
feature_importance.items(),
key=lambda x: x[1],
reverse=True
)
return {
'prediction': prediction,
'risk_score': risk_score,
'top_features': sorted_features[:5],
'high_attention_times': high_attention_times
}
# Example usage demonstrating production deployment
def deploy_early_warning_system():
"""
Example of deploying the equity-aware early warning system.
In production, this would interface with hospital EHR systems,
process real-time data streams, and trigger alerts for care teams.
"""
# Configuration
config = TransformerConfig(
d_model=128,
n_heads=8,
n_layers=4,
d_ff=512,
dropout=0.1,
fairness_weight=0.15
)
# Define clinical features monitored
feature_names = [
'heart_rate',
'systolic_bp',
'respiratory_rate',
'temperature',
'oxygen_saturation',
'mental_status',
'urine_output'
]
# Initialize system
system = EquityAwareEarlyWarning(
config=config,
input_dim=len(feature_names),
feature_names=feature_names
)
logger.info("Early warning system deployed and ready for real-time monitoring")
return system
This implementation provides a production-ready transformer-based early warning system with integrated equity constraints. The fairness-aware attention mechanism prevents learning spurious correlations with observation frequency, while the dual-loss formulation ensures equalized false negative rates across patient populations. The interpretability features enable clinicians to understand model predictions through attention weights and feature importance scores.
Advanced Topics and Future Directions
Beyond the core methods covered, several advanced topics merit discussion for researchers pushing the boundaries of equitable clinical time series analysis. Neural ordinary differential equations (Neural ODEs) offer elegant continuous-time modeling by parameterizing derivatives rather than discrete states, naturally handling irregular sampling. Proposed by Chen et al. (2018) and extended to clinical applications by Rubanova et al. (2019), Neural ODEs define hidden state evolution through: $\frac{d\mathbf{h}(t)}{dt} = f_\theta(\mathbf{h}(t), t)$ where $f_\theta$ is a neural network. Given initial state $\mathbf{h}(t_0)$, the hidden state at any time $t$ is obtained by solving the ODE: $\mathbf{h}(t) = \mathbf{h}(t_0) + \int_{t_0}^t f_\theta(\mathbf{h}(s), s)ds$. This formulation provides memory efficiency through adjoint methods and elegant handling of irregular observations, though computational costs during training can be substantial for long sequences.
Causal inference in temporal settings addresses a critical gap in standard predictive modeling. While prediction identifies correlations, causal models reason about interventions and counterfactuals essential for treatment decisions. Time-varying treatment effects can be estimated through marginal structural models or g-computation, adjusting for time-varying confounding through inverse probability weighting or targeted maximum likelihood estimation. Recent work by Schulam and Saria (2017) and Bica et al. (2020) develops deep learning approaches for causal inference from temporal data, learning representations that balance treatment groups over time. From an equity perspective, causal models can identify whether outcome disparities arise from differential treatment patterns versus differential treatment effects, informing targeted interventions.
Multi-task learning enables joint modeling of multiple clinical endpoints, potentially improving prediction through shared representations. For early warning systems, we might simultaneously predict sepsis, cardiac arrest, respiratory failure, and ICU transfer, sharing encoder parameters while maintaining task-specific prediction heads. This approach can improve sample efficiency for rare outcomes and enable auxiliary tasks like predicting missingness patterns to help calibrate uncertainty. However, multi-task learning introduces challenges around task weighting and potential negative transfer where tasks conflict. From an equity perspective, auxiliary tasks that predict observation patterns or care setting may inadvertently leak information about protected attributes into shared representations.
Uncertainty quantification becomes critical for clinical deployment. Point predictions without uncertainty estimates cannot guide clinical decision-making, as clinicians need to know when to trust model outputs. Bayesian deep learning through variational inference or Monte Carlo dropout provides principled uncertainty estimates. Conformal prediction offers distribution-free uncertainty quantification through calibration sets, guaranteeing coverage rates that can be stratified by population. Recent work by Angelopoulos et al. (2021) develops techniques for time series conformal prediction, constructing prediction intervals that adapt to temporal dynamics. For equity, uncertainty quantification reveals when models are uncertain due to limited training data for certain populations, enabling appropriate caution rather than overconfident predictions.
Federated learning enables collaborative model development across institutions without sharing patient-level data, addressing privacy concerns while increasing diversity of training data. Models are trained locally at each institution, with only gradient updates or model parameters shared centrally. This approach could enable early warning systems trained on data from academic medical centers, community hospitals, and safety-net institutions simultaneously, capturing the full spectrum of observation patterns and patient populations without centralizing sensitive health data. However, federated learning introduces technical challenges around heterogeneous data distributions, communication efficiency, and potential for institutions with larger datasets to dominate model development. From an equity perspective, federated learning offers promise for including data from under-resourced settings often excluded from large centralized datasets, but requires careful design to ensure all participating institutions benefit equitably.
Online learning and continual learning address model drift as population characteristics and care practices evolve. Models deployed for years may degrade as new treatments emerge, disease prevalence shifts, and population demographics change. Online learning updates models incrementally as new data arrives, while continual learning aims to incorporate new knowledge without catastrophic forgetting of previous patterns. For clinical deployment, these techniques enable models to adapt to local practices and populations after deployment, but require monitoring systems to detect harmful drift. From an equity perspective, online learning risks perpetuating disparities if feedback loops systematically under-sample certain populations, requiring intentional strategies to ensure diverse representation in online updates.
Conclusion and Practical Guidelines
Time series analysis for clinical data presents unique technical and ethical challenges that require careful attention throughout the modeling pipeline. The methods developed in this chapter provide tools for handling irregular sampling, missing data, and fairness constraints while maintaining the performance necessary for clinical deployment. However, successful implementation requires more than technical solutions alone; it demands ongoing collaboration between data scientists, clinicians, and community stakeholders to ensure that systems serve all patients equitably.
When developing clinical time series models, practitioners should begin by characterizing observation patterns across the populations they intend to serve. Simple exploratory analyses revealing differences in monitoring frequency, missingness patterns, and temporal coverage across care settings or insurance types provide early warning of potential fairness issues. If substantial differences exist, models must explicitly account for these patterns rather than treating them as irrelevant noise. The dual-pathway architectures and fairness constraints demonstrated in this chapter provide starting points, but local context matters immensely. What works for an academic medical center’s ICU may fail in a rural community hospital’s general ward, requiring adaptation and validation in each deployment setting.
For model selection, consider the tradeoffs between different architectures based on application requirements. LSTMs offer explicit state tracking and flexible temporal horizons but require sequential processing. TCNs enable parallel training and fixed receptive fields but may struggle with highly irregular sampling. Transformers provide interpretable attention and capture long-range dependencies but demand substantial data and compute resources. Hybrid approaches combining multiple architectures may leverage complementary strengths. Regardless of architecture choice, ensure that models are evaluated not just for overall performance but for stratified performance across patient populations. A model achieving high AUROC overall but exhibiting widely varying sensitivity across racial groups fails the fundamental fairness requirement regardless of technical sophistication.
Interpretability must be prioritized for clinical adoption. Attention visualizations, feature importance scores, and example-based explanations help clinicians understand model reasoning and identify potential failure modes. Interpretability also serves equity by revealing when models rely on spurious correlations with observation frequency, insurance status proxies, or other features unrelated to clinical need. When attention patterns or feature importance scores highlight non-clinical factors, this signals that the model has learned dataset biases rather than generalizable clinical patterns. Such models should be refined before deployment, as they will likely exhibit poor performance on populations differing from the training distribution.
Deployment infrastructure requires careful design for real-time clinical use. Models must process streaming data with low latency, handle missing observations gracefully, and integrate with existing clinical workflows. Alert fatigue remains a major challenge for early warning systems; models generating excessive false alarms will be ignored regardless of technical merit. Calibrating alert thresholds may require different settings for different clinical contexts, recognizing that appropriate sensitivity-specificity tradeoffs depend on downstream consequences of false positives and false negatives. From an equity perspective, avoid calibrating thresholds separately for different patient groups based on base rate differences unless there is strong clinical justification, as this risks creating disparate treatment that perpetuates existing healthcare inequities.
Ongoing monitoring post-deployment is essential. Model performance should be tracked continuously with stratified metrics across patient populations. Drift in performance overall or differential drift across groups signals the need for model updates or further investigation. Establish processes for clinicians to provide feedback on model errors, particularly focusing on identifying systematic failure modes that may disproportionately affect certain populations. This feedback loop enables continual improvement while maintaining clinical trust through transparency about model limitations.
The field of clinical time series analysis continues to evolve rapidly, with new architectures and training techniques emerging regularly. However, fundamental challenges around equity and fairness require sustained attention regardless of technical advances. As models become more sophisticated, the risk of encoding complex biases into systems that appear objective increases. Maintaining explicit focus on equity throughout model development, testing, and deployment ensures that advances in AI capability translate into improved care for all patients rather than exacerbating existing disparities. The production systems demonstrated in this chapter illustrate that technical excellence and fairness need not be in tension; thoughtful design enables both simultaneously, creating clinical tools that serve diverse populations effectively and equitably.
Bibliography
Angelopoulos, A. N., Bates, S., Candès, E. J., Jordan, M. I., & Lei, L. (2021). Learn then test: Calibrating predictive algorithms to achieve risk control. arXiv preprint arXiv:2110.01052.
Bahdanau, D., Cho, K., & Bengio, Y. (2015). Neural machine translation by jointly learning to align and translate. International Conference on Learning Representations.
Baytas, I. M., Xiao, C., Zhang, X., Wang, F., Jain, A. K., & Zhou, J. (2017). Patient subtyping via time-aware LSTM networks. Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, 65-74.
Bica, I., Alaa, A. M., Jordon, J., & van der Schaar, M. (2020). Estimating counterfactual treatment outcomes over time through adversarially balanced representations. International Conference on Learning Representations.
Che, Z., Purushotham, S., Cho, K., Sontag, D., & Liu, Y. (2018). Recurrent neural networks for multivariate time series with missing values. Scientific Reports, 8(1), 6085.
Chen, I. Y., Johansson, F. D., & Sontag, D. (2020). Why is my classifier discriminatory? Advances in Neural Information Processing Systems, 31, 3543-3554.
Chen, R. T., Rubanova, Y., Bettencourt, J., & Duvenaud, D. K. (2018). Neural ordinary differential equations. Advances in Neural Information Processing Systems, 31, 6571-6583.
Chouldechova, A. (2017). Fair prediction with disparate impact: A study of bias in recidivism prediction instruments. Big Data, 5(2), 153-163.
Hochreiter, S., & Schmidhuber, J. (1997). Long short-term memory. Neural Computation, 9(8), 1735-1780.
Little, R. J., & Rubin, D. B. (2019). Statistical Analysis with Missing Data (3rd ed.). John Wiley & Sons.
Madras, D., Creager, E., Pitassi, T., & Zemel, R. (2018). Learning adversarially fair and transferable representations. International Conference on Machine Learning, 3384-3393.
Neil, D., Pfeiffer, M., & Liu, S. C. (2016). Phased LSTM: Accelerating recurrent network training for long or event-based sequences. Advances in Neural Information Processing Systems, 29, 3882-3890.
Obermeyer, Z., Powers, B., Vogeli, C., & Mullainathan, S. (2019). Dissecting racial bias in an algorithm used to manage the health of populations. Science, 366(6464), 447-453.
Rubin, D. B. (1976). Inference and missing data. Biometrika, 63(3), 581-592.
Rubanova, Y., Chen, R. T., & Duvenaud, D. K. (2019). Latent ordinary differential equations for irregularly-sampled time series. Advances in Neural Information Processing Systems, 32, 5320-5330.
Schulam, P., & Saria, S. (2017). Reliable decision support using counterfactual models. Advances in Neural Information Processing Systems, 30, 1697-1708.
van den Oord, A., Dieleman, S., Zen, H., Simonyan, K., Vinyals, O., Graves, A., Kalchbrenner, N., Senior, A., & Kavukcuoglu, K. (2016). WaveNet: A generative model for raw audio. arXiv preprint arXiv:1609.03499.
Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, Ł., & Polosukhin, I. (2017). Attention is all you need. Advances in Neural Information Processing Systems, 30, 5998-6008.
Yu, F., & Koltun, V. (2016). Multi-scale context aggregation by dilated convolutions. International Conference on Learning Representations.
Zhang, B. H., Lemoine, B., & Mitchell, M. (2018). Mitigating unwanted biases with adversarial learning. Proceedings of the 2018 AAAI/ACM Conference on AI, Ethics, and Society, 335-340.