SV-Cine Segments Single Ventricle Hearts From Cine MRI

Why single ventricle hearts break segmentation models

Single ventricle physiology, often written SVP, covers a group of rare congenital heart disease subtypes with an estimated prevalence of 3.1 to 4.9 per 10,000 live births. The defining feature is that the patient has either one fully developed ventricle or one functional ventricle paired with a severely hypoplastic partner. Both atria drain into that single working chamber, which mixes oxygenated and deoxygenated blood, and these patients carry much higher morbidity and mortality than those with two working ventricles.

The names of the subtypes hint at how varied the anatomy is. Hypoplastic left heart syndrome, double inlet left ventricle, tricuspid atresia, double outlet right ventricle, and unbalanced atrioventricular canal defects all fall under the umbrella. Survival used to be very low, and it improved only through a staged sequence of palliative operations that usually ends with the Fontan procedure. Because those surgeries now work, there is a growing population of adults living with a Fontan circulation who need imaging follow up for the rest of their lives.

Cardiac cine MRI is the workhorse for that follow up. It gives a detailed and noninvasive view of cardiac anatomy and function, and the numbers clinicians care about, ventricular volume, ejection fraction, and cardiac index, all depend on drawing accurate contours around the heart chambers in every slice. That drawing step is the bottleneck. Do it by hand and an expert spends a long time per study. Hand it to an automated model and you hit a wall, because almost every cardiac segmentation model was trained on healthy or common biventricular hearts.

Here is where it gets interesting. A model trained on normal anatomy carries an assumption it never states out loud, that the ventricle on one side is the left and the ventricle on the other is the right, sitting where they usually sit and shaped the way they usually look. Single ventricle hearts violate that assumption constantly. Morphology can be severely altered, asymmetric, or mirror reversed. The dominant chamber might be anatomically a right ventricle doing the job of a left. Ask a conventional model to label these and it will confidently mislabel the dominant ventricle, or invent a second ventricle that is not functionally there.

What came before, and what was missing

Medical image segmentation has a long history, moving from convolutional networks such as U-Net to transformer based architectures that model long range spatial dependencies through self attention, and on to hybrid designs that pair a convolutional encoder with a vision transformer. For cardiac MRI specifically, large public datasets like the UK Biobank pushed the field forward. A recent foundation model called CineMA was pretrained on more than 50,000 cardiac MRI images from the UK Biobank and fine tuned with a segmentation head, reaching Dice scores around 0.936 for the left ventricle, 0.911 for the right ventricle, and 0.879 for myocardium on the ACDC dataset of common cardiac pathologies.

Those numbers are excellent, and they are also the trap. They were measured on hearts with ordinary anatomy. Move to congenital heart disease and the ground shifts. Only limited work has addressed single ventricle disease at all. The one dedicated method, from Yao and colleagues in 2023, segmented the blood pool and the myocardium in single ventricle cases by first localizing the heart and then segmenting it with two U-Net3+ networks. It worked, but it did not separately delineate the left and right ventricular structures, and that distinction matters because dominant ventricular morphology has been tied to long term clinical outcomes.

The other thread the authors pull on is conditioning. Feeding a network a small piece of external clinical information is not new. Lemay and colleagues used Feature-wise Linear Modulation to condition a tumor segmentation network on tumor type, and others embedded lesion specific metadata to sharpen both accuracy and confidence. The idea that a diagnosis could steer a segmentation model was in the air. What SV-Cine does is apply it to a setting where the diagnosis is not a nice to have but the missing key, because appearance genuinely underdetermines the answer. This is the same instinct behind other work we have covered on guiding a model with prior clinical structure rather than pixels alone.

The two part strategy

SV-Cine, from a team at UCLA, the VA Greater Los Angeles system, and Children’s Hospital of Orange County, tackles the problem from two directions at once. One arm manufactures the training data that reality refuses to provide. The other arm rebuilds the segmentation model so it can accept a clinical hint. Neither half works alone, and the paper is careful to show that.

The scarcity problem is brutal. You cannot gather a large annotated dataset of a disease that appears a few times per 10,000 births, spread across many anatomical subtypes, each of which looks different. So the first arm generates anatomically diverse synthetic hearts and synthetic MRI. The second arm takes an existing foundation model and teaches it to read a compact description of the patient’s diagnosis while it segments. The two arms share one idea, the diagnosis, which drives both the synthesis and the segmentation.

