InBrainSyn, Individual Brain Aging From One MRI Scan

Analysis by the aitrendblend editorial team  ·  Pillar, AI for medical imaging and healthcare  ·  Reading time about 15 min

Take a single brain MRI from a fifty year old and ask what that same brain will look like at seventy, both if the person ages normally and if they develop Alzheimer’s. Answering means bending the anatomy forward in time in a way that is specific to this brain, not a generic template, and doing it so the result is still a physically possible brain rather than a smear of pixels. A team spanning Stockholm, Las Palmas, and Cambridge, Massachusetts built a method that does this by borrowing an idea from differential geometry called parallel transport.

Why aging one specific brain is hard

The problem runs deeper than it first appears. Plenty of methods can build an average brain for a population and show how that average changes with age or disease. Those population templates are useful for studying overall trends, but they cannot tell you about the person in the scanner, whose ventricles, cortex, and hippocampus have their own shape and their own starting point. Two people the same age with the same diagnosis age differently, and an average trajectory washes out exactly the individual variation a clinician cares about.

Longitudinal data, repeated scans of the same person over years, is the obvious way to learn a personal trajectory, but it is expensive to collect, logistically hard, and riddled with missing timepoints. So the harder and more valuable question is the one InBrainSyn asks. Given only a single scan, with no history, can you still produce a believable personal aging path? The team behind it, Jingru Fu and colleagues at the KTH Royal Institute of Technology and the Karolinska Institute in Stockholm, with Neel Dey at the Massachusetts Institute of Technology, set out to answer yes.

There is a third demand that is easy to overlook. A synthesized future brain has to be anatomically plausible. A generative model that paints pixels freely can invent structures that no real brain could have, folds that tear, ventricles that appear from nowhere. For a tool meant to help study neurodegeneration, that kind of error is not a cosmetic flaw, it is a disqualifying one. Any method here has to guarantee that the aged brain is a real deformation of the starting brain, not a fantasy.

The core idea, deform rather than paint

Here is where it gets interesting. Instead of generating voxels directly, InBrainSyn generates a deformation, a smooth field that says how every point of the starting brain should move to reach its older self. If you only ever move tissue around, and you do it with a well behaved warp, you cannot create impossible anatomy. The mathematical name for a warp that stretches and folds smoothly without tearing or overlapping is a diffeomorphism, and building the method on diffeomorphisms is what gives it topological consistency for free.

These deformations are represented compactly through a stationary velocity field. Rather than store the full displacement of every voxel, the method stores a velocity field and recovers the displacement by following that velocity over a unit of time. Formally the displacement obeys a simple differential equation, and the full deformation is the result of integrating the velocity across the interval.

Read that as a recipe for motion. The deformation \(\phi\) starts as the identity, meaning every point sits where it began, and the velocity field \(\boldsymbol{v}\) pushes each point along as time runs from zero to one. Collect the whole journey and you get the finished warp, written as the exponential of the velocity field.

That exponential notation is not decoration. It signals that these velocity fields live in a curved space with real geometric structure, the Lie algebra of a group of deformations, and that structure is exactly what makes the next step possible. A useful property is that scaling the velocity composes cleanly, so following a velocity for a longer time is the same as composing shorter steps, which the method leans on for efficient computation.

Parallel transport, the trick that personalizes

The learning happens at the cohort level. Using a generative template network called AtlasGAN, the team trains two separate models, one on healthy control subjects and one on Alzheimer’s subjects, each of which can produce a sharp average brain template at any target age. From those templates it reads off the canonical deformation of aging, how the average healthy brain or the average diseased brain changes from one age to the next. That canonical change is a velocity field living on the average brain.

The catch is that this change belongs to the average brain, not to your patient. You cannot simply staple an average brain’s aging onto a specific brain, because the two sit at different points in the space of anatomies, and a velocity that makes sense on one is wrong on the other. This is the exact problem parallel transport solves. In differential geometry, parallel transport carries a vector along a path on a curved surface while preserving its meaning relative to the surface. Here the surface is the space of brain shapes, and the vector is the aging deformation.

InBrainSyn transports the cohort level aging field from the average template onto the individual brain along the deformation that links the two, using a numerical scheme called the pole ladder together with the Baker-Campbell-Hausdorff formula. The result is a personalized velocity field, the average aging pattern re expressed in the coordinates of this specific brain. Integrate it, apply the warp to the baseline scan, and you get the synthesized future brain.

