OSCR

Dentate gyrus and CA3 activity mediates light-tone second-order conditioning expression in mice.

Code ↔ Paper

6 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 6 matches
  1. [1] § STAR★Methods › Method details › CellRake’s classification algorithm ↔ cellrake/utils.py, lines 651 to 693 · score 0.67 · ROC AUC, F1 score, precision, AP, probabilities, metrics · Report a mismatch
  2. [2] § Results › CellRake accurately quantifies fluorescent markers in histological brain sections ↔ cellrake/utils.py, lines 651 to 693 · score 0.58 · ROC AUC, F1 score, precision, AP, metrics, recall · Report a mismatch
  3. [3] § STAR★Methods › Method details › CellRake’s segmentation algorithm ↔ cellrake/segmentation.py, lines 245 to 278 · score 0.52 · polygonal contours, clips, bounds, segmented, dictionary, CellRake · Report a mismatch
  4. [4] § STAR★Methods › Method details › CellRake’s classification algorithm ↔ cellrake/main.py, lines 130 to 245 · score 0.52 · semi supervised learning, spreading, clustering, algorithm, blobs, classify · Report a mismatch
  5. [5] § STAR★Methods › Method details › CellRake’s classification algorithm ↔ cellrake/training.py, lines 528 to 636 · score 0.51 · semi supervised learning, spreading, clustering, pipeline, algorithm, classify · Report a mismatch
  6. [6] § STAR★Methods › Method details › CellRake’s classification algorithm ↔ cellrake/training.py, lines 139 to 262 · score 0.51 · Minority, SMOTE, kernel, probabilities, entropy, confidence · Report a mismatch

Paper

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

The paper is loaded when this pane is shown.

The authors' code

