hemodialysis-hypotension

Hemodialysis Hypotension Predictor

FT-Transformer (Feature Tokenizer Transformer, Gorishniy et al. 2021) trained on 97,640 real hemodialysis sessions to predict intradialytic hypotension (IDH) from pre-session clinical parameters.

Model Details

Performance

Input Features

20 numeric features (StandardScaler normalized): age, dry_weight_kg, pre_weight_kg, post_weight_kg, interdialytic_gain_kg, dialysate_temp_c, reposition_vol_ml, kt, blood_flow_mlmin, dialysate_flow_mlmin, dialysate_conductivity, bicarbonate_conductivity, arterial_pressure_mmhg, venous_pressure_mmhg, transmembrane_pressure, systolic_bp_mmhg, diastolic_bp_mmhg, pulse_bpm, uf_rate, body_temp_c

4 categorical features (label encoded): sex, dialyzer_type, bath_type, technique

Usage

import torch
import torch.nn as nn
import math

class FeatureTokenizer(nn.Module):
    def __init__(self, n_num, cat_cardinalities, d_token):
        super().__init__()
        self.num_weight = nn.Parameter(torch.empty(n_num, d_token))
        self.num_bias   = nn.Parameter(torch.empty(n_num, d_token))
        self.cat_embs   = nn.ModuleList([nn.Embedding(c+1, d_token) for c in cat_cardinalities])
        nn.init.kaiming_uniform_(self.num_weight, a=math.sqrt(5))
        nn.init.zeros_(self.num_bias)
    def forward(self, x_num, x_cat):
        x_n = x_num.unsqueeze(-1) * self.num_weight + self.num_bias
        x_c = torch.stack([e(x_cat[:, i]) for i, e in enumerate(self.cat_embs)], dim=1)
        return torch.cat([x_n, x_c], dim=1)

class FTTransformer(nn.Module):
    def __init__(self, n_num, cat_cardinalities, d_token=256, n_heads=8, n_layers=6, dropout=0.1):
        super().__init__()
        self.tokenizer = FeatureTokenizer(n_num, cat_cardinalities, d_token)
        self.cls_token = nn.Parameter(torch.zeros(1, 1, d_token))
        enc = nn.TransformerEncoderLayer(d_model=d_token, nhead=n_heads,
            dim_feedforward=4*d_token, dropout=dropout, batch_first=True,
            norm_first=True, activation='gelu')
        self.encoder = nn.TransformerEncoder(enc, num_layers=n_layers)
        self.head = nn.Sequential(nn.LayerNorm(d_token), nn.Linear(d_token, 1))
    def forward(self, x_num, x_cat):
        x = self.tokenizer(x_num, x_cat)
        cls = self.cls_token.expand(x.size(0), -1, -1)
        x = self.encoder(torch.cat([cls, x], dim=1))
        return self.head(x[:, 0]).squeeze(-1)

# Load
ckpt  = torch.load("hemodialysis_ft.pt", map_location="cpu")
model = FTTransformer(n_num=20, cat_cardinalities=ckpt["cat_cardinalities"])
model.load_state_dict(ckpt["model_state"])
model.eval()

# Inference (x_num normalized with ckpt scaler_mean/scaler_scale)
prob = torch.sigmoid(model(x_num, x_cat)).item()
print(f"Hypotension probability: {prob:.1%}")

Citation

Dataset: Sánchez-Crisostomo et al. (2023). Mendeley Data. https://doi.org/10.17632/7kmtsmsgfw.1

Model: Liodon AI (2026). FT-Transformer for intradialytic hypotension prediction.