OSCR

MindGrab: A spectrally-motivated architecture for accessible deep learning in neuroimaging.

Code ↔ Paper

The paper beside its authors' code: matches between them have not been computed for this paper yet.

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 · 451 lines · 15 KB · LGPL-2.1

  1. #!/usr/bin/env python3
  2. """compare_backends.py — Build, test, and compare broccolini across GPU backends.
  4. Detects which backends are available on the current platform, builds each,
  5. runs the standard registration tests, and produces a Markdown table with
  6. timing, peak memory, accuracy (NCC), and HF variance — matching the
  7. Benchmarks section of README.md.
  9. Usage:
  10. python3 compare_backends.py # auto-detect backends, run all
  11. python3 compare_backends.py --backends metal opencl
  12. python3 compare_backends.py --skip-build # use existing binaries
  13. python3 compare_backends.py --output bench.md
  14. """
  16. import argparse
  17. import os
  18. import platform
  19. import shutil
  20. import subprocess
  21. import sys
  22. import time
  24. try:
  25. import numpy as np
  26. except ImportError:
  27. print("Error: numpy required. Install with: pip install numpy")
  28. sys.exit(1)
  30. try:
  31. import nibabel as nib
  32. except ImportError:
  33. print("Error: nibabel required. Install with: pip install nibabel")
  34. sys.exit(1)
  36. # ---------------------------------------------------------------------------
  37. # Configuration
  38. # ---------------------------------------------------------------------------
  40. SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
  42. EXAMPLES_DIR = os.path.join(SCRIPT_DIR, "examples")
  43. T1 = os.path.join(EXAMPLES_DIR, "t1_brain.nii.gz")
  44. EPI = os.path.join(EXAMPLES_DIR, "EPI_brain.nii.gz")
  45. MNI_1MM = os.path.join(EXAMPLES_DIR, "MNI152_T1_1mm_brain.nii.gz")
  47. # Filter directory: try ../filters/ relative to repo, then ../BROCCOLI/filters/
  48. FILTER_DIR = None
  49. for candidate in [
  50. os.path.join(SCRIPT_DIR, "filters"),
  51. os.path.join(SCRIPT_DIR, "..", "filters"),
  52. os.path.join(SCRIPT_DIR, "..", "BROCCOLI", "filters"),
  53. ]:
  54. if os.path.isdir(candidate) and os.path.exists(
  55. os.path.join(candidate, "filter1_real_linear_registration.bin")):
  56. FILTER_DIR = os.path.abspath(candidate)
  57. break
  59. # Each test: (name, cli_args as list)
  60. TESTS = [
  61. (
  62. "EPI to T1 (linear)",
  63. ["-in", EPI, "-ref", T1, "-omat", "{outdir}/epi_t1_params.txt"],
  64. "epi_t1_aligned.nii.gz",
  65. ),
  66. (
  67. "T1 to MNI 1mm (linear)",
  68. [
  69. "-in", T1, "-ref", MNI_1MM,
  70. "-coarsestscale", "8", "-zcut", "30",
  71. "-omat", "{outdir}/t1_mni_1mm_linear_params.txt",
  72. ],
  73. "t1_mni_1mm_aligned_linear.nii.gz",
  74. ),
  75. (
  76. "T1 to MNI 1mm (nonlinear)",
  77. [
  78. "-in", T1, "-ref", MNI_1MM,
  79. "-nonlineariter", "5", "-coarsestscale", "8", "-zcut", "30",
  80. "-omat", "{outdir}/t1_mni_1mm_params.txt",
  81. "-ofield", "{outdir}/t1_mni_1mm_disp",
  82. ],
  83. "t1_mni_1mm_aligned_nonlinear.nii.gz",
  84. ),
  85. ]
  88. # ---------------------------------------------------------------------------
  89. # Backend detection
  90. # ---------------------------------------------------------------------------
  92. def detect_backends():
  93. """Return list of backends available on this platform."""
  94. available = []
  95. system = platform.system()
  97. if system == "Darwin":
  98. # Metal is always available on macOS with Xcode CLI tools
  99. available.append("metal")
  101. # OpenCL: check for headers/library
  102. if system == "Darwin":
  103. # macOS bundles OpenCL in its SDK
  104. available.append("opencl")
  105. elif system == "Linux":
  106. # Check for libOpenCL on various architectures
  107. import glob as _glob
  108. if (shutil.which("clinfo") or
  109. os.path.exists("/usr/lib/x86_64-linux-gnu/libOpenCL.so") or
  110. os.path.exists("/usr/lib/x86_64-linux-gnu/libOpenCL.so.1") or
  111. os.path.exists("/usr/lib/aarch64-linux-gnu/libOpenCL.so") or
  112. os.path.exists("/usr/lib/aarch64-linux-gnu/libOpenCL.so.1") or
  113. os.path.exists("/usr/lib64/libOpenCL.so") or
  114. os.path.exists("/usr/lib/libOpenCL.so") or
  115. _glob.glob("/usr/lib/*/libOpenCL.so*")):
  116. available.append("opencl")
  118. # WebGPU: need wgpu-native
  119. wgpu_dir = os.environ.get("WGPU_DIR",
  120. os.path.join(SCRIPT_DIR, "webgpu", "wgpu-native"))
  121. if os.path.isdir(os.path.join(wgpu_dir, "include")):
  122. available.append("webgpu")
  124. # CUDA: check for nvcc compiler
  125. if shutil.which("nvcc"):
  126. available.append("cuda")
  128. return available
  131. # ---------------------------------------------------------------------------
  132. # Build
  133. # ---------------------------------------------------------------------------
  135. def build_backend(backend, src_dir):
  136. """Build broccolini for a specific backend. Returns path to binary."""
  137. build_dir = os.path.join(src_dir, f"build_{backend}")
  138. os.makedirs(build_dir, exist_ok=True)
  140. make_args = ["make", f"BACKEND={backend}", f"BUILDDIR={build_dir}",
  141. f"TARGET={build_dir}/broccolini", "-j4"]
  143. if backend == "webgpu":
  144. wgpu_dir = os.environ.get("WGPU_DIR",
  145. os.path.join(src_dir, "webgpu", "wgpu-native"))
  146. make_args.append(f"WGPU_DIR={wgpu_dir}")
  148. print(f" Building {backend}...", end=" ", flush=True)
  149. result = subprocess.run(make_args, cwd=src_dir,
  150. capture_output=True, text=True)
  151. if result.returncode != 0:
  152. print("FAILED")
  153. print(result.stderr)
  154. return None
  156. binary = os.path.join(build_dir, "broccolini")
  157. if not os.path.isfile(binary):
  158. print("FAILED (binary not found)")
  159. return None
  161. print("OK")
  162. return binary
  165. # ---------------------------------------------------------------------------
  166. # Run a single test
  167. # ---------------------------------------------------------------------------
  169. def run_test(binary, backend, test_name, cli_args, out_filename, out_dir):
  170. """Run one registration test. Returns dict with timing, peak_mb, out_path."""
  171. os.makedirs(out_dir, exist_ok=True)
  172. out_path = os.path.join(out_dir, out_filename)
  174. # Substitute {outdir} in cli args
  175. args = [a.replace("{outdir}", out_dir) for a in cli_args]
  176. cmd = [binary, *args, "-out", out_path, "-verbose"]
  177. if FILTER_DIR:
  178. cmd.extend(["-filters", FILTER_DIR])
  180. env = os.environ.copy()
  181. if backend == "opencl":
  182. env["BROCCOLI_DIR"] = os.path.join(SCRIPT_DIR, "opencl/")
  183. if backend == "webgpu":
  184. wgpu_dir = os.environ.get("WGPU_DIR",
  185. os.path.join(SCRIPT_DIR, "webgpu", "wgpu-native"))
  186. ld_key = ("DYLD_LIBRARY_PATH" if platform.system() == "Darwin"
  187. else "LD_LIBRARY_PATH")
  188. lib_dir = os.path.join(wgpu_dir, "lib")
  189. env[ld_key] = lib_dir + ":" + env.get(ld_key, "")
  191. # Measure with /usr/bin/time on macOS or Linux
  192. system = platform.system()
  193. if system == "Darwin":
  194. # GNU time not available; use resource module via wrapper
  195. peak_mb, elapsed, returncode, stderr = _run_with_resource(cmd, env)
  196. else:
  197. # Linux: use /usr/bin/time -v
  198. peak_mb, elapsed, returncode, stderr = _run_with_gnu_time(cmd, env)
  200. if returncode != 0:
  201. print(f" {test_name}: FAILED (exit {returncode})")
  202. if stderr:
  203. for line in stderr.strip().split("\n")[-5:]:
  204. print(f" {line}")
  205. return None
  207. return {
  208. "elapsed": elapsed,
  209. "peak_mb": peak_mb,
  210. "out_path": out_path,
  211. }
  214. def _run_with_resource(cmd, env):
  215. """Run command and measure peak RSS via /usr/bin/time -l on macOS."""
  216. time_cmd = ["/usr/bin/time", "-l"] + cmd
  217. start = time.monotonic()
  218. proc = subprocess.run(time_cmd, env=env, capture_output=True, text=True)
  219. elapsed = time.monotonic() - start
  220. peak_mb = 0.0
  221. for line in proc.stderr.split("\n"):
  222. # macOS /usr/bin/time -l: " NNN peak memory footprint" (bytes)
  223. # or older: " NNN maximum resident set size"
  224. if "peak memory footprint" in line or "maximum resident set size" in line:
  225. try:
  226. peak_mb = int(line.strip().split()[0]) / (1024 * 1024)
  227. except (ValueError, IndexError):
  228. pass
  229. break
  230. return peak_mb, elapsed, proc.returncode, proc.stderr
  233. def _run_with_gnu_time(cmd, env):
  234. """Run command with /usr/bin/time -v on Linux."""
  235. time_cmd = ["/usr/bin/time", "-v"] + cmd
  236. start = time.monotonic()
  237. proc = subprocess.run(time_cmd, env=env, capture_output=True, text=True)
  238. elapsed = time.monotonic() - start
  239. peak_mb = 0.0
  240. for line in proc.stderr.split("\n"):
  241. if "Maximum resident set size" in line:
  242. # Value in KB
  243. try:
  244. peak_mb = int(line.strip().split()[-1]) / 1024
  245. except ValueError:
  246. pass
  247. break
  248. return peak_mb, elapsed, proc.returncode, proc.stderr
  251. # ---------------------------------------------------------------------------
  252. # Accuracy metrics
  253. # ---------------------------------------------------------------------------
  255. def load_nifti(path):
  256. """Load NIfTI file as float32 array, or None if missing."""
  257. if not os.path.exists(path):
  258. return None
  259. return nib.load(path).get_fdata().astype(np.float32)
  262. def ncc(a, b):
  263. """Normalized cross-correlation."""
  264. a = a.flatten().astype(np.float64)
  265. b = b.flatten().astype(np.float64)
  266. a -= a.mean()
  267. b -= b.mean()
  268. denom = np.sqrt(np.sum(a ** 2) * np.sum(b ** 2))
  269. if denom == 0:
  270. return 0.0
  271. return float(np.sum(a * b) / denom)
  274. def hf_variance(data):
  275. """High-frequency variance: mean |v[i]-v[i-1]| over consecutive nonzero voxels."""
  276. flat = data.flatten().astype(np.float64)
  277. diffs = np.abs(flat[1:] - flat[:-1])
  278. mask = (flat[:-1] != 0.0) & (flat[1:] != 0.0)
  279. valid = diffs[mask]
  280. if len(valid) < 2:
  281. return 0.0
  282. return float(valid.mean())
  285. # ---------------------------------------------------------------------------
  286. # Report generation
  287. # ---------------------------------------------------------------------------
  289. def generate_report(results, backends):
  290. """Generate Markdown benchmark tables from results.
  292. results: dict[backend][test_name] -> {elapsed, peak_mb, out_path}
  293. """
  294. lines = []
  295. test_names = [t[0] for t in TESTS]
  297. # --- Timing / memory table ---
  298. lines.append("### Performance")
  299. lines.append("")
  300. header = "| Task |" + " | ".join(f" {b.capitalize()} " for b in backends) + " |"
  301. sep = "|------|" + " | ".join("-------" for _ in backends) + " |"
  302. lines.append(header)
  303. lines.append(sep)
  304. for tname in test_names:
  305. cells = []
  306. for b in backends:
  307. r = results.get(b, {}).get(tname)
  308. if r:
  309. cells.append(f"{r['elapsed']:.1f}s / {r['peak_mb']:.0f} MB")
  310. else:
  311. cells.append("—")
  312. lines.append(f"| {tname} | " + " | ".join(cells) + " |")
  313. lines.append("")
  315. # --- NCC table (cross-backend pairs) ---
  316. if len(backends) >= 2:
  317. lines.append("### Cross-backend NCC")
  318. lines.append("")
  319. pairs = []
  320. for i in range(len(backends)):
  321. for j in range(i + 1, len(backends)):
  322. pairs.append((backends[i], backends[j]))
  324. header = "| Task |" + " | ".join(
  325. f" {a.capitalize()} vs {b.capitalize()} " for a, b in pairs) + " |"
  326. sep = "|------|" + " | ".join("-------" for _ in pairs) + " |"
  327. lines.append(header)
  328. lines.append(sep)
  330. for tname in test_names:
  331. cells = []
  332. for a, b in pairs:
  333. ra = results.get(a, {}).get(tname)
  334. rb = results.get(b, {}).get(tname)
  335. if ra and rb:
  336. va = load_nifti(ra["out_path"])
  337. vb = load_nifti(rb["out_path"])
  338. if va is not None and vb is not None and va.shape == vb.shape:
  339. cells.append(f"{ncc(va, vb):.4f}")
  340. else:
  341. cells.append("shape mismatch")
  342. else:
  343. cells.append("—")
  344. lines.append(f"| {tname} | " + " | ".join(cells) + " |")
  345. lines.append("")
  347. # --- HF variance table ---
  348. lines.append("### HF variance")
  349. lines.append("")
  350. header = "| Task |" + " | ".join(f" {b.capitalize()} HF " for b in backends) + " |"
  351. sep = "|------|" + " | ".join("-------" for _ in backends) + " |"
  352. lines.append(header)
  353. lines.append(sep)
  354. for tname in test_names:
  355. cells = []
  356. for b in backends:
  357. r = results.get(b, {}).get(tname)
  358. if r:
  359. vol = load_nifti(r["out_path"])
  360. if vol is not None:
  361. cells.append(f"{hf_variance(vol):.1f}")
  362. else:
  363. cells.append("—")
  364. else:
  365. cells.append("—")
  366. lines.append(f"| {tname} | " + " | ".join(cells) + " |")
  367. lines.append("")
  369. return "\n".join(lines)
  372. # ---------------------------------------------------------------------------
  373. # Main
  374. # ---------------------------------------------------------------------------
  376. def main():
  377. parser = argparse.ArgumentParser(
  378. description="Build, test, and compare broccolini across GPU backends")
  379. parser.add_argument("--backends", nargs="+",
  380. help="Backends to test (default: auto-detect)")
  381. parser.add_argument("--skip-build", action="store_true",
  382. help="Skip building; use existing build_<backend>/broccolini")
  383. parser.add_argument("--output", "-o", default=None,
  384. help="Write Markdown report to file (default: stdout)")
  385. args = parser.parse_args()
  387. backends = args.backends or detect_backends()
  388. if not backends:
  389. print("No backends detected. Use --backends to specify manually.")
  390. sys.exit(1)
  392. # Verify test data exists
  393. for path in [T1, EPI, MNI_1MM]:
  394. if not os.path.exists(path):
  395. print(f"Missing test data: {path}")
  396. sys.exit(1)
  398. print(f"Platform: {platform.system()} {platform.machine()}")
  399. print(f"Backends: {', '.join(backends)}")
  400. print()
  402. # Build each backend
  403. binaries = {}
  404. for backend in backends:
  405. if args.skip_build:
  406. binary = os.path.join(SCRIPT_DIR, f"build_{backend}", "broccolini")
  407. if not os.path.isfile(binary):
  408. print(f" {backend}: binary not found at {binary}, skipping")
  409. continue
  410. binaries[backend] = binary
  411. else:
  412. binary = build_backend(backend, SCRIPT_DIR)
  413. if binary:
  414. binaries[backend] = binary
  416. if not binaries:
  417. print("No backends built successfully.")
  418. sys.exit(1)
  420. # Run tests
  421. results = {} # results[backend][test_name] = {...}
  422. print()
  423. for backend, binary in binaries.items():
  424. print(f"=== Testing {backend} ===")
  425. results[backend] = {}
  426. out_dir = os.path.join(EXAMPLES_DIR, backend)
  428. for test_name, cli_args, out_filename in TESTS:
  429. print(f" {test_name}...", end=" ", flush=True)
  430. r = run_test(binary, backend, test_name, cli_args, out_filename, out_dir)
  431. if r:
  432. results[backend][test_name] = r
  433. print(f"{r['elapsed']:.1f}s / {r['peak_mb']:.0f} MB")
  434. else:
  435. print("FAILED")
  436. print()
  438. # Generate report
  439. active_backends = [b for b in backends if b in results and results[b]]
  440. report = generate_report(results, active_backends)
  442. if args.output:
  443. with open(args.output, "w") as f:
  444. f.write(report)
  445. print(f"Report written to {args.output}")
  446. else:
  447. print(report)
  450. if __name__ == "__main__":
  451. main()

