🤖 AI

Towards end-to-end LLM-based censoring-aware survival analysis

The paper introduces LLMSurvival, a framework that enables unmodified large language models to perform end-to-end, censoring-aware survival analysis on tabular clinical data by reformulating time-to-event prediction as a pairwise ranking task, achieving superior performance over traditional Cox models and deep learning baselines in ICU mortality and fracture risk prediction.

Original authors: Yishu Wei, Hexin Dong, Yi Lin, Jiahe Qian, Yi Liu, Yifan Peng

Published 2026-05-26

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Yishu Wei, Hexin Dong, Yi Lin, Jiahe Qian, Yi Liu, Yifan Peng

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Problem: The "Missing Time" Puzzle

Imagine you are trying to predict who will finish a marathon first. In a normal race, you watch everyone cross the finish line and record their times.

But in medical studies (called survival analysis), things are tricky. Sometimes, a runner (patient) drops out of the race early because they get sick, or the race ends before they finish. We don't know when they would have finished if they had stayed in the race. In statistics, this is called censoring.

For a long time, powerful AI tools called Large Language Models (LLMs)—the same tech behind chatbots—couldn't solve this puzzle. They are great at reading text and answering questions, but they struggle when the "answer key" is missing or incomplete. Most researchers had to use the AI just to read the notes and then hand the data to a different, older math model to do the actual predicting.

The Solution: LLMSurvival

The authors created a new framework called LLMSurvival. Instead of asking the AI, "How many days until this patient gets sick?", they changed the question entirely.

The Analogy: The "Who's in Worse Shape?" Game
Imagine you are a doctor looking at two patients, Patient A and Patient B.