In that shorthand \(\boldsymbol{u}\) is the cohort aging field from the template, \(\boldsymbol{v}\) is the deformation from the template to the subject, and \(\hat{\boldsymbol{u}}\) is the transported field that now carries the aging pattern onto the individual. The whole pipeline never paints a pixel. It moves them, which is why the output always remains a valid brain.

Modeling the switch from healthy to Alzheimer’s

One of the more striking capabilities is simulating a transition. Because the method holds two cohort models, a healthy one and a disease one, it can follow the healthy aging templates up to a chosen age and then hand the trajectory over to the Alzheimer’s templates from that age onward. That models the onset of disease at a specific point in a person’s life, producing a single continuous trajectory that starts as normal aging and bends into neurodegeneration. It is a clean way to ask a what if question about when disease begins, all from one baseline scan.

What the numbers show

The team trained and tested on OASIS-3, a longitudinal dataset for normal aging and Alzheimer’s. After curation the study used 2,366 scans from 1,158 subjects, split into 739 healthy controls and 419 Alzheimer’s subjects, with an eighty to twenty train and test split. The headline comparison pits InBrainSyn against methods that also need only a single scan, including a version of itself without parallel transport and the latent diffusion model BrLP, while two methods that require longitudinal data are shown only as an upper reference.

The numbers tell a clear story. Among methods that work from a single scan, InBrainSyn has the lowest error on the regional volumes clinicians actually track, and its ventricle and hippocampus errors approach those of Two Visits, which cheats by using a second real scan. The gap over BrLP is real and consistent, and it repeats in the Alzheimer’s cohort, where InBrainSyn cut the ventricle error to 0.433 against 0.544 for BrLP. On the six image similarity metrics the pattern held, with a structural similarity of 0.903 for healthy subjects and 0.901 for Alzheimer’s subjects against 0.848 and 0.852 for BrLP, and a peak signal to noise ratio roughly two and a half decibels higher.

An external test on a subset of a different dataset backed this up. On held out ADNI subjects InBrainSyn again posted the lowest single scan errors on most regions, for example a cerebrospinal fluid volume error of 0.265 against 0.619 for BrLP in the healthy cohort, which is the reassuring result because it came from data and a scanner the model never trained on.

A method that only moves tissue can approach the accuracy of one that peeks at a second real scan, while promising something the pixel painters cannot, a brain that is always anatomically real. On reading the single scan comparison

The efficiency story is part of the point

Accuracy is only half of why this matters. The other half is cost. Running a diffusion model on a full 3D brain is memory hungry, which is why BrLP and another baseline effectively operate at half resolution, and lower resolution hurts the very segmentation analysis clinicians rely on. InBrainSyn sidesteps this. It works on half resolution velocity fields but upsamples them to full resolution without losing much, because a smooth velocity field survives downsampling far better than an image does.

The memory figures make the contrast concrete. At peak, BrLP reached about 15.7 GB on the processor and near 18 GB on a graphics card, while InBrainSyn needed roughly 4.5 GB for its main steps and a mere 0.2 GB for the parallel transport itself. That is the difference between needing specialized hardware and running on a modest machine, which the authors rightly frame as what makes the method accessible for cost sensitive settings such as hospitals and smaller research groups. Sharper output and a lighter footprint at the same time is an unusual and welcome combination.

How this compares to a diffusion approach

It is worth pausing on the contrast with latent diffusion methods such as BrLP, because the two represent different philosophies for the same task. A latent diffusion model learns to generate a brain from noise, conditioned on age and metadata, which lets it in principle create new appearances that were not in the input, such as certain lesions. That freedom is also its risk, since a generative painter can drift from real anatomy and tends to smooth away fine detail through its autoencoder. InBrainSyn takes the opposite bet. By restricting itself to smooth deformations of the real scan it gives up the ability to invent genuinely new structures, and in exchange it guarantees plausibility, keeps full resolution, and runs light. Neither is strictly better. The deformation approach wins when faithfulness and efficiency matter most, and the generative approach has room to model changes that pure warping cannot capture.

The clinical translation gap

