🤖 machine learning

A Filtered Mixture-of-Generators for Fully Synthetic Survival Training

The paper introduces FoGS, a novel framework that improves survival analysis in data-scarce clinical settings by filtering synthetic samples from a diverse pool of generators using an ensemble of survival models, thereby achieving performance comparable to or better than training on real data while preserving privacy.

Original authors: Niccolò Maria Rizzi, Eugenio Lomurno, Alberto Archetti, Matteo Matteucci

Published 2026-07-02

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Niccolò Maria Rizzi, Eugenio Lomurno, Alberto Archetti, Matteo Matteucci

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 Problem: The "Small Sample" Dilemma

Imagine you are a doctor trying to predict how long a patient might live after a specific treatment. To build a smart computer model to do this, you need a massive library of patient records.

But there's a catch:

Time: You have to wait years to see if a patient passes away or gets better.
Privacy: You can't just share patient files between hospitals because of strict privacy laws.
Result: You end up with very small, isolated groups of data.

When you try to teach a computer using these tiny groups, it often fails to learn the big picture.

The Old Solution: The "Bad Photocopier"

Scientists tried to fix this by using "Generative AI." Think of this as a photocopier that tries to create fake patient records that look exactly like the real ones.

The idea was: If we don't have enough real records, let's photocopy them to make a bigger pile, then teach the computer on the fake pile.

The Problem: On small, tricky datasets (like survival data), the photocopier isn't perfect. It tends to make mistakes or miss rare details. If you train your computer on these "bad copies," the computer performs worse than if you had just used the few real records you actually had.

The New Solution: FoGS (The "Talent Scout")

The authors of this paper, Niccolò Maria Rizzi and his team, propose a new system called FoGS (Filtered Mixture-of-Generators for Survival analysis).

Instead of trying to make the photocopier perfect, they changed the strategy entirely. They stopped asking, "How do we generate the best fake data?" and started asking, "How do we pick the best fake data from a huge pile?"

Here is how FoGS works, step-by-step:

1. The "Talent Agency" (The Generator Pool)

Instead of using one photocopier, FoGS hires four different types of AI generators.

Think of them as four different artists: one is a sketcher, one is a painter, one uses digital tools, and one uses a survival-specialized technique.
Each artist tries to create a massive pile of fake patient records based on the small real data they have.
Because they are different, they make different kinds of "mistakes" and capture different parts of the truth.

2. The "Critic Panel" (The Scorer Ensemble)

Now, FoGS has a giant pile of fake records from all four artists. How do we know which ones are good?

FoGS brings in seven expert judges (survival models trained on real data).
These judges look at every single fake record and give it a score. They ask: "Does this fake record look like it belongs in the real world?"
If a record looks suspicious or impossible, it gets a low score. If it looks realistic, it gets a high score.

3. The "Curator" (The Selection Policy)

This is the magic part. FoGS doesn't just pick the highest-scoring records. It acts like a smart museum curator.

The Trap: If you only pick the highest-scoring records, you might accidentally pick 1,000 records that all look exactly the same (the "average" patient). You miss the rare, weird, or extreme cases that are actually important for the computer to learn.
The Fix: FoGS uses a special formula to pick a mix. It picks the best records, BUT it also forces itself to keep a certain percentage of random records, even if they aren't perfect. This ensures the final dataset covers the whole "spectrum" of patients, not just the average ones.

4. The "Two-Level Test"

FoGS runs a double-check loop:

Inner Loop: It trains a test computer model on the selected fake data to see how well it learns.
Outer Loop: It tweaks the "Curator's" rules (how many records to pick from each artist, how much randomness to add) to make that test computer perform as well as possible.

The Results: Did It Work?

The team tested this on 16 different real-world medical datasets (covering cancer, heart disease, etc.).

The Outcome: In 9 out of 16 cases, FoGS improved the computer's performance on both accuracy metrics. In 13 out of 16 cases, it improved at least one metric.
The Comparison: On most of these datasets, training on the filtered fake data worked just as well as, or even better than, training on the actual real data.
Privacy: A major concern with fake data is that it might accidentally reveal real patient secrets. The paper checked this using a "nearest-neighbor" test (checking how close a fake record is to a real one). They found that FoGS did not make the data significantly less private than just randomly picking records.

The Key Takeaways

Don't rely on one generator: Using a mix of different AI generators is better than relying on just one.
Selection is better than generation: The secret sauce wasn't making better fake data; it was filtering the existing fake data to find the best mix.
Randomness is good: You need to keep some "random" records in the mix, even if they aren't perfect, to ensure the computer learns about rare cases.
It works for privacy: You can share these filtered synthetic datasets between hospitals without losing privacy, and they are useful enough to train better medical models.

In short: FoGS is like a talent scout who doesn't try to create the perfect actor, but instead gathers a huge crowd of actors, has a panel of judges rate them, and then carefully selects a diverse cast that performs better than the original small group of real actors.

Technical Summary: A Filtered Mixture-of-Generators for Fully Synthetic Survival Training

Problem Statement

Survival analysis is critical for clinical decision-making in domains such as oncology and cardiology, yet training robust models is hindered by structural data constraints. Events accrue over long follow-up periods, resulting in small cohort sizes, while privacy regulations restrict cross-institutional data sharing. While synthetic tabular generation offers a potential remedy for data augmentation and privacy-preserving sharing, existing approaches struggle in this regime. Single generative models trained on small survival cohorts often fail to characterize the underlying population distribution faithfully. Consequently, "train-on-synthetic, test-on-real" (TSTR) pipelines consistently underperform compared to training on real data, as synthetic sets fail to cover the specific regions of the data manifold required for downstream model generalization.