Building hearts that were never scanned

The synthetic pipeline runs in two stages. The first generates 3D cardiac geometries using a retrained model called SDF4CHD, which learns a disentangled representation of cardiac anatomy by separating what belongs to a diagnosis from what belongs to an individual patient. It predicts signed distance functions for seven cardiac structures and jointly learns a diagnosis conditioned anatomical template plus a patient specific deformation field. In plain terms, it holds a mental model of what a hypoplastic left heart tends to look like, then bends that template into a specific new example. New morphologies come from sampling the shape code from a prior conditioned on a chosen diagnosis, and an experienced radiologist reviewed the generated templates to confirm they were anatomically sensible.

The second stage turns those label maps into images that look like real scans. A conditional generative adversarial network takes the 3D shapes, converts them into stacks of 2D short axis label maps, and paints realistic short axis cardiac MRI onto them. Anatomical labels are injected through SPADE layers while a style image supplies the acquisition appearance. The team even added three surrounding structures, the liver and both lungs, as coarse context, because giving the generator a sense of the thoracic neighborhood improves image realism and slice to slice coherence.

Using this framework the authors generated 500 synthetic MRI cases, deliberately overweighting the rarest anatomies. They produced 15 cases for each non single ventricle congenital defect, 20 for morphological single ventricle, and 40 for the remaining single ventricle subtypes. On top of that they applied the usual online augmentation during training, random intensity and contrast shifts, noise, affine transforms, and coarse dropout. The whole synthetic apparatus exists to manufacture the anatomical diversity that a rare disease denies you. It is the same motivation behind other generative approaches to medical imaging under data scarcity, applied here to whole heart geometry.

Teaching the network the diagnosis

The segmentation model itself, SV-Cine, is a modified version of the CineMA foundation model adapted for this task. The change that matters is how it takes in the diagnosis. The authors reduce each patient’s clinical picture to a tiny binary vector with three elements, flags for whether there is a hypoplastic left ventricle, a hypoplastic right ventricle, and an anatomically univentricular morphology. That is a deliberately minimal description, chosen to be clinically meaningful while staying compatible with the messy variety of real subtypes.

That three element vector is expanded into a richer representation by a small two layer network, producing a 128 dimensional embedding.

The embedding then reaches into the decoder through Feature-wise Linear Modulation, usually shortened to FiLM. The idea is simple and effective. From the diagnosis embedding the model predicts a scaling factor and a shifting factor.

Those two factors are then applied to the decoder’s intermediate feature maps, stretching and offsetting them according to the clinical prior.

Here the feature map is modulated feature by feature. Nothing about this is heavy. There is no giant extra branch, no second image stream. A three bit clinical fact becomes a set of gentle multiplicative and additive nudges inside the decoder, and those nudges are enough to tell the network that the dominant chamber it is looking at should be labeled as the functional ventricle regardless of which side it sits on. The elegance is in the restraint. The model already knows how to find heart tissue from its foundation pretraining. FiLM just tells it how to name what it found.

How it was trained

Training started from the pretrained CineMA encoder weights, while the decoder and the FiLM conditioning layers were randomly initialized. The team used AdamW with an initial learning rate of 0.001, a weight decay of 0.05, and a layer wise learning rate decay of 0.75, a batch size of 4, and an input size of 192x192x16, running up to 500 epochs with early stopping after 30 epochs without improvement. The loss combined Dice and cross entropy. Training data was the real HVSMR dataset together with the synthetic set, split 80 to 20 at the patient level, and the whole thing ran on a single consumer grade RTX 4070. The diagnostic vectors were entered by hand from the clinical diagnoses.

What the numbers say

The model was tested on an internal cohort of 20 adults with single ventricle physiology from UCLA Health, imaged with a gradient echo sequence at 1.5 T, with ground truth drawn by a radiologist with five years of cardiovascular MRI experience. Performance was reported as median values with interquartile ranges, and statistical comparisons used the Wilcoxon signed rank test at a threshold of 0.05, a nonparametric choice that suits a small sample.