compare_backends.py at commit 95bfee3, under LGPL-2.1 · at the source

Overview

Authors: Armina Fani1, Mike Doan1, Isabelle Le1, Alex Fedorov2, Malte Hoffmann3, Chris Rorden4, Sergey Plis1
ORCID iDs: Armina Fani, Mike Doan, Alex Fedorov, Malte Hoffmann, Chris Rorden, Sergey Plis
  1. Tri-Institutional Center for Translational Research in Neuroimaging and Data Science (TReNDS), Georgia State University, Georgia Institute of Technology, Emory University, 55 Park Pl NE, Atlanta, GA, 30303, USA
  2. Emory University, 201 Dowman Dr, Atlanta, GA, 30322, USA
  3. Harvard University, Massachusetts Hall, Cambridge, MA, 02138, USA
  4. University of South Carolina, 1501 Pendleton St, Columbia, SC, 29208, USA
Institutions: Georgia Institute of Technology (United States); Emory University (United States); Georgia State University (United States); Center for Translational Research in Neuroimaging and Data Science (United States); Harvard University (United States); University of South Carolina (United States)
Journal: NeuroImage, volume 338, article 122074
Dates: published online 23 June 2026; in print September 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1016/j.neuroimage.2026.122074 · PMID 42331200 · PMCID PMC13527664 · OpenAlex W7165642222
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: human (organism), methods / tools (subfield)
Methods: Connectivity, Preprocessing, Machine learning
Keywords: Skull stripping, Neuroimaging, Dilated convolutions, Deep learning, Zero footprint AI, Omnimodal
MeSH: Brain*, Deep Learning*, Image Processing, Computer-Assisted*, Neuroimaging*, Software*, Convolutional Neural Networks, Humans (* major topic)
Topic: Cell Image Analysis Techniques (Biophysics, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: NIMH NIH HHS (RF1 MH133701); National Institute of Child Health and Human Development; NICHD NIH HHS (R00 HD101553); National Institute of Biomedical Imaging and Bioengineering; National Institute on Deafness and Other Communication Disorders; NIDCD NIH HHS (P50 DC014664); National Institute of Mental Health; National Science Foundation
Citations: not cited yet (Europe PMC); 32 references in the paper

Abstract

Deployment complexity and specialized hardware requirements hinder the adoption of deep learning models in neuroimaging. We present MindGrab, a lightweight, fully convolutional model for volumetric skull stripping across the evaluated imaging modalities. MindGrab’s architecture is designed from first principles using a spectral interpretation of dilated convolutions, and demonstrates state-of-the-art performance on the tested benchmarks (mean Dice score across datasets and modalities: 95.9 ± 1.6), with up to 40-fold speedups and substantially lower memory demands compared to established methods. Its minimal footprint allows for fast, full-volume processing in resource-constrained environments, including direct in-browser execution. MindGrab is delivered via the BrainChop platform as both a simple command-line tool (pip install brainchop) and a zero-installation web application (brainchop.org). By removing traditional deployment barriers without sacrificing accuracy, MindGrab makes state-of-the-art neuroimaging analysis broadly accessible.

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

Repository

Its files are read in the Code ↔ Paper reader above.

neurolabusc/broccolini

License: LGPL-2.1
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 95bfee3dfcd3d256b588bd337f3adbd8a615bd8a, 14 March 2026
Languages: C/C++ (267), C++ (17), C (3), Python (1), CUDA (1)
Size: 433 files, 289 scripts
Software Heritage: not archived
Found in: the references
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NiBabel (1 file), NumPy (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
288 files
At the source: github.com/neurolabusc/broccolini

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;
  • 286 scripts, each with its path and the digest of its content;
  • no match between paragraphs and code yet;
  • 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 statement

MindGrab is publicly and freely available for use on the browser (brainchop.org) and command-line (brainchop-cli). Both versions are released under a permissive open source MIT license. Benchmark datasets used for evaluation are publicly accessible and detailed in the manuscript.

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

  • Publisher: n/a → Elsevier BV
  • Authors: added Mike Doan (0009-0008-0703-8585); Malte Hoffmann (0000-0002-5511-0739); removed Mike Doan; Malte Hoffmann

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 7 authors, 6 keywords, 7 MeSH terms, 8 funders, 29 references.

Cite

This paper

Fani, A., Doan, M., Le, I., Fedorov, A., Hoffmann, M., Rorden, C., & Plis, S. (2026). MindGrab: A spectrally-motivated architecture for accessible deep learning in neuroimaging. NeuroImage, 338, 122074. https://doi.org/10.1016/j.neuroimage.2026.122074

BibTeX

@article{fani2026mindgrab,
author = {Fani, Armina and Doan, Mike and Le, Isabelle and Fedorov, Alex and Hoffmann, Malte and Rorden, Chris and Plis, Sergey},
title = {{MindGrab: A spectrally-motivated architecture for accessible deep learning in neuroimaging}},
journal = {NeuroImage},
year = {2026},
month = jun,
volume = {338},
pages = {122074},
publisher = {Elsevier BV},
issn = {1053-8119},
doi = {10.1016/j.neuroimage.2026.122074},
url = {https://doi.org/10.1016/j.neuroimage.2026.122074},
pmid = {42331200},
pmcid = {PMC13527664}
}

RIS

TY - JOUR
AU - Fani, Armina
AU - Doan, Mike
AU - Le, Isabelle
AU - Fedorov, Alex
AU - Hoffmann, Malte
AU - Rorden, Chris
AU - Plis, Sergey
TI - MindGrab: A spectrally-motivated architecture for accessible deep learning in neuroimaging
T2 - NeuroImage
J2 - Neuroimage
PY - 2026
DA - 2026/06/23
VL - 338
SP - 122074
SN - 1053-8119
PB - Elsevier BV
DO - 10.1016/j.neuroimage.2026.122074
UR - https://doi.org/10.1016/j.neuroimage.2026.122074
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.neuroimage.2026.122074",
"type": "article-journal",
"title": "MindGrab: A spectrally-motivated architecture for accessible deep learning in neuroimaging",
"container-title": "NeuroImage",
"author": [
{
"family": "Fani",
"given": "Armina"
},
{
"family": "Doan",
"given": "Mike"
},
{
"family": "Le",
"given": "Isabelle"
},
{
"family": "Fedorov",
"given": "Alex"
},
{
"family": "Hoffmann",
"given": "Malte"
},
{
"family": "Rorden",
"given": "Chris"
},
{
"family": "Plis",
"given": "Sergey"
}
],
"container-title-short": "Neuroimage",
"volume": "338",
"page": "122074",
"DOI": "10.1016/j.neuroimage.2026.122074",
"PMID": "42331200",
"PMCID": "PMC13527664",
"ISSN": "1053-8119",
"publisher": "Elsevier BV",
"URL": "https://doi.org/10.1016/j.neuroimage.2026.122074",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
23
]
]
}
}

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.1162/imag.a.1183 [code]
Learning-based segmentation of diffusion-weighted MR images with arbitrary &lt;i&gt;q&lt;/i&gt;-space samplings.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: NiBabel, NumPy, methods / tools, 5 references
[2] doi:10.1002/nbm.70353 [code]
Automated Surface-Based Segmentation of Deep Gray Matter Regions Based on Diffusion Tensor Images Reveals Unique Age Trajectories Over the Healthy Lifespan.
Journal: NMR in biomedicine
In common: NiBabel, NumPy, 4 references
[3] doi:10.1371/journal.pbio.3003856 [code]
Aging and metabolism contribute separately to brain-body health.
Journal: PLoS biology
In common: NiBabel, NumPy, 3 references
[4] doi:10.1162/imag.a.1352 [code]
Brain-age in ultra-low-field MRI: How well does it work?
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: NiBabel, NumPy, methods / tools, 2 references
[5] doi:10.1002/advs.76596 [code]
DDSurfer: A Weakly-Supervised Dual-Stream Deep Learning Framework for Cortical Surface Reconstruction From Diffusion MRI.
Journal: Advanced science (Weinheim, Baden-Wurttemberg, Germany)
In common: NiBabel, NumPy, methods / tools, 3 references
[6] doi:10.64898/2026.03.10.26348006 [code]
AI-Based Pipeline for the Segmentation of White Matter Hypoattenuations in CT Scans: A Design-Choice Validation Study
Journal: medRxiv (preprint)
In common: NiBabel, NumPy, methods / tools, 2 references
[7] doi:10.1162/imag.a.1129
Deep learning interpretability in neuroimaging: A comprehensive survey and methodological recommendations.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: author Sergey Plis
[8] doi:10.1038/s41467-026-75661-x [code]
A neural signature of sleep deprivation in the human brain.
Journal: Nature communications
In common: NiBabel, NumPy, 3 references
[9] doi:10.1038/s41467-026-71719-y [code]
Brain functional-structural gradient coupling reflects development, behavior and genetic influences.
Journal: Nature communications
In common: NiBabel, NumPy, 3 references
[10] doi:10.1038/s41597-026-07184-5 [code]
A Multiple Sclerosis MRI Dataset with Tri-Mask Annotations for Lesion Segmentation.
Journal: Scientific data
In common: NiBabel, NumPy, methods / tools, 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.