OSCR

Multispectral 7 Tesla MRI as a potential predictor of dopamine transporter deficiency in Parkinson's disease.

Code ↔ Paper

9 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 9 matches
  1. [1] § Methods › Contrastive embedder ↔ embedder/trainer.py, lines 138–165 · score 0.94 · additive Gaussian noise, monotone gamma, channel gain, low rank, feature dropout, shifts
  2. [2] § Methods › DaT predictor ↔ nt_mlp/trainer.py, lines 16–64 · score 0.83 · cosine annealing scheduler, mixed precision, AdamW, weight decay, batch, train
  3. [3] § Methods › Contrastive embedder ↔ embedder/model.py, lines 84–100 · score 0.72 · ReLU, layer normalization, predicts subject, subject head, hidden, dropout
  4. [4] § Methods › Contrastive embedder ↔ nt_mlp/trainer.py, lines 16–64 · score 0.69 · mixed precision, AdamW, weight decay, batch, losses, train
  5. [5] § Methods › Contrastive embedder ↔ embedder/trainer.py, lines 22–103 · score 0.69 · weight decay, adversarial losses, mixed precision, adversarial heads, encoder, batch
  6. [6] § Methods › Contrastive embedder ↔ embedder/trainer.py, lines 22–103 · score 0.63 · hidden layers, adversarial heads, coordinate head, architectural, dimensional, encoder
  7. [7] § Methods › Contrastive embedder ↔ embedder/model.py, lines 190–229 · score 0.60 · ReLU, layer normalization, vectors, hidden, MLP, encoder
  8. [8] § Methods › Contrastive embedder ↔ nt_mlp/core_model.py, lines 25–67 · score 0.58 · ReLU, layer normalization, activation, MLP, hidden, dropout
  9. [9] § Results › Quantitative ROI analysis ↔ nt_mlp/cv_evaluator.py, lines 887–1006 · score 0.52 · predicted binding potentials, boxplots, FDR, fold, striatum, HC

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 · 637 lines · 25 KB · MIT · 3 matches

  1. import torch
  2. import torch.optim as optim
  3. from torch.utils.data import DataLoader
  4. import torch.nn.functional as F
  5. import numpy as np
  6. from pathlib import Path
  7. import json
  8. import argparse
  9. import math
  10. import matplotlib.pyplot as plt
  13. from augs import (
  14. Compose, RandomGlobalGainShift, RandomChannelLowRankGain,
  15. BatchPartitionGain, RandomMonotoneGammaWarp, AdditiveGaussianNoise,
  16. FeatureDropout
  17. )
  20. from model import *
  21. from data_handler import ContrastiveDataHandler
  22. def parse_args():
  23. """Parse command-line arguments for contrastive learning training.
  25. Defaults are set to match the values used in run_experiment.py.
  26. """
  27. parser = argparse.ArgumentParser(description='Contrastive Learning for MRI Voxels')
  29. # Required arguments
  30. parser.add_argument('--subjects', nargs='+', required=True,
  31. help='List of training subject IDs')
  32. parser.add_argument('--exp_name', type=str, required=True,
  33. help='Experiment name for saving outputs')
  35. # Data settings
  36. parser.add_argument('--test_subjects', nargs='+', default=None,
  37. help='Test subject IDs (for visualization only)')
  38. parser.add_argument('--fname', type=str, default="train_data.npy",
  39. help='Data filename to load from each subject directory')
  41. # Training hyperparameters (defaults from run_experiment.py)
  42. parser.add_argument('--steps', type=int, default=4000,
  43. help='Number of training steps')
  44. parser.add_argument('--batch_vox', type=int, default=16384,
  45. help='Number of voxels per batch')
  46. parser.add_argument('--lr', type=float, default=1e-4,
  47. help='Learning rate')
  48. parser.add_argument('--weight_decay', type=float, default=1e-2,
  49. help='Weight decay (L2 regularization)')
  50. parser.add_argument('--temperature', type=float, default=0.07,
  51. help='Temperature for contrastive loss')
  52. parser.add_argument('--random_seed', type=int, default=66,
  53. help='Random seed for reproducibility')
  55. # Model architecture (defaults from run_experiment.py)
  56. parser.add_argument('--embedding_dim', type=int, default=16,
  57. help='Embedding dimension')
  58. parser.add_argument('--hidden_dims', nargs='+', type=int, default=[2048, 2048, 2048, 2048],
  59. help='Hidden layer dimensions')
  60. parser.add_argument('--dropout', type=float, default=0.3,
  61. help='Dropout rate for encoder')
  62. parser.add_argument('--hidden_dim_adv', type=int, default=512,
  63. help='Hidden dimension for adversarial heads')
  64. parser.add_argument('--adv_dropout', type=float, default=0.3,
  65. help='Dropout rate for adversarial heads')
  67. # Learning rate warmup
  68. parser.add_argument('--warmup_steps', type=int, default=0,
  69. help='Linear LR warmup steps (0 disables warmup)')
  70. parser.add_argument('--warmup_start_factor', type=float, default=0.1,
  71. help='Warmup start factor relative to lr')
  73. # Loss weights (defaults from run_experiment.py)
  74. parser.add_argument('--w_inst', type=float, default=1.0,
  75. help='Weight for instance contrastive loss')
  76. parser.add_argument('--w_coord_adv', type=float, default=20.0,
  77. help='Weight for coordinate adversary loss')
  78. parser.add_argument('--w_subj_adv', type=float, default=20.0,
  79. help='Weight for subject adversary loss')
  81. # Adversarial training (defaults from run_experiment.py)
  82. parser.add_argument('--use_coord_adv', action='store_true',
  83. help='Use coordinate adversary (enabled in run_experiment)')
  84. parser.add_argument('--use_subject_adv', action='store_true',
  85. help='Use subject adversary (enabled in run_experiment)')
  86. parser.add_argument('--coordHeadBins', type=int, default=16,
  87. help='Number of bins for coordinate head')
  89. # Augmentation (defaults from run_experiment.py)
  90. parser.add_argument('--use_weak_strong_aug', action='store_true',
  91. help='Use weak vs strong augmentations (enabled in run_experiment)')
  92. parser.add_argument('--weak_strength', type=float, default=0.30,
  93. help='Weak view magnitude in [0,1] (scaled into each op range)')
  94. parser.add_argument('--strong_strength', type=float, default=0.75,
  95. help='Strong view magnitude in [0,1] (scaled into each op range)')
  96. parser.add_argument('--aug_ramp', action='store_true',
  97. help='Cosine-ramp augmentation strength (enabled in run_experiment)')
  99. # Training options
  100. parser.add_argument('--amp_scaler', action='store_true',
  101. help='Use mixed precision training (enabled in run_experiment)')
  103. return parser.parse_args()
  105. def setup_experiment_dir(exp_name):
  106. """Create experiment directory and return path."""
  107. exp_dir = Path(f"experiments/{exp_name}")
  108. exp_dir.mkdir(parents=True, exist_ok=True)
  109. return exp_dir
  111. def save_config(exp_dir, args):
  112. """Save experiment configuration."""
  113. config = vars(args)
  114. with open(exp_dir / "config.json", 'w') as f:
  115. json.dump(config, f, indent=2)
  117. def digitize(v, edges, bins):
  118. """Discretize continuous values into bins.
  120. Args:
  121. v: Continuous values to discretize
  122. edges: Bin edges
  123. bins: Number of bins
  125. Returns:
  126. Integer bin indices in [0, bins-1]
  127. """
  128. idx = torch.bucketize(v, edges[1:-1]) # exclude first/last edge
  129. return idx.clamp_(0, bins-1)
  131. def _lerp(a, b, t):
  132. return a + (b - a) * t
  134. def cosine_ramp(t: float) -> float:
  135. t = max(0.0, min(1.0, t))
  136. return 0.5 * (1.0 - math.cos(math.pi * t))
  138. def build_augment_from_strength(m: float) -> Compose:
  139. """Magnitude m in [0,1] controls intensity per operator via interpolation."""
  140. # Global/channel gain-shift
  141. gain_logstd = _lerp(0.05, 0.30, m)
  142. bias_std = _lerp(0.02, 0.1, m)
  143. rank = int(round(_lerp(6, 18, m)))
  144. gain_std = _lerp(0.12, 0.30, m)
  146. # Batch/domain randomization
  147. n_groups = int(round(_lerp(4, 12, m)))
  148. part_logstd = _lerp(0.12, 0.30, m)
  150. # Monotone gamma warp
  151. delta = _lerp(0.15, 0.40, m)
  152. gamma_p = _lerp(0.6, 1.0, m)
  154. # Noise + feature dropout
  155. sigma = _lerp(0.03, 0.10, m)
  156. p_drop = _lerp(0.1, 0.50, m)
  158. return Compose(
  159. RandomGlobalGainShift(gain_logstd=gain_logstd, bias_std=bias_std, p=0.75),
  160. RandomChannelLowRankGain(feat_dim=349, rank=rank, gain_std=gain_std, p=0.75),
  161. BatchPartitionGain(n_groups=n_groups, logstd=part_logstd, p=0.75),
  162. RandomMonotoneGammaWarp(delta=delta, per_feature=True, p=0.75, eps=1e-4),
  163. AdditiveGaussianNoise(sigma=sigma, p=1.0),
  164. FeatureDropout(p_drop=p_drop),
  165. )
  167. def softmax_top1_acc(logits, y):
  168. return (logits.argmax(dim=1) == y).float().mean()
  170. def q_edges(v, bins):
  171. qs = torch.linspace(0, 1, bins+1).to(v.device)
  172. e = torch.quantile(v, qs, interpolation="linear")
  173. e[0], e[-1] = 0.0, 1.0 # clamp ends
  174. # enforce strict monotonicity to avoid bucketize ties
  175. for i in range(1, e.numel()):
  176. if e[i] <= e[i-1]:
  177. e[i] = min(1.0, e[i-1] + 1e-6)
  178. return e
  180. def main():
  181. args = parse_args()
  183. set_random_seeds(args.random_seed)
  184. print(f"Random seed set to: {args.random_seed}")
  186. # Setup experiment
  187. exp_dir = setup_experiment_dir(args.exp_name)
  188. save_config(exp_dir, args)
  189. print(f"Experiment directory: {exp_dir}")
  191. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
  192. print(f"Using device: {device}")
  194. # Enable TF32 for additional speed on Ampere+ (safe for training)
  195. if torch.cuda.is_available():
  196. torch.backends.cuda.matmul.allow_tf32 = True
  197. torch.backends.cudnn.allow_tf32 = True
  199. # Decide AMP dtype based on hardware support (prefer BF16)
  200. bf16_ok = False
  201. if torch.cuda.is_available():
  202. if hasattr(torch.cuda, "is_bf16_supported") and torch.cuda.is_bf16_supported():
  203. bf16_ok = True
  204. else:
  205. try:
  206. major, _ = torch.cuda.get_device_capability()
  207. if major >= 8:
  208. bf16_ok = True
  209. except Exception:
  210. pass
  212. autocast_dtype = torch.bfloat16 if bf16_ok else torch.float16
  213. print(f"AMP: enabled={bool(args.amp_scaler)} | dtype={autocast_dtype} | bf16_supported={bf16_ok}")
  215. # !!! augs assume z-scored features
  217. # Pre-build static augment if not using weak/strong policy
  218. use_ws = args.use_weak_strong_aug
  219. if not use_ws:
  220. augment = Compose(
  221. AdditiveGaussianNoise(sigma=0.05, p=1.0),
  222. FeatureDropout(p_drop=0.3),
  223. )
  224. else:
  225. augment = None # will build per-step weak/strong aug below
  227. # Data setup
  228. dataset = ContrastiveDataHandler(subject_ids=args.subjects,
  229. batch_vox=args.batch_vox,
  230. fname=args.fname, augment=augment)
  232. # Model setup
  233. base_encoder = VoxelEncoder(
  234. in_dim=349,
  235. hidden_dims=args.hidden_dims,
  236. embedding_dim=args.embedding_dim,
  237. dropout=args.dropout
  238. ).to(device)
  239. # Wrap with adversarial heads for GRL training
  240. model = VoxelEncoderAdv(
  241. base_encoder=base_encoder,
  242. embedding_dim=args.embedding_dim,
  243. use_coord_adv=args.use_coord_adv,
  244. use_subject_adv=args.use_subject_adv,
  245. n_subjects=dataset.n_subj,
  246. adv_hidden=args.hidden_dim_adv,
  247. adv_dropout=args.adv_dropout,
  248. coordHeadBins=args.coordHeadBins,
  249. ).to(device)
  252. # Optional compile for speed (PyTorch 2.x)
  253. if hasattr(torch, "compile"):
  254. try:
  255. model = torch.compile(model)
  256. print("Compiled model with torch.compile (max-autotune)")
  257. except Exception:
  258. print("torch.compile not available or failed; continuing without compile")
  260. crit = WeightedSupConLoss(temperature=args.temperature)
  261. try:
  262. optimizer = optim.AdamW(model.parameters(), lr=args.lr, weight_decay=args.weight_decay, fused=True)
  263. print("Using fused AdamW optimizer")
  264. except TypeError:
  265. optimizer = optim.AdamW(model.parameters(), lr=args.lr, weight_decay=args.weight_decay)
  267. #optimizer = optim.AdamW(model.parameters(), lr=args.lr, weight_decay=args.weight_decay)
  268. # Learning-rate schedule with optional linear warmup into cosine decay
  269. if args.warmup_steps > 0:
  270. total_after_warmup = max(1, args.steps - args.warmup_steps)
  271. warmup = optim.lr_scheduler.LinearLR(
  272. optimizer,
  273. start_factor=max(1e-6, min(1.0, args.warmup_start_factor)),
  274. total_iters=args.warmup_steps,
  275. )
  276. cosine = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=total_after_warmup)
  277. sched = optim.lr_scheduler.SequentialLR(
  278. optimizer,
  279. schedulers=[warmup, cosine],
  280. milestones=[args.warmup_steps],
  281. )
  282. print(f"Using LR warmup: {args.warmup_steps} steps, start_factor={args.warmup_start_factor}")
  283. else:
  284. sched = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=args.steps)
  286. print(f"Training with {len(args.subjects)} subjects: {args.subjects}")
  288. # Test BEFORE training
  289. print("=== BEFORE TRAINING ===")
  291. # Training loop
  292. loss_history = []
  293. # Track individual loss components for plotting
  294. contr_history = []
  295. coord_history = []
  296. subj_history = []
  297. log_steps = []
  299. print(f"\n=== TRAINING FOR {args.steps} STEPS ===")
  302. loader = torch.utils.data.DataLoader(
  303. dataset,
  304. batch_size=None, # iterable yields whole batches
  305. num_workers=8, # start with 4–8, tune
  306. pin_memory=True,
  307. persistent_workers=True,
  308. prefetch_factor=2
  309. )
  310. data_iter = iter(loader)
  312. edges_x = edges_y = edges_z = None
  314. if args.use_coord_adv:
  316. #average of some batches for stable bin edges
  317. with torch.no_grad():
  318. all_coords = []
  319. n_avg = 20
  320. for _ in range(n_avg):
  321. try:
  322. _, coords, _ = next(data_iter)
  323. except StopIteration:
  324. data_iter = iter(loader)
  325. _, coords, _ = next(data_iter)
  326. all_coords.append(coords)
  328. all_coords = torch.cat(all_coords,0)
  330. edges_x = q_edges(all_coords[:,0], args.coordHeadBins).to(device)
  331. edges_y = q_edges(all_coords[:,1], args.coordHeadBins).to(device)
  332. edges_z = q_edges(all_coords[:,2], args.coordHeadBins).to(device)
  334. #reset data_iter to start of epoch
  335. data_iter = iter(loader)
  341. warmup_steps = max(1, int(args.steps * 0)) # avoid div by zero
  342. model.set_grl_lambdas(coord=1.0 if args.use_coord_adv else 0.0,
  343. subj=1.0 if args.use_subject_adv else 0.0)
  345. for step in range(args.steps):
  346. # ramp *before* forward so this step uses current weights
  347. ramp = min(1.0, step / warmup_steps)
  348. # Backward-compat: map deprecated lambda_* to weights if new weights are unset
  349. w_coord = args.w_coord_adv if (args.w_coord_adv is not None) else args.lambda_coord
  350. w_subj = args.w_subj_adv if (args.w_subj_adv is not None) else args.lambda_subject
  351. # Effective ramped weights
  352. eff_w_coord = (w_coord if args.use_coord_adv else 0.0) * ramp
  353. eff_w_subj = (w_subj if args.use_subject_adv else 0.0) * ramp
  354. # Set GRL λ to 1.0 (when enabled) so strength is controlled via loss weights
  357. optimizer.zero_grad(set_to_none=True)
  358. try:
  359. feats, coords, sids = next(data_iter)
  360. except StopIteration:
  361. data_iter = iter(loader)
  362. feats, coords, sids = next(data_iter)
  364. # Transfer to GPU with non-blocking for async copy
  365. feats = feats.to(device, non_blocking=True)
  366. coords = coords.to(device, non_blocking=True)
  367. sids = sids.to(device, non_blocking=True)
  369. # Apply augmentations; either static (HA presets) or dynamic weak/strong
  370. if augment is not None:
  371. x1 = augment(feats)
  372. x2 = augment(feats)
  373. else:
  374. # dynamic policy
  375. if args.use_weak_strong_aug:
  376. t = step / float(max(1, args.steps - 1))
  377. ramp_factor = max(cosine_ramp(t) , 0.2) if args.aug_ramp else 1.0
  378. m_w = float(np.clip(args.weak_strength * ramp_factor, 0.0, 1.0))
  379. m_s = float(np.clip(args.strong_strength * ramp_factor, 0.0, 1.0))
  380. aug_w = build_augment_from_strength(m_w)
  381. aug_s = build_augment_from_strength(m_s)
  382. x1 = aug_w(feats)
  383. x2 = aug_s(feats)
  384. else:
  385. x1 = feats
  386. x2 = feats
  390. # Forward pass under autocast (compute in BF16/FP16)
  391. with torch.amp.autocast('cuda', enabled=bool(args.amp_scaler), dtype=autocast_dtype):
  392. compute_heads = (args.use_coord_adv or args.use_subject_adv)
  393. z1, coord1, subj1 = model(x1, compute_heads=compute_heads)
  394. z2, coord2, subj2 = model(x2, compute_heads=compute_heads)
  396. # Compute all losses in float32 for numerical stability
  397. z1f, z2f = z1.float(), z2.float()
  399. contr_loss = crit(z1f, z2f)
  401. # Start with contrastive loss
  402. loss = contr_loss
  404. if args.use_coord_adv:
  405. bins = args.coordHeadBins
  406. cx = digitize(coords[:, 0].contiguous(), edges_x, bins)
  407. cy = digitize(coords[:, 1].contiguous(), edges_y, bins)
  408. cz = digitize(coords[:, 2].contiguous(), edges_z, bins)
  410. logit_x1, logit_y1, logit_z1 = coord1
  411. logit_x2, logit_y2, logit_z2 = coord2
  413. # CE on float32 logits for stability
  414. coord_loss1 = (
  415. F.cross_entropy(logit_x1.float(), cx)
  416. + F.cross_entropy(logit_y1.float(), cy)
  417. + F.cross_entropy(logit_z1.float(), cz)
  418. ) / 3.0
  420. coord_loss2 = (
  421. F.cross_entropy(logit_x2.float(), cx)
  422. + F.cross_entropy(logit_y2.float(), cy)
  423. + F.cross_entropy(logit_z2.float(), cz)
  424. ) / 3.0
  426. coord_loss = (coord_loss1 + coord_loss2) / 2.0
  427. else:
  428. coord_loss = torch.tensor(0.0, device=device)
  430. if args.use_subject_adv:
  431. subj_loss1 = (
  432. F.cross_entropy(subj1.float(), sids)
  433. if subj1 is not None
  434. else torch.tensor(0.0, device=device)
  435. )
  436. subj_loss2 = (
  437. F.cross_entropy(subj2.float(), sids)
  438. if subj2 is not None
  439. else torch.tensor(0.0, device=device)
  440. )
  441. subj_loss = (subj_loss1 + subj_loss2) / 2.0
  442. else:
  443. subj_loss = torch.tensor(0.0, device=device)
  445. # Include head losses so heads train; scale by effective weights; encoder protection via --stop_grad_from_heads
  446. if args.use_coord_adv:
  447. loss = loss + eff_w_coord * coord_loss
  448. if args.use_subject_adv:
  449. loss = loss + eff_w_subj * subj_loss
  451. # Backward + step (no GradScaler for BF16 path)
  452. loss.backward()
  453. optimizer.step()
  454. sched.step()
  456. if step % 250 == 0 or step == args.steps - 1:
  458. loss_history.append(loss.item())
  459. # Store component losses and the step for plotting
  460. contr_history.append(float(contr_loss.item()))
  461. coord_history.append(float(coord_loss.item()))
  462. subj_history.append(float(subj_loss.item()))
  463. log_steps.append(int(step))
  465. # Lightweight monitoring metrics for logging cadence
  466. chance_logs = []
  467. with torch.no_grad():
  468. if args.use_subject_adv and (subj1 is not None and subj2 is not None):
  469. K = dataset.n_subj
  470. subj_acc1 = softmax_top1_acc(subj1, sids).item()
  471. subj_acc2 = softmax_top1_acc(subj2, sids).item()
  472. subj_acc = 0.5*(subj_acc1 + subj_acc2)
  473. subj_ch_acc = 1.0 / K
  474. subj_ch_ce = np.log(K)
  475. chance_logs.append(f"SubjAcc {subj_acc:.3f} (~{subj_ch_acc:.3f}), CE~{subj_ch_ce:.3f}")
  477. if args.use_coord_adv and (coord1 is not None and coord2 is not None):
  478. bins = args.coordHeadBins
  479. cx = digitize(coords[:, 0].contiguous(), edges_x, bins)
  480. cy = digitize(coords[:, 1].contiguous(), edges_y, bins)
  481. cz = digitize(coords[:, 2].contiguous(), edges_z, bins)
  482. (logit_x1, logit_y1, logit_z1) = coord1
  483. (logit_x2, logit_y2, logit_z2) = coord2
  484. ax_accs = []
  485. for (lx, ly, lz), (cx_, cy_, cz_) in [((logit_x1,logit_y1,logit_z1),(cx,cy,cz)),
  486. ((logit_x2,logit_y2,logit_z2),(cx,cy,cz))]:
  487. ax_accs.append((
  488. softmax_top1_acc(lx, cx_).item(),
  489. softmax_top1_acc(ly, cy_).item(),
  490. softmax_top1_acc(lz, cz_).item()
  491. ))
  492. ax_acc = tuple(np.mean([a[i] for a in ax_accs]) for i in range(3))
  493. coord_ch_acc = 1.0 / bins
  494. coord_ch_ce = np.log(bins)
  495. chance_logs.append(f"CoordAcc x/y/z {ax_acc[0]:.3f}/{ax_acc[1]:.3f}/{ax_acc[2]:.3f} (~{coord_ch_acc:.3f}), CE~{coord_ch_ce:.3f}")
  497. chance_str = " | ".join(chance_logs)
  499. print(
  500. f"Step {step:5d} | ramp {ramp:0.2f} | "
  501. f"Wc {eff_w_coord:0.2f} Ws {eff_w_subj:0.2f} | "
  502. f"ContLoss: {contr_loss.item():.4f} | "
  503. f"CoordLoss: {coord_loss.item():.4f} | "
  504. f"SubjLoss: {subj_loss.item():.4f} | "
  505. f"loss {loss.item():.4f} |"
  506. f"Alignment: {alignment(z1, z2):.4f} |"
  507. f"Uniformity z1: {uniformity(z1):.4f} |"
  508. f"Uniformity z2: {uniformity(z2):.4f} |"
  509. f"{chance_str}"
  510. )
  512. # Plot component losses + dotted sum line with legend
  513. save_loss_plot(exp_dir, log_steps, contr_history, coord_history, subj_history)
  515. # Save checkpoint and quick similarity stats
  516. torch.save({
  517. 'adv_model_state_dict': model.state_dict(),
  518. 'base_encoder_state_dict': base_encoder.state_dict(),
  519. 'optimizer_state_dict': optimizer.state_dict(),
  520. 'args': args,
  521. 'loss_history': loss_history
  522. }, exp_dir / "model_checkpoint.pth")
  524. with torch.no_grad():
  525. pos = (z1f * z2f).sum(dim=1) # cosine if z’s are L2-normalized of positive pairs
  526. idx = torch.randperm(z1f.size(0))[:2048] # subset for negatives
  527. z1s, z2s = z1f[idx], z2f[idx]
  528. neg = (z1s @ z2s.t())
  529. neg = neg[~torch.eye(neg.size(0), dtype=bool, device=neg.device)]
  530. print(f"Pos cos μ={pos.mean():.3f}, σ={pos.std():.3f} | Neg cos μ={neg.mean():.3f}, σ={neg.std():.3f}")
  532. S = z1f @ z2f.t()
  533. top1 = S.argmax(dim=1)
  534. inst_r1 = (top1 == torch.arange(S.size(0), device=S.device)).float().mean().item()
  535. print(f"Instance R@1: {inst_r1:.3f}")
  539. # Save loss history
  540. np.save(exp_dir / "loss_history.npy", np.array(loss_history))
  542. print(f"\nExperiment completed! Results saved to: {exp_dir}")
  552. def save_loss_plot(exp_dir: Path, steps: list, contr_hist: list, coord_hist: list, subj_hist: list):
  553. """Save a plot with separate loss components and a dotted sum line.
  555. This version avoids stretching artefacts in SVG viewers by:
  556. - keeping annotations inside the axes range
  557. - using a slightly more square aspect ratio
  558. - relaxing the tight bounding box so the axes, not labels, define width.
  560. Args:
  561. exp_dir: Output directory where the plot will be saved.
  562. steps: Logged training steps.
  563. contr_hist: Contrastive loss values.
  564. coord_hist: Coordinate loss values.
  565. subj_hist: Subject loss values.
  566. """
  567. steps_np = np.asarray(steps, dtype=float)
  568. if steps_np.size == 0:
  569. return
  571. contr_np = np.asarray(contr_hist, dtype=float)
  572. coord_np = np.asarray(coord_hist, dtype=float)
  573. subj_np = np.asarray(subj_hist, dtype=float)
  574. total_np = contr_np + coord_np + subj_np
  576. # Use a restrained, publication-friendly palette (ColorBrewer-inspired)
  577. colors = {
  578. "Contrastive": "#1b9e77",
  579. "Coordinate": "#d95f02",
  580. "Subject": "#7570b3",
  581. "Total": "#000000",
  582. }
  584. # Slightly more square figure for better appearance in wide editors
  585. fig, ax = plt.subplots(figsize=(5.0, 3.8), constrained_layout=True)
  587. # Plot individual components
  588. ax.plot(steps_np, contr_np, label="Contrastive", color=colors["Contrastive"], lw=1.8)
  589. ax.plot(steps_np, coord_np, label="Coordinate", color=colors["Coordinate"], lw=1.8)
  590. ax.plot(steps_np, subj_np, label="Subject", color=colors["Subject"], lw=1.8)
  591. # Dotted total line (subtle)
  592. ax.plot(steps_np, total_np, label="Total", color=colors["Total"], lw=1.4,
  593. linestyle=(0, (3, 2)))
  595. # Axis styling: remove clutter, subtle horizontal grid only
  596. ax.spines['top'].set_visible(False)
  597. ax.spines['right'].set_visible(False)
  598. ax.grid(axis='y', color="#dddddd", linewidth=0.6, alpha=0.6)
  599. ax.grid(axis='x', alpha=0.0)
  601. ax.set_xlabel("Step", labelpad=6)
  602. ax.set_ylabel("Loss", labelpad=6)
  603. ax.set_title("Training Loss Components", pad=10)
  605. # Ticks: modest sizing
  606. ax.tick_params(axis='both', labelsize=10, width=0.8, length=4)
  608. # Annotate last value of each component *inside* the axes to avoid
  609. # expanding the SVG width excessively when viewing the figure.
  610. if steps_np.size > 1:
  611. x_last = steps_np[-1]
  612. x_prev = steps_np[-2]
  613. # small offset but stay within [x_prev, x_last]
  614. x_off = 0.25 * (x_last - x_prev)
  615. x_anno = x_last - x_off
  616. else:
  617. x_anno = steps_np[0]
  619. for arr, name in [(contr_np, "Contrastive"), (coord_np, "Coordinate"), (subj_np, "Subject")]:
  620. if arr.size:
  621. ax.text(x_anno, arr[-1], f"{arr[-1]:.3g}",
  622. color=colors[name], fontsize=9, va='center', ha='right')
  624. # Legend without frame
  625. ax.legend(frameon=False, fontsize=10, handlelength=3, loc='upper right')
  627. # Save without an overly tight bbox so labels don't dominate width
  628. out_path = Path(exp_dir) / "loss_plot.svg"
  629. fig.savefig(out_path, dpi=300)
  630. plt.close(fig)
  636. if __name__ == "__main__":
  637. main()