Methodology: FoGS Pipeline

The authors propose FoGS (Filtered Mixture-of-Generators for Survival analysis), a two-level optimization pipeline that reframes synthetic data construction not as a generation problem, but as a sample selection problem. The goal is to construct a high-utility synthetic training set by selecting the best samples from a heterogeneous pool, driven by a per-sample plausibility signal.

1. Generator Pool and Candidate Generation

FoGS draws a candidate pool of synthetic samples from four architecturally distinct tabular generators, ensuring the pool is not tied to the inductive bias of any single architecture:

ARF: Adversarial Random Forests (non-parametric density estimation).
Bayesian Network: Explicit factorization with hill-climbing structure learning.
TabDDPM: Denoising diffusion models for mixed categorical and numerical features.
SurvivalCTGAN: A CTGAN variant adapted for censored survival data (generating covariates via GAN and event times via a survival head).

Each generator $g$ is trained on the real training split $D_r$ and produces a candidate pool $D_g$ of size $N_g = \lceil \kappa N_r \rceil$ (where $\kappa=100$ in experiments). The union of these pools forms the candidate set $D_{synth}$ .

2. Per-Sample Plausibility Scoring

Instead of using a single metric, FoGS employs an ensemble of seven survival models (including Cox, DeepSurv, DeepHit, RSF, FPBoost, XGBoost-Cox, and a weighted ensemble) trained on the real data $D_r$ to score every synthetic sample. Each scorer assigns two proper scoring rule losses to a sample:

Integrated Brier Score (IBS): Measures prediction accuracy over time.
Negative Log-Likelihood (NLL): Measures probabilistic calibration.

Low loss values indicate that a synthetic sample is plausible with respect to the real population distribution.

3. Selection Policy

The filtered synthetic dataset $D^*_s$ is constructed via a selection operator $\Phi$ defined by a policy vector $\pi$ . This policy includes:

Generator Quotas ( $p_g$ ): The proportion of samples drawn from each generator's pool.
Scorer Weights ( $w_{m,k}$ ): Aggregation weights for the IBS and NLL losses across the seven scorers.
Random Complement ( $\rho$ ): A fraction of samples selected uniformly at random from the pool, while the remaining fraction $(1-\rho)$ is selected deterministically based on the lowest aggregated loss. This balances plausibility (selecting high-quality samples) with population coverage (retaining rare cases in the tails).
Stratification Flags ( $b_{alt}, b_{alc}$ ): Optional constraints to ensure the selected set matches the event-time distribution and censoring rate of the real data.

4. Two-Level Optimization

The pipeline optimizes $\pi$ through nested loops:

Inner Loop: Trains a downstream survival model (instantiated as XGBoost-Cox) on the filtered set $D^*_s$ and tunes its hyperparameters $\theta$ to maximize a composite validation score ( $C_{val} - 2 \cdot IBS_{val}$ ) on a held-out real validation split.
Outer Loop: Optimizes the selection policy $\pi$ to minimize the IBS of the resulting downstream model on the real validation split. This ensures the selection policy is tuned specifically for downstream utility.

Key Contributions

FoGS Pipeline: The first pipeline to optimize synthetic data construction for survival analysis by recasting it as a sample selection problem over a heterogeneous generator pool, driven by per-sample plausibility signals.
Comprehensive Benchmarking: Evaluation across 16 public survival datasets, demonstrating that FoGS matches or exceeds real-data training performance on the majority of cohorts.
Structural Insights: Identification of two governing phenomena in synthetic data selection:
- A quality–coverage trade-off, where retaining a non-trivial random fraction of samples is necessary to preserve population coverage and prevent over-representation of dense regions.
- Dataset-dependence, where no single scorer-weighting strategy prevails across all cohorts; optimal weights must be tuned per dataset.

Results

Evaluated on 16 public datasets using the TSTR paradigm with XGBoost-Cox as the downstream model:

Performance Gains: FoGS improved both C-index and IBS on 9 of 16 datasets and at least one metric on 13 of 16.
Statistical Significance: Mean improvements were +2.17 in C-index and +0.67 in IBS. One-sided Wilcoxon signed-rank tests yielded $p=0.039$ for C-index and $p=0.035$ for IBS.
Ablation Studies:
- Restricting FoGS to a single generator (even the best-performing ARF) resulted in lower aggregate utility than the full four-generator pool.
- Replacing the tuned selection policy with a random draw from the same pool caused performance to drop below the real-data baseline ( $\Delta C = -0.50$ ), confirming that the improvement stems from the selection policy, not the generators themselves.
Privacy: The filtered set showed no significant degradation in the nearest-neighbour privacy margin (NNDR) relative to unfiltered random sampling ( $p=0.087$ ).

Significance

The paper asserts that sample filtering over a heterogeneous generator pool is a viable substitute for real-data training in privacy-restricted clinical settings.

The significance lies in shifting the paradigm from "generating better data" to "selecting better data." By treating synthetic construction as a policy-tuned selection problem, FoGS overcomes the limitations of small cohort sizes where single generators fail to capture complex distributions. The framework enables institutions to share synthetic cohorts safely without disclosing patient-level records while maintaining, or even improving, the utility of downstream survival models compared to training on real data alone. The approach is modular, allowing for the integration of new generators or scorers without altering the core pipeline.