OSCR

Deep visual proteomics uncovers nociceptor diversity and pain targets.

Code ↔ Paper

The paper beside its authors' code: matches between them have not been computed for this paper yet.

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

Jupyter notebook · 573 lines · 22 KB · Apache-2.0

  1. # %% [markdown]
  2. # This notebook is an adaptation of the ["Cellpose (2D and 3D)" notebook from ZeroCostDL4Mic](https://colab.research.google.com/github/HenriquesLab/ZeroCostDL4Mic/blob/master/Colab_notebooks/Beta%20notebooks/Cellpose_2D_ZeroCostDL4Mic.ipynb)
  4. # %% [markdown]
  5. # # Installation
  6. # If you are missing dependencies, these are the ones needed to run this notebook. Uncomment the line as needed
  8. # %%
  9. #!pip install numpy==1.19.3 numba==0.53.1 scikit-image==0.19.3 scikit-learn==1.1.1 opencv-python==4.6.0.66 matplotlib==3.5.2 pandas==1.4.3 tqdm==4.64.0 astropy==5.1 tabulate==0.8.10
  11. # %% [markdown]
  12. # # All imports and functions
  14. # %%
  15. import csv
  16. import cv2
  17. import matplotlib as mpl
  18. import numpy as np
  19. import os
  20. import pandas as pd
  21. import random
  22. import shutil
  23. import subprocess
  24. import sys
  25. import time
  26. import urllib
  27. import zipfile
  29. from astropy.visualization import simple_norm
  31. from collections import namedtuple
  33. from datetime import datetime
  35. from glob import glob
  37. from matplotlib import pyplot as plt
  39. from numba import jit
  41. from pathlib import Path
  43. from pip._internal.operations.freeze import freeze
  45. from scipy import signal, ndimage
  46. from scipy.optimize import linear_sum_assignment
  48. from skimage import io
  49. from skimage.metrics import structural_similarity
  50. from skimage.metrics import peak_signal_noise_ratio as psnr
  51. from skimage.util import img_as_ubyte, img_as_uint, img_as_float32
  53. from sklearn.linear_model import LinearRegression
  55. from tabulate import tabulate
  57. from tifffile import imread, imsave
  59. from tqdm import tqdm
  61. from zipfile import ZIP_DEFLATED
  63. from IPython.display import HTML
  64. from IPython.display import display
  66. matching_criteria = dict()
  68. def label_are_sequential(y):
  69. """ returns true if y has only sequential labels from 1... """
  70. labels = np.unique(y)
  71. return (set(labels)-{0}) == set(range(1,1+labels.max()))
  74. def is_array_of_integers(y):
  75. return isinstance(y,np.ndarray) and np.issubdtype(y.dtype, np.integer)
  78. def _check_label_array(y, name=None, check_sequential=False):
  79. err = ValueError("{label} must be an array of {integers}.".format(
  80. label = 'labels' if name is None else name,
  81. integers = ('sequential ' if check_sequential else '') + 'non-negative integers',
  82. ))
  83. is_array_of_integers(y) or print("An error occured")
  84. if check_sequential:
  85. label_are_sequential(y) or print("An error occured")
  86. else:
  87. y.min() >= 0 or print("An error occured")
  88. return True
  91. def label_overlap(x, y, check=True):
  92. if check:
  93. _check_label_array(x,'x',True)
  94. _check_label_array(y,'y',True)
  95. x.shape == y.shape or _raise(ValueError("x and y must have the same shape"))
  96. return _label_overlap(x, y)
  98. @jit(nopython=True)
  99. def _label_overlap(x, y):
  100. x = x.ravel()
  101. y = y.ravel()
  102. overlap = np.zeros((1+x.max(),1+y.max()), dtype=np.uint)
  103. for i in range(len(x)):
  104. overlap[x[i],y[i]] += 1
  105. return overlap
  108. def intersection_over_union(overlap):
  109. _check_label_array(overlap,'overlap')
  110. if np.sum(overlap) == 0:
  111. return overlap
  112. n_pixels_pred = np.sum(overlap, axis=0, keepdims=True)
  113. n_pixels_true = np.sum(overlap, axis=1, keepdims=True)
  114. return overlap / (n_pixels_pred + n_pixels_true - overlap)
  116. matching_criteria['iou'] = intersection_over_union
  119. def intersection_over_true(overlap):
  120. _check_label_array(overlap,'overlap')
  121. if np.sum(overlap) == 0:
  122. return overlap
  123. n_pixels_true = np.sum(overlap, axis=1, keepdims=True)
  124. return overlap / n_pixels_true
  126. matching_criteria['iot'] = intersection_over_true
  129. def intersection_over_pred(overlap):
  130. _check_label_array(overlap,'overlap')
  131. if np.sum(overlap) == 0:
  132. return overlap
  133. n_pixels_pred = np.sum(overlap, axis=0, keepdims=True)
  134. return overlap / n_pixels_pred
  136. matching_criteria['iop'] = intersection_over_pred
  139. def precision(tp,fp,fn):
  140. return tp/(tp+fp) if tp > 0 else 0
  141. def recall(tp,fp,fn):
  142. return tp/(tp+fn) if tp > 0 else 0
  143. def accuracy(tp,fp,fn):
  144. # also known as "average precision" (?)
  145. # -> https://www.kaggle.com/c/data-science-bowl-2018#evaluation
  146. return tp/(tp+fp+fn) if tp > 0 else 0
  147. def f1(tp,fp,fn):
  148. # also known as "dice coefficient"
  149. return (2*tp)/(2*tp+fp+fn) if tp > 0 else 0
  152. def _safe_divide(x,y):
  153. return x/y if y>0 else 0.0
  155. def matching(y_true, y_pred, thresh=0.5, criterion='iou', report_matches=False):
  156. """Calculate detection/instance segmentation metrics between ground truth and predicted label images.
  157. Currently, the following metrics are implemented:
  158. 'fp', 'tp', 'fn', 'precision', 'recall', 'accuracy', 'f1', 'criterion', 'thresh', 'n_true', 'n_pred', 'mean_true_score', 'mean_matched_score', 'panoptic_quality'
  159. Corresponding objects of y_true and y_pred are counted as true positives (tp), false positives (fp), and false negatives (fn)
  160. whether their intersection over union (IoU) >= thresh (for criterion='iou', which can be changed)
  161. * mean_matched_score is the mean IoUs of matched true positives
  162. * mean_true_score is the mean IoUs of matched true positives but normalized by the total number of GT objects
  163. * panoptic_quality defined as in Eq. 1 of Kirillov et al. "Panoptic Segmentation", CVPR 2019
  164. Parameters
  165. ----------
  166. y_true: ndarray
  167. ground truth label image (integer valued)
  168. predicted label image (integer valued)
  169. thresh: float
  170. threshold for matching criterion (default 0.5)
  171. criterion: string
  172. matching criterion (default IoU)
  173. report_matches: bool
  174. if True, additionally calculate matched_pairs and matched_scores (note, that this returns even gt-pred pairs whose scores are below 'thresh')
  175. Returns
  176. -------
  177. Matching object with different metrics as attributes
  178. Examples
  179. --------
  180. >>> y_true = np.zeros((100,100), np.uint16)
  181. >>> y_true[10:20,10:20] = 1
  182. >>> y_pred = np.roll(y_true,5,axis = 0)
  183. >>> stats = matching(y_true, y_pred)
  184. >>> print(stats)
  185. Matching(criterion='iou', thresh=0.5, fp=1, tp=0, fn=1, precision=0, recall=0, accuracy=0, f1=0, n_true=1, n_pred=1, mean_true_score=0.0, mean_matched_score=0.0, panoptic_quality=0.0)
  186. """
  187. _check_label_array(y_true,'y_true')
  188. _check_label_array(y_pred,'y_pred')
  189. y_true.shape == y_pred.shape or _raise(ValueError("y_true ({y_true.shape}) and y_pred ({y_pred.shape}) have different shapes".format(y_true=y_true, y_pred=y_pred)))
  190. criterion in matching_criteria or _raise(ValueError("Matching criterion '%s' not supported." % criterion))
  191. if thresh is None: thresh = 0
  192. thresh = float(thresh) if np.isscalar(thresh) else map(float,thresh)
  194. y_true, _, map_rev_true = relabel_sequential(y_true)
  195. y_pred, _, map_rev_pred = relabel_sequential(y_pred)
  197. overlap = label_overlap(y_true, y_pred, check=False)
  198. scores = matching_criteria[criterion](overlap)
  199. assert 0 <= np.min(scores) <= np.max(scores) <= 1
  201. # ignoring background
  202. scores = scores[1:,1:]
  203. n_true, n_pred = scores.shape
  204. n_matched = min(n_true, n_pred)
  206. def _single(thr):
  207. not_trivial = n_matched > 0 and np.any(scores >= thr)
  208. if not_trivial:
  209. # compute optimal matching with scores as tie-breaker
  210. costs = -(scores >= thr).astype(float) - scores / (2*n_matched)
  211. true_ind, pred_ind = linear_sum_assignment(costs)
  212. assert n_matched == len(true_ind) == len(pred_ind)
  213. match_ok = scores[true_ind,pred_ind] >= thr
  214. tp = np.count_nonzero(match_ok)
  215. else:
  216. tp = 0
  217. fp = n_pred - tp
  218. fn = n_true - tp
  219. # assert tp+fp == n_pred
  220. # assert tp+fn == n_true
  222. # the score sum over all matched objects (tp)
  223. sum_matched_score = np.sum(scores[true_ind,pred_ind][match_ok]) if not_trivial else 0.0
  225. # the score average over all matched objects (tp)
  226. mean_matched_score = _safe_divide(sum_matched_score, tp)
  227. # the score average over all gt/true objects
  228. mean_true_score = _safe_divide(sum_matched_score, n_true)
  229. panoptic_quality = _safe_divide(sum_matched_score, tp+fp/2+fn/2)
  231. stats_dict = dict (
  232. criterion = criterion,
  233. thresh = thr,
  234. fp = fp,
  235. tp = tp,
  236. fn = fn,
  237. precision = precision(tp,fp,fn),
  238. recall = recall(tp,fp,fn),
  239. accuracy = accuracy(tp,fp,fn),
  240. f1 = f1(tp,fp,fn),
  241. n_true = n_true,
  242. n_pred = n_pred,
  243. mean_true_score = mean_true_score,
  244. mean_matched_score = mean_matched_score,
  245. panoptic_quality = panoptic_quality,
  246. )
  247. if bool(report_matches):
  248. if not_trivial:
  249. stats_dict.update (
  250. # int() to be json serializable
  251. matched_pairs = tuple((int(map_rev_true[i]),int(map_rev_pred[j])) for i,j in zip(1+true_ind,1+pred_ind)),
  252. matched_scores = tuple(scores[true_ind,pred_ind]),
  253. matched_tps = tuple(map(int,np.flatnonzero(match_ok))),
  254. )
  255. else:
  256. stats_dict.update (
  257. matched_pairs = (),
  258. matched_scores = (),
  259. matched_tps = (),
  260. )
  261. return namedtuple('Matching',stats_dict.keys())(*stats_dict.values())
  263. return _single(thresh) if np.isscalar(thresh) else tuple(map(_single,thresh))
  267. def matching_dataset(y_true, y_pred, thresh=0.5, criterion='iou', by_image=False, show_progress=True, parallel=False):
  268. """matching metrics for list of images, see `stardist.matching.matching`
  269. """
  270. len(y_true) == len(y_pred) or _raise(ValueError("y_true and y_pred must have the same length."))
  271. return matching_dataset_lazy (
  272. tuple(zip(y_true,y_pred)), thresh=thresh, criterion=criterion, by_image=by_image, show_progress=show_progress, parallel=parallel,
  273. )
  277. def matching_dataset_lazy(y_gen, thresh=0.5, criterion='iou', by_image=False, show_progress=True, parallel=False):
  279. expected_keys = set(('fp', 'tp', 'fn', 'precision', 'recall', 'accuracy', 'f1', 'criterion', 'thresh', 'n_true', 'n_pred', 'mean_true_score', 'mean_matched_score', 'panoptic_quality'))
  281. single_thresh = False
  282. if np.isscalar(thresh):
  283. single_thresh = True
  284. thresh = (thresh,)
  286. tqdm_kwargs = {}
  287. tqdm_kwargs['disable'] = not bool(show_progress)
  288. if int(show_progress) > 1:
  289. tqdm_kwargs['total'] = int(show_progress)
  291. # compute matching stats for every pair of label images
  292. if parallel:
  293. from concurrent.futures import ThreadPoolExecutor
  294. fn = lambda pair: matching(*pair, thresh=thresh, criterion=criterion, report_matches=False)
  295. with ThreadPoolExecutor() as pool:
  296. stats_all = tuple(pool.map(fn, tqdm(y_gen,**tqdm_kwargs)))
  297. else:
  298. stats_all = tuple (
  299. matching(y_t, y_p, thresh=thresh, criterion=criterion, report_matches=False)
  300. for y_t,y_p in tqdm(y_gen,**tqdm_kwargs)
  301. )
  303. # accumulate results over all images for each threshold separately
  304. n_images, n_threshs = len(stats_all), len(thresh)
  305. accumulate = [{} for _ in range(n_threshs)]
  306. for stats in stats_all:
  307. for i,s in enumerate(stats):
  308. acc = accumulate[i]
  309. for k,v in s._asdict().items():
  310. if k == 'mean_true_score' and not bool(by_image):
  311. # convert mean_true_score to "sum_matched_score"
  312. acc[k] = acc.setdefault(k,0) + v * s.n_true
  313. else:
  314. try:
  315. acc[k] = acc.setdefault(k,0) + v
  316. except TypeError:
  317. pass
  319. # normalize/compute 'precision', 'recall', 'accuracy', 'f1'
  320. for thr,acc in zip(thresh,accumulate):
  321. set(acc.keys()) == expected_keys or _raise(ValueError("unexpected keys"))
  322. acc['criterion'] = criterion
  323. acc['thresh'] = thr
  324. acc['by_image'] = bool(by_image)
  325. if bool(by_image):
  326. for k in ('precision', 'recall', 'accuracy', 'f1', 'mean_true_score', 'mean_matched_score', 'panoptic_quality'):
  327. acc[k] /= n_images
  328. else:
  329. tp, fp, fn, n_true = acc['tp'], acc['fp'], acc['fn'], acc['n_true']
  330. sum_matched_score = acc['mean_true_score']
  332. mean_matched_score = _safe_divide(sum_matched_score, tp)
  333. mean_true_score = _safe_divide(sum_matched_score, n_true)
  334. panoptic_quality = _safe_divide(sum_matched_score, tp+fp/2+fn/2)
  336. acc.update(
  337. precision = precision(tp,fp,fn),
  338. recall = recall(tp,fp,fn),
  339. accuracy = accuracy(tp,fp,fn),
  340. f1 = f1(tp,fp,fn),
  341. mean_true_score = mean_true_score,
  342. mean_matched_score = mean_matched_score,
  343. panoptic_quality = panoptic_quality,
  344. )
  346. accumulate = tuple(namedtuple('DatasetMatching',acc.keys())(*acc.values()) for acc in accumulate)
  347. return accumulate[0] if single_thresh else accumulate
  351. # copied from scikit-image master for now (remove when part of a release)
  352. def relabel_sequential(label_field, offset=1):
  353. """Relabel arbitrary labels to {`offset`, ... `offset` + number_of_labels}.
  354. This function also returns the forward map (mapping the original labels to
  355. the reduced labels) and the inverse map (mapping the reduced labels back
  356. to the original ones).
  357. Parameters
  358. ----------
  359. label_field : numpy array of int, arbitrary shape
  360. An array of labels, which must be non-negative integers.
  361. offset : int, optional
  362. The return labels will start at `offset`, which should be
  363. strictly positive.
  364. Returns
  365. -------
  366. relabeled : numpy array of int, same shape as `label_field`
  367. The input label field with labels mapped to
  368. {offset, ..., number_of_labels + offset - 1}.
  369. The data type will be the same as `label_field`, except when
  370. offset + number_of_labels causes overflow of the current data type.
  371. forward_map : numpy array of int, shape ``(label_field.max() + 1,)``
  372. The map from the original label space to the returned label
  373. space. Can be used to re-apply the same mapping. See examples
  374. for usage. The data type will be the same as `relabeled`.
  375. inverse_map : 1D numpy array of int, of length offset + number of labels
  376. The map from the new label space to the original space. This
  377. can be used to reconstruct the original label field from the
  378. relabeled one. The data type will be the same as `relabeled`.
  379. Notes
  380. -----
  381. The label 0 is assumed to denote the background and is never remapped.
  382. The forward map can be extremely big for some inputs, since its
  383. length is given by the maximum of the label field. However, in most
  384. situations, ``label_field.max()`` is much smaller than
  385. ``label_field.size``, and in these cases the forward map is
  386. guaranteed to be smaller than either the input or output images.
  387. Examples
  388. --------
  389. >>> from skimage.segmentation import relabel_sequential
  390. >>> label_field = np.array([1, 1, 5, 5, 8, 99, 42])
  391. >>> relab, fw, inv = relabel_sequential(label_field)
  392. >>> relab
  393. array([1, 1, 2, 2, 3, 5, 4])
  394. >>> fw
  395. array([0, 1, 0, 0, 0, 2, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  396. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0,
  397. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  398. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  399. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5])
  400. >>> inv
  401. array([ 0, 1, 5, 8, 42, 99])
  402. >>> (fw[label_field] == relab).all()
  403. True
  404. >>> (inv[relab] == label_field).all()
  405. True
  406. >>> relab, fw, inv = relabel_sequential(label_field, offset=5)
  407. >>> relab
  408. array([5, 5, 6, 6, 7, 9, 8])
  409. """
  410. offset = int(offset)
  411. if offset <= 0:
  412. raise ValueError("Offset must be strictly positive.")
  413. if np.min(label_field) < 0:
  414. raise ValueError("Cannot relabel array that contains negative values.")
  415. max_label = int(label_field.max()) # Ensure max_label is an integer
  416. if not np.issubdtype(label_field.dtype, np.integer):
  417. new_type = np.min_scalar_type(max_label)
  418. label_field = label_field.astype(new_type)
  419. labels = np.unique(label_field)
  420. labels0 = labels[labels != 0]
  421. new_max_label = offset - 1 + len(labels0)
  422. new_labels0 = np.arange(offset, new_max_label + 1)
  423. output_type = label_field.dtype
  424. required_type = np.min_scalar_type(new_max_label)
  425. if np.dtype(required_type).itemsize > np.dtype(label_field.dtype).itemsize:
  426. output_type = required_type
  427. forward_map = np.zeros(max_label + 1, dtype=output_type)
  428. forward_map[labels0] = new_labels0
  429. inverse_map = np.zeros(new_max_label + 1, dtype=output_type)
  430. inverse_map[offset:] = labels0
  431. relabeled = forward_map[label_field]
  432. return relabeled, forward_map, inverse_map
  440. # ------------- For display ------------
  441. def showQCResults( model, image_folder ):
  443. image_folder = Path(image_folder)
  445. # Grab all tif images
  446. raw_images = [x for x in Path(image_folder).glob("*.tif") if not ( "masks" in x.name or "flows" in x.name )]
  447. gt_images = [x for x in Path(image_folder).glob("*.tif") if ( "masks" in x.name and not "cp_masks" in x.name )]
  448. pred_images = [x for x in Path(image_folder).glob("*.tif") if ( "cp_masks" in x.name )]
  450. # Define save folder from the parent of the predicted_labels_folder
  451. results_path = image_folder / "QC-Results"
  454. # Plot for each image
  455. for raw, gt, pred in zip(raw_images, gt_images, pred_images):
  456. print( 'Running QC on: ' + raw.name + " with model : "+model)
  458. plt.figure(figsize=(25,5))
  459. source_image = io.imread( raw )
  461. target_image = io.imread( gt , as_gray = True)
  462. prediction = io.imread( pred, as_gray = True)
  464. stats = matching(prediction, target_image, thresh=0.5)
  466. target_image_mask = np.empty_like(target_image)
  467. target_image_mask[target_image > 0] = 255
  468. target_image_mask[target_image == 0] = 0
  470. prediction_mask = np.empty_like(prediction)
  471. prediction_mask[prediction > 0] = 255
  472. prediction_mask[prediction == 0] = 0
  474. intersection = np.logical_and(target_image_mask, prediction_mask)
  475. union = np.logical_or(target_image_mask, prediction_mask)
  476. iou_score = np.sum(intersection) / np.sum(union)
  478. norm = simple_norm(source_image, percent = 99)
  480. #Input
  481. plt.subplot(1,4,1)
  482. plt.axis('off')
  483. plt.imshow(source_image)
  485. plt.title( raw.name )
  487. #Ground-truth
  488. plt.subplot(1,4,2)
  489. plt.axis('off')
  490. plt.imshow(target_image_mask, aspect='equal', cmap='Greens')
  491. plt.title('Ground Truth')
  493. #Prediction
  494. plt.subplot(1,4,3)
  495. plt.axis('off')
  496. plt.imshow(prediction_mask, aspect='equal', cmap='Purples')
  497. plt.title('Prediction')
  499. #Overlay
  500. plt.subplot(1,4,4)
  501. plt.axis('off')
  502. plt.imshow(target_image_mask, cmap='Greens')
  503. plt.imshow(prediction_mask, alpha=0.5, cmap='Purples')
  504. plt.title('Ground Truth and Prediction, Intersection over Union:'+str(round(iou_score,3 )));
  505. plt.savefig(results_path / (model+"_"+raw.name.replace(".tif",".png")),bbox_inches='tight',pad_inches=0)
  508. # Here we start testing the differences between GT and predicted label images
  509. def compareLabels( model_name, image_folder ):
  511. image_folder = Path(image_folder)
  512. # Grab all tif images
  513. raw_images = [x for x in Path(image_folder).glob("*.tif") if not ( "masks" in x.name or "flows" in x.name )]
  514. gt_images = [x for x in Path(image_folder).glob("*.tif") if ( "masks" in x.name and not "cp_masks" in x.name )]
  515. pred_images = [x for x in Path(image_folder).glob("*.tif") if ( "cp_masks" in x.name )]
  517. # Define save folder from the parent of the predicted_labels_folder
  518. results_path = image_folder / "QC-Results"
  520. # Make the directory if it's missing
  521. results_path.absolute().mkdir( exist_ok=True )
  523. with open(results_path / ( "Quality_Control for "+model_name+".csv" ), "w", newline='') as file:
  524. writer = csv.writer(file, delimiter=",")
  526. writer.writerow(["model","image","Prediction v. GT Intersection over Union", "false positive", "true positive", "false negative", "precision", "recall", "accuracy", "f1 score", "n_true", "n_pred", "mean_true_score", "mean_matched_score", "panoptic_quality"])
  528. # define the images
  529. for raw, gt, pred in zip(raw_images, gt_images, pred_images):
  530. print( 'Running QC on: ' + raw.name )
  531. test_input = io.imread(raw)
  532. test_prediction = io.imread(pred)
  533. test_ground_truth_image = io.imread(gt)
  535. # Calculate the matching (with IoU threshold `thresh`) and all metrics
  537. stats = matching(test_ground_truth_image, test_prediction, thresh=0.5)
  539. #Convert pixel values to 0 or 255
  540. test_prediction_0_to_255 = test_prediction
  541. test_prediction_0_to_255[test_prediction_0_to_255>0] = 255
  543. #Convert pixel values to 0 or 255
  544. test_ground_truth_0_to_255 = test_ground_truth_image
  545. test_ground_truth_0_to_255[test_ground_truth_0_to_255>0] = 255
  548. # Intersection over Union metric
  549. intersection = np.logical_and(test_ground_truth_0_to_255, test_prediction_0_to_255)
  550. union = np.logical_or(test_ground_truth_0_to_255, test_prediction_0_to_255)
  551. iou_score = np.sum(intersection) / np.sum(union)
  552. writer.writerow([model_name, raw, str(iou_score), str(stats.fp), str(stats.tp), str(stats.fn), str(stats.precision), str(stats.recall), str(stats.accuracy), str(stats.f1), str(stats.n_true), str(stats.n_pred), str(stats.mean_true_score), str(stats.mean_matched_score), str(stats.panoptic_quality)])
  555. df = pd.read_csv (results_path / ( "Quality_Control for "+model_name+".csv" ))
  556. display(tabulate(df, headers='keys', tablefmt="html"))
  560. # %% [markdown]
  561. # # Open Images and Compute QC Metrics
  563. # %%
  564. data_folder = "../Cellpose Training Folder/test"
  566. model_name = "cellpose_residual_on_style_on_concatenation_off_train_2021_10_28_11_33_45.741069"
  568. compareLabels(model_name, data_folder)
  570. showQCResults(model_name, data_folder)
  572. # %%

