OSCR

Deep learning-assisted mapping of dendritic spines using sequential 2D two-photon calcium imaging.

Code ↔ Paper

21 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 21 matches · 1 of them tie a paragraph to a whole file, not to given lines: a weak match, whose lines are not tinted
  1. [1] § STAR★Methods › Method details › ROI design and optimization ↔ src/ROIpy/core/structures.py, lines 289–402 · score 0.94 · longitudinal axis, bin factor, fill fraction, frame flyback, start position, dwell
  2. [2] § STAR★Methods › Method details › DeepD3 training and inference ↔ src/spyne/core/spines/analysis/segmentation/post_processing.py, lines 68–113 · score 0.92 · peak local max, cv2.distanceTransform, binary masks, post processed, dendritic mask, spine masks
  3. [3] § STAR★Methods › Method details › ROI design and optimization ↔ src/ROIpy/core/makeroi/make_roi.py, lines 12–149 · score 0.90 · Coplanar nodes, neuronal morphologies, dendritic ROIs, scan period, farthest, frame rate
  4. [4] § STAR★Methods › Method details › Calcium event classifier training and inference ↔ calcium_event_classifier/core/train_loop.py, lines 21–89 · score 0.88 · torch nn, PyTorch, validation loss, loss function, F1 score, recall
  5. [5] § STAR★Methods › Method details › DeepD3 training and inference ↔ src/spyne/core/spines/analysis/segmentation/pipeline.py, lines 176–254 · score 0.85 · cv2.distanceTransform, dendrites probability maps, binary masks, post processed, algorithm, inference
  6. [6] § STAR★Methods › Method details › Calcium event classifier training and inference ↔ calcium_event_classifier/core/classifier_dff.py, lines 63–145 · score 0.84 · fully connected layer, residual blocks, PyTorch, dropout, flattened, leaky
  7. [7] § Results › ROIpy produces rectangular ROIs aligned with dendritic trajectories ↔ src/ROIpy/core/makeroi/make_roi.py, lines 12–149 · score 0.80 · Short rectangles, apical dendrites, neuronal morphology, coverage, frame rate, elongating
  8. [8] § STAR★Methods › Method details › ROI design and optimization ↔ src/ROIpy/core/structures.py, lines 289–402 · score 0.80 · numerical aperture, starting position, um ratio, Nyquist, laser, wavelength
  9. [9] § STAR★Methods › Method details › Calcium imaging and analysis ↔ src/spyne/core/spines/analysis/timeseries/timeseries.py, lines 28–87 · score 0.78 · dilated spine, area outside, spine masks, disk, neuropil, dilation
  10. [10] § Results › Custom deep learning classifier automatically identifies active spines ↔ calcium_event_classifier/core/classifier_dff.py, lines 5–60 · score 0.77 · leaky ReLU, residual block, Skip connections, convolutional layer, batch normalization, activation
  11. [11] § Results › Custom deep learning classifier automatically identifies active spines ↔ calcium_event_classifier/core/train_loop.py, lines 201–266 · score 0.68 · precision recall, validation loss, F1 score, calcium event, curve, trained
  12. [12] § Results › ROIpy produces rectangular ROIs aligned with dendritic trajectories ↔ src/ROIpy/core/components.py, lines 36–175 · score 0.67 · ScanImage, child, encodes, density, volume, compartment
  13. [13] § STAR★Methods › Method details › Calcium imaging and analysis ↔ src/spyne/core/spines/analysis/timeseries/pipeline.py, lines 9–70 · score 0.67 · background signal, contamination, dilated, disk, neuropil, dilation
  14. [14] § Results › Mapping dendritic spines from discrete 2D ROIs ↔ src/spyne/core/spines/analysis/timeseries/timeseries.py, lines 91–190 · score 0.65 · modified Okada filter, spine masks, rolling, background, fraction, baseline
  15. [15] § Results › Mapping dendritic spines from discrete 2D ROIs ↔ src/spyne/core/spines/analysis/__init__.py, the whole file · a weak match · score 0.62 · modified Okada filter, dendritic spines, calcium event, centroid, transformation, inference
  16. [16] § STAR★Methods › Method details › ROI design and optimization ↔ src/spyne/core/imaging/visualization.py, lines 17–131 · score 0.61 · scan duration, frame period, frame rate, loop, allocated, dimension
  17. [17] § STAR★Methods › Method details › Gated PMTs artifact correction ↔ src/spyne/core/imaging/load.py, lines 391–443 · score 0.59 · Gating artifact correction, stripe, PMTs, channel, scanning, frame
  18. [18] § STAR★Methods › Method details › CSBDeep model training for CARE ↔ calcium_event_classifier/core/train_loop.py, lines 21–89 · score 0.58 · validation loss, loss function, epochs, optimizer, trained, model
  19. [19] § STAR★Methods › Method details › CSBDeep model training for CARE ↔ src/spyne/core/spines/analysis/backends/csbdeep_backend.py, lines 51–74 · score 0.58 · CSBDeep, quality, restoration
  20. [20] § STAR★Methods › Method details › Logistic regression classifier ↔ calcium_event_classifier/core/inference.py, lines 7–40 · score 0.54 · neural network, calcium event, Hyperparameters, weight, classifier, train
  21. [21] § STAR★Methods › Method details › Patch-clamp electrophysiology ↔ src/spyne/core/electrophysiology/analysis/pyabf_passive_props.py, lines 139–257 · score 0.53 · access resistance, isolated, pulses, electrode, slices, min

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 · 315 lines · 10 KB · no license · 3 matches

  1. """ Created on Tue Jul 8 14:46:08 2025
  2. @author: dcupolillo """
  4. import torch
  5. from torch.optim.lr_scheduler import ReduceLROnPlateau
  6. from torch.utils.data import DataLoader
  7. import torch.nn as nn
  8. import copy
  9. import time
  10. from tqdm import tqdm
  11. from sklearn.metrics import (
  12. f1_score, precision_recall_curve, average_precision_score)
  13. import numpy as np
  16. def compute_l1_regularization(model) -> float:
  18. return sum(p.abs().sum() for p in model.parameters())
  21. def train(
  22. train_loader: DataLoader,
  23. valid_loader: DataLoader,
  24. model: nn.Module,
  25. criterion: torch.nn.modules.loss,
  26. device: str,
  27. epochs: int,
  28. learning_rate: float,
  29. lr_drop_factor: float,
  30. lr_drop_patience: int,
  31. lambda1: float,
  32. lambda2: float,
  33. patience: int,
  34. ) -> tuple:
  35. """
  36. Train a model with early stopping and optional latent feature extraction.
  38. Parameters
  39. ----------
  40. train_loader : DataLoader
  41. DataLoader for training data.
  42. valid_loader : DataLoader
  43. DataLoader for validation data.
  44. model : nn.Module
  45. PyTorch model to train.
  46. criterion: torch.nn.modules.loss,
  47. Loss function.
  48. device : str
  49. Device identifier ("cpu" or "cuda").
  50. epochs : int
  51. Maximum number of training epochs.
  52. learning_rate : float
  53. Initial learning rate for the optimizer.
  54. lambda1 : float
  55. L1 regularization weight.
  56. lambda2 : float
  57. L2 regularization weight (weight decay).
  58. patience : int
  59. Number of epochs with no improvement before early stopping.
  61. Returns
  62. -------
  63. model : nn.Module
  64. Best-performing model on the validation set.
  65. train_loss : list of float
  66. Training loss per epoch.
  67. validation_loss : list of float
  68. Validation loss per epoch.
  69. train_f1 : list of float
  70. F1 score on the training set per epoch.
  71. validation_f1 : list of float
  72. F1 score on the validation set per epoch.
  73. validation_precision : list of float
  74. Precision on the validation set per epoch.
  75. validation_recall : list of float
  76. Recall on the validation set per epoch.
  77. best_thresholds : list of float
  78. Optimal classification threshold per epoch.
  79. validation_auc_pr : list of float
  80. AUC-PR score per epoch.
  81. valid_epoch_features : list of torch.Tensor or None
  82. Latent features from validation set per epoch (if available).
  83. valid_epoch_labels : list of torch.Tensor or None
  84. Corresponding labels for validation features (if available).
  85. train_epoch_features : list of torch.Tensor or None
  86. Latent features from training set per epoch (if available).
  87. train_epoch_labels : list of torch.Tensor or None
  88. Corresponding labels for training features (if available).
  89. """
  91. model.to(device)
  93. optimizer = torch.optim.Adam(
  94. model.parameters(),
  95. lr=learning_rate,
  96. weight_decay=lambda2,
  97. amsgrad=True
  98. )
  99. scheduler = ReduceLROnPlateau(
  100. optimizer,
  101. mode='min',
  102. factor=lr_drop_factor,
  103. patience=lr_drop_patience,
  104. verbose=True
  105. )
  107. train_loss, validation_loss = [], []
  108. train_f1, validation_f1 = [], []
  109. validation_precision, validation_recall, best_thresholds = [], [], []
  110. validation_auc_pr = []
  112. valid_epoch_features = []
  113. valid_epoch_labels = []
  114. train_epoch_features = []
  115. train_epoch_labels = []
  117. best_loss = float('inf')
  118. best_model = copy.deepcopy(model)
  119. wait = 0
  121. print("======================================")
  122. print(" #### Training ####")
  123. print("======================================\n")
  124. start_time = time.time()
  126. for epoch in range(epochs):
  128. # Training
  129. model.train()
  130. running_loss = 0.0
  131. total_train_samples = 0
  132. all_preds = []
  133. all_targets = []
  134. all_train_feats = []
  136. # Looping through all the traces
  137. for data, target in tqdm(
  138. train_loader, desc=f"Training Epoch {epoch+1}/{epochs}"):
  140. if data.ndim == 2:
  141. data = data.unsqueeze(1).float() # (B, T) → (B, 1, T)
  142. elif data.ndim == 3:
  143. data = data.float() # already [B, C, T]
  145. # Change dtype before sending to device
  146. # data = data.float().unsqueeze(1).to(device)
  147. target = target.float().view(-1, 1)
  149. data, target = data.to(device), target.to(device)
  151. optimizer.zero_grad()
  153. # Forward pass
  154. features, logits = model(data, return_features=True)
  155. loss = criterion(logits, target)
  156. probs = torch.sigmoid(logits)
  158. l1_norm = compute_l1_regularization(model)
  159. loss += lambda1 * l1_norm
  160. # ...smoothing loss removed...
  162. running_loss += loss.item() * data.size(0)
  163. total_train_samples += data.size(0)
  165. loss.backward() # Backpropagate
  166. optimizer.step() # Update weights
  168. all_preds.extend(probs.detach().cpu().numpy().flatten())
  169. all_targets.extend(target.detach().cpu().numpy().flatten())
  170. all_train_feats.append(features.detach().cpu())
  172. # Compute average loss and prec./recall for training across batches
  173. avg_train_loss = running_loss / total_train_samples
  174. train_loss.append(avg_train_loss)
  176. precision, recall, thresholds = precision_recall_curve(
  177. all_targets, all_preds)
  179. precision_ = precision[1:]
  180. recall_ = recall[1:]
  182. f1_scores = 2 * (precision_ * recall_) / (precision_ + recall_ + 1e-8)
  184. if len(thresholds) > 0:
  185. best_idx = np.argmax(f1_scores)
  186. best_threshold = thresholds[best_idx]
  187. else:
  188. # degenerate case: all_preds identical; fall back to 0.5
  189. best_idx = 0
  190. best_threshold = 0.5
  192. binarized_preds = (
  193. np.array(all_preds) >= best_threshold).astype(int)
  195. train_f1.append(
  196. f1_score(all_targets, binarized_preds, zero_division=0))
  198. train_epoch_features.append(torch.cat(all_train_feats))
  199. train_epoch_labels.append(torch.tensor(all_targets))
  201. # Validation
  202. model.eval()
  203. running_loss = 0.0
  204. total_valid_samples = 0
  205. all_preds = []
  206. all_targets = []
  207. all_valid_feats = []
  209. with torch.no_grad(): # Disable gradient calculation for validation
  211. for data, target in valid_loader:
  213. if data.ndim == 2: # [B, T]
  214. data = data.unsqueeze(1) # → [B, 1, T]
  215. elif data.ndim == 3:
  216. data = data # already [B, C, T]
  218. target = target.float()
  219. target = target.view(-1, 1)
  220. data, target = data.to(device), target.to(device)
  222. features, logits = model(data, return_features=True)
  223. loss = criterion(logits, target)
  224. probs = torch.sigmoid(logits)
  226. running_loss += loss.item() * data.size(0)
  227. total_valid_samples += data.size(0)
  229. all_preds.extend(probs.detach().cpu().numpy().flatten())
  230. all_targets.extend(target.detach().cpu().numpy().flatten())
  231. all_valid_feats.append(features.cpu())
  233. # Compute average loss and prec./recall for validation
  234. avg_valid_loss = running_loss / total_valid_samples
  235. validation_loss.append(avg_valid_loss)
  237. precision, recall, thresholds = precision_recall_curve(
  238. all_targets, all_preds)
  240. precision_ = precision[1:]
  241. recall_ = recall[1:]
  243. f1_scores = 2 * (precision_ * recall_) / (precision_ + recall_ + 1e-8)
  245. if len(thresholds) > 0:
  246. best_idx = np.argmax(f1_scores)
  247. best_threshold = thresholds[best_idx]
  248. val_f1 = f1_scores[best_idx]
  249. else:
  250. best_idx = 0
  251. best_threshold = 0.5
  252. # compute F1 at this fixed threshold for logging
  253. bin_preds = (np.array(all_preds) >= best_threshold).astype(int)
  254. val_f1 = f1_score(all_targets, bin_preds, zero_division=0)
  256. val_auc_pr = average_precision_score(all_targets, all_preds)
  258. validation_f1.append(val_f1)
  259. validation_precision.append(precision[best_idx])
  260. validation_recall.append(recall[best_idx])
  261. best_thresholds.append(best_threshold)
  263. validation_auc_pr.append(val_auc_pr)
  265. valid_epoch_features.append(torch.cat(all_valid_feats))
  266. valid_epoch_labels.append(torch.tensor(all_targets))
  268. # Eventually, reduces learning rate
  269. scheduler.step(avg_valid_loss)
  271. # Early Stopping Check based on accuracy
  272. if avg_valid_loss < best_loss: # check if new best loss
  273. best_loss = avg_valid_loss
  274. best_model = copy.deepcopy(model)
  275. wait = 0
  276. else:
  277. # if loss is not improving, increase the wait until patience
  278. wait += 1
  280. if wait > patience:
  281. print(f"Early stopping at epoch: {epoch+1}")
  282. break
  284. print(
  285. f"Epoch {epoch+1}: "
  286. f"🔵 Train loss: {avg_train_loss:.2f} | "
  287. f"🟢 Val loss: {avg_valid_loss:.2f} | "
  288. f"🎯 Val F1: {validation_f1[-1]:.3f} @ thr={best_threshold:.2f} | "
  289. f"🔻 Prec: {validation_precision[-1]:.3f}, "
  290. f"Rec: {validation_recall[-1]:.3f} | "
  291. f"🏆 Best loss: {best_loss:.2f}"
  293. )
  295. end_time = time.time()
  296. training_time = (
  297. time.strftime("%H:%M:%S", time.gmtime(end_time - start_time)))
  298. print(f"\n🕒 Time for training: {training_time}")
  299. print("======================================\n")
  301. return (
  302. best_model,
  303. train_loss,
  304. validation_loss,
  305. train_f1,
  306. validation_f1,
  307. validation_precision,
  308. validation_recall,
  309. best_thresholds,
  310. validation_auc_pr,
  311. valid_epoch_features,
  312. valid_epoch_labels,
  313. train_epoch_features,
  314. train_epoch_labels
  315. )

