OSCR

Image Distortion Correction for Diffusion MR Imaging Using a Transformer-based U-Net.

Code ↔ Paper

6 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 6 matches
  1. [1] § Materials and Methods › Network architecture › TransDisCo (proposed method) ↔ Baseline_Transformers/models/nnFormer/Swin_Unet_s_ACDC_2laterdown.py, lines 420–533 · score 0.77 · SW MSA, Swin Transformer block, Patch merging, layer normalization, partition, upsampling
  2. [2] § Materials and Methods › Network architecture › TransDisCo (proposed method) ↔ Baseline_Transformers/models/nnFormer/Swin_Unet_l_gelunorm.py, lines 445–544 · score 0.76 · SW MSA, Swin Transformer block, Patch merging, layer normalization, partition, upsampling
  3. [3] § Materials and Methods › Network architecture ↔ Baseline_Transformers/models/CoTr/training/network_training/nnUNetTrainer.py, lines 233–264 · score 0.56 · LeakyReLU, Conv3d, kernel, architectural, Network, Transformer
  4. [4] § Materials and Methods › Network architecture › CNN-DisCo (ablation study model) ↔ Baseline_Transformers/models/configs_PVT.py, lines 1–26 · score 0.55 · Swin Transformer blocks, skip connections, convolutional layers, depth, model
  5. [5] § Materials and Methods › Network architecture › CNN-DisCo (ablation study model) ↔ IXI/TransMorph/models/configs_TransMorph.py, lines 1–28 · score 0.55 · Swin Transformer blocks, skip connections, convolutional layers, depth, model
  6. [6] § Materials and Methods › Network architecture ↔ Baseline_Transformers/models/nnFormer/generic_UNet.py, lines 184–246 · score 0.54 · LeakyReLU, Conv3d, kernel, architectural, convolutional, blocks

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 · 976 lines · 38 KB · MIT · 1 match

  1. from einops import rearrange
  2. from copy import deepcopy
  3. from nnformer.utilities.nd_softmax import softmax_helper
  4. from torch import nn
  5. import torch
  6. import numpy as np
  7. from nnformer.network_architecture.initialization import InitWeights_He
  8. from nnformer.network_architecture.neural_network import SegmentationNetwork
  9. import torch.nn.functional
  12. import torch.nn.functional as F
  13. import torch.utils.checkpoint as checkpoint
  14. from timm.models.layers import DropPath, to_3tuple, trunc_normal_
  17. class Mlp(nn.Module):
  18. """ Multilayer perceptron."""
  20. def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
  21. super().__init__()
  22. out_features = out_features or in_features
  23. hidden_features = hidden_features or in_features
  24. self.fc1 = nn.Linear(in_features, hidden_features)
  25. self.act = act_layer()
  26. self.fc2 = nn.Linear(hidden_features, out_features)
  27. self.drop = nn.Dropout(drop)
  29. def forward(self, x):
  30. x = self.fc1(x)
  31. x = self.act(x)
  32. x = self.drop(x)
  33. x = self.fc2(x)
  34. x = self.drop(x)
  35. return x
  38. def window_partition(x, window_size):
  40. B, S, H, W, C = x.shape
  42. x = x.view(B, S // window_size[0], window_size[0], H // window_size[1], window_size[1], W // window_size[2], window_size[2], C)
  43. windows = x.permute(0, 1, 3, 5, 2, 4, 6, 7).contiguous().view(-1, window_size[0], window_size[1], window_size[2], C)
  44. return windows
  47. def window_reverse(windows, window_size, S, H, W):
  49. B = int(windows.shape[0] / (S * H * W / window_size[0] / window_size[1] / window_size[2]))
  50. x = windows.view(B, S // window_size[0], H // window_size[1], W // window_size[2], window_size[0], window_size[1], window_size[2], -1)
  51. x = x.permute(0, 1, 4, 2, 5, 3, 6, 7).contiguous().view(B, S, H, W, -1)
  52. return x
  55. class WindowAttention(nn.Module):
  56. """ Window based multi-head self attention (W-MSA) module with relative position bias.
  57. It supports both of shifted and non-shifted window.
  59. Args:
  60. dim (int): Number of input channels.
  61. window_size (tuple[int]): The height and width of the window.
  62. num_heads (int): Number of attention heads.
  63. qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
  64. qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set
  65. attn_drop (float, optional): Dropout ratio of attention weight. Default: 0.0
  66. proj_drop (float, optional): Dropout ratio of output. Default: 0.0
  67. """
  69. def __init__(self, dim, window_size, num_heads, qkv_bias=True, qk_scale=None, attn_drop=0., proj_drop=0.):
  71. super().__init__()
  72. self.dim = dim
  73. self.window_size = window_size # Wh, Ww
  74. self.num_heads = num_heads
  75. head_dim = dim // num_heads
  76. self.scale = qk_scale or head_dim ** -0.5
  78. # define a parameter table of relative position bias
  79. self.relative_position_bias_table = nn.Parameter(
  80. torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1) * (2 * window_size[2] - 1),
  81. num_heads))
  83. # get pair-wise relative position index for each token inside the window
  84. coords_s = torch.arange(self.window_size[0])
  85. coords_h = torch.arange(self.window_size[1])
  86. coords_w = torch.arange(self.window_size[2])
  87. coords = torch.stack(torch.meshgrid([coords_s, coords_h, coords_w]))
  88. coords_flatten = torch.flatten(coords, 1)
  89. relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :]
  90. relative_coords = relative_coords.permute(1, 2, 0).contiguous()
  91. relative_coords[:, :, 0] += self.window_size[0] - 1 # shift to start from 0
  92. relative_coords[:, :, 1] += self.window_size[1] - 1
  93. relative_coords[:, :, 2] += self.window_size[2] - 1
  96. relative_coords[:, :, 0] *= 3 * self.window_size[1] - 1
  97. relative_coords[:, :, 1] *= 2 * self.window_size[1] - 1
  99. relative_position_index = relative_coords.sum(-1)
  100. self.register_buffer("relative_position_index", relative_position_index)
  102. self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
  103. self.attn_drop = nn.Dropout(attn_drop)
  104. self.proj = nn.Linear(dim, dim)
  105. self.proj_drop = nn.Dropout(proj_drop)
  107. trunc_normal_(self.relative_position_bias_table, std=.02)
  108. self.softmax = nn.Softmax(dim=-1)
  110. def forward(self, x, mask=None):
  112. B_, N, C = x.shape
  114. qkv = self.qkv(x)
  116. qkv=qkv.reshape(B_, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
  117. q, k, v = qkv[0], qkv[1], qkv[2] # make torchscript happy (cannot use tensor as tuple)
  119. q = q * self.scale
  120. attn = (q @ k.transpose(-2, -1))
  121. relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)].view(
  122. self.window_size[0] * self.window_size[1] * self.window_size[2],
  123. self.window_size[0] * self.window_size[1] * self.window_size[2], -1)
  124. relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous()
  125. attn = attn + relative_position_bias.unsqueeze(0)
  127. if mask is not None:
  128. nW = mask.shape[0]
  129. attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0)
  130. attn = attn.view(-1, self.num_heads, N, N)
  131. attn = self.softmax(attn)
  132. else:
  133. attn = self.softmax(attn)
  135. attn = self.attn_drop(attn)
  137. x = (attn @ v).transpose(1, 2).reshape(B_, N, C)
  138. x = self.proj(x)
  139. x = self.proj_drop(x)
  140. return x
  143. class SwinTransformerBlock(nn.Module):
  144. """ Swin Transformer Block.
  146. Args:
  147. dim (int): Number of input channels.
  148. num_heads (int): Number of attention heads.
  149. window_size (int): Window size.
  150. shift_size (int): Shift size for SW-MSA.
  151. mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.
  152. qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
  153. qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
  154. drop (float, optional): Dropout rate. Default: 0.0
  155. attn_drop (float, optional): Attention dropout rate. Default: 0.0
  156. drop_path (float, optional): Stochastic depth rate. Default: 0.0
  157. act_layer (nn.Module, optional): Activation layer. Default: nn.GELU
  158. norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
  159. """
  161. def __init__(self, dim, input_resolution, num_heads, window_size=7, shift_size=0,
  162. mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0., drop_path=0.,
  163. act_layer=nn.GELU, norm_layer=nn.LayerNorm):
  164. super().__init__()
  165. self.dim = dim
  166. self.input_resolution = input_resolution
  167. self.num_heads = num_heads
  168. self.window_size = window_size
  169. self.shift_size = shift_size
  170. self.mlp_ratio = mlp_ratio
  171. if tuple(self.input_resolution) == tuple(self.window_size):
  173. # if window size is larger than input resolution, we don't partition windows
  174. self.shift_size = [0,0,0]
  175. #self.window_size = min(self.input_resolution)
  176. #assert 0 <= self.shift_size < self.window_size, "shift_size must in 0-window_size"
  178. self.norm1 = norm_layer(dim)
  179. self.attn = WindowAttention(
  180. dim, window_size=self.window_size, num_heads=num_heads,
  181. qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop)
  183. self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
  184. self.norm2 = norm_layer(dim)
  185. mlp_hidden_dim = int(dim * mlp_ratio)
  186. self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
  188. def forward(self, x, mask_matrix):
  190. B, L, C = x.shape
  191. S, H, W = self.input_resolution
  193. assert L == S * H * W, "input feature has wrong size"
  195. shortcut = x
  196. x = self.norm1(x)
  197. x = x.view(B, S, H, W, C)
  199. # pad feature maps to multiples of window size
  200. pad_r = (self.window_size[2] - W % self.window_size[2]) % self.window_size[2]
  201. pad_b = (self.window_size[1] - H % self.window_size[1]) % self.window_size[1]
  202. pad_g = (self.window_size[0] - S % self.window_size[0]) % self.window_size[0]
  204. x = F.pad(x, (0, 0, 0, pad_r, 0, pad_b, 0, pad_g))
  205. _, Sp, Hp, Wp, _ = x.shape
  207. # cyclic shift
  208. if min(self.shift_size) > 0:
  209. shifted_x = torch.roll(x, shifts=(-self.shift_size[0], -self.shift_size[1],-self.shift_size[2]), dims=(1, 2,3))
  210. attn_mask = mask_matrix
  211. else:
  212. shifted_x = x
  213. attn_mask = None
  215. # partition windows
  216. x_windows = window_partition(shifted_x, self.window_size)
  217. x_windows = x_windows.view(-1, self.window_size[0] * self.window_size[1] * self.window_size[2],
  218. C)
  219. # W-MSA/SW-MSA
  220. attn_windows = self.attn(x_windows, mask=attn_mask)
  222. # merge windows
  223. attn_windows = attn_windows.view(-1, self.window_size[0], self.window_size[1], self.window_size[2], C)
  224. shifted_x = window_reverse(attn_windows, self.window_size, Sp, Hp, Wp)
  226. # reverse cyclic shift
  227. if min(self.shift_size) > 0:
  228. x = torch.roll(shifted_x, shifts=(self.shift_size[0], self.shift_size[1], self.shift_size[2]), dims=(1, 2, 3))
  229. else:
  230. x = shifted_x
  232. if pad_r > 0 or pad_b > 0 or pad_g > 0:
  233. x = x[:, :S, :H, :W, :].contiguous()
  235. x = x.view(B, S * H * W, C)
  237. # FFN
  238. x = shortcut + self.drop_path(x)
  239. x = x + self.drop_path(self.mlp(self.norm2(x)))
  241. return x
  244. class PatchMerging(nn.Module):
  245. """ Patch Merging Layer
  247. Args:
  248. dim (int): Number of input channels.
  249. norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
  250. """
  252. def __init__(self, dim, norm_layer=nn.LayerNorm,tag=None):
  253. super().__init__()
  254. self.dim = dim
  255. if tag==0:
  256. self.reduction = nn.Conv3d(dim,dim*2,kernel_size=[1,2,2],stride=[1,2,2])
  257. else:
  258. self.reduction = nn.Conv3d(dim,dim*2,kernel_size=[2,2,2],stride=[2,2,2])
  260. self.norm = norm_layer(dim)
  262. def forward(self, x, S, H, W):
  264. B, L, C = x.shape
  266. assert L == H * W * S, "input feature has wrong size"
  268. x = x.view(B, S, H, W, C)
  270. x = F.gelu(x)
  271. x = self.norm(x)
  272. x=x.permute(0,4,1,2,3)
  273. x=self.reduction(x)
  274. x=x.permute(0,2,3,4,1).view(B,-1,2*C)
  276. return x
  278. class Patch_Expanding(nn.Module):
  279. def __init__(self, dim, norm_layer=nn.LayerNorm,tag=None):
  280. super().__init__()
  281. self.dim = dim
  282. self.norm = norm_layer(dim)
  283. if tag==0:
  284. self.up=nn.ConvTranspose3d(dim,dim//2,[1,2,2],[1,2,2])
  285. elif tag==1:
  286. self.up=nn.ConvTranspose3d(dim,dim//2,[2,2,2],[2,2,2])
  287. elif tag==2:
  288. self.up=nn.ConvTranspose3d(dim,dim//2,[2,2,2],[2,2,2],output_padding=[1,0,0])
  289. def forward(self, x, S, H, W):
  290. """ Forward function.
  292. Args:
  293. x: Input feature, tensor size (B, H*W, C).
  294. H, W: Spatial resolution of the input feature.
  295. """
  297. B, L, C = x.shape
  298. assert L == H * W * S, "input feature has wrong size"
  300. x = x.view(B, S, H, W, C)
  303. x = self.norm(x)
  304. x=x.permute(0,4,1,2,3)
  305. x = self.up(x)
  306. x=x.permute(0,2,3,4,1).view(B,-1,C//2)
  308. return x
  309. class BasicLayer(nn.Module):
  310. """ A basic Swin Transformer layer for one stage.
  312. Args:
  313. dim (int): Number of feature channels
  314. depth (int): Depths of this stage.
  315. num_heads (int): Number of attention head.
  316. window_size (int): Local window size. Default: 7.
  317. mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4.
  318. qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
  319. qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
  320. drop (float, optional): Dropout rate. Default: 0.0
  321. attn_drop (float, optional): Attention dropout rate. Default: 0.0
  322. drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0
  323. norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
  324. downsample (nn.Module | None, optional): Downsample layer at the end of the layer. Default: None
  325. use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.
  326. """
  328. def __init__(self,
  329. dim,
  330. input_resolution,
  331. depth,
  332. num_heads,
  333. window_size=7,
  334. mlp_ratio=4.,
  335. qkv_bias=True,
  336. qk_scale=None,
  337. drop=0.,
  338. attn_drop=0.,
  339. drop_path=0.,
  340. norm_layer=nn.LayerNorm,
  341. downsample=True,
  342. use_checkpoint=False,
  343. i_layer=None):
  344. super().__init__()
  345. self.window_size = window_size
  346. self.shift_size = [window_size[0] // 2,window_size[1] // 2,window_size[2] // 2]
  347. self.depth = depth
  348. self.use_checkpoint = use_checkpoint
  349. self.i_layer=i_layer
  350. # build blocks
  351. self.blocks = nn.ModuleList([
  352. SwinTransformerBlock(
  353. dim=dim,
  354. input_resolution=input_resolution,
  355. num_heads=num_heads,
  356. window_size=window_size,
  357. shift_size=[0,0,0] if (i % 2 == 0) else self.shift_size,
  358. mlp_ratio=mlp_ratio,
  359. qkv_bias=qkv_bias,
  360. qk_scale=qk_scale,
  361. drop=drop,
  362. attn_drop=attn_drop,
  363. drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path, norm_layer=norm_layer)
  364. for i in range(depth)])
  366. # patch merging layer
  367. if downsample is not None:
  368. if i_layer==1 or i_layer==2:
  369. self.downsample = downsample(dim=dim, norm_layer=norm_layer,tag=1)
  370. else:
  371. self.downsample = downsample(dim=dim, norm_layer=norm_layer,tag=0)
  372. else:
  373. self.downsample = None
  375. def forward(self, x, S, H, W):
  378. # calculate attention mask for SW-MSA
  379. Sp = int(np.ceil(S / self.window_size[0])) * self.window_size[0]
  380. Hp = int(np.ceil(H / self.window_size[1])) * self.window_size[1]
  381. Wp = int(np.ceil(W / self.window_size[2])) * self.window_size[2]
  382. img_mask = torch.zeros((1, Sp, Hp, Wp, 1), device=x.device)
  383. s_slices = (slice(0, -self.window_size[0]),
  384. slice(-self.window_size[0], -self.shift_size[0]),
  385. slice(-self.shift_size[0], None))
  386. h_slices = (slice(0, -self.window_size[1]),
  387. slice(-self.window_size[1], -self.shift_size[1]),
  388. slice(-self.shift_size[1], None))
  389. w_slices = (slice(0, -self.window_size[2]),
  390. slice(-self.window_size[2], -self.shift_size[2]),
  391. slice(-self.shift_size[2], None))
  392. cnt = 0
  393. for s in s_slices:
  394. for h in h_slices:
  395. for w in w_slices:
  396. img_mask[:, s, h, w, :] = cnt
  397. cnt += 1
  399. mask_windows = window_partition(img_mask, self.window_size)
  400. mask_windows = mask_windows.view(-1,
  401. self.window_size[0] * self.window_size[1] * self.window_size[2])
  402. attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
  403. attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0))
  404. for blk in self.blocks:
  405. blk.H, blk.W = H, W
  406. if self.use_checkpoint:
  407. x = checkpoint.checkpoint(blk, x, attn_mask)
  408. else:
  409. x = blk(x, attn_mask)
  410. if self.downsample is not None:
  411. x_down = self.downsample(x, S, H, W)
  412. if self.i_layer!=1 and self.i_layer!=2:
  413. Ws, Wh, Ww = S , (H + 1) // 2, (W + 1) // 2
  414. else:
  415. Ws, Wh, Ww = S//2 , (H + 1) // 2, (W + 1) // 2
  416. return x, S, H, W, x_down, Ws, Wh, Ww
  417. else:
  418. return x, S, H, W, x, S, H, W
  420. class BasicLayer_up(nn.Module):
  421. """ A basic Swin Transformer layer for one stage.
  423. Args:
  424. dim (int): Number of feature channels
  425. depth (int): Depths of this stage.
  426. num_heads (int): Number of attention head.
  427. window_size (int): Local window size. Default: 7.
  428. mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4.
  429. qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
  430. qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
  431. drop (float, optional): Dropout rate. Default: 0.0
  432. attn_drop (float, optional): Attention dropout rate. Default: 0.0
  433. drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0
  434. norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
  435. downsample (nn.Module | None, optional): Downsample layer at the end of the layer. Default: None
  436. use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.
  437. """
  439. def __init__(self,
  440. dim,
  441. input_resolution,
  442. depth,
  443. num_heads,
  444. window_size=7,
  445. mlp_ratio=4.,
  446. qkv_bias=True,
  447. qk_scale=None,
  448. drop=0.,
  449. attn_drop=0.,
  450. drop_path=0.,
  451. norm_layer=nn.LayerNorm,
  452. upsample=True,
  453. i_layer=None
  454. ):
  455. super().__init__()
  456. self.window_size = window_size
  457. self.shift_size = [window_size[0] // 2,window_size[1] // 2,window_size[2] // 2]
  458. self.depth = depth
  461. # build blocks
  462. self.blocks = nn.ModuleList([
  463. SwinTransformerBlock(
  464. dim=dim,
  465. input_resolution=input_resolution,
  466. num_heads=num_heads,
  467. window_size=window_size,
  468. shift_size=[0,0,0] if (i % 2 == 0) else self.shift_size,
  469. mlp_ratio=mlp_ratio,
  470. qkv_bias=qkv_bias,
  471. qk_scale=qk_scale,
  472. drop=drop,
  473. attn_drop=attn_drop,
  474. drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path, norm_layer=norm_layer)
  475. for i in range(depth)])
  477. # patch merging layer
  478. self.i_layer=i_layer
  479. if i_layer==1:
  480. self.Upsample = upsample(dim=2*dim, norm_layer=norm_layer,tag=1)
  481. elif i_layer==0:
  482. self.Upsample = upsample(dim=2*dim, norm_layer=norm_layer,tag=2)
  483. else:
  484. self.Upsample = upsample(dim=2*dim, norm_layer=norm_layer,tag=0)
  485. def forward(self, x,skip, S, H, W):
  486. """ Forward function.
  488. Args:
  489. x: Input feature, tensor size (B, H*W, C).
  490. H, W: Spatial resolution of the input feature.
  491. """
  492. skip = skip.flatten(2).transpose(1, 2)
  493. x_up = self.Upsample(x, S, H, W)
  495. x_up+=skip
  496. if self.i_layer==1:
  497. S, H, W = S * 2 , H * 2, W * 2
  498. elif self.i_layer==0:
  499. S, H, W = (S * 2)+1 , H * 2, W * 2
  500. else:
  501. S, H, W = S , H * 2, W * 2
  503. # calculate attention mask for SW-MSA
  504. Sp = int(np.ceil(S / self.window_size[0])) * self.window_size[0]
  505. Hp = int(np.ceil(H / self.window_size[1])) * self.window_size[1]
  506. Wp = int(np.ceil(W / self.window_size[2])) * self.window_size[2]
  507. img_mask = torch.zeros((1, Sp, Hp, Wp, 1), device=x.device)
  509. s_slices = (slice(0, -self.window_size[0]),
  510. slice(-self.window_size[0], -self.shift_size[0]),
  511. slice(-self.shift_size[0], None))
  512. h_slices = (slice(0, -self.window_size[1]),
  513. slice(-self.window_size[1], -self.shift_size[1]),
  514. slice(-self.shift_size[1], None))
  515. w_slices = (slice(0, -self.window_size[2]),
  516. slice(-self.window_size[2], -self.shift_size[2]),
  517. slice(-self.shift_size[2], None))
  518. cnt = 0
  519. for s in s_slices:
  520. for h in h_slices:
  521. for w in w_slices:
  522. img_mask[:, s, h, w, :] = cnt
  523. cnt += 1
  525. mask_windows = window_partition(img_mask, self.window_size)
  526. mask_windows = mask_windows.view(-1,
  527. self.window_size[0] * self.window_size[1] * self.window_size[2])
  528. attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
  529. attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0))
  530. for blk in self.blocks:
  531. x_up = blk(x_up, attn_mask)
  533. return x_up, S, H, W
  535. # done
  536. class project(nn.Module):
  537. def __init__(self,in_dim,out_dim,stride,padding,activate,norm,last=False):
  538. super().__init__()
  539. self.out_dim=out_dim
  540. self.conv1=nn.Conv3d(in_dim,out_dim,kernel_size=3,stride=stride,padding=padding)
  541. self.conv2=nn.Conv3d(out_dim,out_dim,kernel_size=3,stride=1,padding=1)
  542. self.activate=activate()
  543. self.norm1=norm(out_dim)
  544. self.last=last
  545. if not last:
  546. self.norm2=norm(out_dim)
  548. def forward(self,x):
  549. x=self.conv1(x)
  550. x=self.activate(x)
  551. #norm1
  552. Ws, Wh, Ww = x.size(2), x.size(3), x.size(4)
  553. x = x.flatten(2).transpose(1, 2)
  554. x = self.norm1(x)
  555. x = x.transpose(1, 2).view(-1, self.out_dim, Ws, Wh, Ww)
  558. x=self.conv2(x)
  559. if not self.last:
  560. x=self.activate(x)
  561. #norm2
  562. Ws, Wh, Ww = x.size(2), x.size(3), x.size(4)
  563. x = x.flatten(2).transpose(1, 2)
  564. x = self.norm2(x)
  565. x = x.transpose(1, 2).view(-1, self.out_dim, Ws, Wh, Ww)
  566. return x
  570. class PatchEmbed(nn.Module):
  571. """ Image to Patch Embedding
  573. Args:
  574. patch_size (int): Patch token size. Default: 4.
  575. in_chans (int): Number of input image channels. Default: 3.
  576. embed_dim (int): Number of linear projection output channels. Default: 96.
  577. norm_layer (nn.Module, optional): Normalization layer. Default: None
  578. """
  580. def __init__(self, patch_size=4, in_chans=4, embed_dim=96, norm_layer=None):
  581. super().__init__()
  582. patch_size = to_3tuple(patch_size)
  583. self.patch_size = patch_size
  585. self.in_chans = in_chans
  586. self.embed_dim = embed_dim
  588. self.proj1 = project(in_chans,embed_dim//2,[1,2,2],1,nn.GELU,nn.LayerNorm,False)
  589. self.proj2 = project(embed_dim//2,embed_dim,[1,2,2],1,nn.GELU,nn.LayerNorm,True)
  590. if norm_layer is not None:
  591. self.norm = norm_layer(embed_dim)
  592. else:
  593. self.norm = None
  595. def forward(self, x):
  596. """Forward function."""
  597. # padding
  598. _, _, S, H, W = x.size()
  599. if W % self.patch_size[2] != 0:
  600. x = F.pad(x, (0, self.patch_size[2] - W % self.patch_size[2]))
  601. if H % self.patch_size[1] != 0:
  602. x = F.pad(x, (0, 0, 0, self.patch_size[1] - H % self.patch_size[1]))
  603. if S % self.patch_size[0] != 0:
  604. x = F.pad(x, (0, 0, 0, 0, 0, self.patch_size[0] - S % self.patch_size[0]))
  605. x = self.proj1(x)
  606. x = self.proj2(x)
  607. if self.norm is not None:
  608. Ws, Wh, Ww = x.size(2), x.size(3), x.size(4)
  609. x = x.flatten(2).transpose(1, 2)
  610. x = self.norm(x)
  611. x = x.transpose(1, 2).view(-1, self.embed_dim, Ws, Wh, Ww)
  613. return x
  617. class SwinTransformer(nn.Module):
  618. """ Swin Transformer backbone.
  619. A PyTorch impl of : `Swin Transformer: Hierarchical Vision Transformer using Shifted Windows` -
  620. https://arxiv.org/pdf/2103.14030
  622. Args:
  623. pretrain_img_size (int): Input image size for training the pretrained model,
  624. used in absolute postion embedding. Default 224.
  625. patch_size (int | tuple(int)): Patch size. Default: 4.
  626. in_chans (int): Number of input image channels. Default: 3.
  627. embed_dim (int): Number of linear projection output channels. Default: 96.
  628. depths (tuple[int]): Depths of each Swin Transformer stage.
  629. num_heads (tuple[int]): Number of attention head of each stage.
  630. window_size (int): Window size. Default: 7.
  631. mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4.
  632. qkv_bias (bool): If True, add a learnable bias to query, key, value. Default: True
  633. qk_scale (float): Override default qk scale of head_dim ** -0.5 if set.
  634. drop_rate (float): Dropout rate.
  635. attn_drop_rate (float): Attention dropout rate. Default: 0.
  636. drop_path_rate (float): Stochastic depth rate. Default: 0.2.
  637. norm_layer (nn.Module): Normalization layer. Default: nn.LayerNorm.
  638. ape (bool): If True, add absolute position embedding to the patch embedding. Default: False.
  639. patch_norm (bool): If True, add normalization after patch embedding. Default: True.
  640. out_indices (Sequence[int]): Output from which stages.
  641. frozen_stages (int): Stages to be frozen (stop grad and set eval mode).
  642. -1 means not freezing any parameters.
  643. use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.
  644. """
  646. def __init__(self,
  647. pretrain_img_size=224,
  648. patch_size=4,
  649. in_chans=1 ,
  650. embed_dim=96,
  651. depths=[2, 2, 2, 2],
  652. num_heads=[4, 8, 16, 32],
  653. window_size=7,
  654. mlp_ratio=4.,
  655. qkv_bias=True,
  656. qk_scale=None,
  657. drop_rate=0.,
  658. attn_drop_rate=0.,
  659. drop_path_rate=0.2,
  660. norm_layer=nn.LayerNorm,
  661. ape=False,
  662. patch_norm=True,
  663. out_indices=(0, 1, 2, 3),
  664. frozen_stages=-1,
  665. use_checkpoint=False):
  666. super().__init__()
  668. self.pretrain_img_size = pretrain_img_size
  670. self.num_layers = len(depths)
  671. self.embed_dim = embed_dim
  672. self.ape = ape
  673. self.patch_norm = patch_norm
  674. self.out_indices = out_indices
  675. self.frozen_stages = frozen_stages
  677. # split image into non-overlapping patches
  678. self.patch_embed = PatchEmbed(
  679. patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim,
  680. norm_layer=norm_layer if self.patch_norm else None)
  682. # absolute position embedding
  683. if self.ape:
  684. pretrain_img_size = to_3tuple(pretrain_img_size)
  685. patch_size = to_3tuple(patch_size)
  686. patches_resolution = [pretrain_img_size[0] // patch_size[0], pretrain_img_size[1] // patch_size[1],
  687. pretrain_img_size[2] // patch_size[2]]
  689. self.absolute_pos_embed = nn.Parameter(
  690. torch.zeros(1, embed_dim, patches_resolution[0], patches_resolution[1], patches_resolution[2]))
  691. trunc_normal_(self.absolute_pos_embed, std=.02)
  693. self.pos_drop = nn.Dropout(p=drop_rate)
  695. # stochastic depth
  696. dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))] # stochastic depth decay rule
  697. down_size=[[1,4,4],[1,8,8],[2,16,16],[4,32,32]]
  698. # build layers
  699. self.layers = nn.ModuleList()
  700. for i_layer in range(self.num_layers):
  701. layer = BasicLayer(
  702. dim=int(embed_dim * 2 ** i_layer),
  703. input_resolution=(
  704. pretrain_img_size[0] // down_size[i_layer][0], pretrain_img_size[1] // down_size[i_layer][1],
  705. pretrain_img_size[2] // down_size[i_layer][2]),
  706. depth=depths[i_layer],
  707. num_heads=num_heads[i_layer],
  708. window_size=window_size,
  709. mlp_ratio=mlp_ratio,
  710. qkv_bias=qkv_bias,
  711. qk_scale=qk_scale,
  712. drop=drop_rate,
  713. attn_drop=attn_drop_rate,
  714. drop_path=dpr[sum(
  715. depths[:i_layer]):sum(depths[:i_layer + 1])],
  716. norm_layer=norm_layer,
  717. downsample=PatchMerging,
  718. use_checkpoint=use_checkpoint,
  719. i_layer=i_layer)
  720. self.layers.append(layer)
  722. num_features = [int(embed_dim * 2 ** i) for i in range(self.num_layers)]
  723. self.num_features = num_features
  725. # add a norm layer for each output
  726. for i_layer in out_indices:
  727. layer = norm_layer(num_features[i_layer])
  728. layer_name = f'norm{i_layer}'
  729. self.add_module(layer_name, layer)
  731. self._freeze_stages()
  733. def _freeze_stages(self):
  734. if self.frozen_stages >= 0:
  735. self.patch_embed.eval()
  736. for param in self.patch_embed.parameters():
  737. param.requires_grad = False
  739. if self.frozen_stages >= 1 and self.ape:
  740. self.absolute_pos_embed.requires_grad = False
  742. if self.frozen_stages >= 2:
  743. self.pos_drop.eval()
  744. for i in range(0, self.frozen_stages - 1):
  745. m = self.layers[i]
  746. m.eval()
  747. for param in m.parameters():
  748. param.requires_grad = False
  752. def forward(self, x):
  753. """Forward function."""
  755. x = self.patch_embed(x)
  756. down=[]
  758. Ws, Wh, Ww = x.size(2), x.size(3), x.size(4)
  759. if self.ape:
  760. # interpolate the position embedding to the corresponding size
  761. absolute_pos_embed = F.interpolate(self.absolute_pos_embed, size=(Ws, Wh, Ww), align_corners=True,
  762. mode='trilinear')
  763. x = (x + absolute_pos_embed).flatten(2).transpose(1, 2)
  764. else:
  765. x = x.flatten(2).transpose(1, 2)
  766. x = self.pos_drop(x)
  769. for i in range(self.num_layers):
  770. layer = self.layers[i]
  771. x_out, S, H, W, x, Ws, Wh, Ww = layer(x, Ws, Wh, Ww)
  772. if i in self.out_indices:
  773. norm_layer = getattr(self, f'norm{i}')
  774. x_out = norm_layer(x_out)
  776. out = x_out.view(-1, S, H, W, self.num_features[i]).permute(0, 4, 1, 2, 3).contiguous()
  778. down.append(out)
  779. return down
  781. def train(self, mode=True):
  782. """Convert the model into training mode while keep layers freezed."""
  783. super(SwinTransformer, self).train(mode)
  784. self._freeze_stages()
  786. class encoder(nn.Module):
  787. def __init__(self,
  788. pretrain_img_size,
  789. embed_dim,
  790. patch_size=4,
  791. depths=[2,2,2],
  792. num_heads=[24,12,6],
  793. window_size=4,
  794. mlp_ratio=4.,
  795. qkv_bias=True,
  796. qk_scale=None,
  797. drop_rate=0.,
  798. attn_drop_rate=0.,
  799. drop_path_rate=0.2,
  800. norm_layer=nn.LayerNorm
  801. ):
  802. super().__init__()
  805. self.num_layers = len(depths)
  806. self.pos_drop = nn.Dropout(p=drop_rate)
  808. # stochastic depth
  809. dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))] # stochastic depth decay rule
  810. up_size=[[2,16,16],[1,8,8],[1,4,4]]
  811. # build layers
  812. self.layers = nn.ModuleList()
  813. for i_layer in range(self.num_layers)[::-1]:
  815. layer = BasicLayer_up(
  816. dim=int(embed_dim * 2 ** (len(depths)-i_layer-1)),
  817. input_resolution=(
  818. pretrain_img_size[0] // up_size[i_layer][0], pretrain_img_size[1] // up_size[i_layer][1],
  819. pretrain_img_size[2] // up_size[i_layer][2]),
  820. depth=depths[i_layer],
  821. num_heads=num_heads[i_layer],
  822. window_size=window_size,
  823. mlp_ratio=mlp_ratio,
  824. qkv_bias=qkv_bias,
  825. qk_scale=qk_scale,
  826. drop=drop_rate,
  827. attn_drop=attn_drop_rate,
  828. drop_path=dpr[sum(
  829. depths[:i_layer]):sum(depths[:i_layer + 1])],
  830. norm_layer=norm_layer,
  831. upsample=Patch_Expanding,
  832. i_layer=i_layer
  833. )
  834. self.layers.append(layer)
  835. self.num_features = [int(embed_dim * 2 ** i) for i in range(self.num_layers)]
  836. def forward(self,x,skips):
  838. outs=[]
  839. S, H, W = x.size(2), x.size(3), x.size(4)
  840. x = x.flatten(2).transpose(1, 2)
  842. x = self.pos_drop(x)
  844. for i in range(self.num_layers)[::-1]:
  846. layer = self.layers[i]
  848. x, S, H, W, = layer(x,skips[i], S, H, W)
  849. out = x.view(-1, S, H, W, self.num_features[i])
  850. outs.append(out)
  851. return outs
  857. class final_patch_expanding(nn.Module):
  858. def __init__(self,dim,num_class,patch_size):
  859. super().__init__()
  860. self.up=nn.ConvTranspose3d(dim,num_class,patch_size,patch_size)
  862. def forward(self,x):
  863. x=x.permute(0,4,1,2,3)
  864. x=self.up(x)
  866. return x
  872. class swintransformer(SegmentationNetwork):
  874. def __init__(self, input_channels, base_num_features, num_classes, num_pool, num_conv_per_stage=2,
  875. feat_map_mul_on_downscale=2, conv_op=nn.Conv2d,
  876. norm_op=nn.BatchNorm2d, norm_op_kwargs=None,
  877. dropout_op=nn.Dropout2d, dropout_op_kwargs=None,
  878. nonlin=nn.LeakyReLU, nonlin_kwargs=None, deep_supervision=True, dropout_in_localization=False,
  879. final_nonlin=softmax_helper, weightInitializer=InitWeights_He(1e-2), pool_op_kernel_sizes=None,
  880. conv_kernel_sizes=None,
  881. upscale_logits=False, convolutional_pooling=False, convolutional_upsampling=False,
  882. max_num_features=None, basic_block=None,
  883. seg_output_use_bias=False):
  885. super(swintransformer, self).__init__()
  888. self._deep_supervision = deep_supervision
  889. self.do_ds = deep_supervision
  890. self.num_classes=num_classes
  891. self.conv_op=conv_op
  894. self.upscale_logits_ops = []
  897. self.upscale_logits_ops.append(lambda x: x)
  900. embed_dim=96
  901. depths=[2, 2, 2, 2]
  902. num_heads=[3, 6, 12, 24]
  903. patch_size=[1,4,4]
  904. self.model_down=SwinTransformer(pretrain_img_size=[14,160,160],window_size=[3,5,5],embed_dim=embed_dim,patch_size=patch_size,depths=depths,num_heads=num_heads,in_chans=1)
  905. self.encoder=encoder(pretrain_img_size=[14,160,160],embed_dim=embed_dim,window_size=[3,5,5],patch_size=patch_size,num_heads=[12,6,3],depths=[2,2,2])
  907. self.final=[]
  908. for i in range(len(depths)-1):
  909. self.final.append(final_patch_expanding(embed_dim*2**i,self.num_classes,patch_size=patch_size))
  910. self.final=nn.ModuleList(self.final)
  912. def forward(self, x):
  916. seg_outputs=[]
  917. skips = self.model_down(x)
  918. neck=skips[-1]
  921. out=self.encoder(neck,skips)
  923. for i in range(len(out)):
  924. seg_outputs.append(self.final[-(i+1)](out[i]))
  926. if self._deep_supervision and self.do_ds:
  927. return tuple([seg_outputs[-1]] + [i(j) for i, j in
  928. zip(list(self.upscale_logits_ops)[::-1], seg_outputs[:-1][::-1])])
  929. else:
  931. return seg_outputs[-1]
  937. @staticmethod
  938. def compute_approx_vram_consumption(patch_size, num_pool_per_axis, base_num_features, max_num_features,
  939. num_modalities, num_classes, pool_op_kernel_sizes, deep_supervision=False,
  940. conv_per_stage=2):
  941. """
  942. This only applies for num_conv_per_stage and convolutional_upsampling=True
  943. not real vram consumption. just a constant term to which the vram consumption will be approx proportional
  944. (+ offset for parameter storage)
  945. :param deep_supervision:
  946. :param patch_size:
  947. :param num_pool_per_axis:
  948. :param base_num_features:
  949. :param max_num_features:
  950. :param num_modalities:
  951. :param num_classes:
  952. :param pool_op_kernel_sizes:
  953. :return:
  954. """
  955. if not isinstance(num_pool_per_axis, np.ndarray):
  956. num_pool_per_axis = np.array(num_pool_per_axis)
  958. npool = len(pool_op_kernel_sizes)
  960. map_size = np.array(patch_size)
  961. tmp = np.int64((conv_per_stage * 2 + 1) * np.prod(map_size, dtype=np.int64) * base_num_features +
  962. num_modalities * np.prod(map_size, dtype=np.int64) +
  963. num_classes * np.prod(map_size, dtype=np.int64))
  965. num_feat = base_num_features
  967. for p in range(npool):
  968. for pi in range(len(num_pool_per_axis)):
  969. map_size[pi] /= pool_op_kernel_sizes[p][pi]
  970. num_feat = min(num_feat * 2, max_num_features)
  971. num_blocks = (conv_per_stage * 2 + 1) if p < (npool - 1) else conv_per_stage # conv_per_stage + conv_per_stage for the convs of encode/decode and 1 for transposed conv
  972. tmp += num_blocks * np.prod(map_size, dtype=np.int64) * num_feat
  973. if deep_supervision and p < (npool - 2):
  974. tmp += np.prod(map_size, dtype=np.int64) * num_classes
  975. # print(p, map_size, num_feat, tmp)
  976. return tmp

Swin_Unet_s_ACDC_2laterdown.py at commit 6357a1d, under MIT · at the source

Overview

Authors: Tsuyoshi Ueyama1,2, Erika Takahashi1, Naoto Fujita1, Yuichi Suzuki2, Shohei Inui3, Koichiro Yasaka3, Hideyuki Iwanaga2, Osamu Abe3, Yasuhiko Terada1
ORCID iDs: Koichiro Yasaka
  1. Institute of Pure and Applied Sciences, University of Tsukuba, Tsukuba, Ibaraki, Japan
  2. Department of Radiology, The University of Tokyo Hospital, Tokyo, Japan
  3. Department of Radiology, The University of Tokyo, Tokyo, Japan
Institutions: University of Tsukuba (Japan); University of Tokyo Hospital (Japan); The University of Tokyo (Japan)
Journal: Magnetic resonance in medical sciences : MRMS : an official journal of Japan Society of Magnetic Resonance in Medicine, volume 25, issue 2, pages 2024-0149
Dates: received 8 October 2024; accepted 3 April 2026; published online 14 May 2026; in print May 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.2463/mrms.mp.2024-0149 · PMID 42128846 · PMCID PMC13500223 · OpenAlex W7160981048
Open access: diamond, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), human (organism), stroke (population), clinical / translational (subfield)
Methods: Connectivity, Statistics, Machine learning, fMRI & imaging, Physiology & signal measures
Keywords: deep learning, diffusion-weighted image, distortion correction, image registration
MeSH: Diffusion Magnetic Resonance Imaging*, Image Interpretation, Computer-Assisted*, Image Processing, Computer-Assisted*, Brain, Brain Neoplasms, Cerebrovascular Disorders, Convolutional Neural Networks, Diffusion Tensor Imaging, Female, Humans, Male (* major topic)
Journal subjects: Major Paper
Topic: Advanced MRI Techniques and Applications (Radiology, Nuclear Medicine and Imaging, Medicine), according to OpenAlex
Funding: Japan Society for the Promotion of Science (JP24K00891)
Citations: not cited yet (Europe PMC); 26 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 6 matches between paragraphs and lines of code.