Quality Control-Cellpose.ipynb at commit 5d14816, under Apache-2.0 · at the source

Overview

Authors: Sampurna Chakrabarti1,2, Anuar Makhmut3,4, Atena Mohammadi1, Wenhan Luo1, Lin Wang1, Gary R Lewin1,4,5, Fabian Coscia3,6
ORCID iDs: Sampurna Chakrabarti, Anuar Makhmut, Wenhan Luo, Lin Wang, Gary R Lewin, Fabian Coscia
  1. Max-Delbrück-Center for Molecular Medicine in the Helmholtz Association (MDC), Molecular Physiology of Somatic Sensation Laboratory, 13125 Berlin, Germany
  2. Helmholtz Centre for Infection Research (HZI), Pathways in Infection and Nociception (PAIN) Group, 38124 Braunschweig, Germany
  3. Max-Delbrück-Center for Molecular Medicine in the Helmholtz Association (MDC), Spatial Proteomics Group, 13125 Berlin, Germany
  4. Charité-Universitätsmedizin Berlin, Charitéplatz 1, 10117 Berlin, Germany
  5. German Center for Mental Health (DZPG), Partner Site Berlin, Berlin, Germany
  6. German Cancer Consortium (DKTK), Partner Site Berlin, Heidelberg, Germany