train_loop.py at commit 8d12d2a, no license · at the source

Overview

Authors: Dario Cupolillo1, Vincenzo Regio1, Valentina Galleano1,2, Andrea Barberis1
ORCID iDs: Dario Cupolillo
  1. Istituto Italiano di Tecnologia, Synaptic Plasticity of Inhibitory Networks, 16163 Genova, Italy
  2. The Open University, School of Life, Health and Chemical Sciences, Milton Keynes MK7 6AA, UK
Institutions: Italian Institute of Technology (Italy); The Open University (United Kingdom)
Journal: iScience, volume 29, issue 8, article 117010
Dates: received 5 December 2025; accepted 15 July 2026; published online 1 August 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1016/j.isci.2026.117010 · PMID 42577014 · PMCID PMC13453581 · OpenAlex W7172225065
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: histology / microscopy (modality), optical imaging (calcium, voltage, 2-photon) (modality), cellular / molecular (subfield)
Methods: Spectral & time-frequency, Connectivity, Statistics, Machine learning, Preprocessing, Evoked potentials, fMRI & imaging, Single-unit activity, calcium imaging
Keywords: dendritic spines, synaptic spatial organization, sequential dendritic imaging, two-dimensional two-photon microscopy, calcium imaging, single-spine calcium imaging, calcium event classification
Topic: Nonlinear Optical Materials Studies (Biomedical Engineering, Engineering), according to OpenAlex
Funding: Horizon (MSCA-2021-PF-01 –SynEMO, 101068871)
Citations: not cited yet (Europe PMC); 65 references in the paper
Research resources: AAV5-CaMKIIa-hChR2(H134R)-EYFP RRID:Addgene_26969, Mouse: Fos2A-iCreERT2 RRID:IMSR_JAX:030323, Fiji RRID:SCR_002285, scikit-learn RRID:SCR_002577, scipy RRID:SCR_008058, Python 3 RRID:SCR_008394, matplotlib RRID:SCR_008624, numpy RRID:SCR_008633, pCLAMP 11 RRID:SCR_011323, Scanimage 2021 RRID:SCR_014307, Allen Cell Types Database38 RRID:SCR_014806, pytorch RRID:SCR_018536, scikit-posthoc RRID:SCR_021363, tifffile RRID:SCR_023338, nnU-net RRID:SCR_028165

