OSCR

Human neuron activity during an 83-minute movie from 2,286 neurons and 29 patients.

Code ↔ Paper

16 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 16 matches
  1. [1] § Data Records › Single-neuron data ↔ nwb_generation/write_nwb.py, lines 553–566 · score 0.92 · isi_violations, peak_SNR, waveform_sem, putative pyramidal cell, csc_nr, brain_region
  2. [2] § Methods › Spike sorting and data processing ↔ nwb_generation/stats/collect_mad_values.m, lines 1–47 · score 0.88 · median absolute deviation, 300–3000 Hz, peak signal, noise ratio, Spike sorting, bandpassed
  3. [3] § Technical Validation › Single-neuron data and spike-sorting quality metrics ↔ nwb_generation/stats/collect_mad_values.m, lines 1–47 · score 0.86 · median absolute deviation, 300–3000 Hz, peak signal, noise ratio, spike sorted, bandpassed
  4. [4] § Data Records › Movie stimulus ↔ ML_framework/nwb_loading/nwb_loading.py, lines 161–223 · score 0.84 · machine_learning, corresponding frame, movie bin, binned spike, bin length, movie frame
  5. [5] § Data Records › Movie stimulus ↔ nwb_generation/write_nwb.py, lines 635–682 · score 0.81 · movie_binning_info, machine_learning, movie bin edges, frame onsets, bin length, corresponding frame
  6. [6] § Methods › Spike sorting and data processing ↔ visualization/plot_code/spike_sorting/plot_spike_sorting.ipynb, lines 433–478 · score 0.81 · isolation distances, negative peaks, firing rates, spike sorting, MUs, PCs
  7. [7] § Background & Summary ↔ nwb_generation/session_info.py, lines 3–64 · score 0.77 · University Hospital Bonn, entorhinal cortex, parahippocampal cortex, microwires implanted, hippocampus, amygdala
  8. [8] § Methods › Spike sorting and data processing ↔ nwb_generation/stats/metrics.py, lines 108–131 · score 0.77 · median absolute deviation, noise ratio, Spike sorting, SNR, peak, amplitude
  9. [9] § Methods › Spike sorting and data processing ↔ nwb_generation/stats/metrics.py, lines 54–85 · score 0.76 · inter spike interval, ISI violations, spike events, spike sorted, ratio
  10. [10] § Technical Validation › Single-neuron data and spike-sorting quality metrics ↔ nwb_generation/stats/metrics.py, lines 108–131 · score 0.74 · median absolute deviation, noise ratio, spike sorted, SNR, metrics, peak
  11. [11] § Data Records › Single-neuron data ↔ nwb_generation/write_nwb.py, lines 761–799 · score 0.70 · bundle_index, csc_nr, brain_region, MNI, Hemisphere, localizations
  12. [12] § Background & Summary ↔ nwb_generation/session_info.py, lines 3–64 · score 0.67 · Behnke Fried microwire, entorhinal cortex, parahippocampal cortex, hippocampus, amygdala, EC
  13. [13] § Data Records › Movie annotations ↔ nwb_generation/write_nwb.py, lines 593–615 · score 0.66 · annotations_base, entry_index, label_name, absent, offset, intervals
  14. [14] § Technical Validation › Responses of individual neurons to movie features ↔ visualization/plot_code/decoding_results/decoding_results/notebooks/decoding_performance.ipynb, lines 26–70 · score 0.66 · McKenzie, Scene Cuts, Camera Cut, Tom, Indoor, Summer
  15. [15] § Data Records › Movie annotations ↔ ML_framework/nwb_loading/nwb_loading.py, lines 161–223 · score 0.55 · movie_annotations_indicator_functions, machine_learning, raw, NWB, Summer, frames
  16. [16] § Methods › Task and stimulus ↔ src/epiphyte/preprocessing/data_preprocessing/data_utils.py, lines 277–374 · score 0.55 · neural recording system, movie frame, DAQ, linear, log, timestamp

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 · 1,053 lines · 46 KB · no license · 4 matches

  1. #!/usr/bin/env python3
  2. # -*- coding: utf-8 -*-
  3. """
  4. Code for structuring and saving the file-system-based movies data into the NWB format.
  6. Included as an example -- will not run without access to original server with clinical data.
  9. Author: Alana Darcher, Uniklinikum Bonn
  10. Date: 8 April 2025
  11. License: MIT License
  12. Dependencies: numpy, pandas, pynwb, mat73, locals
  13. """
  14. import logging
  16. import shutil
  17. from collections import Counter
  18. from pathlib import Path
  19. from datetime import datetime
  20. from dateutil import tz
  21. from uuid import uuid4
  22. import re
  24. import numpy as np
  25. import pandas as pd
  26. from scipy.stats import sem
  28. from pynwb import NWBHDF5IO, NWBFile
  29. from pynwb.file import Subject, ProcessingModule
  30. from pynwb.misc import Units, TimeSeries
  31. from pynwb.core import DynamicTable, VectorData
  32. from pynwb.epoch import TimeIntervals
  34. import mat73
  36. from session_info import *
  37. from stats.cell_type import SpikeWidth
  38. from stats.metrics import calc_cv2, calculate_snr, count_isi_violations
  39. from nwb_generation.utils.data_io import *
  40. from utils.process_labels import *
  42. class SessionInfo:
  43. """
  44. Manages session info for a given patient.
  45. """
  46. def __init__(self, subject_dir):
  47. self.subject_dir = subject_dir
  48. self.session_info = self._load_session_info()
  49. self.session_start_time = self._get_session_start_time()
  51. def _load_session_info(self):
  52. session_info_path = self.subject_dir / "session_info.npy"
  53. return np.load(session_info_path, allow_pickle=True).item()
  55. def _get_session_start_time(self):
  56. session_time = f"{self.session_info['date']}"
  57. session_start_time = datetime.strptime(session_time, '%Y-%m-%d',)
  59. # For privacy reasons, we only include the year. All other time values are set to a common value.
  60. session_start_time = datetime.strptime(f"{session_start_time.year}-1-1_12:00:00", '%Y-%m-%d_%H:%M:%S')
  61. return session_start_time.replace(tzinfo=tz.gettz('Europe/Berlin'))
  63. class SpikeInfo:
  64. def __init__(self, subject_dir):
  65. self.subject_dir = subject_dir
  66. self.names_cscs = self._load_cscs()
  67. self.cscs_with_units = self._filter_cscs()
  69. def _load_cscs(self):
  70. """
  71. Loads and sorts the names of the unit data files from the refractored spiking_data directory.
  72. Uses natural sorting/human readable sorting.
  73. Filenames have the following pattern: CSC6_SUA1.npy
  74. """
  75. filepaths_cscs = (self.subject_dir / "spiking_data").glob(f"CSC*")
  76. names_cscs = [p.name for p in filepaths_cscs]
  77. return sorted(names_cscs, key=natural_keys)
  79. def _filter_cscs(self):
  80. """
  81. Grab the channel numbers from the filenames and return all unique numbers.
  82. Because the CSC ids are pulled from the spike files, by definition this list will only
  83. include channels with valid units.
  84. """
  85. return np.unique([int(re.findall(r'-?\d+', f)[0]) for f in self.names_cscs])
  87. class WatchlogInfo:
  88. def __init__(self, subject_dir, pat_id):
  89. self.subject_dir = subject_dir
  90. self.pat_id = pat_id
  92. self.clean_wl = self._load_clean_wl()
  93. self.clean_rec = self._load_clean_rec()
  95. self.raw_wl = self._load_raw_wl()
  96. self.raw_rec = self._load_raw_rec()
  98. self.run_check()
  100. def _load_clean_wl(self):
  101. path = Path(self.subject_dir, "cleaned_watchlog", f"{self.pat_id}_pts.npy")
  102. return np.load(path, allow_pickle=True)
  104. def _load_clean_rec(self):
  105. path = Path(self.subject_dir, "cleaned_watchlog", f"{self.pat_id}_rec.npy")
  106. return np.load(path, allow_pickle=True)
  108. def _load_raw_wl(self):
  109. path = Path(self.subject_dir, "watchlogs", f"raw_{self.pat_id}_pts.npy")
  110. return np.load(path, allow_pickle=True)
  112. def _load_raw_rec(self):
  113. path = Path(self.subject_dir, "watchlogs", f"raw_{self.pat_id}_rec.npy")
  114. return np.load(path, allow_pickle=True) / 1000 # convert to milliseconds
  116. def run_check(self):
  117. if self.clean_rec[0] != self.raw_rec[0]:
  118. print(f"cleaned onset {self.clean_rec[0]}")
  119. print(f"raw onset {self.raw_rec[0]}")
  120. assert self.clean_rec[0] >= self.raw_rec[0]
  122. class MovieBinningData:
  123. def __init__(self, data_dir):
  124. self.data_dir = data_dir
  125. self.bin_lengths = [40, 100, 200, 500, 1000] # multiples of the frame rate (0.04s)
  126. self.actual_bin_length = {"40": 40, "100": 80, "200": 200, "500": 480, "1000": 1000} # hack to get around filenames using other numbers
  127. self.df = self.build_df()
  129. def build_df(self):
  130. bin_info_dicts = []
  132. for bl in self.bin_lengths:
  133. edges = np.load(self.data_dir.parent / "movie_edges" / f"edges_movie_{bl}.npy", allow_pickle=True)
  134. frames = np.load(self.data_dir.parent / "movie_edges" / f"relevant_frames_{bl}.npy", allow_pickle=True)
  136. assert len(edges) == len(frames) + 1
  138. bin_info_dicts.append(
  139. {"bin_length": self.actual_bin_length[str(bl)],
  140. "edges": edges,
  141. "frames": frames}
  142. )
  144. return pd.DataFrame(bin_info_dicts)
  146. class MovieData:
  147. def __init__(self, data_dir):
  148. self.data_dir = data_dir
  149. self.movie_pts = self._load_movie_pts()
  151. def _load_movie_pts(self):
  152. """PTS used for analysis, excludes production credits and end credits."""
  153. return np.load(self.data_dir.parent / "movie_edges" / f"pts_movie.npy", allow_pickle=True)
  155. class LocalizationData:
  156. def __init__(self, subject_dir):
  157. self.subject_dir = subject_dir
  158. self.patient_id = int(self.subject_dir.parent.name)
  159. self.processed_localizations = self._load_processed_localizations()
  160. self.processed_localizations = self._rename_hippocampal_electrodes(self.processed_localizations)
  162. self.df = self.build_df()
  163. self.df = self._rename_hippocampal_electrodes(self.df)
  165. self.df_mtl_only = self.build_df(restrict=True)
  166. self.df_mtl_only = self._rename_hippocampal_electrodes(self.df_mtl_only)
  168. self.df_electrode_groups = self.build_df_electrode_groups(manual_localizations=True)
  169. self.df_electrode_groups = self._rename_hippocampal_electrodes(self.df_electrode_groups)
  171. def _load_legui_csv(self):
  172. localizations = pd.read_csv(list((self.subject_dir / "localizations").glob("*MNI*"))[0])
  173. return localizations
  175. def _load_processed_localizations(self):
  176. loaded_df = pd.read_csv(self.subject_dir / "localizations" / f"{self.patient_id}_finalized_localizations.csv")
  177. bundle_ids = [entry[-1] for entry in loaded_df["channel_name_postop"]]
  178. loaded_df["bundle_index"] = bundle_ids
  179. return loaded_df
  181. def _rename_hippocampal_electrodes(self, df):
  182. """Correct for the outdated/original naming scheme of middle hippocampal electrodes (MH).
  184. Replaces MH with PH (posterior hippocampus) for implantation schemes with only two hippocampal electrodes.
  185. Ignores schemes with three hippocampal electrodes. Uses the region_pre_review (original clincial assignment)
  186. to decide if there were two or three hippocampal electrodes.
  188. Args:
  189. df (pd.DataFrame): dataframe containing electrode information
  191. Returns:
  192. df: dataframe with corrected hippocampal region abbreviation
  193. """
  194. regions_in_dataframe = np.unique(self.processed_localizations["region_pre_review"])
  196. if "AH" and "MH" in regions_in_dataframe:
  197. if "PH" not in regions_in_dataframe:
  198. df.replace({"brain_region":"MH"}, {"brain_region":"PH"}, inplace=True)
  199. return df
  201. def build_df(self, restrict=False):
  202. """
  203. Creates the DataFrame used for populating the NWB electrodes and electrode_groups.
  204. Averages across the MNI coordinates for the micros (within coordinate) and sets the average for the micro locations.
  206. Args:
  207. restrict (bool, optional): Restricts to just originally-labeled MTL neurons when true. Defaults to False.
  209. Returns:
  210. pandas dataframe: DataFrame containing localization information
  211. """
  212. if restrict:
  213. region_set = set(zip(self.processed_localizations["region_pre_review"], self.processed_localizations["hemisphere"]))
  214. region_set = {item for item in region_set if any(item[0].startswith(prefix) for prefix in region_restriction.keys())}
  215. else:
  216. region_set = set(zip(self.processed_localizations["region_pre_review"], self.processed_localizations["hemisphere"]))
  218. for p, pair in enumerate(region_set):
  220. # The matching and averaging is done for using the pre-review locations as these are unique within each patient.
  221. # After localization, it's possible to have "duplicated" regions.
  222. region_matches = self.processed_localizations["region_pre_review"] == pair[0]
  223. hemisphere_matches = self.processed_localizations["hemisphere"] == pair[1]
  224. matching_rows = self.processed_localizations[region_matches & hemisphere_matches].copy()
  225. assert len(matching_rows) == 8, f"{len(matching_rows)}"
  227. matching_rows["mni_x_micro"] = [np.mean(matching_rows["mni_x_micro"])] * 8
  228. matching_rows["mni_y_micro"] = [np.mean(matching_rows["mni_y_micro"])] * 8
  229. matching_rows["mni_z_micro"] = [np.mean(matching_rows["mni_z_micro"])] * 8
  231. if p == 0:
  232. df = matching_rows.copy()
  233. else:
  234. df = pd.concat([df, matching_rows], ignore_index=True)
  235. df = df.sort_values(by='csc_nr')
  236. return df
  238. def handle_duplicate_electrode_groups(self, df):
  239. region_hemisphere_combinations = list((zip(df["brain_region"], df["hemisphere"])))
  240. region_hemisphere_set = set(region_hemisphere_combinations)
  242. if len(region_hemisphere_combinations) == len(region_hemisphere_set):
  243. dummy_column = [""] * len(df)
  244. df["unique_identifier_tags_for_duplicated_locations"] = dummy_column
  245. return df
  246. else:
  247. print("Handling duplicated localization groups.")
  248. duplicate_region_dict = Counter(region_hemisphere_combinations)
  249. unique_region_identifier_tags = []
  251. temp_duplicate_list = []
  252. temp_duplicate_list_2 = []
  254. for entry in region_hemisphere_combinations:
  255. if duplicate_region_dict[entry] == 2:
  256. if entry not in temp_duplicate_list:
  257. unique_region_identifier_tags.append("a")
  258. temp_duplicate_list.append(entry)
  259. else:
  260. unique_region_identifier_tags.append("b")
  261. elif duplicate_region_dict[entry] == 3:
  262. if entry not in temp_duplicate_list:
  263. unique_region_identifier_tags.append("a")
  264. temp_duplicate_list.append(entry)
  265. elif entry not in temp_duplicate_list_2:
  266. unique_region_identifier_tags.append("b")
  267. temp_duplicate_list_2.append(entry)
  268. else:
  269. unique_region_identifier_tags.append("c")
  271. elif duplicate_region_dict[entry] == 1:
  272. unique_region_identifier_tags.append('')
  274. assert len(unique_region_identifier_tags) == len(df["brain_region"])
  275. df["unique_identifier_tags_for_duplicated_locations"] = unique_region_identifier_tags
  276. return df
  278. def build_df_electrode_groups(self, manual_localizations=True):
  279. """
  280. Create the DataFrame used for populating the NWB electrode groups entry.
  281. """
  282. if manual_localizations:
  283. tmp = []
  284. for row in self.processed_localizations.itertuples():
  285. name = row.channel_name_postop
  286. region = row.region_pre_review
  287. hemisphere = row.hemisphere
  289. if int(name[-1]) == 1:
  290. print(f" including {hemisphere}{region} in electrode_groups.")
  291. tmp.append(row)
  292. df = pd.DataFrame(tmp)
  293. df = self.handle_duplicate_electrode_groups(df)
  295. else:
  296. tmp = []
  297. for row in self.processed_localizations.itertuples():
  298. name = row.channel_name_postop
  299. region = row.region_pre_review
  301. if region not in region_restriction.keys():
  302. print(f" excluding {region}")
  303. continue
  305. if int(name[-1]) == 1:
  306. tmp.append(row)
  308. df = pd.DataFrame(tmp)
  309. return df
  311. class ChannelData:
  312. def __init__(self, subject_dir, patient_id):
  313. self.subject_dir = subject_dir
  314. self.patient_id = patient_id
  315. self.micro_channels = self._load_channel_info()
  317. def _load_channel_info(self):
  318. micro_channels = pd.read_csv(self.subject_dir / "ChannelNames.txt", delimiter="\t", header=None, names=['Filename',])
  319. micro_channels["csc_nr"] = micro_channels.index + 1
  320. return micro_channels
  322. class MetricsData:
  323. def __init__(self, subject_dir):
  324. self.subject_dir = subject_dir
  325. self.median_abs_deviation_file = self._load_mad_file()
  326. self.mad = self.median_abs_deviation_file["MAD_channels"]
  328. self.iso_distances = self._load_isolation_distances()
  329. self.iso_channels = self._grab_cscs_with_units()
  331. def _load_mad_file(self):
  332. mad_all_channels = mat73.loadmat(self.subject_dir / 'metrics' / 'median_abs_deviations.mat')
  333. if sum(np.isnan(mad_all_channels["MAD_channels"])) != 0:
  334. print(f"Unassigned value for MAD for a channel. {np.where(np.isnan(mad_all_channels['MAD_channels']))}")
  335. return mad_all_channels
  337. def _load_isolation_distances(self):
  338. return np.load(self.subject_dir / "metrics" / "isolation_distances.npy", allow_pickle=True).item()
  340. def _grab_cscs_with_units(self):
  341. return np.unique([int(name.split("_")[0][3:]) for name in self.iso_distances["filenames"]])
  343. class BaseLabelsData:
  344. def __init__(self, subject_dir):
  345. self.subject_dir = subject_dir
  346. self.base_labels = self._load_base_labels()
  347. self.df = self.build_df()
  349. def _load_base_labels(self):
  350. base_labels = Path(self.subject_dir, "base_labels.npy")
  351. base_labels = np.load(base_labels, allow_pickle=True).item()
  352. df_base_labels = pd.DataFrame(base_labels)
  353. return df_base_labels
  355. def build_df(self):
  356. for i, label in enumerate(self.base_labels.itertuples()):
  357. name = label.names
  358. values = label.values
  359. starts = label.starts
  360. stops = label.stops
  362. if name in dataset_labels:
  363. pass
  364. else:
  365. print(f" {name} not included in base labels.")
  366. continue
  368. assert len(values) == len(starts) == len(stops), "Number of label entries is inconsistent."
  370. entry_index = np.arange(1, len(values)+1) # using 1-indexing for compatibility with matlab
  372. for e, entry in enumerate(entry_index):
  373. d_ = {
  374. "names": [name.lower()],
  375. "entry_index": [entry],
  376. "values": [values[e]],
  377. "starts": [starts[e]],
  378. "stops": [stops[e]]
  379. }
  380. df = pd.DataFrame(d_,)
  382. if i == 0 and e == 0:
  383. df_base_labels_db_format = df.copy()
  384. else:
  385. df_base_labels_db_format = pd.concat([df_base_labels_db_format, df])
  387. return df_base_labels_db_format
  389. class AlignedLabelsData:
  390. def __init__(self, subject_dir, rec):
  391. self.subject_dir = subject_dir
  392. self.rec = rec
  393. self.aligned_labels = self._load_aligned_labels()
  394. self.df = self.build_df()
  396. def _load_aligned_labels(self):
  397. aligned_labels = Path(self.subject_dir, "aligned_labels.npy")
  398. aligned_labels = np.load(aligned_labels, allow_pickle=True).item()
  399. df_aligned_labels = pd.DataFrame(aligned_labels)
  401. return df_aligned_labels
  403. def build_df(self):
  404. for i, label in enumerate(self.aligned_labels.itertuples()):
  405. name = label.names
  406. values = label.values
  407. starts = label.starts / 1000 - self.rec[0]
  408. stops = label.stops / 1000 - self.rec[0]
  410. if name in dataset_labels:
  411. pass
  412. else:
  413. print(f" {name} not included in aligned labels.")
  414. continue
  416. assert len(values) == len(starts) == len(stops), "Number of label entries is inconsistent."
  417. assert len(values) > 1, f"Only one entry for label {label}."
  418. entry_index = np.arange(1, len(values)+1) # using 1-indexing for compatibility with matlab
  420. for e, entry in enumerate(entry_index):
  421. d_ = {
  422. "names": [name.lower()],
  423. "entry_index": [entry],
  424. "values": [values[e]],
  425. "starts": [starts[e]],
  426. "stops": [stops[e]]
  427. }
  428. df = pd.DataFrame(d_,)
  430. if i == 0 and e == 0:
  431. df_aligned_labels_db_format = df.copy()
  432. else:
  433. df_aligned_labels_db_format = pd.concat([df_aligned_labels_db_format, df])
  435. return df_aligned_labels_db_format
  437. ##
  438. # Workhorse Class
  439. ##
  441. class PatientNWB:
  442. def __init__(self, patient_id, sub_id, data_dir, save_dir,):
  443. self.pat_id = patient_id
  444. self.data_dir = data_dir
  445. self.save_dir = save_dir
  446. self.sub_id = sub_id
  447. self.subject_dir = Path(self.data_dir, str(self.pat_id), "session_1")
  449. self.logger = self._init_logger()
  451. self.sw = SpikeWidth()
  453. self.session_info = SessionInfo(self.subject_dir)
  454. self.spike_info = SpikeInfo(self.subject_dir)
  455. self.watchlog_info = WatchlogInfo(self.subject_dir, self.pat_id)
  457. self.movie_binning_data = MovieBinningData(self.data_dir)
  458. self.movie_pts = MovieData(self.data_dir).movie_pts
  460. self.localizations_data = LocalizationData(self.subject_dir)
  461. self.channel_data = ChannelData(self.subject_dir, self.pat_id)
  463. self.metrics = MetricsData(self.subject_dir)
  464. self.median_abs_deviations = self.metrics.mad
  465. assert len(self.median_abs_deviations) == len(self.localizations_data.processed_localizations["csc_nr"]), "Discrepancy in number of channels in MAD results."
  467. self.isolation_distances = self.metrics.iso_distances
  468. self.df_isolation_distances = pd.DataFrame(self.isolation_distances)
  469. assert np.all(self.metrics.iso_channels == self.spike_info.cscs_with_units), f"Mismatch in the number of channels with units. Isodist: {np.unique(self.df_isolation_distances['filenames'])}, SpikeInfos: {self.spike_info.cscs_with_units}"
  471. self.base_labels_data = BaseLabelsData(self.subject_dir)
  472. self.aligned_labels_data = AlignedLabelsData(self.subject_dir, self.watchlog_info.raw_rec)
  474. self.sr = 32768. # sampling rate from the NLX amplifier
  475. self.frame_rate = 0.04 # frame rate of the movie file
  476. self.len_movie = 5029.68
  477. self.fps = 25
  478. self.num_frames = int(self.len_movie / self.frame_rate)+1
  479. self.pts_full_movie = [round((x * self.frame_rate), 2) for x in range(0, self.num_frames)] # includes production and end credits.
  481. self.t_r = 3 # refractory period, ms
  482. self.t_c = (1 / self.sr) * 1000 # censored time period
  484. # init nwbfile components
  485. self.nwbfile = self._init_nwbfile()
  486. self.device = self._define_device()
  487. self._init_electrodes()
  488. self._init_units()
  489. self._init_unit_columns()
  490. self.annotations_patient_aligned = self._init_aligned_annotations()
  491. self.annotations_base = self._init_base_annotations()
  492. self._init_processing_module()
  494. #### initialization functions ####
  496. def _init_logger(self,):
  497. timestamp = datetime.now().strftime("%d-%m-%Y-%H-%M")
  498. logging.basicConfig(
  499. format="{asctime} - {levelname} - {message}",
  500. style="{",
  501. datefmt="%Y-%m-%d %H:%M",
  502. level=logging.DEBUG,
  503. filename=f"logs/write_nwb_{timestamp}.log")
  504. logger = logging.getLogger(__name__)
  505. logger.info(f"patient {self.pat_id}, subject id: {self.sub_id}")
  506. logger.info(f"Data location: {self.data_dir}")
  507. logger.info(f"Save location: {self.save_dir}")
  508. logger.info(f"Subject Dir: {self.subject_dir}")
  509. return logger
  511. def _init_nwbfile(self, ):
  512. # note: session_description includes patient-identifying information
  513. # and is excluded from the codebase.
  514. nwbfile = NWBFile(
  515. session_description=f"{session_description_base_text}{self.sub_id}",
  516. identifier=str(uuid4()),
  517. session_start_time=self.session_info.session_start_time,
  518. session_id=f"sub{self.sub_id}",
  519. lab=lab,
  520. institution=institution,
  521. experiment_description=experiment_description,
  522. keywords=keywords,
  523. related_publications=related_publications
  524. )
  525. self.logger.info("NWBfile created.")
  526. return nwbfile
  528. def _define_device(self, ):
  529. device = self.nwbfile.create_device(
  530. name="NeuraLynx ATLAS",
  531. description="Acquisition amplifier",
  532. manufacturer="NeuraLynx"
  533. )
  534. self.logger.info("Device defined.")
  535. return device
  537. def _init_electrodes(self,):
  538. self.nwbfile.add_electrode_column(name="hemisphere", description="Hemisphere in which electrode was implanted")
  539. self.nwbfile.add_electrode_column(name="brain_region", description="Brain region in which electrode was implanted")
  540. self.nwbfile.add_electrode_column(name="bundle_index", description="Microwire channel number within the implanted bundle (unordered)")
  541. self.nwbfile.add_electrode_column(name="csc_nr", description="Continuously sampling channel (CSC) id assigned to the microwire channel")
  542. self.logger.info("Electrode table created.")
  544. def _init_units(self):
  545. self.nwbfile.units = Units(
  546. name="units",
  547. waveform_rate=self.sr,
  548. waveform_unit="microvolts",
  549. description=f"Spike times (milliseconds), waveforms (uV), and associated spike sorting metrics for {self.sub_id}'s movie session. Spike times are reference to the start of the movie, such that a spike time == 0 would indicate a spike at the exact onset of the movie."
  550. )
  551. self.logger.info("Unit table created.")
  553. def _init_unit_columns(self):
  554. self.nwbfile.add_unit_column(name="unit_id", description="unique integer id for each unit within a session")
  555. self.nwbfile.add_unit_column(name="csc_nr", description="id for the electrode channel from which the unit was sorted, links to electrodes table")
  556. self.nwbfile.add_unit_column(name="brain_region", description="brain region from which unit was recorded.")
  557. self.nwbfile.add_unit_column(name="hemisphere", description="hemisphere from which unit was recorded")
  558. self.nwbfile.add_unit_column(name="is_single_unit", description="indicates if a given unit is a putative single neuron or putative multi-unit activity")
  559. self.nwbfile.add_unit_column(name="peak_SNR", description="signal-to-noise ratio calculated via max. amp of the mean spike waveform")
  560. self.nwbfile.add_unit_column(name="isi_violations", description="percentage of refractory-period violations in the spike train")
  561. self.nwbfile.add_unit_column(name="cv2", description="degree of variation in the inter-spike intervals")
  562. self.nwbfile.add_unit_column(name="iso_dist", description="isolation distance of cluster from other spike events on the same channel")
  563. self.nwbfile.add_unit_column(name="cell_type", description="indicates if a given unit is a putative pyramidal cell or interneuron")
  564. self.nwbfile.add_unit_column(name="waveform_sem", description="standard error of the mean waveform across all spikes for the unit")
  566. self.logger.info("Custom unit columns added.")
  568. def _init_aligned_annotations(self):
  569. annotations_patient_aligned = TimeIntervals(
  570. name="annotations_patient_aligned",
  571. description=("Annotation data for the labeled movie features, aligned to the watchlog of a given participant (handles pauses in movie playback). Can be non-monotonic due to patient-led skips in playbak. Time given in milliseconds. "
  572. " Contents: starts: onset of a labeled segment, stops: offset of the labeled segment, values: whether the feature was present in the labeled segment (1) or not (0)")
  573. )
  575. annotations_patient_aligned.add_column(
  576. name="label_name",
  577. description="label name"
  578. )
  580. annotations_patient_aligned.add_column(
  581. name="entry_index",
  582. description="index for the occurrence of the label within the movie"
  583. )
  585. annotations_patient_aligned.add_column(
  586. name="value",
  587. description="indicates if time span corresponds to labeled entity being present (=1) or absent (=0)"
  588. )
  590. self.logger.info("Patient aligned annotations table created.")
  591. return annotations_patient_aligned
  593. def _init_base_annotations(self):
  594. annotations_base = TimeIntervals(
  595. name="annotations_base",
  596. description=("Annotation data for the labeled movie features, aligned to directly to the movie, given in presentation time stamps (seconds)."
  597. " Contents: starts: onset of a labeled segment, stops: offset of the labeled segment, values: whether the feature was present in the labeled segment (1) or not (0)")
  598. )
  600. annotations_base.add_column(
  601. name="label_name",
  602. description="label name"
  603. )
  605. annotations_base.add_column(
  606. name="entry_index",
  607. description="index for the occurrence of the label within the movie"
  608. )
  610. annotations_base.add_column(
  611. name="value",
  612. description="indicates if time span corresponds to labeled entity being present (=1) or absent (=0)"
  613. )
  614. self.logger.info("Base annotations table created.")
  615. return annotations_base
  617. def _init_processing_module(self):
  618. mod = ProcessingModule(name="machine_learning", description="movie annotation and frame information processed for machine learning applications")
  619. self.nwbfile.add_processing_module(mod)
  620. self.logger.info("Processing table added.")
  622. ##### population functions #####
  624. def populate_subject(self, ):
  625. subject = Subject(
  626. subject_id=str(self.sub_id),
  627. age=f"P{patient_ages[self.pat_id]}Y",
  628. sex=patient_sex[self.pat_id],
  629. species="Homo sapiens",
  630. description="BF-implanted epilepsy patient"
  631. )
  632. self.nwbfile.subject = subject
  633. self.logger.info(f"Subject info populated: {subject}")
  635. def populate_movie_binning_data(self):
  636. """
  637. Adds movie binning data to the NWB file using an explicit DynamicTable with ragged columns for
  638. edges and frames. Populates from MovieBinningData.
  640. Note: differs from other stimulus info and tables as this is not pre-defined.
  641. """
  642. df = self.movie_binning_data.df
  643. n = len(df)
  645. # create the table
  646. table = DynamicTable(
  647. name="movie_binning_info",
  648. description=(
  649. "Edges and corresponding frames indices (given as filenames) for binning the data using the frame onsets as edges."
  650. "Each row corresponds to one bin_length."
  651. ),
  652. id=np.arange(n, dtype=np.int64),
  653. columns=[]
  654. )
  656. # add column: bin_length
  657. table.add_column(
  658. name="bin_length",
  659. description="Length of the bin in milliseconds.",
  660. data=np.array(df["bin_length"].values, dtype=np.int64),
  661. )
  663. edges = [np.asarray(x, dtype=np.float64) for x in df["edges"].tolist()]
  664. table.add_column(
  665. name="edges",
  666. description="Bin edges aligned to frame onsets.",
  667. data=edges,
  668. index=True
  669. )
  671. frames = [list(map(str, x)) for x in df["frames"].tolist()]
  672. table.add_column(
  673. name="frames",
  674. description="Frames indices corresponding to the bin edges.",
  675. data=frames,
  676. index=True
  677. )
  679. mod = self.nwbfile.processing["machine_learning"]
  680. mod.add(table)
  682. self.logger.info("Movie binning info populated.")
  685. def populate_movie_annotations(self):
  686. """
  687. Creates and adds a table to the NWB file containing the indicator functions for
  688. each labeled feature.
  689. """
  690. df = self.base_labels_data.df
  692. table = DynamicTable(
  693. name="movie_annotations_indicator_functions",
  694. description=(
  695. "Indicator functions (0=feature absent, 1=feature present) for all labels, spanning the entire film."
  696. "Each value in the function corresponds to a movie frame, monotonically increasing."
  697. )
  698. )
  700. table.add_column(
  701. name="label_name",
  702. description="Label name (string)."
  703. )
  705. table.add_column(
  706. name="indicator_function",
  707. description=f"Indicates presence/absence of labeled feature for all {self.num_frames} frames in the movie.",
  708. index=True
  709. )
  711. for label, sub in df.groupby("names"):
  712. print(f" {label}")
  713. vec = make_label_from_start_stop_times(sub["values"].to_numpy(), sub["starts"].to_numpy(), sub["stops"].to_numpy(), self.pts_full_movie, )
  714. table.add_row(label_name=str(label).lower(), indicator_function=vec)
  715. print(sum(vec))
  717. mod = self.nwbfile.processing["machine_learning"]
  718. mod.add(table)
  720. self.logger.info("Movie anntation table populated.")
  722. def populate_movie_pts(self, ):
  723. """
  724. Adds movie PTS (presentation timestamps) data to the NWB file from dataframe built by MovieData.
  725. """
  726. movie_pts_nwb = TimeSeries(name="movie_frame_times_analysis",
  727. description="onset times for each frame in the movie for the portion used in analysis (excludes production credits and the end credits), given in the presentation time stamps (seconds, referenced to movie start)",
  728. unit="seconds",
  729. rate=self.frame_rate,
  730. data=self.movie_pts)
  731. self.nwbfile.add_stimulus(stimulus=movie_pts_nwb)
  733. movie_pts_nwb = TimeSeries(name="movie_frame_times_base",
  734. description="onset times for each frame in the movie for the entire movie, given in the presentation time stamps (seconds, referenced to movie start)",
  735. unit="seconds",
  736. rate=self.frame_rate,
  737. data=self.pts_full_movie)
  738. self.nwbfile.add_stimulus(stimulus=movie_pts_nwb)
  740. self.logger.info("Movie PTS info populated (frames analyzed and complete set).")
  742. def populate_electrode_groups(self):
  743. """
  744. Populates the NWB file electrode groups table by adding all macros in the recording.
  745. Uses the dataframe built by LocalizationData.df_electrode_groups.
  746. Name includes post-localization brain region and a character tag in case of duplicated regions.
  747. """
  748. self.logger.info("Populating Electrode Groups table:")
  750. for macro in self.localizations_data.df_electrode_groups.itertuples():
  752. self.nwbfile.create_electrode_group(
  753. name=f"{macro.hemisphere}{macro.brain_region}{macro.unique_identifier_tags_for_duplicated_locations}",
  754. description=f"depth electrode {macro.region_pre_review}{macro.hemisphere} (macro contact), {macro.brain_region}{macro.hemisphere} manual review",
  755. device=self.device,
  756. location=f"{hemisphere_full_names[macro.hemisphere]} {region_full_names[macro.brain_region]}"
  757. )
  759. self.logger.info(f" manual location:{macro.hemisphere}{macro.brain_region} / pre-review: {macro.region_pre_review} added.")
  761. def populate_micro_channels(self):
  762. """
  763. Populates the NWB file electrode table by iterating through all micro channels with valid units.
  764. Only includes channels with valid units AND from regions of interest (e.g. excluding temporal FCD electrodes).
  765. Process:
  766. - processed_localizations (LocalizationData) is filtered to include only channels with valid units
  767. - for each channel, the averaged micro location is taken from LocalizationData.df
  768. """
  769. self.logger.info("Populating Electrode table: ")
  771. for row in self.localizations_data.processed_localizations[self.localizations_data.processed_localizations["csc_nr"].isin(self.spike_info.cscs_with_units)].itertuples():
  773. if row.region_pre_review in region_exclusion:
  774. self.logger.info(f" excluding {row.region_pre_review}")
  775. continue
  777. # manual localizations version
  778. original_channel_name = row.channel_name_postop
  779. original_channel_name_first_microwire = f"{original_channel_name[:-1]}1" # using this as a unique identifier
  780. unique_identifier_tags_for_duplicated_locations = self.localizations_data.df_electrode_groups[self.localizations_data.df_electrode_groups["channel_name_postop"] == original_channel_name_first_microwire]["unique_identifier_tags_for_duplicated_locations"].iloc[0]
  782. # take averaged micro locations
  783. x = self.localizations_data.df[self.localizations_data.df["channel_name_postop"] == original_channel_name]["mni_x_micro"].iloc[0]
  784. y = self.localizations_data.df[self.localizations_data.df["channel_name_postop"] == original_channel_name]["mni_y_micro"].iloc[0]
  785. z = self.localizations_data.df[self.localizations_data.df["channel_name_postop"] == original_channel_name]["mni_z_micro"].iloc[0]
  787. electrode_group = self.nwbfile.electrode_groups[f"{row.hemisphere}{row.brain_region}{unique_identifier_tags_for_duplicated_locations}"]
  788. self.nwbfile.add_electrode(
  789. group=electrode_group,
  790. location=f"{hemisphere_full_names[row.hemisphere]} {region_full_names[row.brain_region]}",
  791. hemisphere=row.hemisphere,
  792. brain_region=row.brain_region,
  793. bundle_index=row.bundle_index,
  794. csc_nr=row.csc_nr,
  795. x=x,
  796. y=y,
  797. z=z
  798. )
  799. self.logger.info(f" {row.hemisphere}{row.brain_region}{row.bundle_index} added.")
  801. def restrict_spiketimes_to_movie(self, unit_path):
  802. unit = np.load(unit_path, allow_pickle=True).item()
  803. times_raw = unit["times"] # in milliseconds
  804. amps_raw = unit["amps"]
  806. # restrict to just the movie-related activity
  807. left_idx = np.searchsorted(times_raw, self.watchlog_info.raw_rec[0], side='left')
  808. right_idx = np.searchsorted(times_raw, self.watchlog_info.raw_rec[-1], side='right')
  809. times_filtered = times_raw[left_idx:right_idx] - self.watchlog_info.raw_rec[0] ## reindex times to the start of the movie, instead of amplifier time
  810. amps_filtered = amps_raw[left_idx:right_idx]
  812. # spikes, but not during the movie period.
  813. if times_raw.any() == 1 and times_filtered.any() == 0:
  814. pass
  816. return times_filtered, amps_filtered
  818. def restrict_spiketimes_to_analyzed_movie(self, times_filtered, amps_filtered):
  819. """
  820. Optionally restrict the spiketimes to just those
  821. included in the portion of the movie analyzed.
  823. Args:
  824. times_filtered (np.ndarray): spike times, standardized to the start of the movie
  825. amps_filtered (np.ndarray): amplitudes of each spike in times_filtered
  826. """
  827. pts_analysis_start, pts_analysis_stop = movie_analysis_pts
  828. left_idx = np.searchsorted(times_filtered, pts_analysis_start, side='left')
  829. right_idx = np.searchsorted(times_filtered, pts_analysis_stop, side='right')
  830. times_filtered_analysis = times_filtered[left_idx:right_idx]
  831. amps_filtered_analysis = amps_filtered[left_idx:right_idx]
  833. assert np.min(times_filtered_analysis) >= pts_analysis_start, f"Something went wrong with the spike time filtering. Min spike time is f{np.min(times_filtered_analysis)}, shouldn't be less than f{pts_analysis_start}."
  834. assert np.max(times_filtered_analysis) <= pts_analysis_stop, f"Something went wrong with the spike time filtering. Max spike time is f{np.max(times_filtered_analysis)}, shouldn't be more than f{pts_analysis_stop}."
  836. return times_filtered_analysis, amps_filtered_analysis
  839. def get_unit_type(self, name, waveform):
  840. unit_class_info = name.split("_")[1]
  841. if unit_class_info[0] == "M":
  842. single_unit = 0
  843. cell_type = "multi-unit"
  844. else:
  845. single_unit = 1
  847. if waveform[19] > 0:
  848. spike_width, cell_type = self.sw.calculate_spike_width(waveform)
  849. else:
  850. cell_type = "negative-peak"
  852. unit_index = int(unit_class_info[-1])
  853. return single_unit, cell_type, unit_index
  855. def isi_contamination_wrapper(self, times):
  856. """
  857. Wraps the ISI contamination functions.
  859. Args:
  860. times (np.array): list of spike times for a unit in milliseconds
  862. Returns:
  863. float: percentage of violations
  864. """
  865. r = count_isi_violations(times, self.t_r)
  866. if len(times) <= 1:
  867. p = 0
  868. else:
  869. p = r / (len(times) - 1) # denomniator is number of ISIs
  870. return p * 100
  872. def grab_isolation_distance(self, filename_csc):
  873. print(filename_csc)
  874. fname = filename_csc.split(".")[0]
  875. matches = self.df_isolation_distances.loc[self.df_isolation_distances["filenames"] == fname, "isolation_distances"]
  876. isolation_distance = float(matches.iloc[0]) if not matches.empty else np.nan
  877. return isolation_distance
  879. def populate_units(self):
  880. self.logger.info(f"Populating unit table:")
  882. nm_units_included = 0
  883. nm_units_excluded = 0
  884. all_regions = []
  885. unit_id = 0
  887. for filename_csc in self.spike_info.names_cscs:
  888. unit_path = self.subject_dir / "spiking_data" / filename_csc
  889. csc_nr = int(re.findall(r'-?\d+', filename_csc)[0])
  890. name = filename_csc.split(".")[0]
  892. brain_region = self.localizations_data.processed_localizations[self.localizations_data.processed_localizations["csc_nr"] == csc_nr]["brain_region"]
  893. if not brain_region.empty:
  894. brain_region = brain_region.iloc[0]
  895. else:
  896. AssertionError
  898. hemisphere = self.localizations_data.processed_localizations[self.localizations_data.processed_localizations["csc_nr"] == csc_nr]["hemisphere"]
  899. if not hemisphere.empty:
  900. hemisphere = hemisphere.iloc[0]
  901. else:
  902. AssertionError
  904. # ############# REMOVE BEFORE RELEASE
  905. region_pre_review = self.localizations_data.processed_localizations[self.localizations_data.processed_localizations["csc_nr"] == csc_nr]["region_pre_review"].iloc[0]
  906. # #####################################
  908. if region_pre_review in region_exclusion:
  909. self.logger.info(f" excluding {name}, {hemisphere}{brain_region}, original region {region_pre_review}")
  910. nm_units_excluded += 1
  911. continue
  912. else:
  913. self.logger.info(f" including {name}, {hemisphere}{brain_region}. original region {region_pre_review}")
  914. nm_units_included += 1
  915. all_regions.append(brain_region)
  917. times, amps = self.restrict_spiketimes_to_movie(unit_path)
  919. waveform_mean = np.mean(amps, axis=0)
  920. waveform_sem = sem(amps, axis=0)
  921. assert len(waveform_mean) == len(waveform_sem), "Waveform mean and sem have different lengths."
  923. single_unit, cell_type, _ = self.get_unit_type(name, waveform_mean)
  925. # metrics
  926. channel_mad = self.median_abs_deviations[csc_nr-1]
  927. peak_snr = calculate_snr(waveform_mean, channel_mad)
  928. isi_below = self.isi_contamination_wrapper(times)
  929. cv2 = calc_cv2(times)
  930. iso_dist = self.grab_isolation_distance(filename_csc)
  932. self.nwbfile.add_unit(spike_times=times, unit_id=unit_id, csc_nr=csc_nr, brain_region=brain_region, hemisphere=hemisphere, is_single_unit=bool(single_unit),
  933. peak_SNR=peak_snr, isi_violations=isi_below, cv2=cv2, iso_dist=iso_dist, cell_type=cell_type,
  934. waveform_mean=waveform_mean, waveform_sem=waveform_sem,
  935. )
  936. unit_id += 1
  938. self.logger.info(f"Number of units included for patient {self.pat_id}: {nm_units_included}")
  939. self.logger.info(f"Number of units excluded for patient {self.pat_id}: {nm_units_excluded}")
  940. self.logger.info(f"Regions kept: {Counter(all_regions)}")
  943. def populate_aligned_annotations(self):
  944. for row in self.aligned_labels_data.df.itertuples():
  946. self.annotations_patient_aligned.add_row(start_time=row.starts, stop_time=row.stops,
  947. label_name=row.names, entry_index=row.entry_index, value=row.values)
  949. self.nwbfile.add_stimulus(stimulus=self.annotations_patient_aligned)
  950. self.logger.info(f"Populated patient aligned annotations.")
  952. def populate_base_annotations(self):
  953. for row in self.base_labels_data.df.itertuples():
  955. self.annotations_base.add_row(start_time=row.starts, stop_time=row.stops,
  956. label_name=row.names, entry_index=row.entry_index, value=int(row.values))
  958. self.nwbfile.add_stimulus(stimulus=self.annotations_base)
  959. self.logger.info(f"Populated base annotations.")
  961. def populate_clean_watchlogs(self):
  962. pts_column = VectorData(
  963. name="pts",
  964. data=self.watchlog_info.clean_wl,
  965. description="presentation timestamps (pts, secoonds) for each frame in the movie shown to the patient during the experiment",
  966. )
  968. neural_rectime_column = VectorData(
  969. name="neural_recording_time",
  970. data=self.watchlog_info.clean_rec - self.watchlog_info.raw_rec[0],
  971. description="neural recording system timestamp (milliseconds) for each frame in the movie shown to the patient during the experiment, corresponds to the pts",
  972. )
  974. watchlogs = DynamicTable(
  975. name="cleaned_watchlogs",
  976. description=("Log of movie presentation to participant. Processed: paused portions unified, inconsistencies in frame rate corrected. "
  977. "Lookup table containing: frame times (presentation time stamps, seconds) and the corresponding timestamp from the neural recording system (milliseconds)."),
  979. colnames=[
  980. "pts",
  981. "neural_recording_time",
  982. ],
  983. columns=[
  984. pts_column,
  985. neural_rectime_column,
  986. ],
  987. )
  988. self.nwbfile.add_stimulus(stimulus=watchlogs)
  989. self.logger.info(f"Populated cleaned watchlogs.")
  991. def populate_raw_watchlogs(self):
  992. pts_column = VectorData(
  993. name="pts",
  994. data=self.watchlog_info.raw_wl,
  995. description="presentation timestamps (pts, seconds) for each frame in the movie shown to the patient during the experiment (in seconds, movie play time)",
  996. )
  998. neural_rectime_column = VectorData(
  999. name="neural_recording_time",
  1000. data=self.watchlog_info.raw_rec - self.watchlog_info.raw_rec[0],
  1001. description="neural recording system timestamp (milliseconds) for each frame in the movie shown to the patient during the experiment, corresponds to the pts",
  1002. )
  1004. watchlogs = DynamicTable(
  1005. name="raw_watchlogs",
  1006. description=("Log of movie presentation to participant. Raw watchlog file, for data record purposes. "
  1007. "Lookup table containing: frame times (presentation time stamps, seconds) and the corresponding timestamp from the neural recording system (milliseconds)."),
  1008. colnames=[
  1009. "pts",
  1010. "neural_recording_time",
  1011. ],
  1012. columns=[
  1013. pts_column,
  1014. neural_rectime_column,
  1015. ],
  1016. )
  1017. self.nwbfile.add_stimulus(stimulus=watchlogs)
  1018. self.logger.info(f"Populated raw watchlogs")
  1020. def save_nwbfile(self, save_path=None):
  1021. if save_path is None:
  1022. save_path = Path(self.subject_dir, f"sub{self.sub_id}.nwb")
  1024. io = NWBHDF5IO(save_path, mode="w")
  1025. io.write(self.nwbfile)
  1026. io.close()
  1028. complete_dataset_path = Path(self.save_dir, f"sub{self.sub_id}.nwb")
  1029. shutil.copy(save_path, complete_dataset_path)
  1030. self.logger.info(f"NWB file saved! \n")
  1032. def generate_nwb(patient_id, sub_id, data_dir, save_dir):
  1033. patNWB = PatientNWB(patient_id=patient_id, sub_id=sub_id, data_dir=data_dir, save_dir=save_dir)
  1034. patNWB.populate_subject()
  1035. patNWB.populate_movie_binning_data()
  1036. patNWB.populate_movie_annotations()
  1037. patNWB.populate_movie_pts()
  1038. patNWB.populate_electrode_groups()
  1039. patNWB.populate_micro_channels()
  1040. patNWB.populate_units()
  1041. patNWB.populate_aligned_annotations()
  1042. patNWB.populate_base_annotations()
  1043. patNWB.populate_clean_watchlogs()
  1044. patNWB.populate_raw_watchlogs()
  1045. patNWB.save_nwbfile()
  1047. if __name__ == "__main__":
  1048. data_dir = Path("/media/al/refractored_data/patient_data")
  1049. save_dir = Path("/media/al/movies_dataset_nwb")
  1051. patient_id = 1 #
  1052. sub_id = 1
  1053. generate_nwb(patient_id=patient_id, sub_id=sub_id, data_dir=data_dir, save_dir=save_dir)