trainer.py at commit a229605, under MIT · at the source

Overview

Authors: Mert Özer1,2, Bernhard Egger1, Angelika Mennecke3, Armin Nagel4, Moritz Zaiss3, Frederik Bernd Laun4, Arnd Dörfler3, Jürgen Winkler2, Alexander German2,3
ORCID iDs: Mert Özer, Moritz Zaiss, Alexander German
  1. Department of Computer Science, Friedrich-Alexander-Universität Erlangen-Nürnberg, Erlangen, Germany
  2. Department of Molecular Neurology, University Hospital Erlangen, Erlangen, Germany
  3. Institute of Neuroradiology, University Hospital Erlangen, Erlangen, Germany
  4. Institute of Radiology, University Hospital Erlangen, Erlangen, Germany
Institutions: Friedrich-Alexander-Universität Erlangen-Nürnberg (Germany); Universitätsklinikum Erlangen (Germany)
Journal: Imaging neuroscience (Cambridge, Mass.), volume 4, article IMAG.a.1241
Dates: received 28 January 2026; accepted 13 April 2026; published online 26 May 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1162/imag.a.1241 · PMID 42212222 · PMCID PMC13214570 · OpenAlex W7156079084
Open access: diamond, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), human (organism), Parkinson's (population)
Methods: Spectral & time-frequency, Statistics, Machine learning, Preprocessing, fMRI & imaging
Keywords: Parkinson’s disease, dopamine transporter, 7 Tesla MRI, multispectral MRI, contrastive learning
Topic: Parkinson's Disease Mechanisms and Treatments (Neurology, Medicine), according to OpenAlex
Funding: Deutsche Forschungsgemeinschaft (500888779, 505539112, RU5534, KFO5024)
Citations: not cited yet (Europe PMC); 61 references in the paper

