OSCR

Deep Learning Empowered Microstructure Codebook: New Paradigm for Multi-Parameter Tissue Characterization Estimation.

Code ↔ Paper

3 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 3 matches
  1. [1] § Materials and Methods › Hybrid Mamba‐CNN Architecture for Joint Microstructure Learning ↔ MultiOrderGatedAggregation.py, lines 268–340 · score 0.60 · Gated Aggregation, MogaNet, block, module
  2. [2] § Materials and Methods › Hybrid Mamba‐CNN Architecture for Joint Microstructure Learning ↔ MultiOrderGatedAggregation.py, lines 268–340 · score 0.57 · SiLU, dilation, gating, aggregate, Moga, activation
  3. [3] § Materials and Methods › Hybrid Mamba‐CNN Architecture for Joint Microstructure Learning ↔ VisionMamba.py, lines 67–139 · score 0.55 · Vision Mamba, connection, transformation, sequence, fused, Residual

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 · 356 lines · 13 KB · no license · 2 matches

  1. # Copyright 2021 Garena Online Private Limited
  2. #
  3. # Licensed under the Apache License, Version 2.0 (the "License");
  4. # you may not use this file except in compliance with the License.
  5. # You may obtain a copy of the License at
  6. #
  7. # http://www.apache.org/licenses/LICENSE-2.0
  8. #
  9. # Unless required by applicable law or agreed to in writing, software
  10. # distributed under the License is distributed on an "AS IS" BASIS,
  11. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12. # See the License for the specific language governing permissions and
  13. # limitations under the License.
  15. import torch
  16. import torch.nn as nn
  17. import torch.nn.functional as F
  18. # MogaNet: Multi-order Gated Aggregation Network (ICLR 2024)
  19. # https://arxiv.org/pdf/2211.03295
  20. # https://github.com/Westlake-AI/MogaNet
  21. # Spatial Block with Multi-order Gated Aggregation
  22. def build_act_layer(act_type):
  23. """Build activation layer."""
  24. if act_type is None:
  25. return nn.Identity()
  26. assert act_type in ['GELU', 'ReLU', 'SiLU']
  27. if act_type == 'SiLU':
  28. return nn.SiLU()
  29. elif act_type == 'ReLU':
  30. return nn.ReLU()
  31. else:
  32. return nn.GELU()
  34. class ElementScale(nn.Module):
  35. """A learnable element-wise scaler."""
  37. def __init__(self, embed_dims, init_value=0., requires_grad=True):
  38. super(ElementScale, self).__init__()
  39. self.scale = nn.Parameter(
  40. init_value * torch.ones((1, embed_dims, 1, 1)),
  41. requires_grad=requires_grad
  42. )
  44. def forward(self, x):
  45. return x * self.scale
  47. class MultiOrderDWConv(nn.Module):
  48. """Multi-order Features with Dilated DWConv Kernel.
  50. Args:
  51. embed_dims (int): Number of input channels.
  52. dw_dilation (list): Dilations of three DWConv layers.
  53. channel_split (list): The raletive ratio of three splited channels.
  54. """
  56. def __init__(self,
  57. embed_dims,
  58. dw_dilation=[1, 2, 3,],
  59. channel_split=[1, 3, 4,],
  60. ):
  61. super(MultiOrderDWConv, self).__init__()
  63. self.split_ratio = [i / sum(channel_split) for i in channel_split]
  64. self.embed_dims_1 = int(self.split_ratio[1] * embed_dims)
  65. self.embed_dims_2 = int(self.split_ratio[2] * embed_dims)
  66. self.embed_dims_0 = embed_dims - self.embed_dims_1 - self.embed_dims_2
  67. self.embed_dims = embed_dims
  68. assert len(dw_dilation) == len(channel_split) == 3
  69. assert 1 <= min(dw_dilation) and max(dw_dilation) <= 3
  70. assert embed_dims % sum(channel_split) == 0
  72. # basic DW conv
  73. self.DW_conv0 = nn.Conv2d(
  74. in_channels=self.embed_dims,
  75. out_channels=self.embed_dims,
  76. kernel_size=5,
  77. padding=(1 + 4 * dw_dilation[0]) // 2,
  78. groups=self.embed_dims,
  79. stride=1, dilation=dw_dilation[0],
  80. )
  81. # DW conv 1
  82. self.DW_conv1 = nn.Conv2d(
  83. in_channels=self.embed_dims_1,
  84. out_channels=self.embed_dims_1,
  85. kernel_size=5,
  86. padding=(1 + 4 * dw_dilation[1]) // 2,
  87. groups=self.embed_dims_1,
  88. stride=1, dilation=dw_dilation[1],
  89. )
  90. # DW conv 2
  91. self.DW_conv2 = nn.Conv2d(
  92. in_channels=self.embed_dims_2,
  93. out_channels=self.embed_dims_2,
  94. kernel_size=7,
  95. padding=(1 + 6 * dw_dilation[2]) // 2,
  96. groups=self.embed_dims_2,
  97. stride=1, dilation=dw_dilation[2],
  98. )
  99. # a channel convolution
  100. self.PW_conv = nn.Conv2d( # point-wise convolution
  101. in_channels=embed_dims,
  102. out_channels=embed_dims,
  103. kernel_size=1)
  105. def forward(self, x):
  106. x_0 = self.DW_conv0(x)
  107. x_1 = self.DW_conv1(
  108. x_0[:, self.embed_dims_0: self.embed_dims_0+self.embed_dims_1, ...])
  109. x_2 = self.DW_conv2(
  110. x_0[:, self.embed_dims-self.embed_dims_2:, ...])
  111. x = torch.cat([
  112. x_0[:, :self.embed_dims_0, ...], x_1, x_2], dim=1)
  113. x = self.PW_conv(x)
  114. return x
  116. class MultiOrderGatedAggregation(nn.Module):
  117. """Spatial Block with Multi-order Gated Aggregation.
  119. Args:
  120. embed_dims (int): Number of input channels.
  121. attn_dw_dilation (list): Dilations of three DWConv layers.
  122. attn_channel_split (list): The raletive ratio of splited channels.
  123. attn_act_type (str): The activation type for Spatial Block.
  124. Defaults to 'SiLU'.
  125. """
  127. def __init__(self,
  128. embed_dims,
  129. attn_dw_dilation=[1, 2, 3],
  130. attn_channel_split=[1, 3, 4],
  131. attn_act_type='SiLU',
  132. attn_force_fp32=False,
  133. ):
  134. super(MultiOrderGatedAggregation, self).__init__()
  136. self.embed_dims = embed_dims
  137. self.attn_force_fp32 = attn_force_fp32
  138. self.proj_1 = nn.Conv2d(
  139. in_channels=embed_dims, out_channels=embed_dims, kernel_size=1)
  140. self.gate = nn.Conv2d(
  141. in_channels=embed_dims, out_channels=embed_dims, kernel_size=1)
  142. self.value = MultiOrderDWConv(
  143. embed_dims=embed_dims,
  144. dw_dilation=attn_dw_dilation,
  145. channel_split=attn_channel_split,
  146. )
  147. self.proj_2 = nn.Conv2d(
  148. in_channels=embed_dims, out_channels=embed_dims, kernel_size=1)
  150. # activation for gating and value
  151. self.act_value = build_act_layer(attn_act_type)
  152. self.act_gate = build_act_layer(attn_act_type)
  154. # decompose
  155. self.sigma = ElementScale(
  156. embed_dims, init_value=1e-5, requires_grad=True)
  158. def feat_decompose(self, x):
  159. x = self.proj_1(x)
  160. # x_d: [B, C, H, W] -> [B, C, 1, 1]
  161. x_d = F.adaptive_avg_pool2d(x, output_size=1)
  162. x = x + self.sigma(x - x_d)
  163. x = self.act_value(x)
  164. return x
  166. def forward_gating(self, g, v):
  167. with torch.autocast(device_type='cuda', enabled=False):
  168. g = g.to(torch.float32)
  169. v = v.to(torch.float32)
  170. return self.proj_2(self.act_gate(g) * self.act_gate(v))
  172. def forward(self, x):
  173. shortcut = x.clone()
  174. # proj 1x1
  175. x = self.feat_decompose(x)
  176. # gating and value branch
  177. g = self.gate(x)
  178. v = self.value(x)
  179. # aggregation
  180. if not self.attn_force_fp32:
  181. x = self.proj_2(self.act_gate(g) * self.act_gate(v))
  182. else:
  183. x = self.forward_gating(self.act_gate(g), self.act_gate(v))
  184. x = x + shortcut
  185. return x
  188. class ChannelAggregationFFN(nn.Module):
  189. """An implementation of FFN with Channel Aggregation.
  191. Args:
  192. embed_dims (int): The feature dimension. Same as
  193. `MultiheadAttention`.
  194. feedforward_channels (int): The hidden dimension of FFNs.
  195. kernel_size (int): The depth-wise conv kernel size as the
  196. depth-wise convolution. Defaults to 3.
  197. act_type (str): The type of activation. Defaults to 'GELU'.
  198. ffn_drop (float, optional): Probability of an element to be
  199. zeroed in FFN. Default 0.0.
  200. """
  202. def __init__(self,
  203. embed_dims,
  204. feedforward_channels,
  205. kernel_size=3,
  206. act_type='GELU',
  207. ffn_drop=0.):
  208. super(ChannelAggregationFFN, self).__init__()
  210. self.embed_dims = embed_dims
  211. self.feedforward_channels = feedforward_channels
  213. self.fc1 = nn.Conv2d(
  214. in_channels=embed_dims,
  215. out_channels=self.feedforward_channels,
  216. kernel_size=1)
  217. self.dwconv = nn.Conv2d(
  218. in_channels=self.feedforward_channels,
  219. out_channels=self.feedforward_channels,
  220. kernel_size=kernel_size,
  221. stride=1,
  222. padding=kernel_size // 2,
  223. bias=True,
  224. groups=self.feedforward_channels)
  225. self.act = build_act_layer(act_type)
  226. self.fc2 = nn.Conv2d(
  227. in_channels=feedforward_channels,
  228. out_channels=embed_dims,
  229. kernel_size=1)
  230. self.drop = nn.Dropout(ffn_drop)
  232. self.decompose = nn.Conv2d(
  233. in_channels=self.feedforward_channels, # C -> 1
  234. out_channels=1, kernel_size=1,
  235. )
  236. self.sigma = ElementScale(
  237. self.feedforward_channels, init_value=1e-5, requires_grad=True)
  238. self.decompose_act = build_act_layer(act_type)
  240. def feat_decompose(self, x):
  241. # x_d: [B, C, H, W] -> [B, 1, H, W]
  242. x = x + self.sigma(x - self.decompose_act(self.decompose(x)))
  243. return x
  245. def forward(self, x):
  246. # proj 1
  247. x = self.fc1(x)
  248. x = self.dwconv(x)
  249. x = self.act(x)
  250. x = self.drop(x)
  251. # proj 2
  252. x = self.feat_decompose(x)
  253. x = self.fc2(x)
  254. x = self.drop(x)
  255. return x
  258. def build_norm_layer(norm_type, embed_dims):
  259. """Build normalization layer."""
  260. assert norm_type in ['BN', 'GN', 'LN2d', 'SyncBN']
  261. if norm_type == 'GN':
  262. return nn.GroupNorm(embed_dims, embed_dims, eps=1e-5)
  263. if norm_type == 'SyncBN':
  264. return nn.SyncBatchNorm(embed_dims, eps=1e-5)
  265. else:
  266. return nn.BatchNorm2d(embed_dims, eps=1e-5)
  268. class MogaBlock(nn.Module):
  269. """A block of MogaNet.
  271. Args:
  272. embed_dims (int): Number of input channels.
  273. ffn_ratio (float): The expansion ratio of feedforward network hidden
  274. layer channels. Defaults to 4.
  275. drop_rate (float): Dropout rate after embedding. Defaults to 0.
  276. drop_path_rate (float): Stochastic depth rate. Defaults to 0.1.
  277. act_type (str): The activation type for projections and FFNs.
  278. Defaults to 'GELU'.
  279. norm_cfg (str): The type of normalization layer. Defaults to 'BN'.
  280. init_value (float): Init value for Layer Scale. Defaults to 1e-5.
  281. attn_dw_dilation (list): Dilations of three DWConv layers.
  282. attn_channel_split (list): The raletive ratio of splited channels.
  283. attn_act_type (str): The activation type for the gating branch.
  284. Defaults to 'SiLU'.
  285. """
  287. def __init__(self,
  288. embed_dims,
  289. ffn_ratio=4.,
  290. drop_rate=0.,
  291. drop_path_rate=0.,
  292. act_type='GELU',
  293. norm_type='BN',
  294. init_value=1e-5,
  295. attn_dw_dilation=[1, 2, 3],
  296. attn_channel_split=[1, 3, 4],
  297. attn_act_type='SiLU',
  298. attn_force_fp32=False,
  299. ):
  300. super(MogaBlock, self).__init__()
  301. self.out_channels = embed_dims
  303. self.norm1 = build_norm_layer(norm_type, embed_dims)
  305. # spatial attention
  306. self.attn = MultiOrderGatedAggregation(
  307. embed_dims,
  308. attn_dw_dilation=attn_dw_dilation,
  309. attn_channel_split=attn_channel_split,
  310. attn_act_type=attn_act_type,
  311. attn_force_fp32=attn_force_fp32,
  312. )
  314. self.norm2 = build_norm_layer(norm_type, embed_dims)
  316. # channel MLP
  317. mlp_hidden_dim = int(embed_dims * ffn_ratio)
  318. self.mlp = ChannelAggregationFFN( # DWConv + Channel Aggregation FFN
  319. embed_dims=embed_dims,
  320. feedforward_channels=mlp_hidden_dim,
  321. act_type=act_type,
  322. ffn_drop=drop_rate,
  323. )
  325. # init layer scale
  326. self.layer_scale_1 = nn.Parameter(
  327. init_value * torch.ones((1, embed_dims, 1, 1)), requires_grad=True)
  328. self.layer_scale_2 = nn.Parameter(
  329. init_value * torch.ones((1, embed_dims, 1, 1)), requires_grad=True)
  331. def forward(self, x):
  332. # spatial
  333. identity = x
  334. x = self.layer_scale_1 * self.attn(self.norm1(x))
  335. x = identity + x
  336. # channel
  337. identity = x
  338. x = self.layer_scale_2 * self.mlp(self.norm2(x))
  339. x = identity + x
  340. return x
  344. if __name__ == '__main__':
  345. # Define the input tensor with a batch size of 4, 64 channels, and spatial dimensions 32x32
  346. input_tensor = torch.randn(1, 64, 32, 32)
  348. # Instantiate the MultiOrderGatedAggregation layer
  349. moga_layer = MogaBlock(embed_dims=64)
  351. # Pass the input tensor through the layer
  352. output_tensor = moga_layer(input_tensor)
  354. # Print the shape of the input and output tensors
  355. print(f"Input shape: {input_tensor.shape}")
  356. print(f"Output shape: {output_tensor.shape}")