write_nwb.py at commit 59fc242, no license · at the source

Overview

Authors: Alana Darcher1, Franziska Gerken2, Johannes Niediek1,3, Marcel S. Kehl1,4, Thomas P. Reber1,5, Stefanie Liebe1,6,7,8, Laura Nett1, Attila Racz1, Lukas Kunz1, Bernhard Staresina4,9, Rachel Rapp10, Pedro J. Gonçalves10,11,12,13, Ismail Elezi2,14, Valeri Borger15, Rainer Surges1, Laura Leal-Taixé2,16, Jakob H. Macke10,17,18, Florian Mormann1
ORCID iDs: Alana Darcher, Franziska Gerken, Johannes Niediek, Marcel S. Kehl, Thomas P. Reber, Stefanie Liebe, Laura Nett, Attila Racz, Lukas Kunz, Rachel Rapp, Pedro J. Gonçalves, Ismail Elezi, Laura Leal-Taixé, Jakob H. Macke, Florian Mormann
18 affiliations
  1. Department of Epileptology, University Hospital Bonn,Bonn, Germany
  2. Dynamic Vision and Learning Group, Technical University of Munich,Munich, Germany
  3. Machine Learning Group, Technische Universität Berlin,Berlin, Germany
  4. Department of Experimental Psychology, University of Oxford,Oxford, UK
  5. Faculty of Psychology, UniDistance Suisse,Brig, Switzerland
  6. Department of Epileptology and Neurology, University Hospital Tübingen,Tübingen, Germany
  7. Hertie Institute for Clinical Brain Science, University of Tübingen,Tübingen, Germany
  8. Hertie Institute for Artificial Intelligence for Brain Health, University of Tübingen,Tübingen, Germany
  9. Oxford Centre for Human Brain Activity, Centre for Integrative Neuroimaging, Department of Psychiatry, University of Oxford,Oxford, UK
  10. Machine Learning in Science, Excellence Cluster Machine Learning and Tübingen AI Center, University of Tübingen,Tübingen, Germany
  11. VIB Center for AI and Computational Biology, VIB,Leuven, Belgium
  12. VIB Center for Neuroscience Leuven, VIB,Leuven, Belgium
  13. Departments of Computer Science and Electrical Engineering, KU Leuven,Leuven, Belgium
  14. Present Address: Huawei, London, United Kingdom
  15. Department of Neurosurgery, University Hospital Bonn,Bonn, Germany
  16. Present Address: NVIDIA Srl Italy, Milan, Italy
  17. Empirical Inference, Max Planck Institute for Intelligent Systems,Tübingen, Germany
  18. Present Address: ELLIS Institute Tübingen,Tübingen, Germany