This is where enthusiasm needs a firm hand. Everything above is a research result on curated data, and the distance to a clinic is real. The scans came from OASIS-3 and were processed with a careful FreeSurfer pipeline, skull stripping, bias field correction, and registration to a standard space. Real hospital scans arrive on many scanners with many protocols and far messier quality, and the study does not show how the method behaves on that kind of input beyond one external cohort.

There is also the deeper gap between synthesizing a plausible future scan and trusting it for a decision. A synthesized brain is a hypothesis about a trajectory, not a diagnosis or a prognosis a clinician can hand to a patient. The authors are careful to frame the disease transition feature as a way to test hypotheses about localized degeneration and as a possible virtual control when a drug is applied, which are research uses with a human in the loop. Using such a forecast to guide the care of an individual would need prospective validation, regulatory review, and far more evidence than a single methods paper can provide. Treat the clinical framing as motivation, not as a result you can act on.

Honest limitations

The authors name their main weakness plainly. The hardest part is modeling Alzheimer’s progression across the cohort, because the disease follows diverse pathways and the model was trained on the whole Alzheimer’s group as if it were one process. Real Alzheimer’s is heterogeneous, and the volumetric trends in the disease group are noisy and fluctuating compared with the smoother healthy trends, which limits how faithfully any single set of templates can capture it.

Data scarcity is the second honest limitation, and it bites hardest exactly where the method is most novel. The disease transition experiment, arguably the most clinically interesting capability, could only be run on three subjects in OASIS-3 who met the strict criteria of starting healthy and progressing to Alzheimer’s with enough scans. Three subjects is a demonstration, not evidence of general performance, and the authors say so. One of those three even showed an atypical atrophy pattern that biased the comparison, a candid detail that shows how thin the ground is here.

A third caveat is structural and follows from the method itself. Because InBrainSyn only deforms the baseline scan, it cannot introduce features that are genuinely new rather than a reshaping of existing tissue, such as white matter hyperintensities that appear as the disease advances. Parallel transport is also an approximation, and its accuracy depends on the quality of the learned templates and the deformation between template and subject. The authors point to learning subtype specific Alzheimer’s templates and transporting real individual progression patterns as ways forward, an honest map of what is missing.

Full implementation in PyTorch

The code below is a compact and runnable reference for the ideas at the heart of InBrainSyn, integrating a stationary velocity field into a diffeomorphic warp, transporting a cohort deformation onto an individual, and applying the result to age a scan. It is a teaching implementation rather than the authors’ exact pipeline, using small 3D volumes and a simplified transport step so the structure stays readable. It builds a scaling and squaring integration layer, a spatial warp, a parallel transport approximation via the Baker-Campbell-Hausdorff formula, a synthesis routine, an evaluation, and a smoke test on dummy data so you can confirm it runs end to end.

# inbrainsyn_reference.py
# A compact, runnable reference for diffeomorphic aging with parallel transport.
# Educational small volume stand in for the 3D InBrainSyn pipeline.

import torch
import torch.nn.functional as F


def identity_grid(shape):
    """Build a normalized sampling grid, the identity deformation."""
    d, h, w = shape
    zs = torch.linspace(-1, 1, d)
    ys = torch.linspace(-1, 1, h)
    xs = torch.linspace(-1, 1, w)
    gz, gy, gx = torch.meshgrid(zs, ys, xs, indexing="ij")
    return torch.stack([gx, gy, gz], dim=-1).unsqueeze(0)  # (1, D, H, W, 3)


def integrate_svf(v, steps=6):
    """
    Scaling and squaring. Turns a stationary velocity field into a
    diffeomorphic displacement by exponentiating it, exp(v).
    v has shape (1, 3, D, H, W) in voxel displacement units.
    """
    disp = v / (2 ** steps)          # small initial step
    for _ in range(steps):
        disp = disp + warp_field(disp, disp)   # compose with itself
    return disp


def warp_field(field, disp):
    """Compose a displacement field with another via grid sampling."""
    shape = field.shape[2:]
    base = identity_grid(shape).to(field.device)
    # Convert voxel displacement to normalized coordinates.
    scale = torch.tensor([s - 1 for s in reversed(shape)],
                         dtype=torch.float32).view(1, 1, 1, 1, 3)
    grid = base + 2 * disp.permute(0, 2, 3, 4, 1) / scale
    sampled = F.grid_sample(field, grid, align_corners=True,
                            padding_mode="border")
    return sampled