The right ventricle is the hard case, and its wide interquartile range tells you why. A hypoplastic right ventricle can occupy only a handful of pixels, so a small contour error swings the score. That fragility showed up cleanly in a subgroup breakdown, where the lowest median Dice, 0.56, landed on right ventricle segmentation in the hypoplastic right ventricle subgroup. The functional numbers followed the same logic. Volume errors indexed to body surface area were 1.83 mL/m² for the dominant ventricle and 0.70 mL/m² for the hypoplastic one, but the ejection fraction error was far worse for the hypoplastic ventricle, 14.5 percentage points against 5.55 for the dominant ventricle. When a chamber is tiny, getting its pumping fraction right is genuinely hard.

The comparison against baselines is where the design justifies itself, especially on the right ventricle.

Read that CineMA row twice. The original foundation model, the very one SV-Cine is built from, scored a median right ventricle Dice of 0.00 with an interquartile range of 0.00 to 0.17 on these patients. It essentially could not find the right ventricle in single ventricle anatomy. Adapt it with a diagnosis prior and synthetic data and the same backbone reaches 0.72. The 2D nnU-Net, a famously strong baseline, managed only 0.33 and sometimes failed to detect the right ventricle entirely. The two stage U-Net3+ pipeline had its own failure mode, tending to predict two ventricles even when only one was functionally present. Against nnU-Net, SV-Cine cut right ventricle contour error from 17.03 mm to 3.85 mm, and the right ventricle and myocardium gains were statistically significant.

Which ingredient actually mattered

The ablation study is blunt about where the accuracy comes from, and the answer is the diagnosis prior.

Strip out the diagnosis conditioning and right ventricle Dice falls off a cliff, from 0.72 to 0.14, while the hypoplastic ventricle ejection fraction error nearly triples to 41.25 percentage points. That single result is the whole thesis in one line. Removing the synthetic data or the foundation pretraining also hurts, dropping right ventricle Dice to 0.36 and 0.24 respectively and widening the spread of results, so all three ingredients pull weight. But the clinical hint is the load bearing wall. Take it away and the model is back to guessing from appearance, which is exactly what failed in the first place.

The clinical translation gap

Strong Dice scores on a research cohort are not the same thing as a tool a hospital can trust, and this paper sits some distance from the clinic for reasons worth naming plainly. The most important is a chicken and egg dependency built into the method. SV-Cine needs the diagnosis as an input, and the ablation proves it needs it badly. In everyday practice that diagnosis is usually already known from a prior cardiology workup before anyone measures volumes, so the requirement is often reasonable. But it means the model cannot help characterize a patient who has not yet been diagnosed, and in this study the diagnostic vectors were typed in by hand rather than extracted automatically. A deployed system would need a reliable way to pull that flag from clinical notes, and a wrong flag would actively mislead the model.

There is also a gap between the metric and the decision. A median right ventricle Dice of 0.72 sounds usable until you remember the interquartile range stretches to 0.54 at the low end, and that the ejection fraction error for a hypoplastic ventricle can reach into the tens of percentage points. Ejection fraction is a number clinicians act on. An automated measurement that is usually close but occasionally far off, with no signal about which case is which, is not yet something you would let run unsupervised on a scan that informs a treatment decision. The authors do not claim otherwise, and that restraint is a point in the work’s favor.

Does it hold up outside its home hospital?

The team tested SV-Cine on a genuinely external cohort, 19 pediatric patients from Children’s Hospital of Orange County, a different institution and a much younger age group with a mean age of 14.4 years against 28.8 at UCLA. This is the test that matters, because a model that only works at the hospital that built it is not much use.

The picture is mixed and honestly reported. Left ventricle and myocardium accuracy dropped on the external cohort, which the authors attribute partly to a different anatomical mix, with more dominant right ventricle cases that were underrepresented in training. But right ventricle Dice actually held steady at 0.73, essentially matching the internal number, and the functional measurements stayed in a comparable range. A model that keeps its hardest structure stable across institutions while slipping on the easier ones is showing a believable, if imperfect, kind of robustness. It also flagged failure cases openly, including a missed left ventricle in one patient and an under segmented cavity in another.

Honest limitations