Abstract

The neuropathological hallmark of Parkinson’s disease (PD) is a progressive degeneration of dopaminergic neurons in the substantia nigra resulting in a reduced striatal dopamine transporter (DaT) concentration. Radioligands can detect degeneration of nigrostriatal projections early in the disease course, but their clinical use is constrained by ionizing radiation exposure and the need for radiotracer production and associated logistics. In this study, we investigate whether a healthy DaT atlas can be predicted directly from native 7 Tesla (7T) multicontrast magnetic resonance imaging (MRI) using a normative atlas as the supervised target for voxel-wise DaT density. Based on these results, we estimate the deviation of sporadic PD patients from the normative DaT atlas. Using this approach, we found that estimated DaT distributions in the putamen differ between PD patients and healthy controls, providing preliminary evidence that high-field advanced multispectral MRI could inform on neurochemical alterations in PD.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repository

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

mert-o/dat_prediction

License: MIT
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: a229605f6bc0b7220a6c5e52bcaa13473de3ff74, 28 January 2026
Languages: Python (13)
Size: 18 files, 13 scripts
Software Heritage: not archived
Found in: “Data and Code Availability”
Holds: README, license file, environment (requirements.txt)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (11 files), PyTorch (9 files), NiBabel (5 files), Matplotlib (4 files), Nilearn (2 files), pandas (2 files), scikit-learn (2 files), SciPy (2 files), statsmodels (2 files)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
15 files
At the source: github.com/mert-o/dat_prediction

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:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 13 scripts, each with its path and the digest of its content;
  • 9 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.