Institutions: University Hospital Bonn (Germany); Technical University of Munich (Germany); Technische Universität Berlin (Germany); University of Oxford (United Kingdom); UniDistance Suisse (Switzerland); Universitätsklinikum Tübingen (Germany); University of Tübingen (Germany); VIB.AI (Belgium); Vlaams Instituut voor Biotechnologie (Belgium); KU Leuven (Belgium); Max Planck Institute for Intelligent Systems (Germany); ELLIS Institute Tübingen (Germany)
Journal: Scientific data, volume 13, issue 1, article 1105
Dates: received 27 February 2026; accepted 20 July 2026; published online 30 July 2026
Type: Data paper · Language: English
License: CC BY
Identifiers: DOI 10.1038/s41597-026-07955-0 · PMID 42533002 · PMCID PMC13424620 · OpenAlex W7171799126
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: human (organism), methods / tools (subfield)
Methods: Spectral & time-frequency, Smoothing, state filtering, decompositions, Machine learning, Single-unit activity, calcium imaging
MeSH: Motion Pictures*, Neurons*, Hippocampus, Humans, Machine Learning, Temporal Lobe (* major topic)
Journal subjects: Data Descriptor
Funding: Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) (DeepHumanVision, FKZ 031L0197A-C); Deutsche Forschungsgemeinschaft (DFG) (EXC 2064/1, PN 391 390727645), SFB 1233 (PN 276693517), SFB 1089 (PN 227953431), SPP 2411 (PN 520287829), MO 930/4-2, M 930/15-1)
Citations: cited by 1 paper (Europe PMC); 60 references in the paper