The headline limitation is sample size. The entire evaluation rests on 39 patients across two centers, and although they span several subtypes, that is nowhere near the full spectrum of single ventricle variability. Rare disease research always fights this, and it is the reason the synthetic pipeline exists, but no amount of synthetic augmentation removes the need to validate on more real patients from more institutions before anyone calls this generalizable.

Dataset bias runs through the whole design. The range of subtypes the synthetic generator can produce is bounded by the diagnoses present in its original training set, so anatomical combinations that were not seen cannot be conjured. The synthetic images also differ visibly from real cine MRI, and while the ablation shows they help segmentation training even so, the authors are clear that image realism has room to improve. The model inherits whatever blind spots its 11 real source anatomies carried.

Generalization concerns are concrete rather than abstract. Right ventricle accuracy was lowest precisely where the structure is most severely hypoplastic and occupies the fewest pixels, which is also where a missed segmentation at end systole inflates the ejection fraction error most. The model works in two dimensions slice by slice, so it has no temporal memory across the cardiac cycle. The authors point to a four dimensional formulation with temporal attention as the natural next step, which lines up with other cardiac work on using motion across frames to stabilize heart segmentation.

One more caveat sits above all of these. This is a preprint. It has not been through peer review, and its clinical claims should be read as provisional until it has. The strongest version of this result would be a larger multi center study with prospective validation, and the authors say as much themselves.

Why the approach travels

Beyond the heart, SV-Cine is a case study in adapting a large pretrained model to a tiny specialized problem. The foundation model brought general knowledge of cardiac MRI from tens of thousands of scans. The diagnosis prior brought the one fact that general knowledge could not supply. The synthetic pipeline bridged the gap between them by manufacturing diversity. That combination, a pretrained backbone plus a cheap conditioning signal plus generative augmentation, is a recipe for a great many rare disease imaging tasks where labeled data will never be plentiful.

It fits a broader pattern in current medical AI, where the interesting work is less about inventing new architectures and more about adapting big models thoughtfully. The same shape appears in efforts like foundation models bent toward a narrow clinical readout and in few shot medical segmentation that learns from a handful of examples. SV-Cine’s contribution is to show that the conditioning signal, not the backbone, can be the decisive ingredient when the task itself is ambiguous.

Reference implementation in PyTorch

The code below is a runnable reconstruction of the SV-Cine idea, the diagnosis embedding and FiLM conditioned segmentation decoder, based on the equations in the paper. A compact convolutional encoder stands in for the CineMA foundation backbone so the file runs without external weights. It includes the diagnosis vector encoder, FiLM modulation layers, an encoder and a conditioned decoder, the combined Dice and cross entropy loss, a training step, a Dice evaluation helper, and a smoke test on dummy tensors. Swap in the real pretrained backbone and dataset for actual experiments.

# sv_cine_reference.py
# Runnable reconstruction of the SV-Cine diagnosis conditioned decoder.
# Replace SimpleEncoder with the pretrained CineMA backbone for real runs.

import torch
import torch.nn as nn
import torch.nn.functional as F


class DiagnosisEncoder(nn.Module):
    """Encodes the 3 bit diagnosis vector d into a 128 dim embedding."""
    def __init__(self, in_dim=3, hidden=64, emb=128):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(in_dim, hidden), nn.ReLU(inplace=True),
            nn.Linear(hidden, emb))              # z = MLP2(MLP1(d))

    def forward(self, d):
        return self.net(d)


class FiLM(nn.Module):
    """Predicts per channel scale and shift from z, applies to features."""
    def __init__(self, emb, channels):
        super().__init__()
        self.to_params = nn.Linear(emb, 2 * channels)   # gamma, beta = MLP(z)
        self.channels = channels

    def forward(self, h, z):
        gb = self.to_params(z)                     # (B, 2C)
        gamma, beta = gb[:, :self.channels], gb[:, self.channels:]
        gamma = gamma.view(-1, self.channels, 1, 1)
        beta = beta.view(-1, self.channels, 1, 1)
        return gamma * h + beta                      # FiLM(h) = gamma x h + beta


class ConvBlock(nn.Module):
    def __init__(self, cin, cout):
        super().__init__()
        self.block = nn.Sequential(
            nn.Conv2d(cin, cout, 3, 1, 1),
            nn.BatchNorm2d(cout), nn.ReLU(inplace=True),
            nn.Conv2d(cout, cout, 3, 1, 1),
            nn.BatchNorm2d(cout), nn.ReLU(inplace=True))

    def forward(self, x):
        return self.block(x)