Data and Code Availability

The data used in this study are available from the corresponding authors upon reasonable request. The preprocessing, training, and evaluation code are available at: https://github.com/mert-o/dat_prediction.

Reproduced under the paper's license (CC BY), from the paper cited above.

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 2, 28 September 2026

  • Funding: added Deutsche Forschungsgemeinschaft: 500888779, 505539112, RU5534, KFO5024

Version 1, 28 September 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 9 authors, 5 keywords, 54 references.

Cite

This paper

Özer, M., Egger, B., Mennecke, A., Nagel, A., Zaiss, M., Laun, F. B., Dörfler, A., Winkler, J., & German, A. (2026). Multispectral 7 Tesla MRI as a potential predictor of dopamine transporter deficiency in Parkinson's disease. Imaging neuroscience (Cambridge, Mass.), 4, IMAG.a.1241. https://doi.org/10.1162/imag.a.1241

BibTeX

@article{ozer2026multispectral,
author = {Özer, Mert and Egger, Bernhard and Mennecke, Angelika and Nagel, Armin and Zaiss, Moritz and Laun, Frederik Bernd and Dörfler, Arnd and Winkler, Jürgen and German, Alexander},
title = {{Multispectral 7 Tesla MRI as a potential predictor of dopamine transporter deficiency in Parkinson's disease}},
journal = {Imaging neuroscience (Cambridge, Mass.)},
year = {2026},
month = may,
volume = {4},
pages = {IMAG.a.1241},
publisher = {MIT Press},
issn = {2837-6056},
doi = {10.1162/imag.a.1241},
url = {https://doi.org/10.1162/imag.a.1241},
pmid = {42212222},
pmcid = {PMC13214570}
}

RIS

TY - JOUR
AU - Özer, Mert
AU - Egger, Bernhard
AU - Mennecke, Angelika
AU - Nagel, Armin
AU - Zaiss, Moritz
AU - Laun, Frederik Bernd
AU - Dörfler, Arnd
AU - Winkler, Jürgen
AU - German, Alexander
TI - Multispectral 7 Tesla MRI as a potential predictor of dopamine transporter deficiency in Parkinson's disease
T2 - Imaging neuroscience (Cambridge, Mass.)
J2 - Imaging Neurosci (Camb)
PY - 2026
DA - 2026/05/26
VL - 4
SP - IMAG.a.1241
SN - 2837-6056
PB - MIT Press
DO - 10.1162/imag.a.1241
UR - https://doi.org/10.1162/imag.a.1241
LA - en
ER -

CSL-JSON

{
"id": "10.1162/imag.a.1241",
"type": "article-journal",
"title": "Multispectral 7 Tesla MRI as a potential predictor of dopamine transporter deficiency in Parkinson's disease",
"container-title": "Imaging neuroscience (Cambridge, Mass.)",
"author": [
{
"family": "Özer",
"given": "Mert"
},
{
"family": "Egger",
"given": "Bernhard"
},
{
"family": "Mennecke",
"given": "Angelika"
},
{
"family": "Nagel",
"given": "Armin"
},
{
"family": "Zaiss",
"given": "Moritz"
},
{
"family": "Laun",
"given": "Frederik Bernd"
},
{
"family": "Dörfler",
"given": "Arnd"
},
{
"family": "Winkler",
"given": "Jürgen"
},
{
"family": "German",
"given": "Alexander"
}
],
"container-title-short": "Imaging Neurosci (Camb)",
"volume": "4",
"page": "IMAG.a.1241",
"DOI": "10.1162/imag.a.1241",
"PMID": "42212222",
"PMCID": "PMC13214570",
"ISSN": "2837-6056",
"publisher": "MIT Press",
"URL": "https://doi.org/10.1162/imag.a.1241",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
26
]
]
}
}

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.1371/journal.pbio.3003856 [code]
Aging and metabolism contribute separately to brain-body health.
Journal: PLoS biology
In common: Nilearn, NiBabel, statsmodels, 6 other tools, structural MRI / diffusion, 1 reference
[2] doi:10.1007/s00234-026-04103-8 [code]
Enhanced detection of subtle cortical abnormalities in focal epilepsy using 7 T MRI surface-based models and graph neural networks.
Journal: Neuroradiology
In common: Nilearn, NiBabel, statsmodels, 6 other tools, structural MRI / diffusion, 1 reference
[3] doi:10.1002/agm2.70073 [code]
Foreign Language Learning in Older Adults Modifies Resting-State Functional Connectivity Between the Subcortical Structures and the Cortex.
Journal: Aging medicine (Milton (N.S.W))
In common: Nilearn, NiBabel, statsmodels, 6 other tools, 1 reference
[4] doi:10.1038/s41467-026-76452-0 [code]
Music evokes shared neural representations of imagined narratives across sensory modalities.
Journal: Nature communications
In common: Nilearn, NiBabel, statsmodels, 6 other tools, 1 reference
[5] doi:10.1016/j.isci.2026.117180 [code]
Developmental changes in similarity between neural representations of mental arithmetic and artificial neural networks.
Journal: iScience
In common: Nilearn, NiBabel, statsmodels, 6 other tools, 1 reference
[6] doi:10.1162/imag.a.1256 [code]
Gamer in the scanner: Event-related analysis of fMRI activity during retro videogame play guided by automated annotations of game content.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Nilearn, NiBabel, statsmodels, 6 other tools, 1 reference
[7] doi:10.7554/elife.107933 [code]
Modality-agnostic decoding of vision and language from fMRI.
Journal: eLife
In common: Nilearn, NiBabel, statsmodels, 6 other tools, 1 reference
[8] doi:10.1126/sciadv.adu9309 [code]
Variations of global brain asymmetry are associated with aging and related diseases.
Journal: Science advances
In common: Nilearn, NiBabel, PyTorch, 4 other tools, Parkinson's, 2 references
[9] doi:10.1038/s41531-026-01354-3 [code]
Neuromodulation-induced normalization of cortical metastable dynamics signatures in Parkinson's disease.
Journal: NPJ Parkinson's disease
In common: Nilearn, NiBabel, statsmodels, 5 other tools, Parkinson's, 1 reference
[10] doi:10.64898/2026.08.18.26360725 [code]
Temporal pole blurring in hippocampal sclerosis reflects seizure-disrupted myelination
Journal: medRxiv (preprint)
In common: Nilearn, NiBabel, statsmodels, 6 other tools, structural MRI / diffusion

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.