OSCR

Association Between Anterior Hippocampal Gyrification and Episodic Memory Performance in Neurotypical Young Adults.

Code ↔ Paper

2 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 2 matches
  1. [1] § Materials and Methods › Hippocampal Segmentation Using HippUnfold ↔ hippunfold/workflow/scripts/seg_synthseg.py, lines 497–522 · score 0.56 · SynthSeg, UNet, network, model, HippUnfold, nn
  2. [2] § Materials and Methods › Hippocampal Segmentation Using HippUnfold ↔ nnunetv2/experiment_planning/experiment_planners/default_experiment_planner.py, lines 155–196 · score 0.50 · lower resolution, artifacts, anisotropic, smaller, voxel, trained

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 · 19 KB · MIT · 1 match

  1. #!/usr/bin/env python3
  2. """
  3. Fully isolated SynthSeg inference script for hippocampus segmentation.
  4. This script contains all necessary code and does not require local imports.
  6. Author: Mahmoud Yaser (mahmoud1yaser)
  7. """
  9. import argparse
  10. import os
  11. import time
  12. import torch
  13. import torch.nn as nn
  14. import torch.nn.functional as F
  15. import numpy as np
  16. import nibabel as nib
  17. from typing import Sequence, Tuple, Optional
  18. from types import GeneratorType as generator
  20. from cornucopia import LoadTransform
  21. from cornucopia.utils import warps # original sampling ops
  24. # utils.ensure_list equivalent
  25. def _ensure_list(x, size=None, crop=True):
  26. if not isinstance(x, (list, tuple, range)):
  27. x = [x]
  28. elif not isinstance(x, list):
  29. x = list(x)
  30. if size and len(x) < size:
  31. x += x[-1:] * (size - len(x))
  32. if size and crop:
  33. x = x[:size]
  34. return x
  37. # === Modules (subset of learn2synth.modules) ===
  38. class ConvBlockBase(nn.Sequential):
  39. """Original ConvBlockBase (order auto-fix, norm channel inference)."""
  41. def __init__(
  42. self,
  43. ndim,
  44. in_channels,
  45. out_channels,
  46. opt_conv=None,
  47. activation="LeakyReLU",
  48. norm=None,
  49. dropout=False,
  50. order="cand",
  51. ):
  52. super().__init__()
  53. self.order = self._fix_order(order)
  54. conv_cls = getattr(nn, f"Conv{ndim}d")
  55. opt_conv = dict(opt_conv or {})
  56. opt_conv.setdefault("kernel_size", 3)
  57. opt_conv.setdefault("bias", True)
  58. opt_conv.setdefault("padding", "same")
  59. conv = conv_cls(in_channels, out_channels, **opt_conv)
  60. act = self._make_activation(activation)
  61. drop = self._make_dropout(dropout, ndim)
  62. norm_mod = self._make_norm(norm, ndim, conv, self.order)
  63. for ch in self.order:
  64. if ch == "n" and norm_mod is not None:
  65. self.add_module("norm", norm_mod)
  66. elif ch == "c":
  67. self.add_module("conv", conv)
  68. elif ch == "d" and drop is not None:
  69. self.add_module("dropout", drop)
  70. elif ch == "a" and act is not None:
  71. self.add_module("activation", act)
  73. @staticmethod
  74. def _fix_order(order):
  75. order = order.lower()
  76. for ch in "ncda":
  77. if ch not in order:
  78. order += ch
  79. return order
  81. @staticmethod
  82. def _make_activation(activation):
  83. if not activation:
  84. return None
  85. if isinstance(activation, str):
  86. activation = getattr(nn, activation)
  87. return activation() if isinstance(activation, type) else activation
  89. @staticmethod
  90. def _make_dropout(dropout, ndim):
  91. if not dropout:
  92. return None
  93. if isinstance(dropout, (int, float)):
  94. return getattr(nn, f"Dropout{ndim}d")(p=float(dropout))
  95. return dropout() if isinstance(dropout, type) else dropout
  97. @staticmethod
  98. def _make_norm(norm, ndim, conv, order):
  99. if not norm:
  100. return None
  101. if isinstance(norm, bool) and norm:
  102. norm = "batch"
  103. idx_n = order.index("n")
  104. idx_c = order.index("c")
  105. in_ch = conv.in_channels if idx_n < idx_c else conv.out_channels
  106. if isinstance(norm, str):
  107. if "instance" in norm.lower():
  108. norm_cls = getattr(nn, f"InstanceNorm{ndim}d")
  109. return norm_cls(in_ch)
  110. if "batch" in norm.lower():
  111. norm_cls = getattr(nn, f"BatchNorm{ndim}d")
  112. return norm_cls(in_ch)
  113. if "layer" in norm.lower():
  114. return nn.GroupNorm(in_ch, in_ch)
  115. return norm() if isinstance(norm, type) else norm
  118. class ConvBlock(ConvBlockBase):
  119. def __init__(
  120. self,
  121. ndim,
  122. in_channels,
  123. out_channels,
  124. kernel_size=3,
  125. bias=True,
  126. activation="LeakyReLU",
  127. norm="instance",
  128. dropout=0,
  129. order="cand",
  130. ):
  131. super().__init__(
  132. ndim,
  133. in_channels,
  134. out_channels,
  135. opt_conv=dict(kernel_size=kernel_size, bias=bias, padding="same"),
  136. activation=activation,
  137. norm=norm,
  138. dropout=dropout,
  139. order=order,
  140. )
  143. class ConvGroup(nn.Sequential):
  144. """Original ConvGroup logic (handles in/mid/out transitions, residual)."""
  146. def __init__(
  147. self,
  148. ndim,
  149. in_channels,
  150. mid_channels=None,
  151. out_channels=None,
  152. kernel_size=3,
  153. nb_conv=2,
  154. residual=False,
  155. activation="LeakyReLU",
  156. norm="instance",
  157. dropout=0,
  158. order="cand",
  159. ):
  160. self.residual = residual
  161. mid_channels = mid_channels or in_channels
  162. out_channels = out_channels or mid_channels
  163. nb_conv = (
  164. nb_conv - (in_channels != mid_channels) - (out_channels != mid_channels)
  165. )
  166. layers = []
  167. if in_channels != mid_channels:
  168. layers.append(
  169. ConvBlock(
  170. ndim,
  171. in_channels,
  172. mid_channels,
  173. kernel_size,
  174. activation=activation,
  175. norm=norm,
  176. dropout=dropout,
  177. order=order,
  178. )
  179. )
  180. for _ in range(nb_conv):
  181. layers.append(
  182. ConvBlock(
  183. ndim,
  184. mid_channels,
  185. mid_channels,
  186. kernel_size,
  187. activation=activation,
  188. norm=norm,
  189. dropout=dropout,
  190. order=order,
  191. )
  192. )
  193. if out_channels != mid_channels:
  194. layers.append(
  195. ConvBlock(
  196. ndim,
  197. mid_channels,
  198. out_channels,
  199. kernel_size,
  200. activation=activation,
  201. norm=norm,
  202. dropout=dropout,
  203. order=order,
  204. )
  205. )
  206. super().__init__(*layers)
  208. def forward(self, x):
  209. if self.residual:
  210. for layer in self:
  211. ident = x
  212. x = layer(x)
  213. if x.shape[1] == ident.shape[1]:
  214. x = x + ident
  215. return x
  216. return super().forward(x)
  219. class Downsample(nn.Module):
  220. """Original warps-based Downsample."""
  222. def __init__(self, factor=2, anchor="center"):
  223. super().__init__()
  224. self.factor = factor
  225. self.anchor = anchor
  227. def forward(self, x, shape=None):
  228. factor = None if shape else self.factor
  229. return warps.downsample(x, factor, shape, self.anchor)
  232. class Upsample(nn.Module):
  233. """Original warps-based Upsample."""
  235. def __init__(self, factor=2, anchor="center"):
  236. super().__init__()
  237. self.factor = factor
  238. self.anchor = anchor
  240. def forward(self, x, shape=None):
  241. factor = None if shape else self.factor
  242. return warps.upsample(x, factor, shape, self.anchor)
  245. class ConvBlockDown(nn.Sequential):
  246. """Original ConvBlockDown (downsample + conv group)."""
  248. def __init__(
  249. self,
  250. ndim,
  251. in_channels,
  252. out_channels,
  253. factor=2,
  254. kernel_size=3,
  255. activation="LeakyReLU",
  256. norm="instance",
  257. dropout=0,
  258. order="cand",
  259. ):
  260. super().__init__()
  261. self.downsample = Downsample(factor=factor)
  262. self.conv = ConvBlock(
  263. ndim,
  264. in_channels,
  265. out_channels,
  266. kernel_size=kernel_size,
  267. activation=activation,
  268. norm=norm,
  269. dropout=dropout,
  270. order=order,
  271. )
  273. def forward(self, x):
  274. return self.conv(self.downsample(x))
  277. class ConvBlockUp(nn.Module):
  278. """Original ConvBlockUp (conv + upsample + skip combine)."""
  280. def __init__(
  281. self,
  282. ndim,
  283. in_channels,
  284. out_channels,
  285. factor=2,
  286. kernel_size=3,
  287. activation="LeakyReLU",
  288. norm="instance",
  289. dropout=0,
  290. order="cand",
  291. combine="cat",
  292. ):
  293. super().__init__()
  294. self.conv = ConvBlock(
  295. ndim,
  296. in_channels,
  297. out_channels,
  298. kernel_size=kernel_size,
  299. activation=activation,
  300. norm=norm,
  301. dropout=dropout,
  302. order=order,
  303. )
  304. self.upsample = Upsample(factor=factor)
  305. self.combine = combine
  307. def forward(self, x, skip=None):
  308. shape = None if skip is None else skip.shape[2:]
  309. x = self.conv(x)
  310. x = self.upsample(x, shape)
  311. if skip is not None:
  312. x = torch.cat([x, skip], dim=1) if self.combine == "cat" else x + skip
  313. return x
  316. class EncoderBlock(nn.Sequential):
  317. def __init__(self, down, conv):
  318. super().__init__()
  319. self.down = down
  320. self.conv = conv
  322. def forward(self, x):
  323. return self.conv(self.down(x))
  326. class DecoderBlock(nn.Sequential):
  327. def __init__(self, conv, up):
  328. super().__init__()
  329. self.conv = conv
  330. self.up = up
  332. def forward(self, x, skip=None):
  333. x = self.conv(x)
  334. return self.up(x, skip)
  337. class UNet(nn.Module):
  338. """Original-style UNet (encoder/decoder pyramids with warps sampling)."""
  340. class defaults:
  341. nb_levels = 6
  342. nb_features = (16, 24, 32, 48, 64, 96, 128, 192, 256, 320)
  343. nb_conv = 2
  344. kernel_size = 3
  345. activation = "LeakyReLU"
  346. norm = "instance"
  347. dropout = 0
  348. residual = False
  349. factor = 2
  350. use_strides = False
  351. order = "cand"
  352. combine = "cat"
  354. def __init__(self, ndim, **kwargs):
  355. super().__init__()
  356. # load defaults
  357. for k, v in UNet.defaults.__dict__.items():
  358. if not k.startswith("_"):
  359. kwargs.setdefault(k, v)
  360. for k, v in kwargs.items():
  361. setattr(self, k, v)
  362. self.ndim = ndim
  363. self.nb_features = _ensure_list(self.nb_features, self.nb_levels)
  364. self.in_channels = self.out_channels = self.nb_features[0]
  365. # encoder
  366. i, o = self.nb_features[0], self.nb_features[0]
  367. encoder = [self._conv_block(i, o)]
  368. for n in range(1, len(self.nb_features) - 1):
  369. i, o = self.nb_features[n - 1], self.nb_features[n]
  370. encoder.append(EncoderBlock(self._down_block(i, o), self._conv_block(o)))
  371. if self.nb_levels > 1:
  372. i, o = self.nb_features[-2], self.nb_features[-1]
  373. encoder.append(self._down_block(i, o))
  374. self.encoder = nn.Sequential(*encoder)
  375. # decoder
  376. decoder = []
  377. for n in range(len(self.nb_features) - 1):
  378. i, o = self.nb_features[-n - 1], self.nb_features[-n - 2]
  379. m = i
  380. if self.combine == "cat" and n > 0:
  381. i *= 2
  382. decoder.append(DecoderBlock(self._conv_block(i, m), self._up_block(m, o)))
  383. i, o = self.nb_features[0], self.nb_features[0]
  384. if self.nb_levels > 1 and self.combine == "cat":
  385. i *= 2
  386. decoder.append(self._conv_block(i, o))
  387. self.decoder = nn.Sequential(*decoder)
  389. def _conv_block(self, i, o=None):
  390. return ConvGroup(
  391. self.ndim,
  392. i,
  393. o or i,
  394. kernel_size=self.kernel_size,
  395. nb_conv=self.nb_conv,
  396. activation=self.activation,
  397. norm=self.norm,
  398. dropout=self.dropout,
  399. order=self.order,
  400. residual=self.residual,
  401. )
  403. def _down_block(self, i, o=None):
  404. return ConvBlockDown(
  405. self.ndim,
  406. i,
  407. o or i,
  408. factor=self.factor,
  409. kernel_size=1,
  410. activation=self.activation,
  411. norm=self.norm,
  412. dropout=self.dropout,
  413. order=self.order,
  414. )
  416. def _up_block(self, i, o=None):
  417. return ConvBlockUp(
  418. self.ndim,
  419. i,
  420. o or i,
  421. factor=self.factor,
  422. kernel_size=1,
  423. activation=self.activation,
  424. norm=self.norm,
  425. dropout=self.dropout,
  426. order=self.order,
  427. combine=self.combine,
  428. )
  430. def forward(self, x):
  431. nb_levels = len(self.encoder)
  432. if any(s < 2**nb_levels for s in x.shape[2:]):
  433. raise ValueError(
  434. f"UNet with {nb_levels} levels requires input spatial dims >= {2**nb_levels}"
  435. )
  436. skips = []
  437. for layer in self.encoder:
  438. x = layer(x)
  439. skips.append(x)
  440. x = skips.pop(-1)
  441. for n in range(len(self.decoder) - 1):
  442. x = self.decoder[n].conv(x)
  443. x = self.decoder[n].up(x, skips.pop(-1))
  444. x = self.decoder[-1](x)
  445. return x
  448. class SegNet(nn.Sequential):
  449. def __init__(
  450. self,
  451. ndim,
  452. in_channels,
  453. out_channels,
  454. kernel_size=3,
  455. activation="Softmax",
  456. backbone="UNet",
  457. kwargs_backbone=None,
  458. ):
  459. if isinstance(backbone, str):
  460. backbone_cls = globals()[backbone]
  461. backbone = backbone_cls(ndim, **(kwargs_backbone or {}))
  462. act = None
  463. if (
  464. activation
  465. and isinstance(activation, str)
  466. and activation.lower() == "softmax"
  467. ):
  468. act = nn.Softmax(1)
  469. feat = ConvBlock(
  470. ndim,
  471. in_channels,
  472. backbone.in_channels,
  473. kernel_size=kernel_size,
  474. activation=None,
  475. norm=None,
  476. )
  477. pred = ConvBlock(
  478. ndim,
  479. backbone.out_channels,
  480. out_channels,
  481. kernel_size=1,
  482. activation=act,
  483. norm=None,
  484. )
  485. super().__init__(feat, backbone, pred)
  488. class SynthSeg(nn.Module):
  489. def __init__(self, segnet):
  490. super().__init__()
  491. self.segnet = segnet
  493. def forward(self, x):
  494. return self.segnet(x)
  497. class Model(nn.Module):
  498. def __init__(
  499. self,
  500. ndim: int = 3,
  501. nb_classes: int = 9,
  502. seg_nb_levels: int = 6,
  503. seg_features: Sequence[int] = (16, 24, 32, 48, 64, 96),
  504. seg_activation: str = "LeakyReLU",
  505. seg_nb_conv: int = 2,
  506. seg_norm: Optional[str] = "instance",
  507. **kwargs,
  508. ):
  509. super().__init__()
  510. backbone = UNet(
  511. ndim,
  512. nb_levels=seg_nb_levels,
  513. nb_features=seg_features,
  514. nb_conv=seg_nb_conv,
  515. activation=seg_activation,
  516. norm=seg_norm,
  517. )
  518. segnet = SegNet(ndim, 1, nb_classes, backbone=backbone, activation=None)
  519. self.network = SynthSeg(segnet)
  521. def forward(self, x):
  522. return self.network(x)
  525. # add Real synth patch class and apply after instantiation
  526. class Real(torch.nn.Module):
  527. def __init__(self, synth):
  528. super().__init__()
  529. self.synth = synth
  531. def forward(self, slab, img, lab):
  532. mask = (lab >= 1001) & (lab <= 1008)
  533. new_lab = torch.zeros_like(lab)
  534. new_lab[mask] = lab[mask] - 1000
  535. return img, new_lab, img, new_lab
  538. # ==============================================================================
  539. # MAIN SCRIPT LOGIC
  540. # ==============================================================================
  541. def load_nifti(path, device="cpu"):
  542. """Load NIfTI file using cornucopia LoadTransform - the working method."""
  543. load_transform = LoadTransform(ndim=3, dtype=torch.float32, device=device)
  544. tensor = load_transform(path)
  545. print(f"Loaded image - shape: {tensor.shape}, dtype: {tensor.dtype}")
  546. print(f"Data range: [{tensor.min():.6f}, {tensor.max():.6f}]")
  547. return tensor
  550. def save_nifti(pred, output_path, reference_path):
  551. """Save prediction as NIfTI file - matching working inference.py exactly"""
  552. # Get affine from reference image if available
  553. affine = np.eye(4)
  554. if reference_path and os.path.exists(reference_path):
  555. try:
  556. reference_img = nib.load(reference_path)
  557. affine = reference_img.affine
  558. except Exception as e:
  559. print(f"Warning: Could not load affine from {reference_path}: {e}")
  561. # Convert to numpy and ensure correct data type
  562. pred_np = pred.cpu().numpy()
  564. # CRITICAL: Apply the same processing as in the working inference.py
  565. # Flip over x-axis (axis=0) to maintain same alignment as input image
  566. if pred_np.shape and pred_np.shape[0] > 0:
  567. pred_np = np.flip(pred_np, axis=0)
  569. # Create NIfTI image with the same affine as the reference
  570. nii_img = nib.Nifti1Image(pred_np.astype(np.uint8), affine)
  572. # Save as NIfTI
  573. nib.save(nii_img, output_path)
  576. def main():
  577. start_total_time = time.time()
  578. parser = argparse.ArgumentParser(
  579. description="SynthSeg hippocampus segmentation inference"
  580. )
  581. parser.add_argument("input", help="Input NIfTI file (.nii or .nii.gz)")
  582. parser.add_argument("checkpoint", help="Model checkpoint (.ckpt file)")
  583. parser.add_argument(
  584. "-o", "--output", required=True, help="Output segmentation file"
  585. )
  586. parser.add_argument("--device", default="auto", choices=["auto", "cpu", "cuda"])
  587. args = parser.parse_args()
  588. if not os.path.exists(args.input):
  589. raise FileNotFoundError(f"Input file not found: {args.input}")
  590. if not os.path.exists(args.checkpoint):
  591. raise FileNotFoundError(f"Checkpoint file not found: {args.checkpoint}")
  592. device = torch.device(
  593. "cuda"
  594. if (args.device == "auto" and torch.cuda.is_available())
  595. else (args.device if args.device != "auto" else "cpu")
  596. )
  597. print(f"Using device: {device}")
  598. output_dir = os.path.dirname(args.output)
  599. if output_dir:
  600. os.makedirs(output_dir, exist_ok=True)
  601. print("Loading original model...")
  602. model = Model()
  603. # patch synth like original inference
  604. if hasattr(model.network, "synth"):
  605. model.network.synth = Real(getattr(model.network, "synth", None))
  606. first_param = next(model.parameters()).clone().detach()
  607. checkpoint = torch.load(args.checkpoint, map_location="cpu")
  608. if "state_dict" in checkpoint:
  609. model.load_state_dict(checkpoint["state_dict"])
  610. print("Loaded state_dict from checkpoint")
  611. else:
  612. model.load_state_dict(checkpoint)
  613. print("Loaded checkpoint directly")
  614. if torch.allclose(first_param, next(model.parameters())):
  615. print("WARNING: parameters unchanged after loading checkpoint")
  616. model.to(device).eval()
  617. print("Loading input image...")
  618. img = LoadTransform(ndim=3, dtype=torch.float32, device=device)(args.input)
  619. if img.dim() == 4:
  620. img = img.unsqueeze(0) # (1,1,D,H,W)
  621. else:
  622. raise ValueError(f"Unexpected input shape {img.shape}")
  623. start_inference_time = time.time()
  624. with torch.no_grad():
  625. pred_logits = model(img)
  626. inference_time = time.time() - start_inference_time
  627. pred = pred_logits.argmax(dim=1) if pred_logits.shape[1] > 1 else pred_logits
  628. pred = pred[0]
  629. print(f"Model inference time: {inference_time:.3f} s")
  630. save_nifti(pred, args.output, args.input)
  631. total_time = time.time() - start_total_time
  632. print("Saved segmentation:", args.output)
  633. print(f"Total processing time: {total_time:.3f} s")
  636. if __name__ == "__main__":
  637. main()