class SimpleEncoder(nn.Module):
    """Stand in for the CineMA foundation encoder. Returns skip features."""
    def __init__(self, in_ch=1, dims=(32, 64, 128, 256)):
        super().__init__()
        self.blocks = nn.ModuleList()
        prev = in_ch
        for d in dims:
            self.blocks.append(ConvBlock(prev, d))
            prev = d
        self.pool = nn.MaxPool2d(2)
        self.dims = dims

    def forward(self, x):
        skips = []
        for i, b in enumerate(self.blocks):
            x = b(x)
            skips.append(x)
            if i < len(self.blocks) - 1:
                x = self.pool(x)
        return skips                                # fine to coarse


class SVCine(nn.Module):
    """Diagnosis conditioned segmentation network."""
    def __init__(self, n_classes=4, dims=(32, 64, 128, 256), emb=128):
        super().__init__()
        self.diag = DiagnosisEncoder(emb=emb)
        self.enc = SimpleEncoder(in_ch=1, dims=dims)
        rev = list(reversed(dims))
        self.ups = nn.ModuleList()
        self.dec = nn.ModuleList()
        self.films = nn.ModuleList()
        for i in range(len(rev) - 1):
            self.ups.append(nn.ConvTranspose2d(rev[i], rev[i + 1], 2, 2))
            self.dec.append(ConvBlock(rev[i + 1] * 2, rev[i + 1]))
            self.films.append(FiLM(emb, rev[i + 1]))  # condition each decoder stage
        self.head = nn.Conv2d(dims[0], n_classes, 1)

    def forward(self, x, d):
        z = self.diag(d)
        skips = self.enc(x)
        skips = list(reversed(skips))
        h = skips[0]
        for i, (up, block, film) in enumerate(zip(self.ups, self.dec, self.films)):
            h = up(h)
            skip = skips[i + 1]
            h = torch.cat([h, skip], dim=1)
            h = block(h)
            h = film(h, z)                         # diagnosis prior nudges features
        return self.head(h)


def dice_ce_loss(logits, target, eps=1.0):
    """Combined Dice and cross entropy, matching the paper's objective."""
    ce = F.cross_entropy(logits, target)
    probs = F.softmax(logits, dim=1)
    n_cls = logits.shape[1]
    oh = F.one_hot(target, n_cls).permute(0, 3, 1, 2).float()
    inter = (probs * oh).sum((0, 2, 3))
    denom = probs.sum((0, 2, 3)) + oh.sum((0, 2, 3))
    dice = 1 - ((2 * inter + eps) / (denom + eps)).mean()
    return ce + dice


def train_step(model, opt, batch):
    model.train()
    img, diag, gt = batch
    logits = model(img, diag)
    loss = dice_ce_loss(logits, gt)
    opt.zero_grad()
    loss.backward()
    opt.step()
    return loss.item()


@torch.no_grad()
def dice_score(model, batch, cls=2):
    """Foreground Dice for one class, e.g. the right ventricle."""
    model.eval()
    img, diag, gt = batch
    pred = model(img, diag).argmax(1)
    p, g = (pred == cls).float(), (gt == cls).float()
    inter = (p * g).sum()
    return (2 * inter / (p.sum() + g.sum()).clamp(min=1e-6)).item()


if __name__ == "__main__":
    # smoke test on dummy data. classes: 0 bg, 1 LV, 2 RV, 3 MYO
    model = SVCine(n_classes=4)
    opt = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=0.05)
    B, H, W = 2, 128, 128
    img = torch.rand(B, 1, H, W)
    diag = torch.tensor([[1., 0., 1.], [0., 1., 1.]])  # HLV/HRV/univentricular
    gt = torch.randint(0, 4, (B, H, W))

    for step in range(3):
        l = train_step(model, opt, (img, diag, gt))
        print("step", step, "loss", round(l, 4))
    print("RV dice", round(dice_score(model, (img, diag, gt), cls=2), 4))
    n = sum(p.numel() for p in model.parameters())
    print("parameters", round(n / 1e6, 2), "M")