Python · 693 lines · 21 KB · MIT · 2 matches

  1. # Created by: Marc Canela
  3. from pathlib import Path
  4. from typing import Any, Dict, List, Optional, Tuple, Union
  6. import numpy as np
  7. import pandas as pd
  8. from scipy.stats import uniform
  9. from shapely.geometry import Polygon
  10. from skimage.draw import polygon
  11. from skimage.feature import graycomatrix, graycoprops, hog, local_binary_pattern
  12. from skimage.measure import label, regionprops
  13. from sklearn.decomposition import PCA
  14. from sklearn.ensemble import ExtraTreesClassifier, RandomForestClassifier
  15. from sklearn.linear_model import LogisticRegression
  16. from sklearn.metrics import (
  17. average_precision_score,
  18. f1_score,
  19. precision_score,
  20. recall_score,
  21. roc_auc_score,
  22. )
  23. from sklearn.model_selection import RandomizedSearchCV, cross_val_predict
  24. from sklearn.pipeline import Pipeline
  25. from sklearn.preprocessing import StandardScaler
  26. from sklearn.svm import SVC
  29. def export_data(data: pd.DataFrame, project_folder: Path, file_name: str) -> None:
  30. """
  31. Save data to CSV and Excel files in the specified project folder.
  33. Parameters
  34. ----------
  35. data : pd.DataFrame
  36. Data to save.
  37. project_folder : Path
  38. Folder to save the files.
  39. file_name : str
  40. Base name of the files (without extensions).
  41. """
  42. data.to_csv(project_folder / f"{file_name}.csv", index=False)
  43. data.to_excel(project_folder / f"{file_name}.xlsx", index=False)
  46. def get_cell_mask(layer: np.ndarray, coordinates: np.ndarray) -> np.ndarray:
  47. """
  48. Generate a binary mask for ROI regions defined by polygonal coordinates.
  50. Parameters
  51. ----------
  52. layer : np.ndarray
  53. 2D image layer determining mask dimensions.
  54. coordinates : np.ndarray
  55. Array of shape (N, 2) representing polygon vertices defining ROI.
  57. Returns
  58. -------
  59. np.ndarray
  60. Binary mask with ROI pixels set to 1, others to 0.
  61. """
  63. mask = np.zeros(layer.shape, dtype=np.uint8)
  65. # Extract x and y coordinates separately
  66. r = coordinates[0, :, 1] # y-coordinates
  67. c = coordinates[0, :, 0] # x-coordinate
  69. # Get the indices of the pixels that are inside the polygon
  70. rr, cc = polygon(r, c, mask.shape)
  72. # Fill the mask
  73. mask[rr, cc] = 1
  75. return mask
  78. def crop_cell(
  79. layer: np.ndarray,
  80. x_coords: Union[List[int], np.ndarray],
  81. y_coords: Union[List[int], np.ndarray],
  82. ) -> np.ndarray:
  83. """
  84. Extract a rectangular subregion from an image layer.
  86. Parameters
  87. ----------
  88. layer : np.ndarray
  89. 2D image layer to crop from.
  90. x_coords : Union[List[int], np.ndarray]
  91. X-coordinates defining horizontal crop boundaries.
  92. y_coords : Union[List[int], np.ndarray]
  93. Y-coordinates defining vertical crop boundaries.
  95. Returns
  96. -------
  97. np.ndarray
  98. Cropped rectangular region from the image layer.
  99. """
  100. # Extract min and max coordinates and convert to integers
  101. x_min, x_max = int(min(x_coords)), int(max(x_coords))
  102. y_min, y_max = int(min(y_coords)), int(max(y_coords))
  104. # Crop the rectangular region from the layer
  105. return layer[y_min : y_max + 1, x_min : x_max + 1]
  108. def extract_roi_stats(
  109. layer: np.ndarray, roi_info: Dict[str, Any]
  110. ) -> Tuple[np.ndarray, Dict[str, Any]]:
  111. """
  112. Extract statistical and texture features from a region of interest (ROI).
  114. Parameters
  115. ----------
  116. layer : np.ndarray
  117. 2D image layer for feature extraction.
  118. roi_info : Dict[str, Any]
  119. Dictionary with ROI coordinates containing "x" and "y" keys.
  121. Returns
  122. -------
  123. Tuple[np.ndarray, Dict[str, Any]]
  124. Binary mask and dictionary of extracted features including intensity,
  125. texture, and morphological statistics.
  126. """
  127. # Extract ROI coordinates from the dictionary
  128. x_coords, y_coords = roi_info["x"], roi_info["y"]
  129. coordinates = np.array([list(zip(x_coords, y_coords))], dtype=np.int32)
  131. # Create a binary mask for the ROI
  132. cell_mask = get_cell_mask(layer, coordinates)
  134. # If the mask is empty, skip
  135. if np.mean(cell_mask) == 0:
  136. cell_mask = None
  137. stats_dict = None
  138. return cell_mask, stats_dict
  140. # Crop the layer and mask to the bounding box of the ROI
  141. layer_cropped = crop_cell(layer, x_coords, y_coords)
  142. cell_mask_cropped = crop_cell(cell_mask, x_coords, y_coords)
  144. # Create a background mask
  145. background_mask_cropped = 1 - cell_mask_cropped
  147. # Extract pixel values for the ROI and background
  148. cell_pixels = layer[cell_mask == 1]
  149. cell_pixels_mean = np.mean(cell_pixels)
  150. background_pixels = layer_cropped[background_mask_cropped == 1]
  151. background_pixels_mean = (
  152. np.mean(background_pixels) if background_pixels.size > 0 else cell_pixels_mean
  153. )
  155. # Mask the cropped layer and calculate texture features
  156. layer_cropped_masked = layer_cropped * cell_mask_cropped
  157. layer_masked = layer * cell_mask
  159. # Calculate Local Binary Pattern (LBP)
  160. lbp = local_binary_pattern(layer_cropped_masked, P=8, R=1, method="uniform")
  162. # Calculate Gray Level Co-occurrence Matrix (GLCM) features
  163. glcm = graycomatrix(
  164. layer_masked, distances=[1], angles=[0], levels=256, symmetric=True, normed=True
  165. )
  167. # Calculate region properties
  168. prop = regionprops(label(cell_mask_cropped))[0]
  170. height, width = layer_cropped_masked.shape[:2]
  171. pixels_per_cell_val = 4
  172. cells_per_block_val = 2
  174. # Set the required minimum size based on the HOG parameters
  175. min_height = pixels_per_cell_val * cells_per_block_val
  176. min_width = pixels_per_cell_val * cells_per_block_val
  178. # Calculate the amount of padding needed
  179. pad_height = max(0, min_height - height)
  180. pad_width = max(0, min_width - width)
  182. # Apply padding to the image
  183. if pad_height > 0 or pad_width > 0:
  184. padded_image = np.pad(
  185. layer_cropped_masked,
  186. ((0, pad_height), (0, pad_width)),
  187. mode="constant",
  188. constant_values=0,
  189. )
  190. else:
  191. padded_image = layer_cropped_masked
  193. # Compute Histogram of Oriented Gradients (HOG) features
  194. h_values, _ = hog(
  195. padded_image,
  196. orientations=9,
  197. pixels_per_cell=(pixels_per_cell_val, pixels_per_cell_val),
  198. cells_per_block=(cells_per_block_val, cells_per_block_val),
  199. block_norm="L2-Hys",
  200. visualize=True,
  201. feature_vector=True,
  202. )
  204. # Flatten the HOG features if needed (though skimage.hog already returns a flat array if feature_vector=True)
  205. hog_descriptor_values = h_values.flatten()
  207. # Create a dictionary to store the extracted features
  208. stats_dict = {
  209. "mean_intensity": cell_pixels_mean,
  210. "median_intensity": np.median(cell_pixels),
  211. "sd_intensity": np.std(cell_pixels),
  212. "min_intensity": np.min(cell_pixels),
  213. "max_intensity": np.max(cell_pixels),
  214. "mean_ratio": cell_pixels_mean
  215. / (background_pixels_mean if background_pixels_mean != 0 else 1),
  216. "mean_difference": cell_pixels_mean - background_pixels_mean,
  217. "mean_all_ratio": None,
  218. "mean_all_difference": None,
  219. "mean_max_ratio": None,
  220. "mean_max_difference": None,
  221. "lbp_mean": np.mean(lbp),
  222. "lbp_std": np.std(lbp),
  223. "contrast": graycoprops(glcm, "contrast")[0, 0],
  224. "correlation": graycoprops(glcm, "correlation")[0, 0],
  225. "energy": graycoprops(glcm, "energy")[0, 0],
  226. "homogeneity": graycoprops(glcm, "homogeneity")[0, 0],
  227. "area": prop.area,
  228. "perimeter": prop.perimeter,
  229. "eccentricity": prop.eccentricity,
  230. "major_axis_length": prop.major_axis_length,
  231. "minor_axis_length": prop.minor_axis_length,
  232. "solidity": prop.solidity,
  233. "extent": prop.extent,
  234. "hog_mean": np.mean(hog_descriptor_values),
  235. "hog_std": np.std(hog_descriptor_values),
  236. }
  238. return cell_mask, stats_dict
  241. def create_stats_dict(
  242. roi_dict: Dict[str, Dict[str, Any]], layer: np.ndarray
  243. ) -> Dict[str, Dict[str, Any]]:
  244. """
  245. Calculate features for multiple ROIs with background statistics.
  247. Parameters
  248. ----------
  249. roi_dict : Dict[str, Dict[str, Any]]
  250. Dictionary mapping ROI names to coordinate dictionaries.
  251. layer : np.ndarray
  252. 2D image layer for feature extraction.
  254. Returns
  255. -------
  256. Dict[str, Dict[str, Any]]
  257. Dictionary with ROI names as keys and feature dictionaries as values.
  258. """
  259. cell_masks = []
  260. roi_props = {}
  262. # Extract statistics for each ROI
  263. for roi_name, roi_info in roi_dict.items():
  264. cell_mask, stats_dict = extract_roi_stats(layer, roi_info)
  266. if cell_mask is not None and stats_dict is not None:
  267. roi_props[roi_name] = stats_dict
  268. cell_masks.append(cell_mask)
  270. # Compute combined background statistics
  271. combined_cell_mask = np.bitwise_or.reduce(cell_masks)
  272. combined_background_mask = 1 - combined_cell_mask
  273. combined_background_pixels = layer[combined_background_mask == 1]
  274. nonzero_background_pixels = combined_background_pixels[
  275. combined_background_pixels != 0
  276. ]
  278. # Handle case when all background pixels are zero to avoid division by zero
  279. mean_background = (
  280. np.mean(nonzero_background_pixels) if nonzero_background_pixels.size > 0 else 0
  281. )
  283. # Update statistics with additional ratios and differences
  284. for stats_dict in roi_props.values():
  285. mean_intensity = stats_dict["mean_intensity"]
  286. stats_dict["mean_all_ratio"] = mean_intensity / (
  287. mean_background if mean_background != 0 else 1
  288. )
  289. stats_dict["mean_all_difference"] = mean_intensity - mean_background
  291. # Compute maximum mean intensity across all ROIs
  292. max_mean_intensity = max(
  293. stats_dict["mean_intensity"] for stats_dict in roi_props.values()
  294. )
  295. for stats_dict in roi_props.values():
  296. mean_intensity = stats_dict["mean_intensity"]
  297. stats_dict["mean_max_ratio"] = max_mean_intensity / (
  298. mean_intensity if mean_intensity != 0 else 1
  299. )
  300. stats_dict["mean_max_difference"] = max_mean_intensity - mean_intensity
  302. return roi_props
  305. def crop_cell_large(
  306. layer: np.ndarray,
  307. x_coords: List[float],
  308. y_coords: List[float],
  309. padding: Optional[int] = None,
  310. ) -> Tuple[np.ndarray, List[float], List[float]]:
  311. """
  312. Extract a padded subregion from an image layer with coordinate adjustment.
  314. Parameters
  315. ----------
  316. layer : np.ndarray
  317. 2D or 3D image layer to crop from.
  318. x_coords : List[float]
  319. X-coordinates defining the crop boundary.
  320. y_coords : List[float]
  321. Y-coordinates defining the crop boundary.
  322. padding : Optional[int]
  323. Padding to add around crop area. If None, uses ROI dimensions.
  325. Returns
  326. -------
  327. Tuple[np.ndarray, List[float], List[float]]
  328. Cropped image layer and adjusted coordinates.
  329. """
  330. # Determine cropping boundaries
  331. x_min, x_max = int(min(x_coords)), int(max(x_coords))
  332. y_min, y_max = int(min(y_coords)), int(max(y_coords))
  334. # Apply padding if specified
  335. if padding is not None:
  336. x_min -= padding
  337. x_max += padding
  338. y_min -= padding
  339. y_max += padding
  340. else:
  341. x_padding = x_max - x_min
  342. y_padding = y_max - y_min
  343. x_min -= x_padding
  344. x_max += x_padding
  345. y_min -= y_padding
  346. y_max += y_padding
  348. # Ensure cropping boundaries are within image dimensions
  349. layer_height, layer_width = layer.shape[:2]
  350. x_min = max(0, x_min)
  351. x_max = min(layer_width - 1, x_max)
  352. y_min = max(0, y_min)
  353. y_max = min(layer_height - 1, y_max)
  355. # Crop the image
  356. layer_cropped = layer[y_min : y_max + 1, x_min : x_max + 1]
  358. # Adjust coordinates relative to the cropped image
  359. x_coords_cropped = [x - x_min for x in x_coords]
  360. y_coords_cropped = [y - y_min for y in y_coords]
  362. return layer_cropped, x_coords_cropped, y_coords_cropped
  365. def fix_polygon(polygon: Polygon) -> Polygon:
  366. """
  367. Validate and fix invalid polygons using buffer operations.
  369. Parameters
  370. ----------
  371. polygon : Polygon
  372. Input polygon to validate and potentially fix.
  374. Returns
  375. -------
  376. Polygon
  377. Valid polygon or None if correction failed.
  378. """
  379. if not polygon.is_valid:
  380. # Attempt to fix the polygon by applying a zero-width buffer
  381. polygon = polygon.buffer(0)
  383. # Check if the polygon is still invalid after buffering
  384. if not polygon.is_valid:
  385. print("Polygon could not be fixed. Skipping this polygon.")
  386. return None
  388. return polygon
  391. def crop(layer: np.ndarray) -> np.ndarray:
  392. """
  393. Remove rows and columns containing only zero values from image layer.
  395. Parameters
  396. ----------
  397. layer : np.ndarray
  398. 2D image layer to trim.
  400. Returns
  401. -------
  402. np.ndarray
  403. Cropped image layer with zero-only rows and columns removed.
  404. """
  405. # Remove rows that are entirely zeros
  406. layer = layer[~np.all(layer == 0, axis=1)]
  408. # Remove columns that are entirely zeros
  409. layer = layer[:, ~np.all(layer == 0, axis=0)]
  411. return layer
  414. def train_svm(processed_dfs: Dict, random_state: int) -> Pipeline:
  415. """
  416. Train an SVM model with hyperparameter tuning using RandomizedSearchCV.
  418. Parameters
  419. ----------
  420. processed_dfs : Dict
  421. Dictionary containing processed data sets.
  422. random_state : int, default=42
  423. Random seed for reproducibility.
  425. Returns
  426. -------
  427. Pipeline
  428. Best SVM estimator found by random search.
  429. """
  431. # Perform randomized search with cross-validation with the validation data
  432. pipeline_steps = [
  433. ("scaler", StandardScaler()),
  434. ("pca", PCA(n_components=0.95, random_state=random_state)),
  435. (
  436. "svm",
  437. SVC(
  438. kernel="rbf",
  439. probability=True,
  440. class_weight="balanced",
  441. random_state=random_state
  442. ),
  443. ),
  444. ]
  445. pipeline = Pipeline(pipeline_steps)
  447. param_dist = {
  448. "svm__C": uniform(1, 100), # Regularization parameter
  449. }
  451. random_search = RandomizedSearchCV(
  452. pipeline,
  453. param_dist,
  454. n_iter=50,
  455. cv=3,
  456. random_state=42,
  457. n_jobs=-1,
  458. verbose=0,
  459. error_score="raise",
  460. )
  462. random_search.fit(processed_dfs['val']['X'], processed_dfs['val']['y'])
  463. best_params = random_search.best_params_
  465. # Perform training on the training set with the best parameters
  466. final_pipeline_steps = [
  467. ("scaler", StandardScaler()),
  468. ("pca", PCA(n_components=0.95, random_state=random_state)),
  469. (
  470. "svm",
  471. SVC(
  472. kernel="rbf",
  473. probability=True,
  474. class_weight="balanced",
  475. random_state=random_state,
  476. C=best_params['svm__C']
  477. ),
  478. ),
  479. ]
  480. final_model = Pipeline(final_pipeline_steps)
  481. final_model.fit(processed_dfs['train']['X'], processed_dfs['train']['y'])
  483. return final_model
  486. def train_rf(
  487. processed_dfs: Dict, model_type: str, random_state : int
  488. ) -> Union[RandomForestClassifier, ExtraTreesClassifier]:
  489. """
  490. Train a Random Forest or Extra Trees classifier with hyperparameter tuning.
  492. Parameters
  493. ----------
  494. processed_dfs : Dict
  495. Dictionary containing processed data sets.
  496. model_type : str
  497. Model type: 'rf' for Random Forest or 'et' for Extra Trees.
  498. random_state : int, default=42
  499. Random seed for reproducibility.
  501. Returns
  502. -------
  503. Union[RandomForestClassifier, ExtraTreesClassifier]
  504. Best estimator found by random search.
  505. """
  507. if model_type == "et":
  508. classifier = ExtraTreesClassifier(class_weight="balanced", random_state=random_state)
  509. elif model_type == "rf":
  510. classifier = RandomForestClassifier(class_weight="balanced", random_state=random_state)
  512. # Perform randomized search with cross-validation with the validation data
  513. param_dist = {
  514. f"{model_type}__n_estimators": [int(x) for x in np.linspace(start=50, stop=500, num=10)],
  515. f"{model_type}__max_features": ["sqrt", "log2", None],
  516. f"{model_type}__max_depth": [int(x) for x in np.linspace(10, 100, num=10)] + [None],
  517. f"{model_type}__min_samples_split": [2, 5, 10, 15, 20],
  518. f"{model_type}__min_samples_leaf": [1, 2, 4, 8, 10],
  519. f"{model_type}__bootstrap": [True, False],
  520. f"{model_type}__criterion": ["gini", "entropy"],
  521. }
  523. cv_pipeline = Pipeline([
  524. (model_type, classifier)
  525. ])
  527. random_search = RandomizedSearchCV(
  528. cv_pipeline,
  529. param_dist,
  530. n_iter=50,
  531. cv=3,
  532. random_state=random_state,
  533. n_jobs=-1,
  534. verbose=0,
  535. error_score="raise",
  536. )
  538. random_search.fit(processed_dfs['val']['X'], processed_dfs['val']['y'])
  539. best_params = random_search.best_params_
  541. # Perform training on the training set with the best parameters
  542. final_params = {k.replace(f'{model_type}__', ''): v for k, v in best_params.items()}
  544. if model_type == "et":
  545. final_classifier = ExtraTreesClassifier(class_weight="balanced", random_state=random_state, **final_params)
  546. else:
  547. final_classifier = RandomForestClassifier(class_weight="balanced", random_state=random_state, **final_params)
  549. final_classifier.fit(processed_dfs['train']['X'], processed_dfs['train']['y'])
  551. return final_classifier
  554. def train_logreg(processed_dfs : Dict, random_state : int) -> Pipeline:
  555. """
  556. Train a Logistic Regression model with hyperparameter tuning.
  558. Parameters
  559. ----------
  560. processed_dfs : Dict
  561. Dictionary containing processed data sets.
  562. random_state : int, default=42
  563. Random seed for reproducibility.
  565. Returns
  566. -------
  567. Pipeline
  568. Best estimator pipeline with PCA and LogisticRegression.
  569. """
  571. # Perform randomized search with cross-validation with the validation data
  572. pipeline_steps = [
  573. ("scaler", StandardScaler()),
  574. ("pca", PCA(n_components=0.95, random_state=random_state)),
  575. ("log_reg", LogisticRegression(class_weight="balanced", solver='liblinear', random_state=random_state)),
  576. ]
  578. cv_pipeline = Pipeline(pipeline_steps)
  580. param_dist = {
  581. "log_reg__C": uniform(1, 100),
  582. "log_reg__penalty": ['l1', 'l2', 'elasticnet']
  583. }
  585. random_search = RandomizedSearchCV(
  586. cv_pipeline,
  587. param_dist,
  588. n_iter=50,
  589. cv=3,
  590. random_state=random_state,
  591. n_jobs=-1,
  592. verbose=0,
  593. error_score="raise",
  594. )
  596. random_search.fit(processed_dfs['val']['X'], processed_dfs['val']['y'])
  597. best_params = random_search.best_params_
  599. # Perform training on the training set with the best parameters
  600. final_pipeline_steps = [
  601. ("scaler", StandardScaler()),
  602. ("pca", PCA(n_components=0.95, random_state=random_state)),
  603. (
  604. "log_reg",
  605. LogisticRegression(
  606. class_weight="balanced",
  607. random_state=random_state,
  608. solver='liblinear',
  609. C=best_params['log_reg__C'],
  610. penalty=best_params['log_reg__penalty']
  611. ),
  612. ),
  613. ]
  615. final_model = Pipeline(final_pipeline_steps)
  616. final_model.fit(processed_dfs['train']['X'], processed_dfs['train']['y'])
  618. return final_model
  621. def train_model(
  622. processed_dfs: Dict, model_type: str, random_state: int
  623. ) -> Union[Pipeline, RandomForestClassifier, ExtraTreesClassifier]:
  624. """
  625. Train a machine learning model based on the specified model type.
  627. Parameters
  628. ----------
  629. processed_dfs : Dict
  630. Dictionary containing processed data sets.
  631. model_type : str
  632. Model type: "svm", "rf", "et", or "logreg".
  633. random_state : int, default=42
  634. Random seed for reproducibility.
  636. Returns
  637. -------
  638. Union[Pipeline, RandomForestClassifier, ExtraTreesClassifier]
  639. Trained machine learning model.
  640. """
  641. if model_type == "svm":
  642. best_model = train_svm(processed_dfs, random_state)
  643. elif model_type in ["rf", "et"]:
  644. best_model = train_rf(processed_dfs, model_type, random_state)
  645. elif model_type == "logreg":
  646. best_model = train_logreg(processed_dfs, random_state)
  648. return best_model
  651. def evaluate_model(
  652. best_model: Union[Pipeline, RandomForestClassifier, ExtraTreesClassifier],
  653. processed_dfs: Dict,
  654. ) -> Dict[str, float]:
  655. """
  656. Evaluate model performance using cross-validated predictions.
  658. Parameters
  659. ----------
  660. best_model : Union[Pipeline, RandomForestClassifier, ExtraTreesClassifier]
  661. Model to be evaluated.
  662. processed_dfs : Dict
  663. Dictionary containing processed data sets.
  665. Returns
  666. -------
  667. Dict[str, float]
  668. Dictionary containing evaluation metrics: roc_auc, ap, precision, recall, f1_score.
  669. """
  670. X = processed_dfs['X']
  671. y = processed_dfs['y']
  673. # Get cross-validated predictions and probabilities
  674. y_pred_proba = cross_val_predict(best_model, X, y, cv=3, method="predict_proba")
  675. y_pred = (y_pred_proba[:, 1] >= 0.5).astype(int)
  676. y_proba = y_pred_proba[:, 1]
  678. # Calculate metrics
  679. roc_auc = roc_auc_score(y, y_proba)
  680. ap = average_precision_score(y, y_proba)
  681. precision_score_value = precision_score(y, y_pred)
  682. recall_score_value = recall_score(y, y_pred)
  683. f1_score_value = f1_score(y, y_pred)
  685. metrics = {
  686. "roc_auc": roc_auc,
  687. "ap": ap,
  688. "precision": precision_score_value,
  689. "recall": recall_score_value,
  690. "f1_score": f1_score_value,
  691. }
  693. return metrics

