OSCR

BasNet: Attention U-Net-Based Automated Axon Segmentation in Bielschowsky Silver-Stained Histology.

Code ↔ Paper

15 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 15 matches
  1. [1] § Methods › Performance Evaluation › Whole Slide Image Maps ↔ BasNet_code/axon_directionality.py, lines 1 to 45 · score 0.81 · square cells, Axon orientation, axon pixels, structural tensor, Scharr, axon density · Report a mismatch
  2. [2] § Methods › Loss Function and Optimization ↔ BasNet_code/train.py, lines 85 to 160 · score 0.81 · AdamW, ReduceLROnPlateau, Learning rate scheduling, hyperparameter, patience, optimized · Report a mismatch
  3. [3] § Methods › Network Architecture ↔ BasNet_code/attention_unet.py, lines 50 to 91 · score 0.75 · gating signal, attention weighted, skip connection, decoder, channel, sigmoid · Report a mismatch
  4. [4] § Methods › Performance Evaluation › Whole Slide Image Maps ↔ BasNet_code/axon_directionality.py, lines 1 to 45 · score 0.74 · secondary orientation, primary orientation, Eigenanalysis, eigenvectors, perpendicular, deviation · Report a mismatch
  5. [5] § Methods › Implementation ↔ BasNet_code/train.py, lines 1 to 28 · score 0.73 · Weights Biases, PyTorch, experiment tracking, Lightning, pipeline, batch · Report a mismatch
  6. [6] § Methods › Loss Function and Optimization ↔ BasNet_code/loss_functions.py, lines 1 to 21 · score 0.65 · Focal Tversky Loss, class imbalance, axon segmentation, weighting · Report a mismatch
  7. [7] § Results › Baseline Comparison (nnU-Net) ↔ BasNet_code/utils/stratified_metrics.py, lines 21 to 124 · score 0.61 · ground truth, tile prediction, tile metrics, IoU, recall, patch · Report a mismatch
  8. [8] § Methods › Network Architecture ↔ BasNet_code/attention_unet.py, lines 94 to 143 · score 0.61 · spatial resolution, 2–4, bottleneck, Dropout, max, channel · Report a mismatch
  9. [9] § Methods › Loss Function and Optimization ↔ BasNet_code/train_lowo.py, lines 88 to 230 · score 0.59 · Gradient clipping, scheduling, patience, optimized, configuration, loss · Report a mismatch
  10. [10] § Methods › Network Architecture ↔ BasNet_code/attention_unet.py, lines 1 to 23 · score 0.58 · attention gates, Bielschowsky stained, architecture, decoder, encoder, tissue · Report a mismatch
  11. [11] § Methods › Baseline Comparison (nnU-Net) ↔ BasNet_code/inference_wsi.py, lines 196 to 277 · score 0.56 · sliding window inference, matching, predictions, patches, segmentation, trained · Report a mismatch
  12. [12] § Methods › Patch Extraction Strategy › Data Leakage Prevention ↔ BasNet_code/train_lowo.py, lines 340 to 376 · score 0.53 · cross validation, training WSIs, LOWO, fold, model · Report a mismatch
  13. [13] § Results › Training Performance ↔ BasNet_code/train.py, lines 167 to 244 · score 0.51 · trainable parameters, monitored, patience, gradient, epoch, batch · Report a mismatch
  14. [14] § Methods › Loss Function and Optimization ↔ BasNet_code/loss_functions.py, lines 50 to 77 · score 0.51 · smoothing constant, TP, FP, FN, weight, Loss · Report a mismatch
  15. [15] § Methods › Network Architecture ↔ BasNet_code/attention_unet.py, lines 50 to 91 · score 0.51 · encoder features, attention gates, decoder · Report a mismatch

Paper