Conclusion

The core achievement of SV-Cine is narrow and clear. It gives clinicians a way to segment single ventricle hearts on cine MRI with an automated model that no longer mislabels the dominant chamber, and it does so by handing the network the one piece of information that appearance alone cannot supply. On the internal cohort it reached a median Dice of 0.89 for the dominant left ventricle and 0.72 for the right ventricle, and it recovered a foundation model that had scored zero on the right ventricle in this population. Those are meaningful gains on a task where prior automated tools mostly failed.

The conceptual shift underneath is worth holding onto. For most of the past decade the reflex in medical imaging has been to want more data and bigger models. This work makes a quieter argument, that when the task is genuinely ambiguous, the highest leverage move can be to inject a small, trustworthy prior rather than to scale. A three element diagnosis vector, expanded by a tiny network and applied through Feature-wise Linear Modulation, did more for right ventricle accuracy than any amount of additional appearance based training could, because the missing information was never in the pixels to begin with.

The synthetic data pipeline deserves its own credit. Building a usable training set from only 11 real anatomies, by teaching a generative model to imagine diverse hearts and then paint plausible scans onto them, is a template for rare disease imaging in general. Collecting large annotated datasets for conditions that appear a few times per 10,000 births will never be practical, so the ability to manufacture anatomical diversity that respects a diagnosis is a genuinely useful capability, not just a convenience.

The honest remaining limitations keep expectations where they belong. This is a preprint on 39 patients across two centers, the synthetic images still look artificial, the model needs a diagnosis it cannot itself produce, and the hardest cases, severely hypoplastic ventricles measured at end systole, are exactly where the errors concentrate. None of that erases the result. It frames it. What the paper offers is early, well argued evidence that a specific combination of ideas works, not a finished clinical instrument.

For anyone building imaging models under data scarcity, the practical message is compact. Start from a strong pretrained backbone. Find the one clinical fact that resolves the ambiguity your task hides, and inject it cheaply rather than hoping the network infers it. Manufacture the diversity your real data lacks, tied to that same fact. SV-Cine shows the combination can turn a model that scored zero into one that clears the bar, and the reference code above is a place to start testing that idea on a rare condition of your own.

Frequently asked questions

What is single ventricle physiology?

It is a group of rare congenital heart disease subtypes in which a patient has only one fully functional heart ventricle, often paired with a severely underdeveloped second chamber. Both atria drain into the working ventricle, which mixes oxygen rich and oxygen poor blood. It is managed with a staged sequence of operations that usually ends with the Fontan procedure.

What does SV-Cine actually do?

SV-Cine segments the heart chambers and myocardium in cardiac cine MRI for patients with single ventricle physiology. It adapts a pretrained cardiac foundation model and adds the patient’s diagnosis as a small input, so the model can correctly identify the dominant and hypoplastic ventricles rather than mislabeling them based on appearance.

How does adding the diagnosis help the model?

The diagnosis is reduced to a three element vector flagging a hypoplastic left ventricle, a hypoplastic right ventricle, or univentricular morphology. That vector is turned into a small embedding and used to scale and shift the decoder features through Feature-wise Linear Modulation. In the ablation, removing this prior dropped right ventricle Dice from 0.72 to 0.14, so the clinical hint carries most of the accuracy.

Why did the team train on synthetic hearts?

Single ventricle disease is rare and anatomically varied, so real annotated scans are far too scarce to train a robust model. The team used a generative pipeline to create 500 synthetic cases with diverse anatomies conditioned on diagnosis, plus matching synthetic MRI, which supplied the variety that real data could not.

Is SV-Cine ready for clinical use?

No. It is an unreviewed preprint validated on 39 patients across two centers, and the model requires a diagnosis it cannot generate on its own. Accuracy is weakest for severely hypoplastic ventricles, where ejection fraction errors can reach tens of percentage points. The authors call for larger multi center studies with prospective validation before any clinical use.

How well did it work on patients from a different hospital?

On an external pediatric cohort of 19 patients, right ventricle Dice held steady at 0.73 compared with 0.72 internally, while left ventricle and myocardium scores dropped to 0.76 and 0.65. The authors attribute the drop mainly to a different mix of anatomies, with more dominant right ventricle cases than the training data contained.