Abstract

Neurons transform complex spatiotemporal synaptic inputs into structured action potential sequences. Excitatory inputs initiate or interact with dendritic spikes or plateau potentials, adding computational layers that diversify input-output transformations. Because synapse location strategically shapes the dendritic events, mapping synaptic organization is critical for understanding neuronal function. Spine calcium imaging offers a direct readout of active contact location but requires access to spines distributed across intricate three-dimensional dendrites. We present a software pipeline for targeted dendritic imaging and analysis using sequential two-dimensional scanning on standard two-photon microscopes. It includes a ScanImage-compatible pre-acquisition tool, ROIpy, which generates dendrite-aligned region-of-interests (ROIs) for depth-specific dendritic imaging, and a post-acquisition suite, Spyne, which includes deep learning modules for spine detection and binary classification of calcium activity (active vs. non-active spines). This method accommodates diverse experimental designs, including two-photon imaging with patch-clamp or all-optical setups, supporting whole-arbor or branch-specific imaging.

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

dcupolillo/ROIpy

License: MIT
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: 7f920ed31f0ec41ae27fd935c5519dd7ba9a0143, 13 July 2026
Languages: Python (19)
Size: 33 files, 19 scripts
Software Heritage: not archived
Found in: “Data and code availability”
Holds: README, license file, CITATION.cff, environment (environment.yaml, pyproject.toml)
Not found: tests, continuous integration, documentation
Tools: NumPy (9 files), Matplotlib (5 files), tifffile (2 files), SciPy (1 file)
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
21 files
At the source: github.com/dcupolillo/ROIpy