Institutions: Max Delbrück Center (Germany); Helmholtz Centre for Infection Research (Germany); Charité - Universitätsmedizin Berlin (Germany); Deutsches Zentrum für Psychische Gesundheit (Germany); Deutsches Konsortium für Translationale Krebsforschung (Germany)
Journal: Nature communications, volume 17, issue 1, article 3437
Dates: received 12 February 2026; accepted 19 March 2026; published online 11 April 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1038/s41467-026-71418-8 · PMID 41965357 · PMCID PMC13076600 · OpenAlex W7153557317
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: genetics / omics (modality), mouse (organism), pain (population), cellular / molecular (subfield)
Methods: Spectral & time-frequency, Statistics, Machine learning, Preprocessing, Connectivity
Keywords: Somatosensory system, Chronic pain
MeSH: Nociceptors*, Pain*, Proteome*, Proteomics*, Animals, Ganglia, Spinal, Male, Mice, Mice, Inbred C57BL, Nerve Growth Factor, Protein Kinase C, Sensory Receptor Cells, Transcriptome (* major topic)
Topic: Pain Mechanisms and Treatments (Physiology, Medicine), according to OpenAlex
Funding: European Research Council (101142488, 101115681); Bundesministerium für Bildung und Forschung (Federal Ministry of Education and Research) (161L0222)
Citations: cited by 2 papers (Europe PMC); 66 references in the paper