def warp_image(img, disp):
    """Apply a displacement field to warp a 3D image."""
    shape = img.shape[2:]
    base = identity_grid(shape).to(img.device)
    scale = torch.tensor([s - 1 for s in reversed(shape)],
                         dtype=torch.float32).view(1, 1, 1, 1, 3)
    grid = base + 2 * disp.permute(0, 2, 3, 4, 1) / scale
    return F.grid_sample(img, grid, align_corners=True, padding_mode="border")


def lie_bracket(a, b):
    """Approximate the Lie bracket [a, b] of two velocity fields."""
    return jacobian_vector(b, a) - jacobian_vector(a, b)


def jacobian_vector(field, vec):
    """Directional derivative of field along vec, a finite difference."""
    eps = 1e-3
    return (warp_field(field, eps * vec) - field) / eps


def parallel_transport_bch(u, v, n=10):
    """
    Transport the cohort aging field u onto the individual along v,
    using a truncated Baker-Campbell-Hausdorff series (the pole ladder idea).
    Returns the individualized velocity field u_hat.
    """
    u_j = u.clone()
    for _ in range(n):
        br1 = lie_bracket(v, u_j) / n
        br2 = lie_bracket(v, lie_bracket(v, u_j)) / (2 * n * n)
        u_j = u_j + br1 + br2
    return u_j


def synthesize_aging(baseline_img, cohort_u, template_to_subject_v):
    """Age a single scan by transporting a cohort field and warping."""
    u_hat = parallel_transport_bch(cohort_u, template_to_subject_v)
    disp = integrate_svf(u_hat)          # exp(u_hat)
    return warp_image(baseline_img, disp)


def evaluate(pred, target):
    """Report MAE and a simple global SSIM proxy."""
    mae = (pred - target).abs().mean().item()
    px, py = pred.mean(), target.mean()
    vx, vy = pred.var(), target.var()
    cov = ((pred - px) * (target - py)).mean()
    c1, c2 = 0.01, 0.03
    ssim = ((2 * px * py + c1) * (2 * cov + c2)) / \
           ((px ** 2 + py ** 2 + c1) * (vx + vy + c2))
    return mae, ssim.item()


def smoke_test():
    """End to end check on dummy data. Confirms the pipeline runs."""
    torch.manual_seed(0)
    D = H = W = 16
    # A simple baseline brain, a bright blob on a dark field.
    zz, yy, xx = torch.meshgrid(torch.linspace(-1, 1, D),
                                torch.linspace(-1, 1, H),
                                torch.linspace(-1, 1, W), indexing="ij")
    blob = torch.exp(-4 * (xx ** 2 + yy ** 2 + zz ** 2))
    img = blob.view(1, 1, D, H, W)

    # A cohort aging field, gentle outward push, mimics ventricle growth.
    cohort_u = 0.6 * torch.stack([xx, yy, zz], dim=0).unsqueeze(0)
    # A template to subject field, a small random deformation.
    tmpl_to_subj = 0.1 * torch.randn(1, 3, D, H, W)

    aged = synthesize_aging(img, cohort_u, tmpl_to_subj)
    mae, ssim = evaluate(aged, img)
    print(f"aged scan shape {tuple(aged.shape)}")
    print(f"change from baseline, MAE {mae:.4f}")
    print(f"SSIM proxy to baseline {ssim:.4f}")
    # A valid warp keeps intensities in range, a quick plausibility check.
    print(f"intensity range [{aged.min():.3f}, {aged.max():.3f}]")


if __name__ == "__main__":
    smoke_test()

The smoke test builds a toy baseline brain, defines a cohort aging field and a template to subject deformation, transports the first onto the second, integrates it into a diffeomorphic warp, and applies it to synthesize an aged scan. Because the output is only a warp of the input, its intensities stay in range, the quick plausibility check the real method guarantees by construction. To move toward the real system you would train an AtlasGAN template network per cohort, obtain the cohort and template to subject velocity fields from a learned registration network, use the full pole ladder transport, and run at proper 3D resolution with upsampled velocity fields.

Conclusion