Zenodo 21334250

License: MIT
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Data and code availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (9 files), Matplotlib (5 files), tifffile (2 files), SciPy (1 file)
Availability: 1 check, the latest on 26 September 2026: the link answers (HTTP 200)
  • 26 September 2026: the link answers (HTTP 200)
21 files
At the source: doi.org/10.5281/zenodo.21334250

dcupolillo/spyne

License: none: the authors keep all their rights
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: 9c7ad551825afd866afda24f6094acb9218efd1d, 13 July 2026
Languages: Python (54)
Size: 65 files, 54 scripts
Software Heritage: not archived
Found in: “Data and code availability”
Holds: README, CITATION.cff, environment (environment.yml, environment_CPU.yml, pyproject.toml)
Not found: license file, tests, continuous integration, documentation
Tools: NumPy (30 files), SciPy (6 files), TensorFlow (6 files), tifffile (6 files), Matplotlib (4 files), scikit-image (4 files), OpenCV (3 files), pyABF (3 files), PyTorch (2 files), pandas (1 file), scikit-learn (1 file)
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
55 files
At the source: github.com/dcupolillo/spyne

Zenodo 21334656

License: CC-BY-4.0
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Data and code availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (30 files), SciPy (6 files), TensorFlow (6 files), tifffile (6 files), Matplotlib (4 files), scikit-image (4 files), OpenCV (3 files), pyABF (3 files), PyTorch (2 files), pandas (1 file), scikit-learn (1 file)
Availability: 1 check, the latest on 26 September 2026: the link answers (HTTP 200)
  • 26 September 2026: the link answers (HTTP 200)
