求基于LSTM的含缺失值非规则医疗时间序列补全实现示例

Hey there! I’ve worked on several medical time series projects dealing with missing values, so I get exactly where you’re coming from—wanting to leverage LSTM/GRU for imputation without building everything from scratch, and ditching the basic mean/mode hacks that don’t capture temporal context. Here’s my practical advice with ready-to-adapt examples:

1. Use Masked LSTM with Keras (No Zero-to-Hero Coding) #

Irregular time series often have variable-length sequences, so masking is critical to ignore padded/missing values during training. This example uses Keras’ built-in layers to create an imputer that learns temporal patterns:

import tensorflow as tf
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, LSTM, Dense, Masking, RepeatVector, TimeDistributed

# Configure based on your data
num_features = 5  # e.g., heart rate, blood pressure, etc.
mask_token = -999.0  # Replace NaNs with this value pre-processing

# Define the imputer architecture
input_seq = Input(shape=(None, num_features))  # None = variable sequence length
masked_input = Masking(mask_value=mask_token)(input_seq)

# Encoder: Learn temporal patterns from valid data
encoder_lstm = LSTM(64, return_state=True)
encoder_outputs, state_h, state_c = encoder_lstm(masked_input)

# Repeat hidden state to match sequence length for decoder
decoder_input = RepeatVector(tf.shape(masked_input)[1])(state_h)

# Decoder: Generate imputed values using encoder's context
decoder_lstm = LSTM(64, return_sequences=True)
decoder_outputs = decoder_lstm(decoder_input, initial_state=[state_h, state_c])

# Output layer: Reconstruct each time step's features
output = TimeDistributed(Dense(num_features))(decoder_outputs)

# Build and compile
model = Model(inputs=input_seq, outputs=output)
model.compile(optimizer='adam', loss='mse')

How to Use This: #

• Preprocess your data: Replace all NaN values with mask_token
• Split your data into sequences (even variable-length ones—Keras handles this)
• For better efficiency, use a custom loss function that only calculates loss on positions where values were missing (instead of the entire sequence)

2. Leverage sktime's Built-in LSTMImputer #

If you want something even more out-of-the-box, sktime has a dedicated LSTM imputer optimized for time series. It automatically handles irregular sequences and missing values without manual masking/padding:

from sktime.imputation.deep_lstm import LSTMImputer
import pandas as pd
import numpy as np

# Assume your data is a pandas DataFrame with datetime index and medical features
# Leave NaNs as-is—sktime handles them internally
your_data = pd.read_csv("medical_time_series.csv", index_col=0, parse_dates=True)

# Initialize the imputer
imputer = LSTMImputer(
    hidden_size=64,
    batch_size=32,
    epochs=50,
    verbose=1,
    random_state=42
)

# Fit on your data and get imputed results
imputed_data = imputer.fit_transform(your_data)

This is perfect for medical data because it’s designed to capture temporal dependencies, and you don’t have to mess with low-level model architecture details.

3. Custom PyTorch LSTM Imputer (For More Control) #

If you prefer PyTorch and want to prioritize missing-value-specific training, this custom model focuses loss only on missing positions, which speeds up convergence and improves imputation quality:

import torch
import torch.nn as nn
import torch.optim as optim

class MedicalLSTMImputer(nn.Module):
    def __init__(self, input_size, hidden_size=64):
        super().__init__()
        self.encoder = nn.LSTM(input_size, hidden_size, batch_first=True)
        self.decoder = nn.LSTM(hidden_size, input_size, batch_first=True)
        self.mask_token = -999.0

    def forward(self, x):
        # Create mask: 1 = valid value, 0 = missing
        mask = (x != self.mask_token).float()
        
        # Encoder processes only valid data
        _, (hidden, cell) = self.encoder(x * mask)
        
        # Repeat hidden state to match sequence length for decoding
        decoder_input = hidden.repeat(1, x.size(1), 1)
        
        # Decoder generates imputed values
        output, _ = self.decoder(decoder_input)
        
        # Combine original valid values with imputed ones
        imputed = x * mask + output * (1 - mask)
        return imputed

# Initialize model, loss, optimizer
num_features = 5
model = MedicalLSTMImputer(input_size=num_features)
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Simplified training loop (adjust for your dataset)
for epoch in range(50):
    model.train()
    optimizer.zero_grad()
    
    # Assume train_data is a tensor with NaNs replaced by mask_token
    outputs = model(train_data)
    
    # Calculate loss ONLY on missing positions
    missing_mask = (train_data == model.mask_token)
    loss = criterion(outputs[missing_mask], train_data[missing_mask])
    
    loss.backward()
    optimizer.step()
    
    if epoch % 5 == 0:
        print(f"Epoch {epoch}, Loss: {loss.item():.4f}")

Critical Tips for Medical Time Series #

• Domain Validation: Don’t just rely on numerical metrics (like MSE). Ensure imputed values are clinically realistic (e.g., heart rate between 40-180 bpm, blood pressure within normal ranges). Add custom loss terms to penalize invalid values if needed.
• Irregularity Handling: For data with uneven time intervals, consider resampling to a fixed frequency first (e.g., hourly) or use models that include time stamps as a feature to capture interval context.
• Evaluate with Clinical Metrics: Track metrics like mean absolute error for critical features, or check if imputations preserve important trends (e.g., a rising temperature before a fever event).

内容的提问来源于stack exchange，提问作者Cristi Vlad