MultiOrderGatedAggregation.py at commit 709f52d, no license · at the source

Overview

Authors: Tenglong Wang1, Zhonghua Wan1, Shuxin Cao1, Jiahao Yu1, Yifei He1, Yu Xie1, Fan Zhang2, Ye Wu1
ORCID iDs: Tenglong Wang, Zhonghua Wan, Yifei He
  1. School of Computer Science and Engineering, Nanjing University of Science and Technology, Nanjing, China
  2. School of Information and Communication Engineering, University of Electronic Science and Technology of China, Chengdu, China
Institutions: Nanjing University of Science and Technology (China); University of Electronic Science and Technology of China (China)
Journal: Human brain mapping, volume 47, issue 5, article e70513
Dates: received 10 August 2025; accepted 11 March 2026; published online 19 March 2026; in print April 2026
Type: Research article · Language: English
License: CC BY-NC
Identifiers: DOI 10.1002/hbm.70513 · PMID 41857810 · PMCID PMC13140400 · OpenAlex W7139065729
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), human (organism)
Methods: Connectivity, Smoothing, state filtering, decompositions, Machine learning, Physiology & signal measures, fMRI & imaging
Keywords: codebook, diffusion MRI, hybrid Mamba‐CNN, microstructure
MeSH: Brain*, Deep Learning*, Diffusion Magnetic Resonance Imaging*, Image Processing, Computer-Assisted*, Neuroimaging*, Convolutional Neural Networks, Humans (* major topic)
Topic: Advanced Neuroimaging Techniques and Applications (Radiology, Nuclear Medicine and Imaging, Medicine), according to OpenAlex
Funding: Postgraduate Research & Practice Innovation Program of Jiangsu Province (KYCX25_0757, KYCX25_0752); National Natural Science Foundation of China (62201265); National Key Research and Development Program of China (2023YFF1204803, 2023YFE0118600); Key Project of Jiangsu Provincial Natural Science Fund (BK20253028)
Citations: cited by 1 paper (Europe PMC); 73 references in the paper