Abstract

Despite a growing trend towards more naturalistic experiments, few single-unit datasets collected during dynamic and naturalistic stimuli have been released, and none using a full-length movie. Here, we present SUMMER (Single Unit activity during a Movie in the human Medial temporal lobe via Electrophysiological Recordings), a dataset containing recordings from 2,286 neurons from the human amygdala, hippocampus, entorhinal cortex, parahippocampal cortex, and neighboring structures during the complete presentation of the commercial film 500 Days of Summer to 29 intracranially implanted patients. We provide a rich set of frame-wise annotations spanning the entirety of the movie’s 83-minute runtime, which systematically label the most salient narrative and visual elements, from characters and locations to camera cuts and main character speech. This Neurodata Without Borders-formatted dataset contains the spike times and corresponding mean waveforms from all recorded neurons, along with demographic information and electrode localizations. For technical validation, we provide spike-sorting metrics and demonstrate the tuning of individual neurons to movie features. We additionally provide decoding results from a machine learning-based pipeline for predicting movie features from neuronal population activity. To facilitate immediate use, we offer the dataset in a machine learning-ready format alongside a codebase demonstrating both neural feature and movie feature prediction tasks. This dataset offers a valuable foundation for exploring how the human brain processes semantic content, particularly in real-world contexts involving dynamic and naturalistic stimuli.

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

