OSCR

Realistic PET image synthesis from MRI for automated inference of brain atrophy and Alzheimer's.

Code ↔ Paper

13 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 13 matches
  1. [1] § Results › MRI2PET generates realistic PET images from MRI scans ↔ src/evaluation/calcFID.py, lines 1–32 · score 0.77 · Fr chet inception, inception v3, axial slicing, distance, FID, trained
  2. [2] § STAR★Methods › Method details › MRI2PET › Denoising with DDPM ↔ src/models/diffusionModel.py, lines 1–30 · score 0.65 · timestep embedding, diffusion models, CNN, DDPM, architectures, linear
  3. [3] § Results › MRI2PET generates realistic PET images from MRI scans ↔ src/evaluation/calcRealFID.py, lines 1–32 · score 0.63 · Fr chet, inception v3, distance, FID, model, PET
  4. [4] § STAR★Methods › Method details › MRI2PET › Laplacian Pyramid Loss Formalization ↔ src/models/diffusionModel.py, lines 287–299 · score 0.62 · Laplacian Pyramid loss, predicted image, predicted noise, model
  5. [5] § STAR★Methods › Method details › MRI2PET › Laplacian Pyramid Loss Formalization ↔ src/train_scripts/tune_MRI2PET.py, lines 1–61 · score 0.58 · noise prediction, Laplacian Pyramid, weighted, DDPM, loss, training
  6. [6] § STAR★Methods › Method details › MRI2PET › Style-Transferred Pre-Training ↔ src/utils/styleTransfer.py, lines 1–29 · score 0.57 · style transfer, neural, template, MRIs, real PET, layers
  7. [7] § STAR★Methods › Method details › MRI2PET › Style-Transferred Pre-Training ↔ src/train_scripts/pretrain_MRI2PET.py, lines 1–60 · score 0.55 · style transfer, added noise, diffusion model, real PET, tuning, training
  8. [8] § Results › Dataset ↔ src/utils/PET_PreProcessing.py, lines 1–53 · score 0.54 · rigidly registered, affine registered, frame, PET, MRI
  9. [9] § STAR★Methods › Method details › MRI2PET ↔ src/utils/styleTransfer.py, lines 1–29 · score 0.54 · synthesizing PET, Style Transferred, MRI2PET, Training
  10. [10] § Results › MRI2PET enhances downstream machine learning tasks ↔ src/evaluation/calcUtilityMMSE.py, lines 1–32 · score 0.54 · Mini Mental State, MMSE, utility, score, ADNI, prediction
  11. [11] § STAR★Methods › Method details › Experimental Setup ↔ src/generation/generateDownstream.py, lines 1–34 · score 0.54 · downstream utility, MRI2PET model, cluster, ADNI, train
  12. [12] § Results › MRI2PET enhances downstream machine learning tasks ↔ src/evaluation/calcUtility.py, lines 1–42 · score 0.52 · MMSE regression, synthetic PET, AUROC, real PET, accuracy, classification
  13. [13] § Results › Baseline comparisons › External baselines ↔ src/baselines/models/cdcGAN.py, lines 1–21 · score 0.51 · cross domain correspondences, CDC, GAN, External, baselines

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 334 lines · 13 KB · MIT · 2 matches

  1. """MRI-conditioned 3D diffusion model used by MRI2PET.
  3. This module defines the main generative architecture in the paper: a 3D
  4. U-Net DDPM that takes a T1-weighted MRI volume as context and predicts the
  5. noise that was added to a paired amyloid-PET volume.
  7. Layout:
  9. * ``ImageEncoder`` — a small 3D CNN that produces a fixed-size embedding of
  10. the MRI context volume. The embedding is added to the standard
  11. sinusoidal timestep embedding and threaded through every U-Net block.
  12. * ``RMSNorm`` / ``LinearAttention`` / ``DoubleConv`` /
  13. ``DownBlock`` / ``UpBlock`` — building blocks of the U-Net.
  14. * ``DiffusionModel`` — the full model. Implements the standard DDPM noise
  15. schedule, an optional Laplacian-pyramid auxiliary loss (the paper's
  16. ``L_lap`` term, weighted by ``config.laplace_lambda``), DDPM ancestral
  17. sampling, and per-image NLL evaluation used by
  18. ``src/evaluation/calcBitsPerDim.py``.
  20. Checkpoints written by ``src/train_scripts/pretrain_MRI2PET.py`` and
  21. ``src/train_scripts/tune_MRI2PET.py`` store this model's state dict under
  22. the ``'model'`` key.
  23. """
  25. import torch
  26. import numpy as np
  27. from tqdm import tqdm
  28. import torch.nn as nn
  29. import torch.nn.functional as F
  30. from einops import rearrange
  32. class ImageEncoder(nn.Module):
  33. def __init__(self, config):
  34. super(ImageEncoder, self).__init__()
  35. self.depth = config.n_mri_channels
  36. self.image_dim = config.mri_image_dim
  37. self.conv1 = nn.Conv3d(1, 8, kernel_size=3, stride=1, padding=1)
  38. self.conv2 = nn.Conv3d(8, 16, kernel_size=3, stride=1, padding=1)
  39. self.conv3 = nn.Conv3d(16, 32, kernel_size=3, stride=1, padding=1)
  40. self.conv4 = nn.Conv3d(32, 64, kernel_size=3, stride=1, padding=1)
  41. self.flat_dim = 64 * (self.depth // 16) * (self.image_dim // 16) * (self.image_dim // 16)
  42. self.fc1 = nn.Linear(self.flat_dim, config.embed_dim)
  43. self.fc2 = nn.Linear(config.embed_dim, config.embed_dim)
  45. def forward(self, x):
  46. # Convolution + ReLU + MaxPooling
  47. x = F.relu(self.conv1(x))
  48. x = F.max_pool3d(x, 2)
  50. x = F.relu(self.conv2(x))
  51. x = F.max_pool3d(x, 2)
  53. x = F.relu(self.conv3(x))
  54. x = F.max_pool3d(x, 2)
  56. x = F.relu(self.conv4(x))
  57. x = F.max_pool3d(x, 2)
  59. # Flattening the output
  60. x = x.view(-1, self.flat_dim)
  62. # Passing through the fully connected layers
  63. x = F.relu(self.fc1(x))
  64. x = self.fc2(x)
  65. return x
  67. class RMSNorm(nn.Module):
  68. def __init__(self, dim):
  69. super().__init__()
  70. self.g = nn.Parameter(torch.ones(1, dim, 1, 1, 1))
  72. def forward(self, x):
  73. return F.normalize(x, dim = 1) * self.g * (x.shape[1] ** 0.5)
  75. class LinearAttention(nn.Module):
  76. def __init__(self, dim, heads=4, dim_head=32):
  77. super().__init__()
  78. self.heads = heads
  79. hidden_dim = dim_head * heads
  80. self.to_qkv = nn.Conv3d(dim, hidden_dim * 3, 1, bias = False)
  81. self.to_out = nn.Conv3d(hidden_dim, dim, 1)
  83. def forward(self, x):
  84. b, c, d, h, w = x.shape
  85. qkv = self.to_qkv(x)
  86. q, k, v = rearrange(qkv, 'b (qkv heads c) d h w -> qkv b heads c (d h w)', heads = self.heads, qkv=3)
  87. k = k.softmax(dim=-1)
  88. context = torch.einsum('bhdn,bhen->bhde', k, v)
  89. out = torch.einsum('bhde,bhdn->bhen', context, q)
  90. out = rearrange(out, 'b heads c (d h w) -> b (heads c) d h w', heads=self.heads, d=d, h=h, w=w)
  91. return self.to_out(out)
  93. class DoubleConv(nn.Module):
  94. def __init__(self, in_channels, out_channels, mid_channels=None, residual=False):
  95. super(DoubleConv, self).__init__()
  96. self.residual = residual
  97. if not mid_channels:
  98. mid_channels = out_channels
  99. self.double_conv = nn.Sequential(
  100. nn.Conv3d(in_channels, mid_channels, kernel_size=3, padding=1, bias=False),
  101. nn.GroupNorm(1, mid_channels),
  102. nn.GELU(),
  103. nn.Conv3d(mid_channels, out_channels, kernel_size=3, padding=1, bias=False),
  104. nn.GroupNorm(1, out_channels),
  105. )
  107. def forward(self, x):
  108. if self.residual:
  109. return F.gelu(x + self.double_conv(x))
  110. else:
  111. return self.double_conv(x)
  113. class DownBlock(nn.Module):
  114. def __init__(self, in_channels, out_channels, emb_dim=128):
  115. super(DownBlock, self).__init__()
  116. self.maxpool_conv = nn.Sequential(
  117. nn.MaxPool3d(2),
  118. DoubleConv(in_channels, in_channels, residual=True),
  119. DoubleConv(in_channels, out_channels),
  120. )
  122. self.emb_layer = nn.Sequential(
  123. nn.SiLU(),
  124. nn.Linear(
  125. emb_dim,
  126. out_channels
  127. ),
  128. )
  130. def forward(self, x, t):
  131. x = self.maxpool_conv(x)
  132. emb = self.emb_layer(t)[:, :, None, None, None].repeat(1, 1, x.shape[-3], x.shape[-2], x.shape[-1])
  133. return x + emb
  135. class UpBlock(nn.Module):
  136. def __init__(self, in_channels, out_channels, emb_dim=128):
  137. super(UpBlock, self).__init__()
  138. self.up = nn.Upsample(scale_factor=2, mode="trilinear", align_corners=True)
  139. self.conv = nn.Sequential(
  140. DoubleConv(in_channels, in_channels, residual=True),
  141. DoubleConv(in_channels, out_channels, in_channels // 2),
  142. )
  144. self.emb_layer = nn.Sequential(
  145. nn.SiLU(),
  146. nn.Linear(
  147. emb_dim,
  148. out_channels
  149. ),
  150. )
  152. def forward(self, x, skip_x, t):
  153. x = self.up(x)
  154. x = torch.cat([skip_x, x], dim=1)
  155. x = self.conv(x)
  156. emb = self.emb_layer(t)[:, :, None, None, None].repeat(1, 1, x.shape[-3], x.shape[-2], x.shape[-1])
  157. return x + emb
  159. class DiffusionModel(nn.Module):
  160. def __init__(self, config, laplace=0):
  161. super(DiffusionModel, self).__init__()
  162. self.num_timesteps = config.num_timesteps
  163. self.beta_start = config.beta_start
  164. self.beta_end = config.beta_end
  165. self.beta = torch.linspace(self.beta_start, self.beta_end, self.num_timesteps)
  166. self.alpha = 1 - self.beta
  167. self.alpha_hat = torch.cumprod(self.alpha, dim=0)
  168. self.image_dim = config.pet_image_dim
  169. self.n_channels = config.n_pet_channels
  170. self.embed_dim = config.embed_dim
  171. self.llambda = laplace
  173. self.contextEmbedding = ImageEncoder(config)
  174. self.inc = DoubleConv(1, 8)
  176. self.down1 = DownBlock(8, 16, self.embed_dim)
  177. self.sa1 = LinearAttention(16)
  178. self.down2 = DownBlock(16, 32, self.embed_dim)
  179. self.sa2 = LinearAttention(32)
  180. self.down3 = DownBlock(32, 64, self.embed_dim)
  181. self.sa3 = LinearAttention(64)
  182. self.down4 = DownBlock(64, 128, self.embed_dim)
  183. self.sa4 = LinearAttention(128)
  185. self.bot1 = DoubleConv(128, 128)
  186. self.bot2 = DoubleConv(128, 128)
  187. self.bot3 = DoubleConv(128, 128)
  189. self.up1 = UpBlock(192, 64, self.embed_dim)
  190. self.sa5 = LinearAttention(64)
  191. self.up2 = UpBlock(96, 32, self.embed_dim)
  192. self.sa6 = LinearAttention(32)
  193. self.up3 = UpBlock(48, 16, self.embed_dim)
  194. self.sa7 = LinearAttention(16)
  195. self.up4 = UpBlock(24, 8, self.embed_dim)
  196. self.sa8 = LinearAttention(8)
  197. self.outc = nn.Conv3d(8, 1, kernel_size=1)
  199. def timestep_embedding(self, t, channels, max_period=100):
  200. inv_freq = 1.0 / (
  201. max_period
  202. ** (torch.arange(0, channels, 2, device=t.device).float() / channels)
  203. )
  204. pos_enc_a = torch.sin(t.unsqueeze(1).repeat(1, channels // 2) * inv_freq)
  205. pos_enc_b = torch.cos(t.unsqueeze(1).repeat(1, channels // 2) * inv_freq)
  206. pos_enc = torch.cat([pos_enc_a, pos_enc_b], dim=-1)
  207. return pos_enc
  209. def sample_timesteps(self, n, device='cpu'):
  210. return torch.randint(low=1, high=self.num_timesteps, size=(n,), device=device)
  212. def noise_images(self, x, t, noise_level=1):
  213. "Add noise to images at instant t"
  214. self.alpha_hat = self.alpha_hat.to(x.device)
  215. sqrt_alpha_hat = torch.sqrt(self.alpha_hat.to(t.device)[t])[:, None, None, None].to(x.device)
  216. sqrt_one_minus_alpha_hat = torch.sqrt(1 - self.alpha_hat[t])[:, None, None, None].to(x.device)
  217. Ɛ = torch.randn_like(x)
  218. Ɛ = noise_level * Ɛ
  219. return sqrt_alpha_hat * x + sqrt_one_minus_alpha_hat * Ɛ, Ɛ
  221. def _forward(self, noised_images, t, condImage):
  222. "Forward pass through the model"
  223. noised_images = noised_images.unsqueeze(1)
  224. condImage = condImage.unsqueeze(1)
  226. emb = self.timestep_embedding(t, self.embed_dim, max_period=self.num_timesteps)
  227. emb += self.contextEmbedding(condImage)
  229. x1 = self.inc(noised_images)
  230. x2 = self.down1(x1, emb)
  231. x2 = self.sa1(x2)
  232. x3 = self.down2(x2, emb)
  233. x3 = self.sa2(x3)
  234. x4 = self.down3(x3, emb)
  235. x4 = self.sa3(x4)
  236. x5 = self.down4(x4, emb)
  237. x5 = self.sa4(x5)
  239. x5 = self.bot1(x5)
  240. x5 = self.bot2(x5)
  241. x5 = self.bot3(x5)
  243. x = self.up1(x5, x4, emb)
  244. x = self.sa5(x)
  245. x = self.up2(x, x3, emb)
  246. x = self.sa6(x)
  247. x = self.up3(x, x2, emb)
  248. x = self.sa7(x)
  249. x = self.up4(x, x1, emb)
  250. x = self.sa8(x)
  251. x = self.outc(x)
  253. x = x.squeeze(1)
  254. condImage = condImage.squeeze(1)
  255. return x
  257. def construct_image(self, noised_x, t, pred_noise):
  258. sqrt_alpha_hat = torch.sqrt(self.alpha_hat[t])[:, None, None, None].to(noised_x.device)
  259. sqrt_one_minus_alpha_hat = torch.sqrt(1 - self.alpha_hat[t])[:, None, None, None].to(noised_x.device)
  260. pred_x = (1 / sqrt_alpha_hat) * noised_x - (sqrt_one_minus_alpha_hat / sqrt_alpha_hat) * pred_noise
  261. return pred_x
  263. def laplacian_pyramid_loss(self, img1, img2, max_levels=5):
  264. def pyr_down(image):
  265. return F.avg_pool2d(image, kernel_size=2, stride=2, padding=0)
  267. def laplacian_pyramid(image, max_levels):
  268. current = image
  269. pyramid = []
  271. for _ in range(max_levels):
  272. down = pyr_down(current)
  273. up = F.interpolate(down, size=current.shape[-2:], mode='bilinear', align_corners=False)
  274. diff = current - up
  275. pyramid.append(diff)
  276. current = down
  278. return pyramid
  280. pyramid1 = laplacian_pyramid(img1, max_levels)
  281. pyramid2 = laplacian_pyramid(img2, max_levels)
  283. loss = sum(F.mse_loss(a, b) for a, b in zip(pyramid1, pyramid2))
  285. return loss
  287. def forward(self, context, input_images, gen_loss=True, noise_level=1, includeLaplace=False):
  288. noise_level = torch.sqrt(torch.tensor(noise_level))
  289. t = self.sample_timesteps(input_images.size(0), context.device)
  290. noised_images, noise = self.noise_images(input_images, t, noise_level)
  291. predictedNoise = self._forward(noised_images, t, context)
  292. if gen_loss:
  293. loss = F.mse_loss(noise, predictedNoise)
  294. if includeLaplace and self.llambda > 0:
  295. predictedImage = self.construct_image(noised_images, t, predictedNoise)
  296. laplace_loss = self.laplacian_pyramid_loss(input_images, predictedImage)
  297. loss += self.llambda * laplace_loss
  298. return loss, predictedNoise
  299. return predictedNoise
  301. def generate(self, context):
  302. n = context.size(0)
  303. x = torch.randn(n, self.n_channels, self.image_dim, self.image_dim, device=context.device)
  304. for timestep in tqdm(reversed(range(1, self.num_timesteps)), total=self.num_timesteps-1):
  305. t = (torch.ones(n) * timestep).long().to(context.device)
  306. predicted_noise = self._forward(x, t, context)
  307. alpha = self.alpha[t][:, None, None, None].to(context.device)
  308. alpha_hat = self.alpha_hat[t][:, None, None, None].to(context.device)
  309. beta = self.beta[t][:, None, None, None].to(context.device)
  310. if timestep > 1:
  311. noise = torch.randn_like(x, device=context.device)
  312. else:
  313. noise = torch.zeros_like(x, device=context.device)
  314. x = 1 / torch.sqrt(alpha) * (x - ((1 - alpha) / (torch.sqrt(1 - alpha_hat))) * predicted_noise) + torch.sqrt(beta) * noise
  315. return x
  317. def calculate_nll(self, context, input_images):
  318. nll = 0.0
  319. for timestep in tqdm(range(1, self.num_timesteps), leave=False):
  320. t = torch.ones(input_images.size(0), device=context.device, dtype=torch.long) * timestep
  321. noised_images, actual_noise = self.noise_images(input_images, t)
  322. predicted_noise = self._forward(noised_images, t, context)
  324. # Calculate the mean squared error between predicted and actual noise
  325. mse = torch.mean((predicted_noise - actual_noise) ** 2).cpu().numpy()
  327. # Convert MSE to log-likelihood assuming Gaussian noise
  328. sigma_t = torch.sqrt(1 - self.alpha_hat[t]).cpu().numpy()
  329. log_likelihood = -mse / (2 * sigma_t**2) - 0.5 * np.log(2 * np.pi * sigma_t**2)
  331. # Accumulate NLL
  332. nll += log_likelihood
  334. return [- nll[i].mean().item() * input_images[i].numel() for i in range(input_images.size(0))]

diffusionModel.py at commit 2a978e3, under MIT · at the source

Overview

Authors: Brandon Theodorou1,2, Anant Dadu2,3, Brian Avants4, Mike Nalls2,5,3, Jimeng Sun1, Faraz Faghri2,5,3
ORCID iDs: Brandon Theodorou, Faraz Faghri
  1. Department of Computer Science, University of Illinois at Urbana-Champaign, Urbana, IL, USA
  2. Center for Alzheimer’s and Related Dementias, National Institutes of Health, Bethesda, MD, USA
  3. DataTecnica, LLC, Washington, DC, USA
  4. University of Virginia, Department of Radiology and Medical Imaging, Charlottesville, VA, USA
  5. Laboratory of Neurogenetics, National Institute on Aging, National Institutes of Health, Bethesda, MD, USA
Institutions: National Institutes of Health (United States); University of Illinois Urbana-Champaign (United States); University of Virginia (United States); National Institute on Aging (United States)
Journal: iScience, volume 29, issue 5, article 115747
Dates: received 30 July 2025; accepted 13 April 2026; published online 15 April 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1016/j.isci.2026.115747 · PMID 42164525 · PMCID PMC13185845 · OpenAlex W7154514079
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), PET / SPECT (modality), Alzheimer's / dementia (population), methods / tools (subfield)
Methods: Connectivity, Statistics, Machine learning
Keywords: neurology, neuroscience, computing methodology, machine learning
Topic: Medical Imaging Techniques and Applications (Radiology, Nuclear Medicine and Imaging, Medicine), according to OpenAlex
Funding: NSF (SCH-2205289, SCH-2014438, IIS-2034479); Intramural Research Program; NIH; National Institute on Aging; U.S. Department of Health and Human Services (ZO1 AG000534); NINDS
Citations: not cited yet (Europe PMC); 48 references in the paper

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repositories

Its files are read in the Code ↔ Paper reader above, with 13 matches between paragraphs and lines of code.

Zenodo 15089724

License: CC-BY-4.0
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: the text, “Key resources table”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 29 September 2026: the link answers (HTTP 200)
  • 29 September 2026: the link answers (HTTP 200)
At the source: doi.org/10.5281/zenodo.15089724

btheodorou99/MRI2PET

License: MIT
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: 2a978e3eda78246c6dd3fa28cbf7382b05c1f287, 20 May 2026
Languages: Python (79), Shell (43)
Size: 139 files, 122 scripts
Software Heritage: not archived
Found in: the text, “Experimental Setup”
Holds: README, license file, CITATION.cff, environment (requirements.txt)
Not found: tests, continuous integration, documentation
Tools: NumPy (55 files), PyTorch (51 files), scikit-learn (16 files), ANTs (14 files), SciPy (11 files), pandas (7 files), NiBabel (6 files), Matplotlib (5 files), scikit-image (4 files), dcm2niix (3 files), Pillow (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
124 files
At the source: github.com/btheodorou99/MRI2PET/

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 122 scripts, each with its path and the digest of its content;
  • 13 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Code and data availability statement

The paper has a code and data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

  • it says that the data are available on request

Read it in the paper: doi.org/10.1016/j.isci.2026.115747.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 29 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 6 authors, 4 keywords, 6 funders, 23 references.

Cite

This paper

Theodorou, B., Dadu, A., Avants, B., Nalls, M., Sun, J., & Faghri, F. (2026). Realistic PET image synthesis from MRI for automated inference of brain atrophy and Alzheimer's. iScience, 29(5), 115747. https://doi.org/10.1016/j.isci.2026.115747

BibTeX

@article{theodorou2026realistic,
author = {Theodorou, Brandon and Dadu, Anant and Avants, Brian and Nalls, Mike and Sun, Jimeng and Faghri, Faraz},
title = {{Realistic PET image synthesis from MRI for automated inference of brain atrophy and Alzheimer's}},
journal = {iScience},
year = {2026},
month = apr,
volume = {29},
number = {5},
pages = {115747},
publisher = {Elsevier},
issn = {2589-0042},
doi = {10.1016/j.isci.2026.115747},
url = {https://doi.org/10.1016/j.isci.2026.115747},
pmid = {42164525},
pmcid = {PMC13185845}
}

RIS

TY - JOUR
AU - Theodorou, Brandon
AU - Dadu, Anant
AU - Avants, Brian
AU - Nalls, Mike
AU - Sun, Jimeng
AU - Faghri, Faraz
TI - Realistic PET image synthesis from MRI for automated inference of brain atrophy and Alzheimer's
T2 - iScience
J2 - iScience
PY - 2026
DA - 2026/04/15
VL - 29
IS - 5
SP - 115747
SN - 2589-0042
PB - Elsevier
DO - 10.1016/j.isci.2026.115747
UR - https://doi.org/10.1016/j.isci.2026.115747
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.isci.2026.115747",
"type": "article-journal",
"title": "Realistic PET image synthesis from MRI for automated inference of brain atrophy and Alzheimer's",
"container-title": "iScience",
"author": [
{
"family": "Theodorou",
"given": "Brandon"
},
{
"family": "Dadu",
"given": "Anant"
},
{
"family": "Avants",
"given": "Brian"
},
{
"family": "Nalls",
"given": "Mike"
},
{
"family": "Sun",
"given": "Jimeng"
},
{
"family": "Faghri",
"given": "Faraz"
}
],
"container-title-short": "iScience",
"volume": "29",
"issue": "5",
"page": "115747",
"DOI": "10.1016/j.isci.2026.115747",
"PMID": "42164525",
"PMCID": "PMC13185845",
"ISSN": "2589-0042",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.isci.2026.115747",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
15
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1038/s41597-026-07248-6 [code]
A large-scale fMRI dataset for vision-language semantic association.
Journal: Scientific data
In common: dcm2niix, ANTs, scikit-image, 8 other tools, methods / tools
[2] doi:10.3390/jimaging12070276 [code]
Hyperelastic Regularization for Near-Diffeomorphic Transformer-Based Brain MRI Registration.
Journal: Journal of imaging
In common: ANTs, scikit-image, Pillow, 7 other tools, methods / tools, structural MRI / diffusion
[3] doi:10.1002/alz.71649 [code]
Postmortem brain MRI reveals differential associations of subcortical and limbic volumes with cortical thinning and neurodegenerative pathologies.
Journal: Alzheimer's & dementia : the journal of the Alzheimer's Association
In common: ANTs, scikit-image, Pillow, 7 other tools, Alzheimer's / dementia, structural MRI / diffusion
[4] doi:10.1371/journal.pcbi.1014555 [code]
Body surface potential driven personalisation of electrophysiological digital twins in hypertrophic cardiomyopathy.
Journal: PLoS computational biology
In common: ANTs, scikit-image, Pillow, 7 other tools, structural MRI / diffusion
[5] doi:10.2463/mrms.mp.2024-0149 [code]
Image Distortion Correction for Diffusion MR Imaging Using a Transformer-based U-Net.
Journal: Magnetic resonance in medical sciences : MRMS : an official journal of Japan Society of Magnetic Resonance in Medicine
In common: ANTs, scikit-image, Pillow, 7 other tools, structural MRI / diffusion
[6] doi:10.1038/s41467-026-73373-w [code]
Mapping neuro-vascular unit communications reveals distinct angiogenic programs across developing mouse brain regions.
Journal: Nature communications
In common: ANTs, scikit-image, Pillow, 7 other tools
[7] doi:10.1038/s41467-026-71918-7 [code]
Developmental disinhibition gates language lateralization in childhood.
Journal: Nature communications
In common: dcm2niix, ANTs, NiBabel, 6 other tools
[8] doi:10.1038/s41467-026-71719-y [code]
Brain functional-structural gradient coupling reflects development, behavior and genetic influences.
Journal: Nature communications
In common: dcm2niix, ANTs, NiBabel, 6 other tools
[9] doi:10.1162/imag.a.1164 [code]
Bias and generalizability of brain age prediction models: A multi-cohort evaluation with anatomical and interpretability insights.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: ANTs, Pillow, NiBabel, 6 other tools, Alzheimer's / dementia, structural MRI / diffusion
[10] doi:10.1038/s41597-026-06869-1 [code]
Individual Brain Charting: fifth release of high-resolution fMRI data for cognitive mapping.
Journal: Scientific data
In common: ANTs, scikit-image, Pillow, 6 other tools, methods / tools

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.