Abstract

The richness of our somatosensory experience is reflected in the functional diversity of somatic sensory neurons. Single-cell RNA sequencing of sensory neurons has revealed a molecular basis for such diversity1–3. However, sensory neuron diversity has yet to be captured at the level of the proteome. Here, we combined electrophysiology with deep visual proteomics 4 to quantify over 6000 proteins from phenotypically-defined sensory neurons in mice and identified proteomic markers of sensory neuron subtypes. Comparative analysis revealed both concordance and meaningful divergence between transcriptomes and proteomes. We further show that up to 3000 proteins can be quantified from one-fourth of a single neuron, demonstrating subset-specific protein signatures. In culture, nociceptive neurons can be acutely sensitized to mechanical stimuli by nerve growth factor (NGF) which normally drives inflammatory pain in vivo5. Indeed, overnight exposure of peptidergic nociceptors to NGF and a protein kinase C (PKC) activator produced functional sensitization associated with proteome changes. Functional knockdown experiments identified the up-regulated B3GNT2 enzyme as a potential effector of nociceptor sensitization. In summary, we present a high-resolution proteomic resource linking molecular identity to function, enabling the discovery of mechanisms underlying somatic sensation and pain sensitization.

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

Repositories

Its files are read in the Code ↔ Paper reader above.