Loaded from Europe PMC by your browser; OSCR does not store it: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 349 lines · 12 KB · MIT · 4 matches

  1. """
  2. Attention U-Net for Axon Segmentation
  4. Self-contained implementation of the single-task attention U-Net used for
  5. axon segmentation in Bielschowsky-stained postmortem brain tissue.
  7. Architecture:
  8. - Encoder: 4-level contracting path with dropout regularization
  9. - Bottleneck: Deepest feature representation
  10. - Decoder: 4-level expanding path with attention-gated skip connections
  11. - Output: Single-channel binary segmentation mask
  13. Input: (B, 3, 128, 128) — RGB tile
  14. Output: (B, 1, 128, 128) — Axon segmentation logits
  16. Author: UNet Axon Segmentation Project
  17. """
  19. import os
  20. import torch
  21. import torch.nn as nn
  22. import torch.nn.functional as F
  23. from typing import Dict, List, Tuple
  26. # ============================================================================
  27. # BUILDING BLOCKS
  28. # ============================================================================
  30. class DoubleConv(nn.Module):
  31. """Two consecutive Conv2d→BN→ReLU blocks."""
  33. def __init__(self, in_channels: int, out_channels: int, mid_channels: int = None):
  34. super().__init__()
  35. if not mid_channels:
  36. mid_channels = out_channels
  37. self.double_conv = nn.Sequential(
  38. nn.Conv2d(in_channels, mid_channels, kernel_size=3, padding=1, bias=False),
  39. nn.BatchNorm2d(mid_channels),
  40. nn.ReLU(inplace=True),
  41. nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1, bias=False),
  42. nn.BatchNorm2d(out_channels),
  43. nn.ReLU(inplace=True)
  44. )
  46. def forward(self, x: torch.Tensor) -> torch.Tensor:
  47. return self.double_conv(x)
  50. class AttentionGate(nn.Module):
  51. """
  52. Attention gate that weights encoder skip features by their relevance to
  53. the current decoder state.
  55. Args:
  56. F_g: Channels in gating signal (from decoder)
  57. F_l: Channels in skip connection (from encoder)
  58. F_int: Intermediate channels (bottleneck dimension)
  60. Reference: Oktay et al., "Attention U-Net", MIDL 2018.
  61. """
  63. def __init__(self, F_g: int, F_l: int, F_int: int):
  64. super().__init__()
  65. self.W_g = nn.Sequential(
  66. nn.Conv2d(F_g, F_int, kernel_size=1, bias=True),
  67. nn.BatchNorm2d(F_int)
  68. )
  69. self.W_x = nn.Sequential(
  70. nn.Conv2d(F_l, F_int, kernel_size=1, bias=True),
  71. nn.BatchNorm2d(F_int)
  72. )
  73. self.psi = nn.Sequential(
  74. nn.Conv2d(F_int, 1, kernel_size=1, bias=True),
  75. nn.BatchNorm2d(1),
  76. nn.Sigmoid()
  77. )
  78. self.relu = nn.ReLU(inplace=True)
  80. def forward(self, g: torch.Tensor, x: torch.Tensor) -> torch.Tensor:
  81. """
  82. Args:
  83. g: Gating signal from decoder (B, F_g, H, W)
  84. x: Skip features from encoder (B, F_l, H, W)
  85. Returns:
  86. Attention-weighted encoder features (B, F_l, H, W)
  87. """
  88. g1 = self.W_g(g)
  89. x1 = self.W_x(x)
  90. psi = self.psi(self.relu(g1 + x1))
  91. return x * psi
  94. class Encoder(nn.Module):
  95. """
  96. Contracting path of the U-Net.
  98. Progressively increases channel depth while halving spatial resolution
  99. at each level. Returns intermediate feature maps for skip connections.
  101. Args:
  102. in_channels: Number of input channels (3 for RGB)
  103. features: Feature dimensions at each level, e.g. [32, 64, 128, 256]
  104. dropout_rate: Spatial dropout probability applied at levels 2–4
  105. """
  107. def __init__(
  108. self,
  109. in_channels: int = 3,
  110. features: List[int] = [32, 64, 128, 256],
  111. dropout_rate: float = 0.2
  112. ):
  113. super().__init__()
  114. self.features = features
  116. self.encoder1 = DoubleConv(in_channels, features[0])
  117. self.pool1 = nn.MaxPool2d(2, 2)
  119. self.encoder2 = DoubleConv(features[0], features[1])
  120. self.pool2 = nn.MaxPool2d(2, 2)
  121. self.dropout2 = nn.Dropout2d(dropout_rate)
  123. self.encoder3 = DoubleConv(features[1], features[2])
  124. self.pool3 = nn.MaxPool2d(2, 2)
  125. self.dropout3 = nn.Dropout2d(dropout_rate)
  127. self.encoder4 = DoubleConv(features[2], features[3])
  128. self.pool4 = nn.MaxPool2d(2, 2)
  129. self.dropout4 = nn.Dropout2d(dropout_rate)
  131. self.bottleneck = DoubleConv(features[3], features[3] * 2)
  133. def forward(self, x: torch.Tensor) -> Tuple[torch.Tensor, ...]:
  134. """
  135. Returns:
  136. (e1, e2, e3, e4, bottleneck) — encoder features at each scale
  137. """
  138. e1 = self.encoder1(x)
  139. e2 = self.dropout2(self.encoder2(self.pool1(e1)))
  140. e3 = self.dropout3(self.encoder3(self.pool2(e2)))
  141. e4 = self.dropout4(self.encoder4(self.pool3(e3)))
  142. bottleneck = self.bottleneck(self.pool4(e4))
  143. return e1, e2, e3, e4, bottleneck
  146. class Decoder(nn.Module):
  147. """
  148. Expanding path of the U-Net with attention-gated skip connections.
  150. Args:
  151. features: Feature dimensions matching the encoder, e.g. [32, 64, 128, 256]
  152. out_channels: Number of output channels (1 for binary segmentation)
  153. """
  155. def __init__(self, features: List[int] = [32, 64, 128, 256], out_channels: int = 1):
  156. super().__init__()
  157. self.features = features
  159. self.upconv4 = nn.ConvTranspose2d(features[3] * 2, features[3], kernel_size=2, stride=2)
  160. self.att4 = AttentionGate(F_g=features[3], F_l=features[3], F_int=features[3] // 2)
  161. self.decoder4 = DoubleConv(features[3] * 2, features[3])
  163. self.upconv3 = nn.ConvTranspose2d(features[3], features[2], kernel_size=2, stride=2)
  164. self.att3 = AttentionGate(F_g=features[2], F_l=features[2], F_int=features[2] // 2)
  165. self.decoder3 = DoubleConv(features[2] * 2, features[2])
  167. self.upconv2 = nn.ConvTranspose2d(features[2], features[1], kernel_size=2, stride=2)
  168. self.att2 = AttentionGate(F_g=features[1], F_l=features[1], F_int=features[1] // 2)
  169. self.decoder2 = DoubleConv(features[1] * 2, features[1])
  171. self.upconv1 = nn.ConvTranspose2d(features[1], features[0], kernel_size=2, stride=2)
  172. self.att1 = AttentionGate(F_g=features[0], F_l=features[0], F_int=features[0] // 2)
  173. self.decoder1 = DoubleConv(features[0] * 2, features[0])
  175. self.output_conv = nn.Conv2d(features[0], out_channels, kernel_size=1)
  177. def forward(
  178. self,
  179. bottleneck: torch.Tensor,
  180. e1: torch.Tensor,
  181. e2: torch.Tensor,
  182. e3: torch.Tensor,
  183. e4: torch.Tensor
  184. ) -> torch.Tensor:
  185. """
  186. Args:
  187. bottleneck: (B, features[3]*2, H/16, W/16)
  188. e1..e4: Encoder skip features at each scale
  189. Returns:
  190. Segmentation logits (B, out_channels, H, W)
  191. """
  192. d4 = self.upconv4(bottleneck)
  193. d4 = self.decoder4(torch.cat([d4, self.att4(g=d4, x=e4)], dim=1))
  195. d3 = self.upconv3(d4)
  196. d3 = self.decoder3(torch.cat([d3, self.att3(g=d3, x=e3)], dim=1))
  198. d2 = self.upconv2(d3)
  199. d2 = self.decoder2(torch.cat([d2, self.att2(g=d2, x=e2)], dim=1))
  201. d1 = self.upconv1(d2)
  202. d1 = self.decoder1(torch.cat([d1, self.att1(g=d1, x=e1)], dim=1))
  204. return self.output_conv(d1)
  207. # ============================================================================
  208. # MAIN MODEL
  209. # ============================================================================
  211. class SingleTaskAttentionUNet(nn.Module):
  212. """
  213. Single-task Attention U-Net for axon segmentation.
  215. Args:
  216. in_channels: Input channels (default: 3 for RGB)
  217. out_channels: Output channels (default: 1 for binary mask)
  218. features: Feature dimensions at each encoder/decoder level
  219. dropout_rate: Spatial dropout probability in the encoder
  221. Example:
  222. >>> model = SingleTaskAttentionUNet(features=[32, 64, 128, 256])
  223. >>> logits = model(torch.randn(4, 3, 128, 128))
  224. >>> probs = torch.sigmoid(logits) # (4, 1, 128, 128)
  225. """
  227. def __init__(
  228. self,
  229. in_channels: int = 3,
  230. out_channels: int = 1,
  231. features: List[int] = [32, 64, 128, 256],
  232. dropout_rate: float = 0.2
  233. ):
  234. super().__init__()
  235. self.in_channels = in_channels
  236. self.out_channels = out_channels
  237. self.features = features
  238. self.dropout_rate = dropout_rate
  240. self.encoder = Encoder(in_channels=in_channels, features=features, dropout_rate=dropout_rate)
  241. self.decoder = Decoder(features=features, out_channels=out_channels)
  243. def forward(self, x: torch.Tensor) -> torch.Tensor:
  244. """
  245. Args:
  246. x: RGB input images (B, 3, 128, 128)
  247. Returns:
  248. Axon segmentation logits (B, 1, 128, 128)
  249. """
  250. e1, e2, e3, e4, bottleneck = self.encoder(x)
  251. return self.decoder(bottleneck=bottleneck, e1=e1, e2=e2, e3=e3, e4=e4)
  254. # ============================================================================
  255. # UTILITIES
  256. # ============================================================================
  258. def count_parameters(model: nn.Module) -> Dict[str, float]:
  259. """Return total and trainable parameter counts."""
  260. total = sum(p.numel() for p in model.parameters())
  261. trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
  262. return {
  263. 'total_parameters': total,
  264. 'trainable_parameters': trainable,
  265. 'total_parameters_millions': total / 1e6,
  266. 'trainable_parameters_millions': trainable / 1e6
  267. }
  270. def estimate_model_size(model: nn.Module) -> Dict[str, float]:
  271. """Return model memory footprint in MB/GB."""
  272. param_size = sum(p.nelement() * p.element_size() for p in model.parameters())
  273. buffer_size = sum(b.nelement() * b.element_size() for b in model.buffers())
  274. total = param_size + buffer_size
  275. return {
  276. 'parameters_mb': param_size / (1024 ** 2),
  277. 'buffers_mb': buffer_size / (1024 ** 2),
  278. 'total_mb': total / (1024 ** 2),
  279. 'total_gb': total / (1024 ** 3)
  280. }
  283. def load_pretrained_weights(
  284. checkpoint_path: str,
  285. model: SingleTaskAttentionUNet,
  286. verbose: bool = True
  287. ) -> SingleTaskAttentionUNet:
  288. """
  289. Load weights from a previously trained SingleTaskAttentionUNet checkpoint.
  291. Weights are loaded with strict=False to allow partial loading (e.g. when
  292. resuming after architecture changes). Missing or unexpected keys are reported
  293. when verbose=True.
  295. Args:
  296. checkpoint_path: Path to a .ckpt or .pt checkpoint file
  297. model: Model instance to load weights into
  298. verbose: Print loading statistics
  300. Returns:
  301. Model with loaded weights
  302. """
  303. if not os.path.exists(checkpoint_path):
  304. raise FileNotFoundError(f"Checkpoint not found: {checkpoint_path}")
  306. checkpoint = torch.load(checkpoint_path, map_location='cpu')
  308. # Support both raw state_dict and PyTorch Lightning checkpoints
  309. if 'state_dict' in checkpoint:
  310. state_dict = checkpoint['state_dict']
  311. # Lightning prefixes all keys with "model."
  312. state_dict = {k.replace('model.', '', 1): v for k, v in state_dict.items()
  313. if k.startswith('model.')}
  314. else:
  315. state_dict = checkpoint
  317. missing, unexpected = model.load_state_dict(state_dict, strict=False)
  319. if verbose:
  320. loaded = len(state_dict) - len(missing)
  321. print(f"Loaded {loaded}/{len(state_dict)} parameter tensors from {checkpoint_path}")
  322. if missing:
  323. print(f" Missing keys ({len(missing)}): {missing[:5]}{'...' if len(missing) > 5 else ''}")
  324. if unexpected:
  325. print(f" Unexpected keys ({len(unexpected)}): {unexpected[:5]}{'...' if len(unexpected) > 5 else ''}")
  327. return model
  330. def create_model(model_config: dict) -> SingleTaskAttentionUNet:
  331. """
  332. Instantiate SingleTaskAttentionUNet from a configuration dictionary.
  334. Args:
  335. model_config: Dictionary with optional keys:
  336. - in_channels (int, default 3)
  337. - out_channels (int, default 1)
  338. - features (List[int], default [32, 64, 128, 256])
  339. - dropout_rate (float, default 0.2)
  341. Returns:
  342. SingleTaskAttentionUNet instance
  343. """
  344. return SingleTaskAttentionUNet(
  345. in_channels=model_config.get('in_channels', 3),
  346. out_channels=model_config.get('out_channels', 1),
  347. features=model_config.get('features', [32, 64, 128, 256]),
  348. dropout_rate=model_config.get('dropout_rate', 0.2)
  349. )

attention_unet.py at commit bb55e05, under MIT · at the source

Overview

Authors: Lukas Schönenberger1,2, Laurin Egli1,2, Dimitrios Gkotsoulias1,2,3, Christine Stadelmann4, Cristina Granziera1,2,3
ORCID iDs: Lukas Schönenberger
  1. Research Center for Clinical Neuroimmunology and Neuroscience Basel (RC2NB), University of Basel, Basel, Switzerland
  2. Translational Imaging in Neurology Basel, Department of Biomedical Engineering, Faculty of Medicine, University of Basel, Allschwil, Switzerland
  3. Department of Neurology, University Hospital Basel, Basel, Switzerland
  4. Department of Neuropathology, University Medical Center Göttingen, Göttingen, Germany
Institutions: University of Basel (Switzerland); University Hospital of Basel (Switzerland); Universitätsmedizin Göttingen (Germany)
Journal: Neuroinformatics, volume 24, issue 3, article 59
Dates: received 29 May 2026; accepted 1 September 2026; published online 8 September 2026; in print 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1007/s12021-026-09815-z · PMID 42709277 · PMCID PMC13553709 · OpenAlex W7211968831
Open access: hybrid, a free copy (OpenAlex)
Status: code verified (how the code is found and verified)
Categories: histology / microscopy (modality), human (organism)
Methods: Connectivity, Machine learning, fMRI & imaging
Keywords: Bielschowsky, Axon, Segmentation, Quantification, Attention U-net, Deep-learning
MeSH: Axons*, Brain*, Image Processing, Computer-Assisted*, Neural Networks, Computer*, Silver Staining*, Humans (* major topic)
Topic: AI in cancer detection (Artificial Intelligence, Computer Science), according to OpenAlex
Funding: Universität Basel
Citations: not cited yet (Europe PMC); 22 references in the paper

Abstract

Reliable automatic quantification of axon density in histologic sections is important for both research and clinical neuropathology applications - however, it remains a challenge for silver-impregnation stains, such as Bielschowsky. Classical color-deconvolution approaches perform poorly on silver stains, and manual annotation of densely packed axons is time-consuming and subject to inter-rater variability. We developed an automated axon segmentation pipeline in Bielschowsky silver-stained histological brain sections based on an attention U-Net architecture with attention-gated skip connections, trained using Focal Tversky Loss to handle class imbalance and thin structure recovery. Ground truth was manually annotated on 33 image tiles (covering over 25 million pixels) derived from 26 whole-slide images from varying brain regions of four multiple sclerosis patients. Slides were prepared by different laboratory technicians at different time points to capture realistic staining variability. Model performance was evaluated on a held-out test set of unseen tiles. On the test set (eight held-out tiles) the model achieved a mean pixel-wise F1/Dice of 0.717 and an intersection over union (IoU) of 0.584. A dedicated inter-rater experiment on two representative tiles yielded rater-to-rater F1 scores of 0.637 and 0.671, while model-to-rater agreement (F1: 0.681–0.736) met or exceeded that human ceiling. Generated whole-slide density and orientation visualizations accurately reflected regional axon distributions and provided quantitative readouts suitable for downstream analysis. Our attention U-Net provides an open-source solution for axon segmentation from Bielschowsky-stained sections, reducing manual effort and enabling reproducible, slide-level quantitative metrics. This tool can facilitate studies of axonal pathology across research and clinical settings.

Supplementary Information: The online version contains supplementary material available at https://doi.org/10.1007/s12021-026-09815-z.

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

Repositories

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

Zenodo 19455087

License: MIT
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Data Availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: PyTorch (10 files), NumPy (8 files), Pillow (6 files), OpenCV (3 files), PyTorch Lightning (2 files), Matplotlib (2 files), tifffile (2 files), pandas (1 file)
Availability: 1 check, the latest on 26 September 2026: the link answers (HTTP 200)
  • 26 September 2026: the link answers (HTTP 200)
14 files
At the source: doi.org/10.5281/zenodo.19455087

lukasschoenenberger/basnet

License: MIT
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: bb55e05437e7a7240b7258a5d93956f641658d72, 2 April 2026
Languages: Python (13)
Size: 16 files, 13 scripts
Software Heritage: not archived
Found in: the Zenodo archive record
Holds: license file
Not found: README, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: PyTorch (10 files), NumPy (8 files), Pillow (6 files), OpenCV (3 files), PyTorch Lightning (2 files), Matplotlib (2 files), tifffile (2 files), pandas (1 file)
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
14 files
At the source: github.com/LukasSchoenenberger/BasNet/tree/v1.0.1

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 26 scripts, each with its path and the digest of its content;
  • 15 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

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

Data

Datasets cited

Data Availability

Source code (version 1.0.1) is archived on Zenodo and available at https://doi.org/10.5281/zenodo.19455087. The trained model is available on Hugging Face at https://huggingface.co/lukas-schoenenberger/BasNet/tree/main. Annotated training data are deposited on a private Hugging Face repository at https://huggingface.co/datasets/lukas-schoenenberger/Basnet-dataset and are available from the corresponding author upon reasonable request with the permission of the German MS Brain Bank of the Competence Network Multiple Sclerosis.

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

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 3, 28 September 2026

  • Publisher: n/a → Springer Science+Business Media
  • Funding: added Universität Basel

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 5 authors, 6 keywords, 6 MeSH terms, 18 references.

Cite

This paper

Schönenberger, L., Egli, L., Gkotsoulias, D., Stadelmann, C., & Granziera, C. (2026). BasNet: Attention U-Net-Based Automated Axon Segmentation in Bielschowsky Silver-Stained Histology. Neuroinformatics, 24(3), 59. https://doi.org/10.1007/s12021-026-09815-z

BibTeX

@article{schonenberger2026basnet,
author = {Schönenberger, Lukas and Egli, Laurin and Gkotsoulias, Dimitrios and Stadelmann, Christine and Granziera, Cristina},
title = {{BasNet: Attention U-Net-Based Automated Axon Segmentation in Bielschowsky Silver-Stained Histology}},
journal = {Neuroinformatics},
year = {2026},
month = sep,
volume = {24},
number = {3},
pages = {59},
publisher = {Springer Science+Business Media},
issn = {1539-2791},
doi = {10.1007/s12021-026-09815-z},
url = {https://doi.org/10.1007/s12021-026-09815-z},
pmid = {42709277},
pmcid = {PMC13553709}
}

RIS

TY - JOUR
AU - Schönenberger, Lukas
AU - Egli, Laurin
AU - Gkotsoulias, Dimitrios
AU - Stadelmann, Christine
AU - Granziera, Cristina
TI - BasNet: Attention U-Net-Based Automated Axon Segmentation in Bielschowsky Silver-Stained Histology
T2 - Neuroinformatics
J2 - Neuroinformatics
PY - 2026
DA - 2026/09/08
VL - 24
IS - 3
SP - 59
SN - 1539-2791
PB - Springer Science+Business Media
DO - 10.1007/s12021-026-09815-z
UR - https://doi.org/10.1007/s12021-026-09815-z
LA - en
ER -

CSL-JSON

{
"id": "10.1007/s12021-026-09815-z",
"type": "article-journal",
"title": "BasNet: Attention U-Net-Based Automated Axon Segmentation in Bielschowsky Silver-Stained Histology",
"container-title": "Neuroinformatics",
"author": [
{
"family": "Schönenberger",
"given": "Lukas"
},
{
"family": "Egli",
"given": "Laurin"
},
{
"family": "Gkotsoulias",
"given": "Dimitrios"
},
{
"family": "Stadelmann",
"given": "Christine"
},
{
"family": "Granziera",
"given": "Cristina"
}
],
"container-title-short": "Neuroinformatics",
"volume": "24",
"issue": "3",
"page": "59",
"DOI": "10.1007/s12021-026-09815-z",
"PMID": "42709277",
"PMCID": "PMC13553709",
"ISSN": "1539-2791",
"publisher": "Springer Science+Business Media",
"URL": "https://doi.org/10.1007/s12021-026-09815-z",
"language": "en",
"issued": {
"date-parts": [
[
2026,
9,
8
]
]
}
}

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/s41598-026-57519-w [code]
Automated segmentation of neurons and spinal cord structures in immunofluorescence images using SpineDL.
Journal: Scientific reports
In common: tifffile, OpenCV, Pillow, 4 other tools, histology / microscopy, 2 references
[2] doi:10.1038/s41592-024-02245-2 [code]
Virtual reality-empowered deep-learning analysis of brain cells.
Journal: Nature methods
In common: PyTorch Lightning, tifffile, OpenCV, 5 other tools, 1 reference
[3] doi:10.1038/s41597-024-03073-x [code]
Brain tumor segmentation using synthetic MR images - A comparison of GANs and diffusion models.
Journal: Scientific data
In common: PyTorch Lightning, tifffile, OpenCV, 5 other tools, 1 reference
[4] doi:10.1038/s41592-025-02770-8 [code]
Scaling up spatial transcriptomics for large-sized tissues: uncovering cellular-level tissue architecture beyond conventional platforms with iSCALE.
Journal: Nature methods
In common: PyTorch Lightning, tifffile, OpenCV, 5 other tools, histology / microscopy
[5] doi:10.1016/j.crmeth.2025.100989 [code]
Efficient cell-wide mapping of mitochondria in electron microscopic volumes using webKnossos.
Journal: Cell reports methods
In common: PyTorch Lightning, tifffile, OpenCV, 5 other tools, histology / microscopy
[6] doi:10.1038/s42003-024-06877-0 [code]
Abnormal structural‒functional coupling patterning in progressive supranuclear palsy is associated with diverse gradients and histological features.
Journal: Communications biology
In common: PyTorch Lightning, tifffile, OpenCV, 5 other tools, histology / microscopy
[7] doi:10.1162/imag.a.1079 [code]
From fibers to cells: Fourier-based registration enables virtual Cresyl violet staining from 3D polarized light imaging.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: PyTorch Lightning, tifffile, OpenCV, 5 other tools, histology / microscopy
[8] doi:10.3389/fbioe.2024.1411680 [code]
ML-driven segmentation of microvascular features during histological examination of tissue-engineered vascular grafts.
Journal: Frontiers in bioengineering and biotechnology
In common: PyTorch Lightning, OpenCV, Pillow, 4 other tools, histology / microscopy, 1 reference
[9] doi:10.1038/s41586-026-10156-9 [code]
Scalable and multiplexed recorders of gene regulation dynamics across weeks.
Journal: Nature
In common: PyTorch Lightning, tifffile, OpenCV, 5 other tools
[10] doi:10.1016/j.celrep.2024.115149 [code]
Single-nucleus and spatial landscape of the sub-ventricular zone in human glioblastoma.
Journal: Cell reports
In common: PyTorch Lightning, tifffile, OpenCV, 5 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.

Add the badge to the code's README

OSCR: the badge of this paper

If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.

Markdown
<!-- oscr-badge:start -->
[![OSCR](https://openscicode.org/badge/doi/10.1007/s12021-026-09815-z.svg)](https://openscicode.org/badge/doi/10.1007/s12021-026-09815-z)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.1007/s12021-026-09815-z.svg
   :target: https://openscicode.org/badge/doi/10.1007/s12021-026-09815-z
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.1007/s12021-026-09815-z"><img src="https://openscicode.org/badge/doi/10.1007/s12021-026-09815-z.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->

On GitHub, open the README, choose Edit (the pencil), paste the snippet under the title, then "Commit changes".

If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge 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: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.

Report a mismatch between the code and the paper · Report a code error (signed in)

Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.

Report a reproduction failure (signed in)

Versions of its code: the releases of its code tied to a version of this paper (the preprint, the accepted manuscript, the version of record…), each with the tracing map versioned with it.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.