seg_synthseg.py at commit 544fdb6, under MIT · at the source

Overview

Authors: Nima Talaei1,2, Jordan DeKraker3, Bradley G. Karat1,2, Ali R. Khan1,2,4,5, Stefan Köhler1,6
ORCID iDs: Nima Talaei, Jordan DeKraker, Stefan Köhler
  1. Western Institute for Neuroscience, Centre for Brain and Mind, University of Western Ontario London Ontario Canada
  2. Robarts Research Institute, Schulich School of Medicine and Dentistry, University of Western Ontario London Ontario Canada
  3. McConnell Brain Imaging Centre, Montreal Neurological Institute and Hospital, McGill University, Montreal Quebec Canada
  4. School of Biomedical Engineering, the University of Western Ontario London Canada
  5. Department of Medical Biophysics, Schulich School of Medicine and Dentistry The University of Western Ontario London Canada
  6. Department of Psychology University of Western Ontario London Ontario Canada
Institutions: Western University (Canada); Robarts Research Institute (Canada); Montreal Neurological Institute and Hospital (Canada); McGill University (Canada)
Journal: Hippocampus, volume 36, issue 5, article e70124
Dates: received 14 November 2025; accepted 10 August 2026; published online 24 August 2026; in print September 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1002/hipo.70124 · PMID 42635459 · PMCID PMC13501942 · OpenAlex W7204104652
Open access: hybrid, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), human (organism), healthy (population), cognitive (subfield)
Methods: Statistics, Machine learning, Connectivity
Keywords: episodic memory, gyrification, hippocampus, MRI, surface‐based morphometry
MeSH: Hippocampus*, Memory, Episodic*, Adolescent, Adult, Female, Humans, Image Processing, Computer-Assisted, Magnetic Resonance Imaging, Male, Neuropsychological Tests, Organ Size, Young Adult (* major topic)
Topic: Memory and Neural Mechanisms (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Canada Research Chairs (CRC‐2023‐00087); Natural Sciences and Engineering Research Council of Canada (RGPIN‐2023‐05558, RGPIN‐2026‐05465); Canada Foundation for Innovation (CFI) John R. Evans Leaders Fund (Project #37427); Canada First Research Excellence Fund; Brain Canada Foundation
Citations: not cited yet (Europe PMC); 53 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 2 matches between paragraphs and lines of code.

khanlab/hippunfold

License: MIT
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: 544fdb6e37eb42567b1ad3c7f4901a180bdb19b8, 15 June 2026
Languages: Python (27), Shell (4), MATLAB (1)
Size: 331 files, 32 scripts
Software Heritage: archived
Found in: “Data Availability Statement”
Holds: README, license file, environment (Dockerfile, poetry.lock, pyproject.toml, docs/requirements.txt), continuous integration, documentation
Not found: CITATION.cff, tests
Tools: NumPy (16 files), NiBabel (15 files), Matplotlib (6 files), SciPy (4 files), Nilearn (3 files), pandas (3 files), GIfTI library for MATLAB (1 file), Nighres (1 file), PyTorch (1 file), seaborn (1 file)
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
34 files
At the source: github.com/khanlab/hippunfold

mic-dkfz/nnunet

License: Apache-2.0
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: 202f6baa0adc2ef5f7b615df19cc4da970412cc0, 25 September 2026
Languages: Python (216), Shell (7)
Size: 303 files, 223 scripts
Software Heritage: archived
Found in: the text, “Training a New Segmentation Model”
Holds: README, license file, environment (pyproject.toml, setup.py), tests, continuous integration, documentation
Not found: CITATION.cff
Tools: nnU-Net (125 files), NumPy (73 files), PyTorch (56 files), SimpleITK (10 files), scikit-image (6 files), SciPy (5 files), NiBabel (4 files), pandas (4 files), tifffile (3 files), Matplotlib (2 files), scikit-learn (1 file), seaborn (1 file)
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
225 files
At the source: github.com/MIC-DKFZ/nnUNet/tree/master

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;
  • 255 scripts, each with its path and the digest of its content;
  • 2 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

Datasets cited

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:

Read it in the paper: doi.org/10.1002/hipo.70124.

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

  • Publisher: n/a → Wiley

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 5 authors, 5 keywords, 12 MeSH terms, 5 funders, 53 references.

Cite

This paper

Talaei, N., DeKraker, J., Karat, B. G., Khan, A. R., & Köhler, S. (2026). Association Between Anterior Hippocampal Gyrification and Episodic Memory Performance in Neurotypical Young Adults. Hippocampus, 36(5), e70124. https://doi.org/10.1002/hipo.70124

BibTeX

@article{talaei2026association,
author = {Talaei, Nima and DeKraker, Jordan and Karat, Bradley G. and Khan, Ali R. and Köhler, Stefan},
title = {{Association Between Anterior Hippocampal Gyrification and Episodic Memory Performance in Neurotypical Young Adults}},
journal = {Hippocampus},
year = {2026},
month = sep,
volume = {36},
number = {5},
pages = {e70124},
publisher = {Wiley},
issn = {1050-9631},
doi = {10.1002/hipo.70124},
url = {https://doi.org/10.1002/hipo.70124},
pmid = {42635459},
pmcid = {PMC13501942}
}

RIS

TY - JOUR
AU - Talaei, Nima
AU - DeKraker, Jordan
AU - Karat, Bradley G.
AU - Khan, Ali R.
AU - Köhler, Stefan
TI - Association Between Anterior Hippocampal Gyrification and Episodic Memory Performance in Neurotypical Young Adults
T2 - Hippocampus
J2 - Hippocampus
PY - 2026
DA - 2026/09/01
VL - 36
IS - 5
SP - e70124
SN - 1050-9631
PB - Wiley
DO - 10.1002/hipo.70124
UR - https://doi.org/10.1002/hipo.70124
LA - en
ER -

CSL-JSON

{
"id": "10.1002/hipo.70124",
"type": "article-journal",
"title": "Association Between Anterior Hippocampal Gyrification and Episodic Memory Performance in Neurotypical Young Adults",
"container-title": "Hippocampus",
"author": [
{
"family": "Talaei",
"given": "Nima"
},
{
"family": "DeKraker",
"given": "Jordan"
},
{
"family": "Karat",
"given": "Bradley G."
},
{
"family": "Khan",
"given": "Ali R."
},
{
"family": "Köhler",
"given": "Stefan"
}
],
"container-title-short": "Hippocampus",
"volume": "36",
"issue": "5",
"page": "e70124",
"DOI": "10.1002/hipo.70124",
"PMID": "42635459",
"PMCID": "PMC13501942",
"ISSN": "1050-9631",
"publisher": "Wiley",
"URL": "https://doi.org/10.1002/hipo.70124",
"language": "en",
"issued": {
"date-parts": [
[
2026,
9,
1
]
]
}
}

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.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: Nighres, nnU-Net, SimpleITK, 9 other tools, structural MRI / diffusion, 1 reference
[2] doi:10.1186/s12880-026-02335-x [code]
Automatic lateral ventricle and choroid plexus segmentation method in infant brain MR images.
Journal: BMC medical imaging
In common: nnU-Net, SimpleITK, tifffile, 9 other tools, structural MRI / diffusion, 2 references
[3] doi:10.3389/fmed.2026.1875760 [code]
Adaptive multi-stage domain unlearning for white-matter lesion segmentation.
Journal: Frontiers in medicine
In common: nnU-Net, SimpleITK, tifffile, 9 other tools, structural MRI / diffusion, 2 references
[4] doi:10.1016/j.adro.2026.102092 [code]
Effect of Anatomic Contextual Information on the Performance of a Convolutional Neural Network Tasked With Brain Metastasis Detection.
Journal: Advances in radiation oncology
In common: nnU-Net, SimpleITK, tifffile, 9 other tools, 2 references
[5] doi:10.21037/qims-2026-0792 [code]
An nnU-Net-based framework with adaptive feature representation for 3D brain tumor segmentation.
Journal: Quantitative imaging in medicine and surgery
In common: nnU-Net, SimpleITK, tifffile, 9 other tools, structural MRI / diffusion, 1 reference
[6] doi:10.3389/fnins.2026.1870124 [code]
An end-to-end pipeline for automated fetal brain segmentation and biometry from 3D SSFP MRI.
Journal: Frontiers in neuroscience
In common: nnU-Net, SimpleITK, tifffile, 9 other tools, structural MRI / diffusion, 1 reference
[7] doi:10.1007/s12021-026-09817-x [code]
Circle of Willis-Guided Localization for Simultaneous Detection and Classification of Large Vessel Occlusions in Brain CTA.
Journal: Neuroinformatics
In common: nnU-Net, SimpleITK, tifffile, 9 other tools, 1 reference
[8] doi:10.64898/2026.07.15.26357954 [code]
Portable Ultra-Low Field MRI Deep-Learning Algorithms for White Matter Lesion Segmentation Improve Accuracy and Reflect Clinical Disability in Multiple Sclerosis
Journal: medRxiv (preprint)
In common: nnU-Net, SimpleITK, tifffile, 9 other tools, structural MRI / diffusion
[9] doi:10.1136/jnnp-2025-335884 [code]
Diffusivity anisotropy signature of slowly expanding lesions predicts progression independent of relapse activity in multiple sclerosis.
Journal: Journal of neurology, neurosurgery, and psychiatry
In common: nnU-Net, SimpleITK, tifffile, 9 other tools, structural MRI / diffusion
[10] doi:10.1038/s41598-026-55397-w [code]
Fast surface reconstruction of human brain MRI: benchmarking deep-learning based morphometry tools.
Journal: Scientific reports
In common: Nighres, SimpleITK, scikit-image, 6 other tools, structural MRI / diffusion, 2 references

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.