OSCR

AmygdalaGo-BOLT for boundary-aware segmentation of the human amygdala.

Code ↔ Paper

2 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 2 matches
  1. [1] § STAR★Methods › Method details › Model architecture › Multi-granularity adaptive collaboration ↔ H3/AmygdalaGo-BOLT/model/dim2/swin_unet.py, lines 935–1047 · score 0.62 · transformation layer, layer normalization, expanded, query, depth, bias
  2. [2] § STAR★Methods › Method details › Model architecture › Multi-granularity adaptive collaboration ↔ H3/AmygdalaGo-BOLT/model/dim3/utnetv2_utils.py, lines 12–77 · score 0.54 · semantic map, feature map, SoftMax, fusion, module, amygdala

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 · 1,688 lines · 36 KB · GPL-2.0 · 1 match

  1. # code is borrowed from the original repo and fit into our training framework
  2. # https://github.com/HuCaoFighting/Swin-Unet/tree/4375a8d6fa7d9c38184c5d3194db990a00a3e912
  5. from __future__ import absolute_import
  7. from __future__ import division
  9. from __future__ import print_function
  12. import torch
  14. import torch.nn as nn
  16. import torch.utils.checkpoint as checkpoint
  18. from einops import rearrange
  20. from timm.models.layers import DropPath, to_2tuple, trunc_normal_
  25. import copy
  27. import logging
  29. import math
  32. from os.path import join as pjoin
  34. import numpy as np
  38. from torch.nn import CrossEntropyLoss, Dropout, Softmax, Linear, Conv2d, LayerNorm
  40. from torch.nn.modules.utils import _pair
  42. from scipy import ndimage
  48. class Mlp(nn.Module):
  50. def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
  52. super().__init__()
  54. out_features = out_features or in_features
  56. hidden_features = hidden_features or in_features
  58. self.fc1 = nn.Linear(in_features, hidden_features)
  60. self.act = act_layer()
  62. self.fc2 = nn.Linear(hidden_features, out_features)
  64. self.drop = nn.Dropout(drop)
  68. def forward(self, x):
  70. x = self.fc1(x)
  72. x = self.act(x)
  74. x = self.drop(x)
  76. x = self.fc2(x)
  78. x = self.drop(x)
  80. return x
  86. def window_partition(x, window_size):
  88. """
  90. Args:
  92. x: (B, H, W, C)
  94. window_size (int): window size
  98. Returns:
  100. windows: (num_windows*B, window_size, window_size, C)
  102. """
  104. B, H, W, C = x.shape
  106. x = x.view(B, H // window_size, window_size, W // window_size, window_size, C)
  108. windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)
  110. return windows
  116. def window_reverse(windows, window_size, H, W):
  118. """
  120. Args:
  122. windows: (num_windows*B, window_size, window_size, C)
  124. window_size (int): Window size
  126. H (int): Height of image
  128. W (int): Width of image
  132. Returns:
  134. x: (B, H, W, C)
  136. """
  138. B = int(windows.shape[0] / (H * W / window_size / window_size))
  140. x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1)
  142. x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)
  144. return x
  150. class WindowAttention(nn.Module):
  152. r""" Window based multi-head self attention (W-MSA) module with relative position bias.
  154. It supports both of shifted and non-shifted window.
  158. Args:
  160. dim (int): Number of input channels.
  162. window_size (tuple[int]): The height and width of the window.
  164. num_heads (int): Number of attention heads.
  166. qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
  168. qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set
  170. attn_drop (float, optional): Dropout ratio of attention weight. Default: 0.0
  172. proj_drop (float, optional): Dropout ratio of output. Default: 0.0
  174. """
  178. def __init__(self, dim, window_size, num_heads, qkv_bias=True, qk_scale=None, attn_drop=0., proj_drop=0.):
  182. super().__init__()
  184. self.dim = dim
  186. self.window_size = window_size # Wh, Ww
  188. self.num_heads = num_heads
  190. head_dim = dim // num_heads
  192. self.scale = qk_scale or head_dim ** -0.5
  196. # define a parameter table of relative position bias
  198. self.relative_position_bias_table = nn.Parameter(
  200. torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads)) # 2*Wh-1 * 2*Ww-1, nH
  204. # get pair-wise relative position index for each token inside the window
  206. coords_h = torch.arange(self.window_size[0])
  208. coords_w = torch.arange(self.window_size[1])
  210. coords = torch.stack(torch.meshgrid([coords_h, coords_w])) # 2, Wh, Ww
  212. coords_flatten = torch.flatten(coords, 1) # 2, Wh*Ww
  214. relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :] # 2, Wh*Ww, Wh*Ww
  216. relative_coords = relative_coords.permute(1, 2, 0).contiguous() # Wh*Ww, Wh*Ww, 2
  218. relative_coords[:, :, 0] += self.window_size[0] - 1 # shift to start from 0
  220. relative_coords[:, :, 1] += self.window_size[1] - 1
  222. relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1
  224. relative_position_index = relative_coords.sum(-1) # Wh*Ww, Wh*Ww
  226. self.register_buffer("relative_position_index", relative_position_index)
  230. self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
  232. self.attn_drop = nn.Dropout(attn_drop)
  234. self.proj = nn.Linear(dim, dim)
  236. self.proj_drop = nn.Dropout(proj_drop)
  240. trunc_normal_(self.relative_position_bias_table, std=.02)
  242. self.softmax = nn.Softmax(dim=-1)
  246. def forward(self, x, mask=None):
  248. """
  250. Args:
  252. x: input features with shape of (num_windows*B, N, C)
  254. mask: (0/-inf) mask with shape of (num_windows, Wh*Ww, Wh*Ww) or None
  256. """
  258. B_, N, C = x.shape
  260. qkv = self.qkv(x).reshape(B_, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
  262. q, k, v = qkv[0], qkv[1], qkv[2] # make torchscript happy (cannot use tensor as tuple)
  266. q = q * self.scale
  268. attn = (q @ k.transpose(-2, -1))
  272. relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)].view(
  274. self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1) # Wh*Ww,Wh*Ww,nH
  276. relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous() # nH, Wh*Ww, Wh*Ww
  278. attn = attn + relative_position_bias.unsqueeze(0)
  282. if mask is not None:
  284. nW = mask.shape[0]
  286. attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0)
  288. attn = attn.view(-1, self.num_heads, N, N)
  290. attn = self.softmax(attn)
  292. else:
  294. attn = self.softmax(attn)
  298. attn = self.attn_drop(attn)
  302. x = (attn @ v).transpose(1, 2).reshape(B_, N, C)
  304. x = self.proj(x)
  306. x = self.proj_drop(x)
  308. return x
  312. def extra_repr(self) -> str:
  314. return f'dim={self.dim}, window_size={self.window_size}, num_heads={self.num_heads}'
  318. def flops(self, N):
  320. # calculate flops for 1 window with token length of N
  322. flops = 0
  324. # qkv = self.qkv(x)
  326. flops += N * self.dim * 3 * self.dim
  328. # attn = (q @ k.transpose(-2, -1))
  330. flops += self.num_heads * N * (self.dim // self.num_heads) * N
  332. # x = (attn @ v)
  334. flops += self.num_heads * N * N * (self.dim // self.num_heads)
  336. # x = self.proj(x)
  338. flops += N * self.dim * self.dim
  340. return flops
  346. class SwinTransformerBlock(nn.Module):
  348. r""" Swin Transformer Block.
  352. Args:
  354. dim (int): Number of input channels.
  356. input_resolution (tuple[int]): Input resulotion.
  358. num_heads (int): Number of attention heads.
  360. window_size (int): Window size.
  362. shift_size (int): Shift size for SW-MSA.
  364. mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.
  366. qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
  368. qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
  370. drop (float, optional): Dropout rate. Default: 0.0
  372. attn_drop (float, optional): Attention dropout rate. Default: 0.0
  374. drop_path (float, optional): Stochastic depth rate. Default: 0.0
  376. act_layer (nn.Module, optional): Activation layer. Default: nn.GELU
  378. norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
  380. """
  384. def __init__(self, dim, input_resolution, num_heads, window_size=7, shift_size=0,
  386. mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0., drop_path=0.,
  388. act_layer=nn.GELU, norm_layer=nn.LayerNorm):
  390. super().__init__()
  392. self.dim = dim
  394. self.input_resolution = input_resolution
  396. self.num_heads = num_heads
  398. self.window_size = window_size
  400. self.shift_size = shift_size
  402. self.mlp_ratio = mlp_ratio
  404. if min(self.input_resolution) <= self.window_size:
  406. # if window size is larger than input resolution, we don't partition windows
  408. self.shift_size = 0
  410. self.window_size = min(self.input_resolution)
  412. assert 0 <= self.shift_size < self.window_size, "shift_size must in 0-window_size"
  416. self.norm1 = norm_layer(dim)
  418. self.attn = WindowAttention(
  420. dim, window_size=to_2tuple(self.window_size), num_heads=num_heads,
  422. qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop)
  426. self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
  428. self.norm2 = norm_layer(dim)
  430. mlp_hidden_dim = int(dim * mlp_ratio)
  432. self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
  436. if self.shift_size > 0:
  438. # calculate attention mask for SW-MSA
  440. H, W = self.input_resolution
  442. img_mask = torch.zeros((1, H, W, 1)) # 1 H W 1
  444. h_slices = (slice(0, -self.window_size),
  446. slice(-self.window_size, -self.shift_size),
  448. slice(-self.shift_size, None))
  450. w_slices = (slice(0, -self.window_size),
  452. slice(-self.window_size, -self.shift_size),
  454. slice(-self.shift_size, None))
  456. cnt = 0
  458. for h in h_slices:
  460. for w in w_slices:
  462. img_mask[:, h, w, :] = cnt
  464. cnt += 1
  468. mask_windows = window_partition(img_mask, self.window_size) # nW, window_size, window_size, 1
  470. mask_windows = mask_windows.view(-1, self.window_size * self.window_size)
  472. attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
  474. attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0))
  476. else:
  478. attn_mask = None
  482. self.register_buffer("attn_mask", attn_mask)
  486. def forward(self, x):
  488. H, W = self.input_resolution
  490. B, L, C = x.shape
  492. assert L == H * W, "input feature has wrong size"
  496. shortcut = x
  498. x = self.norm1(x)
  500. x = x.view(B, H, W, C)
  504. # cyclic shift
  506. if self.shift_size > 0:
  508. shifted_x = torch.roll(x, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2))
  510. else:
  512. shifted_x = x
  516. # partition windows
  518. x_windows = window_partition(shifted_x, self.window_size) # nW*B, window_size, window_size, C
  520. x_windows = x_windows.view(-1, self.window_size * self.window_size, C) # nW*B, window_size*window_size, C
  524. # W-MSA/SW-MSA
  526. attn_windows = self.attn(x_windows, mask=self.attn_mask) # nW*B, window_size*window_size, C
  530. # merge windows
  532. attn_windows = attn_windows.view(-1, self.window_size, self.window_size, C)
  534. shifted_x = window_reverse(attn_windows, self.window_size, H, W) # B H' W' C
  538. # reverse cyclic shift
  540. if self.shift_size > 0:
  542. x = torch.roll(shifted_x, shifts=(self.shift_size, self.shift_size), dims=(1, 2))
  544. else:
  546. x = shifted_x
  548. x = x.view(B, H * W, C)
  552. # FFN
  554. x = shortcut + self.drop_path(x)
  556. x = x + self.drop_path(self.mlp(self.norm2(x)))
  560. return x
  564. def extra_repr(self) -> str:
  566. return f"dim={self.dim}, input_resolution={self.input_resolution}, num_heads={self.num_heads}, " \
  567. f"window_size={self.window_size}, shift_size={self.shift_size}, mlp_ratio={self.mlp_ratio}"
  571. def flops(self):
  573. flops = 0
  575. H, W = self.input_resolution
  577. # norm1
  579. flops += self.dim * H * W
  581. # W-MSA/SW-MSA
  583. nW = H * W / self.window_size / self.window_size
  585. flops += nW * self.attn.flops(self.window_size * self.window_size)
  587. # mlp
  589. flops += 2 * H * W * self.dim * self.dim * self.mlp_ratio
  591. # norm2
  593. flops += self.dim * H * W
  595. return flops
  601. class PatchMerging(nn.Module):
  603. r""" Patch Merging Layer.
  607. Args:
  609. input_resolution (tuple[int]): Resolution of input feature.
  611. dim (int): Number of input channels.
  613. norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
  615. """
  619. def __init__(self, input_resolution, dim, norm_layer=nn.LayerNorm):
  621. super().__init__()
  623. self.input_resolution = input_resolution
  625. self.dim = dim
  627. self.reduction = nn.Linear(4 * dim, 2 * dim, bias=False)
  629. self.norm = norm_layer(4 * dim)
  633. def forward(self, x):
  635. """
  637. x: B, H*W, C
  639. """
  641. H, W = self.input_resolution
  643. B, L, C = x.shape
  645. assert L == H * W, "input feature has wrong size"
  647. assert H % 2 == 0 and W % 2 == 0, f"x size ({H}*{W}) are not even."
  651. x = x.view(B, H, W, C)
  655. x0 = x[:, 0::2, 0::2, :] # B H/2 W/2 C
  657. x1 = x[:, 1::2, 0::2, :] # B H/2 W/2 C
  659. x2 = x[:, 0::2, 1::2, :] # B H/2 W/2 C
  661. x3 = x[:, 1::2, 1::2, :] # B H/2 W/2 C
  663. x = torch.cat([x0, x1, x2, x3], -1) # B H/2 W/2 4*C
  665. x = x.view(B, -1, 4 * C) # B H/2*W/2 4*C
  669. x = self.norm(x)
  671. x = self.reduction(x)
  675. return x
  679. def extra_repr(self) -> str:
  681. return f"input_resolution={self.input_resolution}, dim={self.dim}"
  685. def flops(self):
  687. H, W = self.input_resolution
  689. flops = H * W * self.dim
  691. flops += (H // 2) * (W // 2) * 4 * self.dim * 2 * self.dim
  693. return flops
  697. class PatchExpand(nn.Module):
  699. def __init__(self, input_resolution, dim, dim_scale=2, norm_layer=nn.LayerNorm):
  701. super().__init__()
  703. self.input_resolution = input_resolution
  705. self.dim = dim
  707. self.expand = nn.Linear(dim, 2*dim, bias=False) if dim_scale==2 else nn.Identity()
  709. self.norm = norm_layer(dim // dim_scale)
  713. def forward(self, x):
  715. """
  717. x: B, H*W, C
  719. """
  721. H, W = self.input_resolution
  723. x = self.expand(x)
  725. B, L, C = x.shape
  727. assert L == H * W, "input feature has wrong size"
  731. x = x.view(B, H, W, C)
  733. x = rearrange(x, 'b h w (p1 p2 c)-> b (h p1) (w p2) c', p1=2, p2=2, c=C//4)
  735. x = x.view(B,-1,C//4)
  737. x= self.norm(x)
  741. return x
  745. class FinalPatchExpand_X4(nn.Module):
  747. def __init__(self, input_resolution, dim, dim_scale=4, norm_layer=nn.LayerNorm):
  749. super().__init__()
  751. self.input_resolution = input_resolution
  753. self.dim = dim
  755. self.dim_scale = dim_scale
  757. self.expand = nn.Linear(dim, 16*dim, bias=False)
  759. self.output_dim = dim
  761. self.norm = norm_layer(self.output_dim)
  765. def forward(self, x):
  767. """
  769. x: B, H*W, C
  771. """
  773. H, W = self.input_resolution
  775. x = self.expand(x)
  777. B, L, C = x.shape
  779. assert L == H * W, "input feature has wrong size"
  783. x = x.view(B, H, W, C)
  785. x = rearrange(x, 'b h w (p1 p2 c)-> b (h p1) (w p2) c', p1=self.dim_scale, p2=self.dim_scale, c=C//(self.dim_scale**2))
  787. x = x.view(B,-1,self.output_dim)
  789. x= self.norm(x)
  793. return x
  797. class BasicLayer(nn.Module):
  799. """ A basic Swin Transformer layer for one stage.
  803. Args:
  805. dim (int): Number of input channels.
  807. input_resolution (tuple[int]): Input resolution.
  809. depth (int): Number of blocks.
  811. num_heads (int): Number of attention heads.
  813. window_size (int): Local window size.
  815. mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.
  817. qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
  819. qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
  821. drop (float, optional): Dropout rate. Default: 0.0
  823. attn_drop (float, optional): Attention dropout rate. Default: 0.0
  825. drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0
  827. norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
  829. downsample (nn.Module | None, optional): Downsample layer at the end of the layer. Default: None
  831. use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.
  833. """
  837. def __init__(self, dim, input_resolution, depth, num_heads, window_size,
  839. mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0.,
  841. drop_path=0., norm_layer=nn.LayerNorm, downsample=None, use_checkpoint=False):
  845. super().__init__()
  847. self.dim = dim
  849. self.input_resolution = input_resolution
  851. self.depth = depth
  853. self.use_checkpoint = use_checkpoint
  857. # build blocks
  859. self.blocks = nn.ModuleList([
  861. SwinTransformerBlock(dim=dim, input_resolution=input_resolution,
  863. num_heads=num_heads, window_size=window_size,
  865. shift_size=0 if (i % 2 == 0) else window_size // 2,
  867. mlp_ratio=mlp_ratio,
  869. qkv_bias=qkv_bias, qk_scale=qk_scale,
  871. drop=drop, attn_drop=attn_drop,
  873. drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path,
  875. norm_layer=norm_layer)
  877. for i in range(depth)])
  881. # patch merging layer
  883. if downsample is not None:
  885. self.downsample = downsample(input_resolution, dim=dim, norm_layer=norm_layer)
  887. else:
  889. self.downsample = None
  893. def forward(self, x):
  895. for blk in self.blocks:
  897. if self.use_checkpoint:
  899. x = checkpoint.checkpoint(blk, x)
  901. else:
  903. x = blk(x)
  905. if self.downsample is not None:
  907. x = self.downsample(x)
  909. return x
  913. def extra_repr(self) -> str:
  915. return f"dim={self.dim}, input_resolution={self.input_resolution}, depth={self.depth}"
  919. def flops(self):
  921. flops = 0
  923. for blk in self.blocks:
  925. flops += blk.flops()
  927. if self.downsample is not None:
  929. flops += self.downsample.flops()
  931. return flops
  935. class BasicLayer_up(nn.Module):
  937. """ A basic Swin Transformer layer for one stage.
  941. Args:
  943. dim (int): Number of input channels.
  945. input_resolution (tuple[int]): Input resolution.
  947. depth (int): Number of blocks.
  949. num_heads (int): Number of attention heads.
  951. window_size (int): Local window size.
  953. mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.
  955. qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
  957. qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
  959. drop (float, optional): Dropout rate. Default: 0.0
  961. attn_drop (float, optional): Attention dropout rate. Default: 0.0
  963. drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0
  965. norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
  967. downsample (nn.Module | None, optional): Downsample layer at the end of the layer. Default: None
  969. use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.
  971. """
  975. def __init__(self, dim, input_resolution, depth, num_heads, window_size,
  977. mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0.,
  979. drop_path=0., norm_layer=nn.LayerNorm, upsample=None, use_checkpoint=False):
  983. super().__init__()
  985. self.dim = dim
  987. self.input_resolution = input_resolution
  989. self.depth = depth
  991. self.use_checkpoint = use_checkpoint
  995. # build blocks
  997. self.blocks = nn.ModuleList([
  999. SwinTransformerBlock(dim=dim, input_resolution=input_resolution,
  1001. num_heads=num_heads, window_size=window_size,
  1003. shift_size=0 if (i % 2 == 0) else window_size // 2,
  1005. mlp_ratio=mlp_ratio,
  1007. qkv_bias=qkv_bias, qk_scale=qk_scale,
  1009. drop=drop, attn_drop=attn_drop,
  1011. drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path,
  1013. norm_layer=norm_layer)
  1015. for i in range(depth)])
  1019. # patch merging layer
  1021. if upsample is not None:
  1023. self.upsample = PatchExpand(input_resolution, dim=dim, dim_scale=2, norm_layer=norm_layer)
  1025. else:
  1027. self.upsample = None
  1031. def forward(self, x):
  1033. for blk in self.blocks:
  1035. if self.use_checkpoint:
  1037. x = checkpoint.checkpoint(blk, x)
  1039. else:
  1041. x = blk(x)
  1043. if self.upsample is not None:
  1045. x = self.upsample(x)
  1047. return x
  1051. class PatchEmbed(nn.Module):
  1053. r""" Image to Patch Embedding
  1057. Args:
  1059. img_size (int): Image size. Default: 224.
  1061. patch_size (int): Patch token size. Default: 4.
  1063. in_chans (int): Number of input image channels. Default: 3.
  1065. embed_dim (int): Number of linear projection output channels. Default: 96.
  1067. norm_layer (nn.Module, optional): Normalization layer. Default: None
  1069. """
  1073. def __init__(self, img_size=224, patch_size=4, in_chans=3, embed_dim=96, norm_layer=None):
  1075. super().__init__()
  1077. img_size = to_2tuple(img_size)
  1079. patch_size = to_2tuple(patch_size)
  1081. patches_resolution = [img_size[0] // patch_size[0], img_size[1] // patch_size[1]]
  1083. self.img_size = img_size
  1085. self.patch_size = patch_size
  1087. self.patches_resolution = patches_resolution
  1089. self.num_patches = patches_resolution[0] * patches_resolution[1]
  1093. self.in_chans = in_chans
  1095. self.embed_dim = embed_dim
  1099. self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)
  1101. if norm_layer is not None:
  1103. self.norm = norm_layer(embed_dim)
  1105. else:
  1107. self.norm = None
  1111. def forward(self, x):
  1113. B, C, H, W = x.shape
  1115. # FIXME look at relaxing size constraints
  1117. assert H == self.img_size[0] and W == self.img_size[1], \
  1118. f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})."
  1120. x = self.proj(x).flatten(2).transpose(1, 2) # B Ph*Pw C
  1122. if self.norm is not None:
  1124. x = self.norm(x)
  1126. return x
  1130. def flops(self):
  1132. Ho, Wo = self.patches_resolution
  1134. flops = Ho * Wo * self.embed_dim * self.in_chans * (self.patch_size[0] * self.patch_size[1])
  1136. if self.norm is not None:
  1138. flops += Ho * Wo * self.embed_dim
  1140. return flops
  1146. class SwinTransformerSys(nn.Module):
  1148. r""" Swin Transformer
  1150. A PyTorch impl of : `Swin Transformer: Hierarchical Vision Transformer using Shifted Windows` -
  1152. https://arxiv.org/pdf/2103.14030
  1156. Args:
  1158. img_size (int | tuple(int)): Input image size. Default 224
  1160. patch_size (int | tuple(int)): Patch size. Default: 4
  1162. in_chans (int): Number of input image channels. Default: 3
  1164. num_classes (int): Number of classes for classification head. Default: 1000
  1166. embed_dim (int): Patch embedding dimension. Default: 96
  1168. depths (tuple(int)): Depth of each Swin Transformer layer.
  1170. num_heads (tuple(int)): Number of attention heads in different layers.
  1172. window_size (int): Window size. Default: 7
  1174. mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4
  1176. qkv_bias (bool): If True, add a learnable bias to query, key, value. Default: True
  1178. qk_scale (float): Override default qk scale of head_dim ** -0.5 if set. Default: None
  1180. drop_rate (float): Dropout rate. Default: 0
  1182. attn_drop_rate (float): Attention dropout rate. Default: 0
  1184. drop_path_rate (float): Stochastic depth rate. Default: 0.1
  1186. norm_layer (nn.Module): Normalization layer. Default: nn.LayerNorm.
  1188. ape (bool): If True, add absolute position embedding to the patch embedding. Default: False
  1190. patch_norm (bool): If True, add normalization after patch embedding. Default: True
  1192. use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False
  1194. """
  1198. def __init__(self, img_size=224, patch_size=4, in_chans=3, num_classes=1000,
  1200. embed_dim=96, depths=[2, 2, 2, 2], depths_decoder=[1, 2, 2, 2], num_heads=[3, 6, 12, 24],
  1202. window_size=7, mlp_ratio=4., qkv_bias=True, qk_scale=None,
  1204. drop_rate=0., attn_drop_rate=0., drop_path_rate=0.1,
  1206. norm_layer=nn.LayerNorm, ape=False, patch_norm=True,
  1208. use_checkpoint=False, final_upsample="expand_first", **kwargs):
  1210. super().__init__()
  1214. print("SwinTransformerSys expand initial----depths:{};depths_decoder:{};drop_path_rate:{};num_classes:{}".format(depths,
  1216. depths_decoder,drop_path_rate,num_classes))
  1220. self.num_classes = num_classes
  1222. self.num_layers = len(depths)
  1224. self.embed_dim = embed_dim
  1226. self.ape = ape
  1228. self.patch_norm = patch_norm
  1230. self.num_features = int(embed_dim * 2 ** (self.num_layers - 1))
  1232. self.num_features_up = int(embed_dim * 2)
  1234. self.mlp_ratio = mlp_ratio
  1236. self.final_upsample = final_upsample
  1240. # split image into non-overlapping patches
  1242. self.patch_embed = PatchEmbed(
  1244. img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim,
  1246. norm_layer=norm_layer if self.patch_norm else None)
  1248. num_patches = self.patch_embed.num_patches
  1250. patches_resolution = self.patch_embed.patches_resolution
  1252. self.patches_resolution = patches_resolution
  1256. # absolute position embedding
  1258. if self.ape:
  1260. self.absolute_pos_embed = nn.Parameter(torch.zeros(1, num_patches, embed_dim))
  1262. trunc_normal_(self.absolute_pos_embed, std=.02)
  1266. self.pos_drop = nn.Dropout(p=drop_rate)
  1270. # stochastic depth
  1272. dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))] # stochastic depth decay rule
  1276. # build encoder and bottleneck layers
  1278. self.layers = nn.ModuleList()
  1280. for i_layer in range(self.num_layers):
  1282. layer = BasicLayer(dim=int(embed_dim * 2 ** i_layer),
  1284. input_resolution=(patches_resolution[0] // (2 ** i_layer),
  1286. patches_resolution[1] // (2 ** i_layer)),
  1288. depth=depths[i_layer],
  1290. num_heads=num_heads[i_layer],
  1292. window_size=window_size,
  1294. mlp_ratio=self.mlp_ratio,
  1296. qkv_bias=qkv_bias, qk_scale=qk_scale,
  1298. drop=drop_rate, attn_drop=attn_drop_rate,
  1300. drop_path=dpr[sum(depths[:i_layer]):sum(depths[:i_layer + 1])],
  1302. norm_layer=norm_layer,
  1304. downsample=PatchMerging if (i_layer < self.num_layers - 1) else None,
  1306. use_checkpoint=use_checkpoint)
  1308. self.layers.append(layer)
  1312. # build decoder layers
  1314. self.layers_up = nn.ModuleList()
  1316. self.concat_back_dim = nn.ModuleList()
  1318. for i_layer in range(self.num_layers):
  1320. concat_linear = nn.Linear(2*int(embed_dim*2**(self.num_layers-1-i_layer)),
  1322. int(embed_dim*2**(self.num_layers-1-i_layer))) if i_layer > 0 else nn.Identity()
  1324. if i_layer ==0 :
  1326. layer_up = PatchExpand(input_resolution=(patches_resolution[0] // (2 ** (self.num_layers-1-i_layer)),
  1328. patches_resolution[1] // (2 ** (self.num_layers-1-i_layer))), dim=int(embed_dim * 2 ** (self.num_layers-1-i_layer)), dim_scale=2, norm_layer=norm_layer)
  1330. else:
  1332. layer_up = BasicLayer_up(dim=int(embed_dim * 2 ** (self.num_layers-1-i_layer)),
  1334. input_resolution=(patches_resolution[0] // (2 ** (self.num_layers-1-i_layer)),
  1336. patches_resolution[1] // (2 ** (self.num_layers-1-i_layer))),
  1338. depth=depths[(self.num_layers-1-i_layer)],
  1340. num_heads=num_heads[(self.num_layers-1-i_layer)],
  1342. window_size=window_size,
  1344. mlp_ratio=self.mlp_ratio,
  1346. qkv_bias=qkv_bias, qk_scale=qk_scale,
  1348. drop=drop_rate, attn_drop=attn_drop_rate,
  1350. drop_path=dpr[sum(depths[:(self.num_layers-1-i_layer)]):sum(depths[:(self.num_layers-1-i_layer) + 1])],
  1352. norm_layer=norm_layer,
  1354. upsample=PatchExpand if (i_layer < self.num_layers - 1) else None,
  1356. use_checkpoint=use_checkpoint)
  1358. self.layers_up.append(layer_up)
  1360. self.concat_back_dim.append(concat_linear)
  1364. self.norm = norm_layer(self.num_features)
  1366. self.norm_up= norm_layer(self.embed_dim)
  1370. if self.final_upsample == "expand_first":
  1372. print("---final upsample expand_first---")
  1374. self.up = FinalPatchExpand_X4(input_resolution=(img_size//patch_size,img_size//patch_size),dim_scale=4,dim=embed_dim)
  1376. self.output = nn.Conv2d(in_channels=embed_dim,out_channels=self.num_classes,kernel_size=1,bias=False)
  1380. self.apply(self._init_weights)
  1384. def _init_weights(self, m):
  1386. if isinstance(m, nn.Linear):
  1388. trunc_normal_(m.weight, std=.02)
  1390. if isinstance(m, nn.Linear) and m.bias is not None:
  1392. nn.init.constant_(m.bias, 0)
  1394. elif isinstance(m, nn.LayerNorm):
  1396. nn.init.constant_(m.bias, 0)
  1398. nn.init.constant_(m.weight, 1.0)
  1402. @torch.jit.ignore
  1404. def no_weight_decay(self):
  1406. return {'absolute_pos_embed'}
  1410. @torch.jit.ignore
  1412. def no_weight_decay_keywords(self):
  1414. return {'relative_position_bias_table'}
  1418. #Encoder and Bottleneck
  1420. def forward_features(self, x):
  1422. x = self.patch_embed(x)
  1424. if self.ape:
  1426. x = x + self.absolute_pos_embed
  1428. x = self.pos_drop(x)
  1430. x_downsample = []
  1434. for layer in self.layers:
  1436. x_downsample.append(x)
  1438. x = layer(x)
  1442. x = self.norm(x) # B L C
  1446. return x, x_downsample
  1450. #Dencoder and Skip connection
  1452. def forward_up_features(self, x, x_downsample):
  1454. for inx, layer_up in enumerate(self.layers_up):
  1456. if inx == 0:
  1458. x = layer_up(x)
  1460. else:
  1462. x = torch.cat([x,x_downsample[3-inx]],-1)
  1464. x = self.concat_back_dim[inx](x)
  1466. x = layer_up(x)
  1470. x = self.norm_up(x) # B L C
  1474. return x
  1478. def up_x4(self, x):
  1480. H, W = self.patches_resolution
  1482. B, L, C = x.shape
  1484. assert L == H*W, "input features has wrong size"
  1488. if self.final_upsample=="expand_first":
  1490. x = self.up(x)
  1492. x = x.view(B,4*H,4*W,-1)
  1494. x = x.permute(0,3,1,2) #B,C,H,W
  1496. x = self.output(x)
  1500. return x
  1504. def forward(self, x):
  1506. x, x_downsample = self.forward_features(x)
  1508. x = self.forward_up_features(x,x_downsample)
  1510. x = self.up_x4(x)
  1514. return x
  1518. def flops(self):
  1520. flops = 0
  1522. flops += self.patch_embed.flops()
  1524. for i, layer in enumerate(self.layers):
  1526. flops += layer.flops()
  1528. flops += self.num_features * self.patches_resolution[0] * self.patches_resolution[1] // (2 ** self.num_layers)
  1530. flops += self.num_features * self.num_classes
  1532. return flops
  1537. logger = logging.getLogger(__name__)
  1541. class SwinUnet_config():
  1542. def __init__(self):
  1543. self.patch_size = 4
  1544. self.in_chans = 3
  1545. self.num_classes = 4
  1546. self.embed_dim = 96
  1547. self.depths = [2, 2, 6, 2]
  1548. self.num_heads = [3, 6, 12, 24]
  1549. self.window_size = 7
  1550. self.mlp_ratio = 4.
  1551. self.qkv_bias = True
  1552. self.qk_scale = None
  1553. self.drop_rate = 0.
  1554. self.drop_path_rate = 0.1
  1555. self.ape = False
  1556. self.patch_norm = True
  1557. self.use_checkpoint = False
  1559. class SwinUnet(nn.Module):
  1561. def __init__(self, config, img_size=224, num_classes=21843, zero_head=False, vis=False):
  1563. super(SwinUnet, self).__init__()
  1565. self.num_classes = num_classes
  1567. self.zero_head = zero_head
  1569. self.config = config
  1573. self.swin_unet = SwinTransformerSys(img_size=img_size,
  1575. patch_size=config.patch_size,
  1577. in_chans=config.in_chans,
  1579. num_classes=self.num_classes,
  1581. embed_dim=config.embed_dim,
  1583. depths=config.depths,
  1585. num_heads=config.num_heads,
  1587. window_size=config.window_size,
  1589. mlp_ratio=config.mlp_ratio,
  1591. qkv_bias=config.qkv_bias,
  1593. qk_scale=config.qk_scale,
  1595. drop_rate=config.drop_rate,
  1597. drop_path_rate=config.drop_path_rate,
  1599. ape=config.ape,
  1601. patch_norm=config.patch_norm,
  1603. use_checkpoint=config.use_checkpoint)
  1607. def forward(self, x):
  1609. if x.size()[1] == 1:
  1611. x = x.repeat(1,3,1,1)
  1613. logits = self.swin_unet(x)
  1615. return logits
  1619. def load_from(self, pretrained_path):
  1622. if pretrained_path is not None:
  1624. print("pretrained_path:{}".format(pretrained_path))
  1626. device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
  1628. pretrained_dict = torch.load(pretrained_path, map_location=device)
  1630. if "model" not in pretrained_dict:
  1632. print("---start load pretrained modle by splitting---")
  1634. pretrained_dict = {k[17:]:v for k,v in pretrained_dict.items()}
  1636. for k in list(pretrained_dict.keys()):
  1638. if "output" in k:
  1640. print("delete key:{}".format(k))
  1642. del pretrained_dict[k]
  1644. msg = self.swin_unet.load_state_dict(pretrained_dict,strict=False)
  1646. # print(msg)
  1648. return
  1650. pretrained_dict = pretrained_dict['model']
  1652. print("---start load pretrained modle of swin encoder---")
  1656. model_dict = self.swin_unet.state_dict()
  1658. full_dict = copy.deepcopy(pretrained_dict)
  1660. for k, v in pretrained_dict.items():
  1662. if "layers." in k:
  1664. current_layer_num = 3-int(k[7:8])
  1666. current_k = "layers_up." + str(current_layer_num) + k[8:]
  1668. full_dict.update({current_k:v})
  1670. for k in list(full_dict.keys()):
  1672. if k in model_dict:
  1674. if full_dict[k].shape != model_dict[k].shape:
  1676. print("delete:{};shape pretrain:{};shape model:{}".format(k,v.shape,model_dict[k].shape))
  1678. del full_dict[k]
  1682. msg = self.swin_unet.load_state_dict(full_dict, strict=False)
  1684. # print(msg)
  1686. else:
  1688. print("none pretrain")

swin_unet.py at commit 9a1fc10, under GPL-2.0 · at the source

Overview

Authors: Quan Zhou1,2,3, Bo Dong4, Peng Gao2,3, Jintao Wei4, Jiale Xiao3, Wei Wang3, Peipeng Liang5, Danhua Lin3, Jie Lu1, Xi-Nian Zuo2,3,6,7, Hongjian He8,9
ORCID iDs: Peng Gao, Xi-Nian Zuo
  1. Department of Radiology and Nuclear Medicine, Xuanwu Hospital, Capital Medical University, Beijing 100053, China
  2. State Key Laboratory of Cognitive Neuroscience and Learning, Beijing Normal University, Beijing 100875, China
  3. Faculty of Psychology, Beijing Normal University, Beijing 100875, China
  4. College of Biomedical Engineering and Instrument Science, Zhejiang University, Hangzhou 310027, China
  5. School of Psychology, Capital Normal University, Beijing 100048, China
  6. Developmental Population Neuroscience Research Center, McGovern Institute for Brain Research, Beijing Normal University, Beijing 100875, China
  7. National Basic Science Data Center, Beijing 100190, China
  8. School of Physics, Zhejiang University, Hangzhou 310058, China
  9. State Key Laboratory of Brain-Machine Intelligence, Zhejiang University, Hangzhou 310027, China
Institutions: Capital Medical University (China); Beijing Normal University (China); Xuan Wu Hospital of the Capital Medical University (China); State Key Laboratory of Cognitive Neuroscience and Learning; Zhejiang University (China); Capital Normal University (China)
Journal: Cell reports methods, volume 6, issue 7, article 101473
Dates: received 4 June 2025; accepted 4 May 2026; published online 2 June 2026; in print July 2026
Type: Research article · Language: English
License: CC BY-NC
Identifiers: DOI 10.1016/j.crmeth.2026.101473 · PMID 42229420 · PMCID PMC13390094 · OpenAlex W7163197754
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), human (organism), methods / tools (subfield)
Methods: Machine learning, Statistics
Keywords: Cp: Neuroscience, Cp: Imaging
MeSH: Amygdala*, Deep Learning*, Image Processing, Computer-Assisted*, Magnetic Resonance Imaging*, Neuroimaging*, Adolescent, Child, Child, Preschool, Female, Humans, Male (* major topic)
Topic: EEG and Brain-Computer Interfaces (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Huizhi Ascent Project of Xuanwu Hospital (HZ2021ZCLJ005); Brain Science and Brain-like Intelligence Technology; National Science and Technology Major Project; Chinese Child Brain Development (2021ZD0200500); Beijing Normal University; National Natural Science Foundation of China (82102134, 82322035, 62273076); Key-Area Research and Development Program of Guangdong Province (2019B030335001); Beijing Municipal Science and Technology Commission (Z161100002616023, Z181100001518003); Major Project of National Social Science Foundation of China (20&ZD296); CAS-NWO Programme (153111KYSB20160020); National Basic Research (973) Program (2015CB351702); Chinese Academy of Sciences Key Research Program (KSZD-EW-TZ-002); International Collaboration of National Natural Science Foundation of China (81220108014); China Postdoctoral Science Foundation (2023M740301)
Citations: not cited yet (Europe PMC); 45 references in the paper

Abstract

Tracing the boundaries of the amygdala from brain images remains a major challenge in human neuroscience. Although large-scale neuroimaging studies increasingly collect thousands of scans to investigate structural development in children and adolescents, reliable segmentation of the amygdala is difficult due to its small size and complex morphology—particularly in pediatric populations. To address this, we developed AmygdalaGo-BOLT, a boundary-aware deep learning model specifically designed for amygdala segmentation. The model was trained and validated on 1,086 manually labeled pediatric MRI scans, with independent datasets used to assess generalizability. It integrates multiscale feature extraction, spatial priors, and self-attention mechanisms within a compact encoder-decoder architecture to enhance boundary detection. Across imaging centers and age groups, AmygdalaGo-BOLT demonstrates strong agreement with expert manual annotations, while substantially improving efficiency and accuracy relative to existing tools. This enables robust and scalable analysis of amygdala morphology in population neuroscience studies where manual tracing is impractical.

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 2 matches between paragraphs and lines of code.

zuoxinian/ccs

License: GPL-2.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 9a1fc10bb560f5a2aa802c7f6fcc80c5a44366ee, 12 September 2024
Languages: MATLAB (563), Python (90), Shell (74), Jupyter (2), R (1)
Size: 1,947 files, 730 scripts
Software Heritage: not archived
Found in: “Data and code availability”
Holds: README, license file, environment (H3/AmygdalaGo-BOLT/requirements_autodl.txt), 1 notebook
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: FreeSurfer (88 files), EEGLAB (75 files), PyTorch (55 files), FSL (42 files), NumPy (40 files), AFNI (21 files), Statistics and Machine Learning Toolbox (19 files), NiBabel (12 files), OpenCV (10 files), SimpleITK (10 files), GIfTI library for MATLAB (9 files), FieldTrip (8 files), ANTs (6 files), Image Processing Toolbox (5 files), Matplotlib (5 files), SciPy (5 files), SPM (4 files), Pillow (3 files), Brain Connectivity Toolbox (2 files), Signal Processing Toolbox (2 files), MONAI (2 files), Connectome Workbench (2 files), scikit-image (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
732 files
At the source: github.com/zuoxinian/CCS/tree/master/H3/AmygdalaGo-BOLT

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;
  • 730 scripts, each with its path and the digest of its content;
  • 2 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

Datasets cited

Data and code availability

• The manually segmented amygdala datasets from the Chongqing cohort of the Chinese Color Nest Cohort (CKG-CCNC), used for model training and internal validation, are publicly available via the National Science DataBank (https://doi.org/10.11922/sciencedb.01299). The original MRI scans and corresponding demographic information (age and sex) are accessible from the Chinese Color Nest Data Community (https://ccndc.scidb.cn/en). External validation was conducted using the Zhejiang University Multi-center Traveler Cohort (ZJU-MTC), which is available on Figshare (https://figshare.com/articles/dataset/Multicenter_dataset_of_multishell_diffusion_magnetic_resonance_imaging_in_healthy_traveling_adults_with_identical_setting/8851955/6). Due to data-sharing agreements and institutional review board restrictions, the BNU-CAC dataset is not publicly available. • All source code used for training, evaluation, and visualization is publicly available via the Science DataBank (https://doi.org/10.57760/sciencedb.o00133.00090) and the Connectome Computation System release at GitHub (https://github.com/zuoxinian/CCS/tree/master/H3/AmygdalaGo-BOLT). • The AmygdalaGo-BOLT online interface is accessible at http://118.196.12.168/. • Any additional information required to re-analyze the data reported by this paper is available from the lead contact upon request.

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, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 11 authors, 2 keywords, 11 MeSH terms, 14 funders, 45 references.

Cite

This paper

Zhou, Q., Dong, B., Gao, P., Wei, J., Xiao, J., Wang, W., Liang, P., Lin, D., Lu, J., Zuo, X.-N., & He, H. (2026). AmygdalaGo-BOLT for boundary-aware segmentation of the human amygdala. Cell reports methods, 6(7), 101473. https://doi.org/10.1016/j.crmeth.2026.101473

BibTeX

@article{zhou2026amygdalago,
author = {Zhou, Quan and Dong, Bo and Gao, Peng and Wei, Jintao and Xiao, Jiale and Wang, Wei and Liang, Peipeng and Lin, Danhua and Lu, Jie and Zuo, Xi-Nian and He, Hongjian},
title = {{AmygdalaGo-BOLT for boundary-aware segmentation of the human amygdala}},
journal = {Cell reports methods},
year = {2026},
month = jun,
volume = {6},
number = {7},
pages = {101473},
publisher = {Elsevier},
issn = {2667-2375},
doi = {10.1016/j.crmeth.2026.101473},
url = {https://doi.org/10.1016/j.crmeth.2026.101473},
pmid = {42229420},
pmcid = {PMC13390094}
}

RIS

TY - JOUR
AU - Zhou, Quan
AU - Dong, Bo
AU - Gao, Peng
AU - Wei, Jintao
AU - Xiao, Jiale
AU - Wang, Wei
AU - Liang, Peipeng
AU - Lin, Danhua
AU - Lu, Jie
AU - Zuo, Xi-Nian
AU - He, Hongjian
TI - AmygdalaGo-BOLT for boundary-aware segmentation of the human amygdala
T2 - Cell reports methods
J2 - Cell Rep Methods
PY - 2026
DA - 2026/06/02
VL - 6
IS - 7
SP - 101473
SN - 2667-2375
PB - Elsevier
DO - 10.1016/j.crmeth.2026.101473
UR - https://doi.org/10.1016/j.crmeth.2026.101473
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.crmeth.2026.101473",
"type": "article-journal",
"title": "AmygdalaGo-BOLT for boundary-aware segmentation of the human amygdala",
"container-title": "Cell reports methods",
"author": [
{
"family": "Zhou",
"given": "Quan"
},
{
"family": "Dong",
"given": "Bo"
},
{
"family": "Gao",
"given": "Peng"
},
{
"family": "Wei",
"given": "Jintao"
},
{
"family": "Xiao",
"given": "Jiale"
},
{
"family": "Wang",
"given": "Wei"
},
{
"family": "Liang",
"given": "Peipeng"
},
{
"family": "Lin",
"given": "Danhua"
},
{
"family": "Lu",
"given": "Jie"
},
{
"family": "Zuo",
"given": "Xi-Nian"
},
{
"family": "He",
"given": "Hongjian"
}
],
"container-title-short": "Cell Rep Methods",
"volume": "6",
"issue": "7",
"page": "101473",
"DOI": "10.1016/j.crmeth.2026.101473",
"PMID": "42229420",
"PMCID": "PMC13390094",
"ISSN": "2667-2375",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.crmeth.2026.101473",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
2
]
]
}
}

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/s41467-026-76011-7 [code]
Human cortex organizes dynamic co-fluctuations along the sensorimotor-association axis.
Journal: Nature communications
In common: MONAI, Brain Connectivity Toolbox, Connectome Workbench, 20 other tools, 1 reference, author Xi-Nian Zuo
[2] doi:10.1038/s41467-026-73668-y [code]
Convergent and divergent brain-cognition development in early adolescence.
Journal: Nature communications
In common: Connectome Workbench, AFNI, GIfTI library for MATLAB, 13 other tools, 1 reference, author Xi-Nian Zuo
[3] doi:10.1038/s41467-026-71151-2 [code]
Common and distinct neural correlates of social interaction processing and theory of mind in narratives.
Journal: Nature communications
In common: Brain Connectivity Toolbox, Connectome Workbench, AFNI, 14 other tools
[4] doi:10.1038/s41398-026-04025-2 [code]
Brain energetic landscapes shape state dysregulation in major depressive disorder: a morphological network controllability perspective.
Journal: Translational psychiatry
In common: Brain Connectivity Toolbox, Connectome Workbench, AFNI, 13 other tools
[5] doi:10.1002/hbm.70483 [code]
Untamed: Unconstrained Tensor Decomposition and Graph Node Embedding for Cortical Parcellation.
Journal: Human brain mapping
In common: Connectome Workbench, AFNI, GIfTI library for MATLAB, 13 other tools, methods / tools
[6] doi:10.1371/journal.pbio.3003856 [code]
Aging and metabolism contribute separately to brain-body health.
Journal: PLoS biology
In common: Connectome Workbench, AFNI, GIfTI library for MATLAB, 12 other tools, structural MRI / diffusion, 1 reference
[7] doi:10.1016/j.neuroimage.2026.122171 [code]
A conserved node degree-based backbone and flexible hub organization of brain connectome during naturalistic movie watching.
Journal: NeuroImage
In common: Connectome Workbench, AFNI, GIfTI library for MATLAB, 12 other tools, methods / tools
[8] doi:10.1093/braincomms/fcag134 [code]
Neurophysiological, imaging and neurobiological markers of central fatigue in multiple sclerosis.
Journal: Brain communications
In common: Connectome Workbench, AFNI, GIfTI library for MATLAB, 12 other tools, structural MRI / diffusion
[9] doi:10.1038/s41467-026-76452-0 [code]
Music evokes shared neural representations of imagined narratives across sensory modalities.
Journal: Nature communications
In common: Connectome Workbench, AFNI, GIfTI library for MATLAB, 12 other tools
[10] 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: Connectome Workbench, AFNI, GIfTI library for MATLAB, 12 other tools

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.