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

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 · 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
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: — → 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.3389/frai.2026.1841639 [code]
Label tree semantic losses for rich multi-class medical image segmentation.
Journal: Frontiers in artificial intelligence
In common: PyTorch Lightning, OpenCV, Pillow, 4 other tools, 1 reference
[3] doi:10.1038/s41598-026-61605-4 [code]
Learning precise segmentation of neurofibrillary tangles from rapid manual point annotations.
Journal: Scientific reports
In common: PyTorch Lightning, OpenCV, Pillow, 4 other tools, histology / microscopy
[4] doi:10.3389/fnins.2026.1870124 [code]
An end-to-end pipeline for automated fetal brain segmentation and biometry from 3D SSFP MRI.
Journal: Frontiers in neuroscience
In common: tifffile, OpenCV, PyTorch, 3 other tools, 2 references
[5] doi:10.1364/boe.600665 [code]
NeuroSeg-MF: robust neuron segmentation in two-photon Ca<sup>2+</sup> imaging using multi-feature fusion and detection-guided SAM.
Journal: Biomedical optics express
In common: tifffile, OpenCV, Pillow, 4 other tools, 1 reference
[6] doi:10.1038/s41467-026-72709-w [code]
An epifluorescence microscope design for naturalistic behavior and cellular activity in freely moving Caenorhabditis elegans.
Journal: Nature communications
In common: tifffile, OpenCV, Pillow, 4 other tools, histology / microscopy
[7] doi:10.1038/s41467-026-73045-9 [code]
Aberration-aware 3D localization microscopy via self-supervised neural-physics learning.
Journal: Nature communications
In common: tifffile, OpenCV, Pillow, 4 other tools, histology / microscopy
[8] doi:10.1371/journal.pcbi.1013499 [code]
VesiclePy: A machine learning vesicle analysis toolbox for volume electron microscopy.
Journal: PLoS computational biology
In common: OpenCV, Pillow, PyTorch, 3 other tools, histology / microscopy, 1 reference
[9] doi:10.1007/s12021-026-09817-x [code]
Circle of Willis-Guided Localization for Simultaneous Detection and Classification of Large Vessel Occlusions in Brain CTA.
Journal: Neuroinformatics
In common: PyTorch Lightning, tifffile, PyTorch, 3 other tools, 1 reference
[10] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: PyTorch Lightning, OpenCV, Pillow, 4 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.