Abstract

Diffusion MRI (dMRI) enables the examination of microstructural profiles and tissue changes using specific microstructural modeling, but it requires long acquisition times and dense q‐space sampling. Current deep learning‐based methods are also limited by their inability to generalize across protocols and extend to new microstructural indices. This work introduces a novel framework that addresses these limitations by learning a microstructural codebook, facilitating accurate, rapid, and multi‐parameter microstructure imaging. Our approach integrates the spherical mean technique (SMT) with a hybrid Mamba‐CNN architecture and learnable tissue‐compartment kernels, effectively capturing multiscale spatial dependencies while linking spherical mean signals to biophysical microstructure models. This design enhances both interpretability and adaptability, enabling robust estimation of 24 microstructural metrics derived from 8 widely used biophysical diffusion models, even under undersampled acquisition conditions. Notably, the framework demonstrates strong generalization across diverse acquisition protocols and enables seamless adaptation to novel microstructural indices with minimal fine‐tuning, underscoring its flexibility and practical utility. Extensive experiments on multiple datasets confirm the method's superior accuracy, generalization, and transferability. This work presents a codebook‐driven framework for microstructure imaging that bridges biophysical modeling and deep learning to enable more interpretable and adaptable dMRI analysis. The code is available at https://github.com/1nlandempire/Microstructure‐codebook‐imaging.

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