55 files
At the source: doi.org/10.5281/zenodo.21334656

dcupolillo/calcium_event_classifier

License: none: the authors keep all their rights
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: 8d12d2a910a7c70501b59b8183a39a54b785a131, 13 July 2026
Languages: Python (11), Jupyter (3)
Size: 24 files, 14 scripts
Software Heritage: not archived
Found in: “Data and code availability”
Holds: README, CITATION.cff, environment (pyproject.toml), 3 notebooks
Not found: license file, tests, continuous integration, documentation
Tools: NumPy (10 files), Matplotlib (8 files), PyTorch (8 files), scikit-learn (5 files), seaborn (2 files)
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
15 files
At the source: github.com/dcupolillo/calcium_event_classifier

Zenodo 21334890

License: CC-BY-4.0
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Data and code availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (10 files), Matplotlib (8 files), PyTorch (8 files), scikit-learn (5 files), seaborn (2 files)
Availability: 1 check, the latest on 26 September 2026: the link answers (HTTP 200)
  • 26 September 2026: the link answers (HTTP 200)
15 files
At the source: doi.org/10.5281/zenodo.21334890

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:

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

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

Data

No dataset and no data link were found in the paper.

Data and code availability

• Data: The following data have been deposited at IIT-Dataverse and are publicly available as of the date of publication at https://doi.org/10.48557/GZYED8: ○ Training images and spine and dendrites labels used to train spine segmentation algorithm. ○ Trained DeepD3 and nnU-net model. ○ High- and low-signal-to-noise ratio images used to train CSBDeep model. ○ Trained CSBDeep model. ○ Calcium imaging traces used to train custom deep learning classifier. ○ Calcium event classifier trained model. • Code: All original code has been deposited on GitHub at https://github.com/dcupolillo/ROIpy (https://doi.org/10.5281/zenodo.21334250), https://github.com/dcupolillo/spyne (https://doi.org/10.5281/zenodo.21334656), and https://github.com/dcupolillo/calcium_event_classifier (https://doi.org/10.5281/zenodo.21334890). • Additional information: Any additional information required to reanalyze the data reported in this paper is available from the lead contact upon request.

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

  • Authors: added Dario Cupolillo (0000-0002-1517-3815); removed Dario Cupolillo

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 4 authors, 7 keywords, 1 funder, 63 references, 15 RRIDs.