The core achievement of this work is a method that ages a single brain MRI forward, for either healthy aging or Alzheimer’s, with regional volume accuracy that beats a latent diffusion baseline while guaranteeing that every synthesized brain is anatomically real. Doing that from one scan, with no longitudinal history, is the hard version of the problem, and InBrainSyn approaches the accuracy of methods that quietly rely on a second real scan.

The conceptual shift underneath the result is worth restating because it travels. Choosing to generate a deformation instead of an image turns a plausibility problem into a guarantee. A smooth warp of a real brain is always a possible brain, so the method never has to hope its output is anatomically valid. Parallel transport is the elegant piece that makes this personal, carrying an average aging pattern onto a specific brain in a way that respects the geometry of anatomical shape rather than crudely pasting it on.

The efficiency is not a footnote, it is part of the contribution. Working on velocity fields that survive downsampling lets InBrainSyn stay at full image resolution while using several times less memory than a diffusion based competitor, which is the difference between a method that needs a cluster and one that runs on a modest workstation. Sharper results and a lighter footprint together are what could make individualized brain aging practical outside a few well funded labs.

The honest remaining limitations keep the excitement in proportion. Real Alzheimer’s is heterogeneous and the model treats it as one process, the most interesting disease transition capability was tested on only three subjects, and the deformation approach by design cannot create genuinely new features that are not a reshaping of the baseline. None of this undercuts the contribution. It locates it accurately as a strong research advance whose reach into varied disease subtypes and messy clinical data still has to be earned.

The direction from here is clear enough to name. Learning subtype specific Alzheimer’s templates, transporting real individual progression patterns rather than cohort averages, and testing on the kind of heterogeneous scans a hospital produces would each move the method forward. The code is open, which means others can build on it. Set beside the generative diffusion approaches to the same problem, InBrainSyn is a reminder that sometimes the most reliable way to imagine a future brain is to carefully bend the real one, and that is a genuinely useful idea to have in the toolkit.

Frequently asked questions

What does InBrainSyn do?

InBrainSyn synthesizes an individual patient’s future 3D brain MRI from a single baseline scan. It can follow a normal aging trajectory or an Alzheimer’s disease trajectory, and it can even simulate a transition from healthy aging to disease at a chosen age.

What is parallel transport and why does InBrainSyn use it?

Parallel transport is a way from differential geometry to carry a change from one point on a curved surface to another while preserving its meaning. InBrainSyn uses it to move an average aging pattern learned from a whole cohort onto one specific brain, which is what turns a population trend into a personalized prediction.

Why are the synthesized brains guaranteed to be anatomically plausible?

InBrainSyn generates a smooth deformation of the real scan rather than painting new pixels. That deformation is a diffeomorphism, a warp that stretches and folds without tearing or overlapping, so the aged brain is always a valid reshaping of the original anatomy by design.

How does InBrainSyn compare to a diffusion model like BrLP?

On the OASIS-3 dataset InBrainSyn achieved lower regional volume error and higher image similarity than the latent diffusion model BrLP among single scan methods, while using far less memory, around 4.5 GB against roughly 16 GB, and producing sharper full resolution scans. The tradeoff is that a deformation method cannot invent genuinely new structures, whereas a diffusion model can in principle.

Can InBrainSyn be used to diagnose or predict Alzheimer’s in a patient?

No. InBrainSyn is a research method that has not been validated or approved for clinical use. It synthesizes imaging patterns, not a diagnosis or a personal prognosis, and it was tested mainly on curated research data. Any clinical decision requires a qualified professional.

What are the main limitations of InBrainSyn?

The biggest limitation is capturing the heterogeneity of real Alzheimer’s, since the model treats the whole disease cohort as one process. The disease transition experiment used only three subjects, and because the method only deforms the baseline scan it cannot create features that are genuinely new rather than a reshaping of existing tissue.

Fu, J., Zheng, Y., Dey, N., Ferreira, D., and Moreno, R. Synthesizing individualized aging brains in health and disease with generative models and parallel transport. Medical Image Analysis, volume 105 (2025), article 103669. KTH Royal Institute of Technology and Karolinska Institute, Stockholm, with the Massachusetts Institute of Technology and data from the Open Access Series of Imaging Studies version 3. Available at https://doi.org/10.1016/j.media.2025.103669.

This analysis is based on the published paper and an independent evaluation of its claims.