Repository

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

1nlandempire/Microstructure-codebook-imaging

License: none: the authors keep all their rights
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: 709f52de75a2876e86f4f11264ab2ba6ea99a5eb, 2 December 2025
Languages: Python (5)
Size: 13 files, 5 scripts
Software Heritage: not archived
Found in: “Data Availability Statement”
Holds: README, environment (environment.yaml)
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: PyTorch (5 files), DIPY (1 file), NumPy (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
6 files
At the source: github.com/1nlandempire/Microstructure-codebook-imaging

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

Data Availability Statement

The data supporting the findings of this study are openly available in public repositories: The SUDMEX CONN dataset at https://openneuro.org/datasets/ds003346/versions/1.1.0 (Wong et al. 2018), the BTC preop dataset at https://openneuro.org/datasets/ds001226/versions/5.0.0 (Merlet and Deriche 2013), the BTC postop dataset at https://openneuro.org/datasets/ds002080/versions/4.0.0 (Merlet and Deriche 2013), the HCP dataset at https://db.humanconnectome.org/data/projects/HCP_1200 (Zhang et al. 2019), and the HCP‐MGH dataset at https://db.humanconnectome.org/data/projects/MGH_DIFF (Angeles‐Valdez et al. 2021). The code is available at https://github.com/1nlandempire/Microstructure‐codebook‐imaging (https://github.com/1nlandempire/Microstructure-codebook-imaging).

Reproduced under the paper's license (CC BY-NC), 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 1, 28 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 8 authors, 4 keywords, 7 MeSH terms, 4 funders, 70 references.

Cite

This paper

Wang, T., Wan, Z., Cao, S., Yu, J., He, Y., Xie, Y., Zhang, F., & Wu, Y. (2026). Deep Learning Empowered Microstructure Codebook: New Paradigm for Multi-Parameter Tissue Characterization Estimation. Human brain mapping, 47(5), e70513. https://doi.org/10.1002/hbm.70513

BibTeX

@article{wang2026deep,
author = {Wang, Tenglong and Wan, Zhonghua and Cao, Shuxin and Yu, Jiahao and He, Yifei and Xie, Yu and Zhang, Fan and Wu, Ye},
title = {{Deep Learning Empowered Microstructure Codebook: New Paradigm for Multi-Parameter Tissue Characterization Estimation}},
journal = {Human brain mapping},
year = {2026},
month = apr,
volume = {47},
number = {5},
pages = {e70513},
publisher = {Wiley},
issn = {1065-9471},
doi = {10.1002/hbm.70513},
url = {https://doi.org/10.1002/hbm.70513},
pmid = {41857810},
pmcid = {PMC13140400}
}

RIS

TY - JOUR
AU - Wang, Tenglong
AU - Wan, Zhonghua
AU - Cao, Shuxin
AU - Yu, Jiahao
AU - He, Yifei
AU - Xie, Yu
AU - Zhang, Fan
AU - Wu, Ye
TI - Deep Learning Empowered Microstructure Codebook: New Paradigm for Multi-Parameter Tissue Characterization Estimation
T2 - Human brain mapping
J2 - Hum Brain Mapp
PY - 2026
DA - 2026/04/01
VL - 47
IS - 5
SP - e70513
SN - 1065-9471
PB - Wiley
DO - 10.1002/hbm.70513
UR - https://doi.org/10.1002/hbm.70513
LA - en
ER -

CSL-JSON

{
"id": "10.1002/hbm.70513",
"type": "article-journal",
"title": "Deep Learning Empowered Microstructure Codebook: New Paradigm for Multi-Parameter Tissue Characterization Estimation",
"container-title": "Human brain mapping",
"author": [
{
"family": "Wang",
"given": "Tenglong"
},
{
"family": "Wan",
"given": "Zhonghua"
},
{
"family": "Cao",
"given": "Shuxin"
},
{
"family": "Yu",
"given": "Jiahao"
},
{
"family": "He",
"given": "Yifei"
},
{
"family": "Xie",
"given": "Yu"
},
{
"family": "Zhang",
"given": "Fan"
},
{
"family": "Wu",
"given": "Ye"
}
],
"container-title-short": "Hum Brain Mapp",
"volume": "47",
"issue": "5",
"page": "e70513",
"DOI": "10.1002/hbm.70513",
"PMID": "41857810",
"PMCID": "PMC13140400",
"ISSN": "1065-9471",
"publisher": "Wiley",
"URL": "https://doi.org/10.1002/hbm.70513",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
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.1038/s43856-026-01614-6 [code]
Simulation-based inference at the theoretical limit for fast, robust microstructural MRI with minimal diffusion data.
Journal: Communications medicine
In common: DIPY, PyTorch, NumPy, structural MRI / diffusion, 7 references
[2] doi:10.1002/nbm.70277 [code]
Hierarchical Bayesian Modelling Improves Microstructural Parameter Mapping in Diffusion and Exchange MRI Data.
Journal: NMR in biomedicine
In common: DIPY, NumPy, structural MRI / diffusion, 7 references
[3] doi:10.1038/s41598-026-51531-w [code]
Multimodal age-dependent diffusion-MRI analysis of the neocortex in a rat model of cortical dysplasia.
Journal: Scientific reports
In common: DIPY, NumPy, structural MRI / diffusion, 5 references
[4] doi:10.1016/j.isci.2026.116671 [code]
A high-resolution functional network-organized atlas of human superficial white matter from ultra-high-field diffusion MRI.
Journal: iScience
In common: DIPY, PyTorch, NumPy, structural MRI / diffusion, author Yifei He
[5] doi:10.1002/mrm.70490 [code]
Dependence of the Extra-Cellular Diffusion Coefficient on the Fractions of Neurites and Cell Bodies in Gray Matter.
Journal: Magnetic resonance in medicine
In common: structural MRI / diffusion, 6 references
[6] doi:10.1002/mrm.70496 [code]
A Deep Nonlinear Subspace Modeling and Reconstruction for Diffusion-Weighted Imaging Using Denoising Auto-Encoder.
Journal: Magnetic resonance in medicine
In common: DIPY, PyTorch, NumPy, structural MRI / diffusion, 3 references
[7] doi:10.1016/j.nicl.2026.104057 [code]
Tensor-derived diffusion MRI metrics and NODDI in multiple sclerosis classification.
Journal: NeuroImage. Clinical
In common: structural MRI / diffusion, 6 references
[8] doi:10.1186/s12916-026-04903-y [code]
Structural connectome architecture and biological vulnerability shape cortical atrophy in cocaine use disorder.
Journal: BMC medicine
In common: NumPy, OpenNeuro ds003346, structural MRI / diffusion, 1 reference
[9] doi:10.1038/s42003-026-10256-2 [code]
Diffusion MRI experimental design optimization for microstructure imaging.
Journal: Communications biology
In common: structural MRI / diffusion, 5 references
[10] doi:10.1162/imag.a.1341 [code]
Massively parallelized brain tractography using compute clusters, supercomputers, and graphics processing units.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: DIPY, NumPy, structural MRI / diffusion, 3 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.