mormannlab/SUMMER

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 59fc2424615150481494edf3e31d707729d395ea, 6 July 2026
Languages: Python (43), Jupyter (14), MATLAB (3)
Size: 93 files, 60 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, environment (environment_no_builds.yml, ML_framework/requirements-train.txt), 14 notebooks
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (27 files), Matplotlib (15 files), pandas (12 files), seaborn (11 files), Neurodata Without Borders (PyNWB, MatNWB) (5 files), Nilearn (4 files), SciPy (4 files), PyTorch Lightning (3 files), PyTorch (2 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
61 files
At the source: github.com/mormannlab/SUMMER

Zenodo 21165561

License: CC-BY-4.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: the references
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (27 files), Matplotlib (15 files), pandas (12 files), seaborn (11 files), Neurodata Without Borders (PyNWB, MatNWB) (5 files), Nilearn (4 files), SciPy (4 files), PyTorch Lightning (3 files), PyTorch (2 files)
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
  • 27 September 2026: the link answers (HTTP 200)
61 files
At the source:

mackelab/epiphyte

License: GPL-3.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 48632c8cc60d2fa1faa707229fb61e75d3174a17, 12 June 2026
Languages: JavaScript (36), Python (26), Jupyter (9), Shell (1)
Size: 133 files, 72 scripts
Software Heritage: archived
Found in: the references
Holds: README, license file, CITATION.cff, environment (setup.py, docs/tutorials/docker files/docker-compose.yaml), continuous integration, documentation, 9 notebooks
Not found: tests
Tools: NumPy (15 files), pandas (5 files), Matplotlib (2 files), SciPy (1 file), seaborn (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
74 files
At the source: github.com/mackelab/epiphyte

Code availability

All code used to generate NWB files, perform technical validation, synchronize movie stimulus versions, and visualize results is provided in a GitHub repository, https://github.com/mormannlab/SUMMER36. The calculation of the median absolute deviation (normalization factor for obtaining the peak signal-to-noise ratio of a channel43) is implemented in MATLAB. All other code is implemented in Python. We provide a conda environment file containing all used dependencies, as well as instructions for creating and using an environment. The previously published work on this data34 was performed using a relational database built for this dataset59.

Beyond traditional analytical workflows, we prioritize accessibility for the machine learning community and offer the dataset in an ML-ready format. To further lower the barrier to entry, our repository includes several modules for training a simple neural network on two demonstrative tasks. Detailed setup instructions are provided to ensure ease of use and facilitate rapid implementation.

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:

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

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

Data

Datasets cited

Data availability

The complete dataset, encompassing both neural data and stimulus data, is formatted as Neurodata Without Borders (NWB) files. The NWB-formatted dataset is available on the DANDI Archive: 10.48324/dandi.001616/0.260702.082426.

We are not able to directly release the movie stimulus used in this experiment. To facilitate access, we have created a set of Python-based modules (see following Code Availability section) that convert a specific DVD version of the movie, 500 Days of Summer, to the version used in our experiment–DVD: Cine Project (2010 Release), EAN: 4010232049162, ASIN: B0030FXXLK.

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

Recorded: type, language, journal, volume, issue, pages, dates, 18 authors, 6 MeSH terms, 2 funders, 54 references.

Cite

This paper

Darcher, A., Gerken, F., Niediek, J., Kehl, M. S., Reber, T. P., Liebe, S., Nett, L., Racz, A., Kunz, L., Staresina, B., Rapp, R., Gonçalves, P. J., Elezi, I., Borger, V., Surges, R., Leal-Taixé, L., Macke, J. H., & Mormann, F. (2026). Human neuron activity during an 83-minute movie from 2,286 neurons and 29 patients. Scientific data, 13(1), 1105. https://doi.org/10.1038/s41597-026-07955-0

BibTeX

@article{darcher2026human,
author = {Darcher, Alana and Gerken, Franziska and Niediek, Johannes and Kehl, Marcel S. and Reber, Thomas P. and Liebe, Stefanie and Nett, Laura and Racz, Attila and Kunz, Lukas and Staresina, Bernhard and Rapp, Rachel and Gonçalves, Pedro J. and Elezi, Ismail and Borger, Valeri and Surges, Rainer and Leal-Taixé, Laura and Macke, Jakob H. and Mormann, Florian},
title = {{Human neuron activity during an 83-minute movie from 2,286 neurons and 29 patients}},
journal = {Scientific data},
year = {2026},
month = jul,
volume = {13},
number = {1},
pages = {1105},
publisher = {Nature Publishing Group},
issn = {2052-4463},
doi = {10.1038/s41597-026-07955-0},
url = {https://doi.org/10.1038/s41597-026-07955-0},
pmid = {42533002},
pmcid = {PMC13424620}
}

RIS

TY - JOUR
AU - Darcher, Alana
AU - Gerken, Franziska
AU - Niediek, Johannes
AU - Kehl, Marcel S.
AU - Reber, Thomas P.
AU - Liebe, Stefanie
AU - Nett, Laura
AU - Racz, Attila
AU - Kunz, Lukas
AU - Staresina, Bernhard
AU - Rapp, Rachel
AU - Gonçalves, Pedro J.
AU - Elezi, Ismail
AU - Borger, Valeri
AU - Surges, Rainer
AU - Leal-Taixé, Laura
AU - Macke, Jakob H.
AU - Mormann, Florian
TI - Human neuron activity during an 83-minute movie from 2,286 neurons and 29 patients
T2 - Scientific data
J2 - Sci Data
PY - 2026
DA - 2026/07/30
VL - 13
IS - 1
SP - 1105
SN - 2052-4463
PB - Nature Publishing Group
DO - 10.1038/s41597-026-07955-0
UR - https://doi.org/10.1038/s41597-026-07955-0
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41597-026-07955-0",
"type": "article-journal",
"title": "Human neuron activity during an 83-minute movie from 2,286 neurons and 29 patients",
"container-title": "Scientific data",
"author": [
{
"family": "Darcher",
"given": "Alana"
},
{
"family": "Gerken",
"given": "Franziska"
},
{
"family": "Niediek",
"given": "Johannes"
},
{
"family": "Kehl",
"given": "Marcel S."
},
{
"family": "Reber",
"given": "Thomas P."
},
{
"family": "Liebe",
"given": "Stefanie"
},
{
"family": "Nett",
"given": "Laura"
},
{
"family": "Racz",
"given": "Attila"
},
{
"family": "Kunz",
"given": "Lukas"
},
{
"family": "Staresina",
"given": "Bernhard"
},
{
"family": "Rapp",
"given": "Rachel"
},
{
"family": "Gonçalves",
"given": "Pedro J."
},
{
"family": "Elezi",
"given": "Ismail"
},
{
"family": "Borger",
"given": "Valeri"
},
{
"family": "Surges",
"given": "Rainer"
},
{
"family": "Leal-Taixé",
"given": "Laura"
},
{
"family": "Macke",
"given": "Jakob H."
},
{
"family": "Mormann",
"given": "Florian"
}
],
"container-title-short": "Sci Data",
"volume": "13",
"issue": "1",
"page": "1105",
"DOI": "10.1038/s41597-026-07955-0",
"PMID": "42533002",
"PMCID": "PMC13424620",
"ISSN": "2052-4463",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41597-026-07955-0",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
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.1038/s41467-026-76939-w [code]
HIPPIE: a generative model for electrophysiological analysis across species, technologies, and modalities.
Journal: Nature communications
In common: Neurodata Without Borders (PyNWB, MatNWB), PyTorch Lightning, PyTorch, 5 other tools, methods / tools, 1 reference
[2] doi:10.1016/j.crmeth.2026.101421 [code]
EthoPy provides an accessible platform for reproducible behavioral neuroscience.
Journal: Cell reports methods
In common: Neurodata Without Borders (PyNWB, MatNWB), seaborn, pandas, 3 other tools, methods / tools, 3 references
[3] doi:10.7554/elife.109717 [code]
Retrosplenial cortex enables context-dependent goal-directed sensorimotor transformation.
Journal: eLife
In common: Neurodata Without Borders (PyNWB, MatNWB), seaborn, pandas, 3 other tools, 3 references
[4] doi:10.1016/j.celrep.2026.117420 [code]
Neural population dynamics of direct electrical stimulation of neocortex.
Journal: Cell reports
In common: Neurodata Without Borders (PyNWB, MatNWB), seaborn, pandas, 3 other tools, 3 references
[5] doi:10.1038/s41467-026-71443-7 [code]
Large-scale single-neuron recording in the human cortex using an ultra-flexible electrode array.
Journal: Nature communications
In common: Neurodata Without Borders (PyNWB, MatNWB), 5 references
[6] doi:10.1523/jneurosci.0038-26.2026 [code]
Multidimensional Feature Tuning in Category Selective Areas of Human Visual Cortex.
Journal: The Journal of neuroscience : the official journal of the Society for Neuroscience
In common: PyTorch, seaborn, pandas, 3 other tools, 3 references
[7] doi:10.7554/elife.107933 [code]
Modality-agnostic decoding of vision and language from fMRI.
Journal: eLife
In common: Nilearn, PyTorch, seaborn, 4 other tools, 2 references
[8] doi:10.7554/elife.110588 [code]
Opening the black box toward a modular approach to spike sorting.
Journal: eLife
In common: Neurodata Without Borders (PyNWB, MatNWB), PyTorch, seaborn, 4 other tools, methods / tools, 1 reference
[9] doi:10.1038/s41592-026-03076-z [code]
Neuropixels Opto: combining high-resolution electrophysiology and optogenetics.
Journal: Nature methods
In common: Neurodata Without Borders (PyNWB, MatNWB), PyTorch, pandas, 3 other tools, 2 references
[10] doi:10.1038/s41467-026-73996-z [code]
Genetic architecture of white matter microstructure captured by unsupervised deep representation learning of fractional anisotropy maps.
Journal: Nature communications
In common: PyTorch Lightning, Nilearn, PyTorch, 5 other tools

Contribute

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

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

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.