utils.py at commit 6a397fc, under MIT · at the source

Overview

Authors: Marc Canela1, Jordi Bach Adell1, David Roura Coll1, Jose Antonio González-Parra1, Julia S. Pinho1, Arnau Busquets-García1
ORCID iDs: Marc Canela, Jose Antonio González-Parra, Arnau Busquets-García
  1. Cell-Type Mechanisms in Normal and Pathological Behavior Research Group, Neuroscience Research Program, Hospital del Mar Research Institute, Barcelona, Spain
Institutions: Hospital Del Mar (Spain); Hospital del Mar Research Institute (Spain)
Journal: iScience, volume 29, issue 4, article 115522
Dates: received 1 September 2025; accepted 11 February 2026; published online 30 March 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1016/j.isci.2026.115522 · PMID 42006365 · PMCID PMC13091456 · OpenAlex W7143520602
Open access: gold, a free copy (OpenAlex)
Status: code verified (how the code is found and verified)
Categories: mouse (organism)
Methods: Statistics, Machine learning, Connectivity, fMRI & imaging
Keywords: Neuroscience, Behavioral neuroscience, Systems neuroscience
Topic: Retinal Development and Disorders (Ophthalmology, Medicine), according to OpenAlex
Funding: Generalitat de Catalunya (SGR-00022); Departament d’Economia i Coneixement de la Generalitat de Catalunya (Spain); European Research Council; EC | Horizon 2020 (EU Framework Programme for Research and Innovation) (948217); “la Caixa” Foundation (100010434)
Citations: not cited yet (Europe PMC); 77 references in the paper

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repositories

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