Old Way: Try to guess the exact date Patient A will get sick. (Hard if you don't have all the data).
LLMSurvival Way: Ask the AI: "Between Patient A and Patient B, who is more likely to get sick sooner?"

This is a pairwise ranking game. Even if we don't know exactly when Patient A will get sick, we might know that Patient A got sick before Patient B dropped out of the study. That is enough information for the AI to learn.

How It Works (Step-by-Step)

Translating Numbers to Stories:
Medical data usually comes in spreadsheets (tables) with numbers like "Age: 65" or "Blood Pressure: 120." The AI can't read spreadsheets well. So, the system turns these rows into a story: "This patient is 65 years old, has high blood pressure, and smokes." Now the AI can read it like a book.
The Training Camp (Pairwise Comparison):
The AI is trained by showing it thousands of pairs of patients. It has to decide: "Who is at higher risk?"
- If the AI gets it right, it learns.
- If it gets it wrong, it adjusts its "brain."
- Crucially, it only compares patients where the outcome is clear (e.g., Patient A definitely got sick before Patient B was lost to follow-up). This bypasses the "missing time" problem.
The Final Exam (The Anchor Method):
When a new patient walks in, the AI doesn't guess a number. Instead, it compares this new patient against a fixed group of 50 "Anchor" patients from the training data.
- Question: "Is the new patient riskier than Anchor #1?" (Yes/No)
- Question: "Is the new patient riskier than Anchor #2?" (Yes/No)
- ...and so on for 50 anchors.
- The Score: If the AI says "Yes" to 40 out of 50 anchors, the patient gets a high-risk score (80%). If it says "Yes" to only 5, the score is low.

Did It Work?

The researchers tested this on two very different medical scenarios:

ICU Mortality: Predicting if a patient in the Intensive Care Unit will pass away soon.
Fracture Risk: Predicting if an older adult will break a bone in the next few years.

The Results:

Better than the Experts: In both cases, LLMSurvival performed better than the standard mathematical models doctors currently use (like the Cox model) and better than the specialized "expert scores" (like SAPS-II for ICU and FRAX for bones).
Better than other AI: It also beat other deep learning models designed specifically for survival analysis.
The "Why": When the researchers asked the AI to explain its choices, it gave logical reasons, like "Patient B has lower oxygen levels and a higher fever," showing it was actually understanding the medical context, not just guessing.

Why This Matters

No More "Feature Extractors": Previously, AI was just a helper that pulled information out of notes. Now, the AI is the doctor making the prediction.
Local & Private: The models used are small enough to run on a single computer (like a standard server in a hospital) without needing to send sensitive patient data to the cloud.
Flexible: The same "game" (comparing two patients) worked perfectly for both a fast-paced ICU emergency and a slow-moving bone fracture risk, proving the method is very adaptable.

In a Nutshell

The paper proves that if you stop asking an AI to predict a specific date (which is hard with missing data) and instead ask it to compare two people (which is easy for an AI to understand), you can build a highly accurate medical prediction tool that handles missing data naturally and outperforms current standard methods.

Technical Summary: LLMSurvival

Problem Statement
Survival analysis is a cornerstone of medical prediction, aiming to model both the occurrence of an event and the time until its occurrence. However, the application of Large Language Models (LLMs) as end-to-end survival models has been hindered by the challenge of censoring. In censored data, the exact time of an event is unknown because a subject may withdraw or the observation period ends before the event occurs. This lack of explicit ground-truth labels prevents the direct use of standard supervised fine-tuning (SFT) and reinforcement learning frameworks, which rely on definitive targets. Consequently, prior research has largely relegated LLMs to the role of feature extractors or required substantial architectural modifications (e.g., adding neural networks on top of LLMs) rather than utilizing the LLM as the primary predictive engine.

Methodology: LLMSurvival
The authors propose LLMSurvival, a framework that enables censoring-aware survival analysis using unmodified LLMs operating directly on tabular clinical data. The core innovation is the reformulation of time-to-event prediction as a pairwise ranking problem, circumventing the need for absolute time labels.

Data Conversion: Structured tabular variables (e.g., age, vital signs, lab results) are converted into natural language statements using a template (e.g., "Age is 79; Gender is FEMALE").
Pairwise Formulation: Instead of predicting a specific survival time, the model is trained to determine which of two comparable subjects will experience the event first.
- Training Pairs: A valid training pair $(i, j)$ is constructed where subject $i$ experienced the event ( $e_i=1$ ) and did so before subject $j$ 's follow-up time ( $t_i < t_j$ ). This includes censored subjects as long as they were observed longer than the event time of the other subject.
- Objective: The model is fine-tuned via supervised learning to predict the relative ordering. The loss function is a binary cross-entropy objective over valid comparable pairs, optimizing the probability that the model assigns a higher risk score to the subject who experiences the event earlier.
- Sampling: To manage the computational cost of generating all possible pairs, a nested case-control sampling strategy is employed, selecting a fixed number of controls (subjects with longer follow-up) for each event case.
Inference via Anchor Comparison: During testing, a subject's risk score is not predicted directly. Instead, the test subject is compared against a fixed set of $K$ $K$ "anchor" individuals sampled from the training cohort.
- The model predicts whether the test subject is at higher risk than each anchor.
- The final risk score is the proportion of anchors against which the test subject is ranked as higher risk.
Models: The framework was evaluated using two instruction-tuned, locally deployable LLMs: Llama 3.1-8B-Instruct and Qwen 2.5-7B-Instruct.

Key Contributions

End-to-End LLM Survival Modeling: The paper presents a proof of concept for training LLMs directly as survival models without architectural modifications, moving beyond their traditional role as feature extractors.
Censoring Resolution: By reframing the problem as a ranking task, the method naturally incorporates censored observations into the training process, addressing the fundamental hurdle of missing event times.
Portability: The framework is demonstrated to be portable across diverse clinical contexts (acute ICU mortality and chronic fracture risk) without task-specific architectural changes.
Local Deployment: The use of compact, publicly available base models (7B/8B parameters) allows for local deployment, mitigating privacy concerns associated with external API calls.

Results
The framework was evaluated on two distinct clinical tasks:

ICU Mortality Prediction (MIMIC-IV):
- LLMSurvival achieved an overall C-index of 0.776 (Llama) and 0.784 (Qwen).
- This represents a 3.1% improvement over the Cox proportional hazards model (0.753) and a 3.0% improvement over the established clinical score SAPS-II (0.746).
- It outperformed three deep learning baselines (Cox-nnet, DeepHit, DeepSurv) on average.
Fragility Fracture Prediction (NYP/WCM Cohort):
- LLMSurvival achieved an overall C-index of 0.742 (Llama) and 0.741 (Qwen).
- This showed a 0.5% improvement over the Cox model and a significant 8.2% improvement over the FRAX clinical score (0.660).
- Performance was competitive with or superior to deep learning baselines across various time horizons (2, 3, and 5 years).

In both tasks, Kaplan–Meier analyses confirmed that LLMSurvival effectively stratified patients into high- and low-risk groups with distinct survival trajectories (Hazard Ratios of 4.80 for ICU and 4.02 for fractures). Qualitative analysis of model outputs indicated that the LLMs generated clinically coherent rationales for their pairwise comparisons, citing relevant risk factors such as admission severity, oxygenation levels, and comorbidity burdens.

Significance and Claims
The authors claim that LLMSurvival demonstrates that survival modeling with censoring can be made compatible with LLM fine-tuning through comparison-based reformulation. The study serves as a proof of concept that LLMs can expand their capabilities to solve complex statistical problems independently, rather than relying on hybrid architectures. The framework's ability to outperform expert-curated clinical scores (SAPS-II and FRAX) suggests that LLMs can learn meaningful risk stratification directly from data. Furthermore, the work illustrates a broader principle: reformulating statistically challenging problems into tasks aligned with LLM capabilities (such as comparative reasoning) can extend the applicability of language models in biomedical machine learning.

Limitations
The authors acknowledge several limitations:

Training exhibited some variability across sampling configurations, suggesting room for optimization stability improvements.
Pair selection relied on random sampling of controls; structured strategies might improve efficiency.
Inference requires multiple pairwise comparisons against anchors, introducing computational overhead.
The current implementation uses only structured tabular inputs; future work is needed to integrate multimodal signals like clinical notes and medical imaging.