BIOP/qupath-extension-cellpose

License: Apache-2.0
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: 5d1481674b467bb4a590cc7d39b29f58fe40c287, 6 July 2026
Languages: JavaScript (10), Java (6), Jupyter (1), Python (1)
Size: 109 files, 18 scripts
Software Heritage: archived
Found in: the text, “Image segmentation”
Holds: README, license file, continuous integration, documentation, 1 notebook
Not found: CITATION.cff, environment file, tests
Tools: NumPy (2 files), scikit-image (2 files), SciPy (2 files), Matplotlib (1 file), Numba (1 file), OpenCV (1 file), pandas (1 file), scikit-learn (1 file), tifffile (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
20 files
At the source: github.com/BIOP/qupath-extension-cellpose

CosciaLab/Qupath_to_LMD

License: GPL-3.0
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: 32df199eea7595a465a880ed99fd15e172c4e4a6, 27 August 2026
Languages: Python (30)
Size: 75 files, 30 scripts
Software Heritage: not archived
Found in: the text, “Image segmentation”
Holds: README, license file, environment (pyproject.toml, requirements.txt, uv.lock), tests, continuous integration
Not found: CITATION.cff, documentation
Tools: NumPy (10 files), pandas (10 files), Matplotlib (2 files)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
32 files
At the source: github.com/CosciaLab/Qupath_to_LMD

Code availability

The code used for analysis and plots were adapted from standard R packages as detailed in the Methods section. More detailed information is available upon request.

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

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;
  • 48 scripts, each with its path and the digest of its content;
  • no match between paragraphs and code yet;
  • 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 availability

The mass spectrometry proteomics data have been deposited to the ProteomeXchange Consortium via the PRIDE partner repository66 with the dataset identifier PXD070495 (https://www.ebi.ac.uk/pride/archive). Source data are provided in this paper.

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

Recorded: type, language, journal, volume, issue, pages, dates, 7 authors, 2 keywords, 13 MeSH terms, 2 funders, 64 references.

Cite

This paper

Chakrabarti, S., Makhmut, A., Mohammadi, A., Luo, W., Wang, L., Lewin, G. R., & Coscia, F. (2026). Deep visual proteomics uncovers nociceptor diversity and pain targets. Nature communications, 17(1), 3437. https://doi.org/10.1038/s41467-026-71418-8

BibTeX

@article{chakrabarti2026deep,
author = {Chakrabarti, Sampurna and Makhmut, Anuar and Mohammadi, Atena and Luo, Wenhan and Wang, Lin and Lewin, Gary R and Coscia, Fabian},
title = {{Deep visual proteomics uncovers nociceptor diversity and pain targets}},
journal = {Nature communications},
year = {2026},
month = apr,
volume = {17},
number = {1},
pages = {3437},
publisher = {Nature Publishing Group},
issn = {2041-1723},
doi = {10.1038/s41467-026-71418-8},
url = {https://doi.org/10.1038/s41467-026-71418-8},
pmid = {41965357},
pmcid = {PMC13076600}
}

RIS

TY - JOUR
AU - Chakrabarti, Sampurna
AU - Makhmut, Anuar
AU - Mohammadi, Atena
AU - Luo, Wenhan
AU - Wang, Lin
AU - Lewin, Gary R
AU - Coscia, Fabian
TI - Deep visual proteomics uncovers nociceptor diversity and pain targets
T2 - Nature communications
J2 - Nat Commun
PY - 2026
DA - 2026/04/11
VL - 17
IS - 1
SP - 3437
SN - 2041-1723
PB - Nature Publishing Group
DO - 10.1038/s41467-026-71418-8
UR - https://doi.org/10.1038/s41467-026-71418-8
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41467-026-71418-8",
"type": "article-journal",
"title": "Deep visual proteomics uncovers nociceptor diversity and pain targets",
"container-title": "Nature communications",
"author": [
{
"family": "Chakrabarti",
"given": "Sampurna"
},
{
"family": "Makhmut",
"given": "Anuar"
},
{
"family": "Mohammadi",
"given": "Atena"
},
{
"family": "Luo",
"given": "Wenhan"
},
{
"family": "Wang",
"given": "Lin"
},
{
"family": "Lewin",
"given": "Gary R"
},
{
"family": "Coscia",
"given": "Fabian"
}
],
"container-title-short": "Nat Commun",
"volume": "17",
"issue": "1",
"page": "3437",
"DOI": "10.1038/s41467-026-71418-8",
"PMID": "41965357",
"PMCID": "PMC13076600",
"ISSN": "2041-1723",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41467-026-71418-8",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
11
]
]
}
}

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.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, Numba, OpenCV, 6 other tools, 2 references
[2] doi:10.1016/j.xcrm.2026.102766 [code]
A longitudinal single-cell and spatial multiomic atlas of pediatric high-grade glioma.
Journal: Cell reports. Medicine
In common: tifffile, Numba, OpenCV, 6 other tools, genetics / omics, cellular / molecular, 1 reference
[3] doi: [code]
Real-time closed-loop feedback system for mouse mesoscale cortical signal and movement control
Journal: eLife
In common: tifffile, Numba, OpenCV, 6 other tools, mouse
[4] doi:10.7554/elife.109717 [code]
Retrosplenial cortex enables context-dependent goal-directed sensorimotor transformation.
Journal: eLife
In common: tifffile, Numba, OpenCV, 6 other tools, mouse
[5] 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, Numba, OpenCV, 6 other tools, mouse
[6] doi:10.1038/s41467-026-73373-w [code]
Mapping neuro-vascular unit communications reveals distinct angiogenic programs across developing mouse brain regions.
Journal: Nature communications
In common: tifffile, OpenCV, scikit-image, 5 other tools, genetics / omics, mouse, 1 reference
[7] doi:10.7554/elife.100880 [code]
An applicable and efficient retrograde monosynaptic circuit mapping tool for larval zebrafish.
Journal: eLife
In common: tifffile, Numba, OpenCV, 6 other tools
[8] doi:10.1002/advs.202515887 [code]
An Open-Source Pipeline for Calcium Imaging and All-Optical Physiology in Human Stem Cell-Derived Neurons.
Journal: Advanced science (Weinheim, Baden-Wurttemberg, Germany)
In common: tifffile, Numba, scikit-image, 5 other tools, 1 reference
[9] doi:10.1038/s41467-026-71458-0 [code]
Early differential impact of MeCP2 mutations on functional networks in Rett syndrome patient-derived human cortical organoids.
Journal: Nature communications
In common: tifffile, Numba, OpenCV, 5 other tools, cellular / molecular
[10] doi:10.1038/s41586-026-10679-1 [code]
Cortical development dynamics across autism spectrum disorder mouse models.
Journal: Nature
In common: tifffile, OpenCV, scikit-image, 5 other tools, genetics / omics, mouse, cellular / molecular

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.