Zenodo 19075438

License: CC-BY-4.0
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Size: 18 files
Software Heritage: not checked
Found in: “Data and code availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 30 September 2026: the link answers (HTTP 200)
  • 30 September 2026: the link answers (HTTP 200)
At the source:

marccanela/cellrake

License: MIT
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 6a397fcdd5a37f99d4ba272d21cc333d033e0cff, 23 November 2025
Languages: Python (6), Jupyter (1)
Size: 42 files, 7 scripts
Software Heritage: not archived
Found in: “Data and code availability”
Holds: README, license file, environment (pyproject.toml), 1 notebook
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (4 files), pandas (4 files), scikit-learn (4 files), Matplotlib (3 files), Pillow (2 files), scikit-image (2 files), SciPy (2 files), imbalanced-learn (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
9 files
At the source: github.com/marccanela/cellrake

Zenodo 19002677

License: MIT
State: the link answers, verified on 30 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 (4 files), pandas (4 files), scikit-learn (4 files), Matplotlib (3 files), Pillow (2 files), scikit-image (2 files), SciPy (2 files), imbalanced-learn (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers (HTTP 200)
  • 30 September 2026: the link answers (HTTP 200)
9 files
At the source:

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:

  • 3 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 14 scripts, each with its path and the digest of its content;
  • 6 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.

Code and data availability statement

The paper has a code and data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

  • it points to the authors' code: marccanela/cellrake, Zenodo 19002677, Zenodo 19075438
  • it says that the data are available on request
  • it says that the code is available on request

Read it in the paper: doi.org/10.1016/j.isci.2026.115522.

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

Recorded: type, language, journal, volume, issue, pages, dates, 6 authors, 3 keywords, 5 funders, 69 references.

Cite

This paper

Canela, M., Adell, J. B., Coll, D. R., González-Parra, J. A., Pinho, J. S., & Busquets-García, A. (2026). Dentate gyrus and CA3 activity mediates light-tone second-order conditioning expression in mice. iScience, 29(4), 115522. https://doi.org/10.1016/j.isci.2026.115522

BibTeX

@article{canela2026dentate,
author = {Canela, Marc and Adell, Jordi Bach and Coll, David Roura and González-Parra, Jose Antonio and Pinho, Julia S. and Busquets-García, Arnau},
title = {{Dentate gyrus and CA3 activity mediates light-tone second-order conditioning expression in mice}},
journal = {iScience},
year = {2026},
month = mar,
volume = {29},
number = {4},
pages = {115522},
publisher = {Elsevier},
issn = {2589-0042},
doi = {10.1016/j.isci.2026.115522},
url = {https://doi.org/10.1016/j.isci.2026.115522},
pmid = {42006365},
pmcid = {PMC13091456}
}

RIS

TY - JOUR
AU - Canela, Marc
AU - Adell, Jordi Bach
AU - Coll, David Roura
AU - González-Parra, Jose Antonio
AU - Pinho, Julia S.
AU - Busquets-García, Arnau
TI - Dentate gyrus and CA3 activity mediates light-tone second-order conditioning expression in mice
T2 - iScience
J2 - iScience
PY - 2026
DA - 2026/03/30
VL - 29
IS - 4
SP - 115522
SN - 2589-0042
PB - Elsevier
DO - 10.1016/j.isci.2026.115522
UR - https://doi.org/10.1016/j.isci.2026.115522
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.isci.2026.115522",
"type": "article-journal",
"title": "Dentate gyrus and CA3 activity mediates light-tone second-order conditioning expression in mice",
"container-title": "iScience",
"author": [
{
"family": "Canela",
"given": "Marc"
},
{
"family": "Adell",
"given": "Jordi Bach"
},
{
"family": "Coll",
"given": "David Roura"
},
{
"family": "González-Parra",
"given": "Jose Antonio"
},
{
"family": "Pinho",
"given": "Julia S."
},
{
"family": "Busquets-García",
"given": "Arnau"
}
],
"container-title-short": "iScience",
"volume": "29",
"issue": "4",
"page": "115522",
"DOI": "10.1016/j.isci.2026.115522",
"PMID": "42006365",
"PMCID": "PMC13091456",
"ISSN": "2589-0042",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.isci.2026.115522",
"language": "en",
"issued": {
"date-parts": [
[
2026,
3,
30
]
]
}
}

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.7554/elife.105863 [code]
Dorsal hippocampus mediates light-tone associations in male mice.
Journal: eLife
In common: pandas, SciPy, Matplotlib, 1 other tool, mouse, 9 references, author Arnau Busquets-García
[2] doi:10.1016/j.isci.2026.116825 [code]
Social hierarchy shapes behavioral and transcriptional responses to chronic stress and ketamine in male mice.
Journal: iScience
In common: imbalanced-learn, scikit-image, Pillow, 5 other tools, mouse, 2 references
[3] doi:10.1038/s41593-023-01281-z [code]
Ascending neurons convey behavioral state to integrative sensory and action selection brain regions.
Journal: Nature neuroscience
In common: imbalanced-learn, scikit-image, Pillow, 5 other tools, 2 references
[4] doi:10.7554/elife.95273 [code]
Unbiased identification of cell identity in dense mixed neural cultures.
Journal: eLife
In common: imbalanced-learn, scikit-image, scikit-learn, 4 other tools, 3 references
[5] doi:10.1371/journal.pbio.3002646 [code]
Deep brain stimulation of the Tbr1-deficient mouse model of autism spectrum disorder at the basolateral amygdala alters amygdalar connectivity, whole-brain synchronization, and social behaviors.
Journal: PLoS biology
In common: scikit-image, scikit-learn, pandas, 3 other tools, mouse, 4 references
[6] doi:10.1126/sciadv.adu9136 [code]
High-resolution in vivo kinematic tracking with customized injectable fluorescent nanoparticles.
Journal: Science advances
In common: scikit-image, Pillow, scikit-learn, 4 other tools, mouse, 3 references
[7] doi:10.1016/j.cell.2022.12.010 [code]
Molecular and spatial signatures of mouse brain aging at single-cell resolution.
Journal: Cell
In common: imbalanced-learn, scikit-image, Pillow, 5 other tools, mouse, 1 reference
[8] doi:10.1242/jcs.261950 [code]
Gut Analysis Toolbox - automating quantitative analysis of enteric neurons.
Journal: Journal of cell science
In common: scikit-image, Pillow, scikit-learn, 4 other tools, mouse, 3 references
[9] doi:10.1038/s41586-024-07780-8 [code]
Inhibitory specificity from a connectomic census of mouse visual cortex.
Journal: Nature
In common: imbalanced-learn, scikit-image, Pillow, 5 other tools, mouse, 1 reference
[10] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: imbalanced-learn, scikit-image, Pillow, 5 other tools, mouse, 1 reference

Contribute

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

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

Add the badge to the code's README

OSCR: the badge of this paper

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

Markdown
<!-- oscr-badge:start -->
[![OSCR](https://openscicode.org/badge/doi/10.1016/j.isci.2026.115522.svg)](https://openscicode.org/badge/doi/10.1016/j.isci.2026.115522)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.1016/j.isci.2026.115522.svg
   :target: https://openscicode.org/badge/doi/10.1016/j.isci.2026.115522
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.1016/j.isci.2026.115522"><img src="https://openscicode.org/badge/doi/10.1016/j.isci.2026.115522.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->

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

If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge page.

Request its removal

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

Discussion, reproductions, activity

Discussion: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.

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

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

Report a reproduction failure (signed in)

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

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