Cite

This paper

Cupolillo, D., Regio, V., Galleano, V., & Barberis, A. (2026). Deep learning-assisted mapping of dendritic spines using sequential 2D two-photon calcium imaging. iScience, 29(8), 117010. https://doi.org/10.1016/j.isci.2026.117010

BibTeX

@article{cupolillo2026deep,
author = {Cupolillo, Dario and Regio, Vincenzo and Galleano, Valentina and Barberis, Andrea},
title = {{Deep learning-assisted mapping of dendritic spines using sequential 2D two-photon calcium imaging}},
journal = {iScience},
year = {2026},
month = aug,
volume = {29},
number = {8},
pages = {117010},
publisher = {Elsevier},
issn = {2589-0042},
doi = {10.1016/j.isci.2026.117010},
url = {https://doi.org/10.1016/j.isci.2026.117010},
pmid = {42577014},
pmcid = {PMC13453581}
}

RIS

TY - JOUR
AU - Cupolillo, Dario
AU - Regio, Vincenzo
AU - Galleano, Valentina
AU - Barberis, Andrea
TI - Deep learning-assisted mapping of dendritic spines using sequential 2D two-photon calcium imaging
T2 - iScience
J2 - iScience
PY - 2026
DA - 2026/08/01
VL - 29
IS - 8
SP - 117010
SN - 2589-0042
PB - Elsevier
DO - 10.1016/j.isci.2026.117010
UR - https://doi.org/10.1016/j.isci.2026.117010
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.isci.2026.117010",
"type": "article-journal",
"title": "Deep learning-assisted mapping of dendritic spines using sequential 2D two-photon calcium imaging",
"container-title": "iScience",
"author": [
{
"family": "Cupolillo",
"given": "Dario"
},
{
"family": "Regio",
"given": "Vincenzo"
},
{
"family": "Galleano",
"given": "Valentina"
},
{
"family": "Barberis",
"given": "Andrea"
}
],
"container-title-short": "iScience",
"volume": "29",
"issue": "8",
"page": "117010",
"DOI": "10.1016/j.isci.2026.117010",
"PMID": "42577014",
"PMCID": "PMC13453581",
"ISSN": "2589-0042",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.isci.2026.117010",
"language": "en",
"issued": {
"date-parts": [
[
2026,
8,
1
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1016/j.celrep.2026.117793 [code]
Clustered inputs engage dendritic nonlinearities and calcium signaling to support efficient place-field formation in CA1 pyramidal neurons.
Journal: Cell reports
In common: seaborn, scikit-learn, pandas, 3 other tools, cellular / molecular, 11 references
[2] doi:10.1126/sciadv.aec3961 [code]
Linking functional and structural dendritic spine remodeling during fear learning and extinction in vivo.
Journal: Science advances
In common: pandas, SciPy, Matplotlib, 1 other tool, histology / microscopy, 9 references
[3] doi:10.1126/sciadv.adz4123 [code]
Highly attenuated dendritic propagation of isolated synaptic potentials in vivo.
Journal: Science advances
In common: cellular / molecular, 11 references
[4] doi:10.1371/journal.pcbi.1014571 [code]
SynAPSeg: A novel dataset and image analysis framework for deep learning-based synapse detection and quantification.
Journal: PLoS computational biology
In common: tifffile, TensorFlow, OpenCV, 8 other tools, 2 references
[5] doi:10.1073/pnas.2533168123 [code]
Dendritic morphology and synaptic nonlinearities enhance functional complexity in human cortical neurons.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: PyTorch, scikit-learn, pandas, 3 other tools, cellular / molecular, 7 references
[6] doi:10.7554/elife.111876 [code]
Distinct sensorimotor encoding in tuft dendrites and somata associated with action, correction, and learning.
Journal: eLife
In common: tifffile, PyTorch, seaborn, 5 other tools, 5 references
[7] doi:10.7554/elife.89629 [code]
Active dendrites enable robust spiking computations despite timing jitter.
Journal: eLife
In common: seaborn, pandas, Matplotlib, 1 other tool, 8 references
[8] doi:10.1016/j.bpj.2026.06.005 [code]
Curvature-based machine-learning method for automated segmentation of dendritic spines.
Journal: Biophysical journal
In common: TensorFlow, scikit-image, scikit-learn, 4 other tools, histology / microscopy, 3 references
[9] doi:10.7554/elife.108352 [code]
Analysis of dendritic input currents during place field dynamics.
Journal: eLife
In common: pandas, Matplotlib, NumPy, 7 references
[10] doi:10.7554/elife.100880 [code]
An applicable and efficient retrograde monosynaptic circuit mapping tool for larval zebrafish.
Journal: eLife
In common: tifffile, OpenCV, scikit-image, 6 other tools, 2 references

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

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