MASILab/Synb0-DISCO

License: none: the authors keep all their rights
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: d813f9435cffb5b663f15b52d55ed0a27181f0b2, 31 July 2025
Languages: MATLAB (6), Python (6), Shell (5)
Size: 61 files, 17 scripts
Software Heritage: not archived
Found in: the text, “Training details”
Holds: README, environment (Singularity)
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: FSL (3 files), NiBabel (3 files), NumPy (3 files), PyTorch (3 files), Tools for NIfTI and ANALYZE image (MATLAB) (2 files), ANTs (1 file), FreeSurfer (1 file), Image Processing Toolbox (1 file), SciPy (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
18 files
At the source: github.com/MASILab/Synb0-DISCO

junyuchen245/transmorph_transformer_for_medical_image_registration

License: MIT
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: 6357a1d7fc44c36db9b1d1ccaa372409253142cf, 22 May 2025
Languages: Python (359), Shell (8)
Size: 463 files, 367 scripts
Software Heritage: not archived
Found in: the text, “Training details”
Holds: README, license file, environment (requirements.txt, Docker/TransMorph_build_Docker/Dockerfile, Docker/TransMorph_build_Docker/requirements.txt)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: PyTorch (252 files), NumPy (243 files), Matplotlib (84 files), SciPy (63 files), scikit-image (23 files), nnU-Net (14 files), NiBabel (13 files), ANTs (5 files), scikit-learn (4 files), Pillow (2 files), pandas (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
369 files
At the source: github.com/junyuchen245/TransMorph_Transformer_for_Medical_Image_Registration/blob/main/TransMorph/models/configs_TransMorph.py

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

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, 9 authors, 4 keywords, 11 MeSH terms, 1 funder, 15 references.

Cite

This paper

Ueyama, T., Takahashi, E., Fujita, N., Suzuki, Y., Inui, S., Yasaka, K., Iwanaga, H., Abe, O., & Terada, Y. (2026). Image Distortion Correction for Diffusion MR Imaging Using a Transformer-based U-Net. Magnetic resonance in medical sciences : MRMS : an official journal of Japan Society of Magnetic Resonance in Medicine, 25(2), 2024-0149. https://doi.org/10.2463/mrms.mp.2024-0149

BibTeX

@article{ueyama2026image,
author = {Ueyama, Tsuyoshi and Takahashi, Erika and Fujita, Naoto and Suzuki, Yuichi and Inui, Shohei and Yasaka, Koichiro and Iwanaga, Hideyuki and Abe, Osamu and Terada, Yasuhiko},
title = {{Image Distortion Correction for Diffusion MR Imaging Using a Transformer-based U-Net}},
journal = {Magnetic resonance in medical sciences : MRMS : an official journal of Japan Society of Magnetic Resonance in Medicine},
year = {2026},
month = may,
volume = {25},
number = {2},
pages = {2024--0149},
publisher = {Japanese Society for Magnetic Resonance in Medicine},
issn = {1347-3182},
doi = {10.2463/mrms.mp.2024-0149},
url = {https://doi.org/10.2463/mrms.mp.2024-0149},
pmid = {42128846},
pmcid = {PMC13500223}
}

RIS

TY - JOUR
AU - Ueyama, Tsuyoshi
AU - Takahashi, Erika
AU - Fujita, Naoto
AU - Suzuki, Yuichi
AU - Inui, Shohei
AU - Yasaka, Koichiro
AU - Iwanaga, Hideyuki
AU - Abe, Osamu
AU - Terada, Yasuhiko
TI - Image Distortion Correction for Diffusion MR Imaging Using a Transformer-based U-Net
T2 - Magnetic resonance in medical sciences : MRMS : an official journal of Japan Society of Magnetic Resonance in Medicine
J2 - Magn Reson Med Sci
PY - 2026
DA - 2026/05/14
VL - 25
IS - 2
SP - 2024
EP - 0149
SN - 1347-3182
PB - Japanese Society for Magnetic Resonance in Medicine
DO - 10.2463/mrms.mp.2024-0149
UR - https://doi.org/10.2463/mrms.mp.2024-0149
LA - en
ER -

CSL-JSON

{
"id": "10.2463/mrms.mp.2024-0149",
"type": "article-journal",
"title": "Image Distortion Correction for Diffusion MR Imaging Using a Transformer-based U-Net",
"container-title": "Magnetic resonance in medical sciences : MRMS : an official journal of Japan Society of Magnetic Resonance in Medicine",
"author": [
{
"family": "Ueyama",
"given": "Tsuyoshi"
},
{
"family": "Takahashi",
"given": "Erika"
},
{
"family": "Fujita",
"given": "Naoto"
},
{
"family": "Suzuki",
"given": "Yuichi"
},
{
"family": "Inui",
"given": "Shohei"
},
{
"family": "Yasaka",
"given": "Koichiro"
},
{
"family": "Iwanaga",
"given": "Hideyuki"
},
{
"family": "Abe",
"given": "Osamu"
},
{
"family": "Terada",
"given": "Yasuhiko"
}
],
"container-title-short": "Magn Reson Med Sci",
"volume": "25",
"issue": "2",
"page": "2024-0149",
"DOI": "10.2463/mrms.mp.2024-0149",
"PMID": "42128846",
"PMCID": "PMC13500223",
"ISSN": "1347-3182",
"publisher": "Japanese Society for Magnetic Resonance in Medicine",
"URL": "https://doi.org/10.2463/mrms.mp.2024-0149",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
14
]
]
}
}

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: nnU-Net, ANTs, FreeSurfer, 10 other tools, structural MRI / diffusion
[2] doi:10.3390/jimaging12070276 [code]
Hyperelastic Regularization for Near-Diffeomorphic Transformer-Based Brain MRI Registration.
Journal: Journal of imaging
In common: nnU-Net, ANTs, scikit-image, 8 other tools, structural MRI / diffusion, 2 references
[3] doi:10.1002/epi.70296 [code]
Fully automated three-dimensional deep learning-based magnetic resonance imaging segmentation of brain cavities in epilepsy surgery.
Journal: Epilepsia
In common: nnU-Net, ANTs, FSL, 9 other tools, structural MRI / diffusion, clinical / translational
[4] doi:10.1162/imag.a.1262 [code]
Frame-wise multi-echo distortion correction for superior functional MRI.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Tools for NIfTI and ANALYZE image (MATLAB), FreeSurfer, FSL, 8 other tools, 2 references
[5] doi:10.1371/journal.pbio.3003856 [code]
Aging and metabolism contribute separately to brain-body health.
Journal: PLoS biology
In common: Tools for NIfTI and ANALYZE image (MATLAB), ANTs, FreeSurfer, 9 other tools, structural MRI / diffusion, clinical / translational
[6] doi:10.1093/braincomms/fcag134 [code]
Neurophysiological, imaging and neurobiological markers of central fatigue in multiple sclerosis.
Journal: Brain communications
In common: Tools for NIfTI and ANALYZE image (MATLAB), ANTs, FreeSurfer, 8 other tools, structural MRI / diffusion, 1 reference
[7] doi:10.1016/j.xcrm.2026.102943 [code]
Parent-of-origin effects in Alzheimer's liability dissociate neurocognitive and cardiovascular traits in at-risk individuals.
Journal: Cell reports. Medicine
In common: Tools for NIfTI and ANALYZE image (MATLAB), ANTs, FreeSurfer, 9 other tools, clinical / translational
[8] doi:10.7554/elife.108408 [code]
Frequency and laminar profile of feature-specific visual activity revealed by interleaved EEG-fMRI.
Journal: eLife
In common: Tools for NIfTI and ANALYZE image (MATLAB), ANTs, FreeSurfer, 8 other tools, 1 reference
[9] doi:10.1038/s41586-026-10631-3 [code]
A prognostic human brain network for diffuse midline glioma.
Journal: Nature
In common: Tools for NIfTI and ANALYZE image (MATLAB), ANTs, FreeSurfer, 8 other tools, clinical / translational, 1 reference
[10] doi:10.1162/imag.a.1222 [code]
Network-based near-scalp personalized brain stimulation targets.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Tools for NIfTI and ANALYZE image (MATLAB), ANTs, FreeSurfer, 8 other tools, 1 reference

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.