OSCR

A lightweight deep convolutional neural network for detecting artifacts in continuous EEG signals.

Code ↔ Paper

14 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 14 matches · 2 of them tie a paragraph to a whole file without given lines: weak matches, whose lines are not tinted
  1. [1] § Materials and methods › Data description › Signal standardization ↔ artifact_identification/preprocessing.py, lines 48 to 94 · score 0.90 · bipolar montage, canonical, resampling, filtering, channel, EEG · Report a mismatch
  2. [2] § Materials and methods › Deep learning method › Model architecture and training ↔ artifact_identification/detectors/eye_movement.py, lines 132 to 190 · score 0.86 · BatchNormalization, MaxPooling1D, Conv1D, Dropout, inferred, kernel · Report a mismatch
  3. [3] § Materials and methods › Deep learning method › Model architecture and training ↔ artifact_identification/detectors/muscle.py, lines 177 to 238 · score 0.86 · BatchNormalization, MaxPooling1D, Conv1D, Dropout, inferred, kernel · Report a mismatch
  4. [4] § Materials and methods › Data description › Referencing and normalization ↔ artifact_identification/preprocessing.py, lines 1 to 45 · score 0.79 · DC offsets, RobustScaler, global normalization, deep learning, preprocessing, filtering · Report a mismatch
  5. [5] § Materials and methods › Performance analysis › Prevalence-adjusted metrics ↔ artifact_identification/detectors/eye_movement.py, lines 232 to 366 · score 0.70 · precision recall curve, target prevalence, PR AUC, metrics · Report a mismatch
  6. [6] § Materials and methods › Performance analysis › Prevalence-adjusted metrics ↔ artifact_identification/detectors/muscle.py, lines 286 to 423 · score 0.70 · precision recall curve, target prevalence, PR AUC, metrics · Report a mismatch
  7. [7] § Materials and methods › Performance analysis › Prevalence-adjusted metrics ↔ artifact_identification/detectors/eye_movement.py, lines 232 to 366 · score 0.70 · partial ROC AUC, target prevalence, FPR limit, metrics · Report a mismatch
  8. [8] § Materials and methods › Performance analysis › Prevalence-adjusted metrics ↔ artifact_identification/detectors/muscle.py, lines 286 to 423 · score 0.70 · partial ROC AUC, target prevalence, FPR limit, metrics · Report a mismatch
  9. [9] § Materials and methods › Data description › Data preprocessing ↔ artifact_identification/preprocessing.py, lines 1 to 45 · score 0.70 · variable sampling rates, channel configurations, deep learning, artifact detection, 250 Hz, preprocessing · Report a mismatch
  10. [10] § Materials and methods › Data description › Data preprocessing ↔ artifact_identification/__init__.py, the whole file · a weak match · score 0.69 · focal loss, model training, EEG artifact detection, network, convolution, eye movement · Report a mismatch
  11. [11] § Materials and methods › Data description › Data preprocessing ↔ artifact_identification/data_preparation.py, lines 1 to 36 · score 0.68 · focal loss parameters, model training, EEG artifact detection, preparation, eye movement, muscle artifact · Report a mismatch
  12. [12] § CRediT authorship contribution statement ↔ artifact_identification/__init__.py, the whole file · a weak match · score 0.65 · Evans Nyanney, Shyam Visweswaran, Zhaohui Geng, Parthasarathy, Thirumala · Report a mismatch
  13. [13] § CRediT authorship contribution statement ↔ artifact_identification/data_preparation.py, lines 1 to 36 · score 0.65 · Evans Nyanney, Shyam Visweswaran, Zhaohui Geng, Parthasarathy, Thirumala · Report a mismatch
  14. [14] § Materials and methods › Data description › Adaptive segmentation and labeling ↔ artifact_identification/preprocessing.py, lines 48 to 94 · score 0.51 · EYEM, MUSC, ELEC, ELPP, SHIV, chewing · 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 · 517 lines · 20 KB · MIT · 4 matches

  1. #!/usr/bin/env python3
  2. """
  3. EEG Preprocessing Pipeline for Deep Lightweight CNN (DLCNN)
  5. A comprehensive pipeline for preprocessing EEG data for deep learning-based artifact detection.
  6. Handles variable sampling rates, channel configurations, and implements standardized steps
  7. for optimal model performance.
  9. Key Features:
  10. - Standardizes sampling rates (250, 256, 400, 512, 1000 Hz)
  11. - Creates bipolar montage and standardizes to 22 canonical channels
  12. - Applies filtering, referencing, and DC offset removal
  13. - Extracts non-overlapping 1s time windows with artifact labeling
  14. - Implements patient-level data splitting to prevent leakage
  15. - Global normalization using RobustScaler for consistent preprocessing
  17. Authors: Evans Nyanney, Parthasarathy D Thirumala, Shyam Visweswaran, Zhaohui Geng
  18. Year: 2025
  19. License: MIT
  20. """
  22. import os
  23. import glob
  24. import logging
  25. from typing import List, Tuple, Dict, Any, Optional
  26. from collections import defaultdict
  27. from pathlib import Path
  29. import numpy as np
  30. import pandas as pd
  31. import mne
  32. from sklearn.preprocessing import RobustScaler
  33. from joblib import Parallel, delayed
  34. from sklearn.model_selection import GroupShuffleSplit
  36. import warnings
  37. warnings.filterwarnings('ignore')
  39. logging.basicConfig(
  40. level=logging.INFO,
  41. format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
  42. )
  43. logger = logging.getLogger(__name__)
  45. __all__ = ['EEGPreprocessingPipeline']
  48. class EEGPreprocessingPipeline:
  49. """
  50. EEG preprocessing pipeline for artifact detection using DLCNN.
  52. This class handles end-to-end preprocessing of EEG data:
  53. - Bipolar montage creation
  54. - Channel standardization (22 canonical channels)
  55. - Resampling, filtering, and referencing
  56. - Windowing and labeling with artifact annotations
  57. - Patient-level train/val/test splitting
  58. - Global normalization for deep learning
  60. Attributes:
  61. target_sampling_rate: Target sampling rate in Hz.
  62. target_channels: Target number of channels.
  63. window_size: Window duration in seconds.
  64. overlap: Fractional overlap between windows.
  65. min_artifact_duration: Minimum duration for valid artifacts.
  66. include_clean_windows: Whether to include clean segments.
  67. clean_label: Label assigned to clean windows.
  68. """
  70. CONFIG = {
  71. 'canonical_channels': [
  72. 'FP1-F7', 'F7-T3', 'T3-T5', 'T5-O1',
  73. 'FP2-F8', 'F8-T4', 'T4-T6', 'T6-O2',
  74. 'A1-T3', 'T3-C3', 'C3-CZ', 'CZ-C4',
  75. 'C4-T4', 'T4-A2',
  76. 'FP1-F3', 'F3-C3', 'C3-P3', 'P3-O1',
  77. 'FP2-F4', 'F4-C4', 'C4-P4', 'P4-O2'
  78. ],
  79. 'bipolar_pairs': [
  80. ('FP1', 'F7'), ('F7', 'T3'), ('T3', 'T5'), ('T5', 'O1'),
  81. ('FP2', 'F8'), ('F8', 'T4'), ('T4', 'T6'), ('T6', 'O2'),
  82. ('A1', 'T3'), ('T3', 'C3'), ('C3', 'CZ'), ('CZ', 'C4'),
  83. ('C4', 'T4'), ('T4', 'A2'),
  84. ('FP1', 'F3'), ('F3', 'C3'), ('C3', 'P3'), ('P3', 'O1'),
  85. ('FP2', 'F4'), ('F4', 'C4'), ('C4', 'P4'), ('P4', 'O2')
  86. ],
  87. 'artifact_mapping': {
  88. 'eyem': 0, 'musc': 1, 'elec': 2, 'chew': 3, 'shiv': 4, 'elpp': 5,
  89. 'eyem_musc': 0, 'eyem_elec': 0, 'musc_elec': 1,
  90. 'eyem_chew': 0, 'chew_musc': 3, 'chew_elec': 3,
  91. 'eyem_shiv': 0, 'shiv_elec': 4,
  92. 'bckg': -1, 'cpsz': -1, 'fnsz': -1, 'gnsz': -1, 'tcsz': -1,
  93. }
  94. }
  96. def __init__(
  97. self,
  98. target_sampling_rate: int = 250,
  99. target_channels: int = 22,
  100. window_size: float = 1.0,
  101. overlap: float = 0.0,
  102. min_artifact_duration: float = 0.1,
  103. include_clean_windows: bool = True,
  104. clean_label: int = 6,
  105. verbose: bool = True,
  106. use_logging: bool = True
  107. ) -> None:
  108. self.target_sampling_rate = target_sampling_rate
  109. self.target_channels = target_channels
  110. self.window_size = window_size
  111. self.overlap = overlap
  112. self.min_artifact_duration = min_artifact_duration
  113. self.include_clean_windows = include_clean_windows
  114. self.clean_label = clean_label
  115. self.verbose = verbose
  116. self.use_logging = use_logging
  118. self.window_samples = int(window_size * target_sampling_rate)
  119. self.step_samples = int(self.window_samples * (1 - overlap))
  121. if use_logging:
  122. self.logger = logging.getLogger(self.__class__.__name__)
  123. self.logger.setLevel(logging.INFO if verbose else logging.WARNING)
  124. else:
  125. self.logger = None
  127. seen: set = set()
  128. self.canonical_channels = [
  129. ch for ch in self.CONFIG['canonical_channels'] if not (ch in seen or seen.add(ch))
  130. ]
  131. self.artifact_mapping = self.CONFIG['artifact_mapping']
  132. self.scaler: Optional[RobustScaler] = None
  133. self.missing_channels_count = 0
  134. self.zero_window_files = 0
  136. def create_bipolar_montage(self, raw: mne.io.Raw) -> mne.io.Raw:
  137. """Create bipolar montage from raw EEG channels."""
  138. clean_ch_names = {}
  139. for ch in raw.ch_names:
  140. if ch.startswith('EEG ') and ch.endswith('-REF'):
  141. clean_ch_names[ch] = ch[4:-4].upper()
  142. else:
  143. clean_ch_names[ch] = ch.upper()
  144. raw.rename_channels(clean_ch_names)
  146. available = set(raw.ch_names)
  147. bipolar_channels = []
  148. for anode, cathode in self.CONFIG['bipolar_pairs']:
  149. if anode in available and cathode in available:
  150. bipolar_channels.append((anode, cathode, f'{anode}-{cathode}'))
  152. if not bipolar_channels:
  153. if self.logger:
  154. self.logger.warning("No valid bipolar pairs found; using original channels.")
  155. return raw
  157. result = mne.set_bipolar_reference(
  158. raw,
  159. anode=[p[0] for p in bipolar_channels],
  160. cathode=[p[1] for p in bipolar_channels],
  161. ch_name=[p[2] for p in bipolar_channels],
  162. verbose=False
  163. )
  164. return result[0] if isinstance(result, tuple) else result
  166. def load_and_validate_file(
  167. self, edf_path: str, csv_path: str
  168. ) -> Tuple[Optional[mne.io.Raw], Optional[pd.DataFrame]]:
  169. """Load and validate EDF and CSV files."""
  170. if csv_path.endswith('_seiz.csv'):
  171. if self.logger:
  172. self.logger.info(f"Skipping seizure file: {csv_path}")
  173. return None, None
  175. try:
  176. raw = mne.io.read_raw_edf(edf_path, preload=True, verbose=False)
  177. annotations = pd.read_csv(csv_path, comment='#')
  179. required_cols = {'start_time', 'stop_time', 'label'}
  180. if not required_cols.issubset(annotations.columns):
  181. raise ValueError(f"Missing columns in {csv_path}")
  183. annotations['label'] = annotations['label'].str.lower()
  185. edf_duration = raw.times[-1]
  186. if annotations['stop_time'].max() > edf_duration + 1.0:
  187. if self.logger:
  188. self.logger.warning(f"Annotations exceed EDF duration in {csv_path}")
  190. if len(annotations) == 0:
  191. if self.logger:
  192. self.logger.warning(f"No annotations in {csv_path}")
  193. return None, None
  195. valid_artifacts = annotations[annotations['label'].isin(self.artifact_mapping)]
  196. if len(valid_artifacts) == 0:
  197. if self.logger:
  198. self.logger.warning(f"No valid artifacts in {csv_path}")
  199. return None, None
  201. return raw, annotations
  203. except Exception as e:
  204. if self.logger:
  205. self.logger.error(f"Error loading {edf_path}: {e}")
  206. return None, None
  208. def resample_eeg(self, raw: mne.io.Raw) -> mne.io.Raw:
  209. """Resample EEG to target sampling rate."""
  210. if raw.info['sfreq'] != self.target_sampling_rate:
  211. if self.logger:
  212. self.logger.info(
  213. f"Resampling from {raw.info['sfreq']} Hz to {self.target_sampling_rate} Hz"
  214. )
  215. raw.resample(self.target_sampling_rate, verbose=False)
  216. return raw
  218. def standardize_channels(self, raw: mne.io.Raw) -> mne.io.Raw:
  219. """Standardize channels to canonical 22-channel bipolar montage."""
  220. raw.rename_channels(lambda x: x.replace('EEG ', '').replace('-REF', '').upper())
  222. has_bipolar = all('-' in ch and not ch.endswith('-REF') for ch in raw.ch_names)
  223. if not has_bipolar:
  224. raw = self.create_bipolar_montage(raw)
  226. current_names = [ch.upper() for ch in raw.ch_names]
  227. available_channels = []
  228. for canonical in self.canonical_channels:
  229. if canonical in current_names:
  230. idx = current_names.index(canonical)
  231. available_channels.append(raw.ch_names[idx])
  233. n_pick = min(len(available_channels), self.target_channels)
  234. if n_pick > 0:
  235. selected = available_channels[:n_pick]
  236. raw.pick_channels(selected, ordered=True, verbose=False)
  237. data, times = raw[:, :]
  238. else:
  239. raw.pick_channels(raw.ch_names[:min(5, len(raw.ch_names))], verbose=False)
  240. data, times = raw[:, :]
  241. selected = raw.ch_names[:len(data)]
  243. if data.shape[0] < self.target_channels:
  244. n_pad = self.target_channels - data.shape[0]
  245. padding = np.zeros((n_pad, data.shape[1]))
  246. combined_data = np.vstack([data, padding])
  247. new_ch_names = selected + [f'PAD_{i}' for i in range(n_pad)]
  248. else:
  249. combined_data = data
  250. new_ch_names = selected[:self.target_channels]
  252. assert combined_data.shape[0] == len(new_ch_names) == self.target_channels
  254. new_info = mne.create_info(new_ch_names, self.target_sampling_rate, ch_types='eeg')
  255. return mne.io.RawArray(combined_data, new_info, verbose=False)
  257. def apply_preprocessing(self, raw: mne.io.Raw) -> mne.io.Raw:
  258. """Apply bandpass (1-40 Hz), notch (50/60 Hz), average reference, and DC removal."""
  259. if self.logger:
  260. self.logger.info("Applying bandpass (1-40 Hz) and notch (50/60 Hz) filters...")
  261. raw.filter(1, 40, verbose=False)
  262. raw.notch_filter([50, 60], verbose=False)
  264. if self.logger:
  265. self.logger.info("Setting average reference and removing DC offset...")
  266. raw.set_eeg_reference('average', verbose=False)
  267. data, times = raw[:, :]
  268. data = data - np.mean(data, axis=1, keepdims=True)
  269. info = mne.create_info(raw.ch_names, self.target_sampling_rate, ch_types='eeg')
  270. return mne.io.RawArray(data, info, verbose=False)
  272. def get_window_label(
  273. self, annotations: pd.DataFrame, start_time: float, end_time: float
  274. ) -> Optional[int]:
  275. """Determine the dominant artifact label in a time window."""
  276. overlapping = annotations[
  277. (annotations['start_time'] <= end_time) &
  278. (annotations['stop_time'] >= start_time)
  279. ]
  281. valid_artifacts = []
  282. for _, row in overlapping.iterrows():
  283. if row['label'] in self.artifact_mapping:
  284. duration = row['stop_time'] - row['start_time']
  285. if duration >= self.min_artifact_duration:
  286. valid_artifacts.append(row)
  288. if not valid_artifacts:
  289. return None
  291. artifact_counts: Dict[int, int] = defaultdict(int)
  292. for row in valid_artifacts:
  293. label = self.artifact_mapping[row['label']]
  294. if label >= 0:
  295. artifact_counts[label] += 1
  297. return max(artifact_counts.items(), key=lambda x: x[1])[0] if artifact_counts else None
  299. def create_time_windows(
  300. self, raw: mne.io.Raw, annotations: pd.DataFrame
  301. ) -> List[Tuple[np.ndarray, int]]:
  302. """Extract non-overlapping time windows with labels."""
  303. data, times = raw[:, :]
  304. data = data.T
  305. windows = []
  307. for start_idx in range(0, len(data) - self.window_samples + 1, self.step_samples):
  308. end_idx = start_idx + self.window_samples
  309. start_time = times[start_idx]
  310. end_time = times[end_idx - 1]
  311. window_data = data[start_idx:end_idx, :]
  313. label = self.get_window_label(annotations, start_time, end_time)
  314. if label is not None:
  315. windows.append((window_data, label))
  316. elif self.include_clean_windows:
  317. windows.append((window_data, self.clean_label))
  319. return windows
  321. def process_single_file(self, edf_path: str, csv_path: str) -> List[Tuple[np.ndarray, int]]:
  322. """Process a single EDF+CSV pair."""
  323. if self.logger:
  324. self.logger.info(f"Processing {Path(edf_path).name}...")
  326. raw, annotations = self.load_and_validate_file(edf_path, csv_path)
  327. if raw is None:
  328. return []
  330. raw = self.resample_eeg(raw)
  331. raw = self.standardize_channels(raw)
  332. raw = self.apply_preprocessing(raw)
  333. windows = self.create_time_windows(raw, annotations)
  335. if len(windows) == 0:
  336. self.zero_window_files += 1
  337. if self.logger:
  338. self.logger.warning(f"No windows extracted from {Path(edf_path).name}")
  340. if self.logger:
  341. self.logger.info(f"Extracted {len(windows)} windows")
  342. return windows
  344. def process_dataset(
  345. self,
  346. edf_dir: str = 'edf/01_tcp_ar',
  347. max_files: Optional[int] = None,
  348. n_jobs: int = 1
  349. ) -> Dict[str, Any]:
  350. """Process all EDF+CSV file pairs in the directory."""
  351. if self.logger:
  352. self.logger.info(f"Processing dataset from {edf_dir}...")
  354. self.missing_channels_count = 0
  355. self.zero_window_files = 0
  357. edf_files = glob.glob(os.path.join(edf_dir, "*.edf"))
  358. if max_files:
  359. edf_files = edf_files[:max_files]
  361. file_pairs = []
  362. for edf_file in edf_files:
  363. base = os.path.splitext(edf_file)[0]
  364. csv_file = base + ".csv"
  365. if os.path.exists(csv_file) and not csv_file.endswith('_seiz.csv'):
  366. file_pairs.append((edf_file, csv_file))
  368. if self.logger:
  369. self.logger.info(f"Found {len(file_pairs)} valid file pairs")
  371. if n_jobs > 1:
  372. if self.logger:
  373. self.logger.info(f"Processing with {n_jobs} parallel jobs...")
  374. results = Parallel(n_jobs=n_jobs)(
  375. delayed(self.process_single_file)(edf, csv) for edf, csv in file_pairs
  376. )
  377. else:
  378. results = []
  379. for i, (edf, csv) in enumerate(file_pairs):
  380. if (i + 1) % 20 == 0 and self.logger:
  381. self.logger.info(f"Processed {i + 1}/{len(file_pairs)} files...")
  382. results.append(self.process_single_file(edf, csv))
  384. all_windows: List[Tuple[np.ndarray, int]] = []
  385. all_sources: List[str] = []
  386. class_counts: Dict[int, int] = defaultdict(int)
  387. file_stats = []
  389. for i, windows in enumerate(results):
  390. for _, label in windows:
  391. class_counts[label] += 1
  392. file_stats.append({
  393. 'file': Path(file_pairs[i][0]).name,
  394. 'windows': len(windows),
  395. 'classes': list(set(w[1] for w in windows))
  396. })
  397. all_windows.extend(windows)
  398. src_id = Path(file_pairs[i][0]).stem
  399. all_sources.extend([src_id] * len(windows))
  401. if self.logger:
  402. self.logger.info(f"Processing Summary:")
  403. self.logger.info(f" Files with missing canonical channels: {self.missing_channels_count}")
  404. self.logger.info(f" Files with zero windows: {self.zero_window_files}")
  406. return {
  407. 'windows': all_windows,
  408. 'window_sources': all_sources,
  409. 'class_counts': dict(class_counts),
  410. 'file_stats': file_stats,
  411. 'total_files': len(edf_files),
  412. 'processed_files': len(file_stats),
  413. 'total_windows': len(all_windows),
  414. 'missing_channels_count': self.missing_channels_count,
  415. 'zero_window_files': self.zero_window_files
  416. }
  418. def prepare_training_data(self, results: Dict[str, Any]) -> Dict[str, Any]:
  419. """Prepare data for DLCNN training with patient-level splitting."""
  420. if self.logger:
  421. self.logger.info("Preparing training data for DLCNN...")
  423. data_list = [w[0] for w in results['windows']]
  424. labels = [w[1] for w in results['windows']]
  426. X = np.array(data_list, dtype=np.float32)
  427. y = np.array(labels, dtype=np.int32)
  429. if self.logger:
  430. self.logger.info(f"Data shape: {X.shape}")
  431. self.logger.info("Applying RobustScaler normalization...")
  433. flat = X.reshape(-1, X.shape[2])
  434. self.scaler = RobustScaler().fit(flat)
  435. X_norm = self.scaler.transform(flat).reshape(X.shape)
  437. groups = np.array(results['window_sources'])
  438. indices = np.arange(len(y))
  440. gss1 = GroupShuffleSplit(n_splits=1, test_size=0.2, random_state=42)
  441. train_val_idx, test_idx = next(gss1.split(indices, y, groups=groups))
  443. gss2 = GroupShuffleSplit(n_splits=1, test_size=0.25, random_state=42)
  444. tv_idx = indices[train_val_idx]
  445. tv_groups = groups[train_val_idx]
  446. tv_y = y[train_val_idx]
  447. train_rel, val_rel = next(gss2.split(tv_idx, tv_y, groups=tv_groups))
  449. train_idx = tv_idx[train_rel]
  450. val_idx = tv_idx[val_rel]
  452. return {
  453. 'X_train_3d': X_norm[train_idx],
  454. 'X_val_3d': X_norm[val_idx],
  455. 'X_test_3d': X_norm[test_idx],
  456. 'y_train': y[train_idx],
  457. 'y_val': y[val_idx],
  458. 'y_test': y[test_idx],
  459. 'idx_train': train_idx,
  460. 'idx_val': val_idx,
  461. 'idx_test': test_idx,
  462. 'X_all_3d': X_norm,
  463. 'y_all': y,
  464. 'original_shape': X.shape,
  465. 'n_classes': len(np.unique(y))
  466. }
  468. def save_data(
  469. self, data_dict: Dict[str, Any], results: Dict[str, Any], output_path: str = '.'
  470. ) -> None:
  471. """Save preprocessed data and metadata."""
  472. if self.logger:
  473. self.logger.info(f"Saving data to {output_path}...")
  475. os.makedirs(output_path, exist_ok=True)
  477. for key in ['X_train_3d', 'X_val_3d', 'X_test_3d', 'X_all_3d']:
  478. if key in data_dict:
  479. np.save(os.path.join(output_path, f"{key}.npy"), data_dict[key])
  480. if self.logger:
  481. self.logger.info(f"Saved {key}.npy")
  483. for key in ['y_train', 'y_val', 'y_test', 'y_all']:
  484. if key in data_dict:
  485. df = pd.DataFrame({key: data_dict[key]})
  486. df.to_csv(os.path.join(output_path, f"{key}.csv"), index=False)
  487. if self.logger:
  488. self.logger.info(f"Saved {key}.csv")
  490. pd.DataFrame(results['file_stats']).to_csv(
  491. os.path.join(output_path, 'file_statistics.csv'), index=False
  492. )
  493. pd.DataFrame(
  494. list(results['class_counts'].items()), columns=['class', 'count']
  495. ).to_csv(os.path.join(output_path, 'class_distribution.csv'), index=False)
  497. summary = {
  498. k: results[k] for k in [
  499. 'total_files', 'processed_files', 'total_windows',
  500. 'missing_channels_count', 'zero_window_files'
  501. ]
  502. }
  503. pd.DataFrame([summary]).to_csv(
  504. os.path.join(output_path, 'processing_summary.csv'), index=False
  505. )
  507. from joblib import dump
  508. dump(self.scaler, os.path.join(output_path, 'robust_scaler.joblib'))
  509. np.savez_compressed(
  510. os.path.join(output_path, 'split_indices.npz'),
  511. idx_train=data_dict['idx_train'],
  512. idx_val=data_dict['idx_val'],
  513. idx_test=data_dict['idx_test']
  514. )
  516. if self.logger:
  517. self.logger.info("Preprocessing completed and data saved.")

preprocessing.py at commit 5d0e234, under MIT · at the source

Overview

Authors: Evans Nyanney1, Parthasarathy D Thirumala2, Shyam Visweswaran3, Zhaohui Geng1
ORCID iDs: Evans Nyanney, Parthasarathy D Thirumala, Shyam Visweswaran, Zhaohui Geng
  1. Ohio University, Department of Industrial and Systems Engineering, 1 Ohio University Drive, 276 Stocker Center, Athens, 45701, OH, USA
  2. University of Pittsburgh, Department of Neurological Surgery, 3550 Terrace Street, Pittsburgh, 15261, PA, USA
  3. University of Pittsburgh, Department of Biomedical Informatics, 5607 Baum Boulevard, Pittsburgh, 15232, PA, USA
Institutions: Ohio University (United States); University of Pittsburgh (United States)
Journal: Clinical neurophysiology practice, volume 11, pages 208-215
Dates: received 12 November 2025; accepted 20 March 2026; published online 24 March 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1016/j.cnp.2026.03.005 · PMID 41953081 · PMCID PMC13054435 · OpenAlex W7140193811
Open access: gold, a free copy (OpenAlex)
Status: code verified (how the code is found and verified)
Categories: EEG (modality), human (organism), clinical / translational (subfield)
Methods: Spectral & time-frequency, Preprocessing, Connectivity, Machine learning, Statistics, Physiology & signal measures
Keywords: Continuous EEG, Artifact detection, Deep learning, Convolutional neural network, Clinical neurophysiology, Signal processing
Topic: EEG and Brain-Computer Interfaces (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Citations: not cited yet (Europe PMC); 27 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 14 matches between paragraphs and lines of code.

evansnyanney/EEG-Artifact-Detection-DLCNN

License: MIT
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 5d0e234c4fa22be602101f270353e1ca57b962aa, 14 June 2026
Languages: Python (30)
Size: 59 files, 30 scripts
Software Heritage: not archived
Found in: “Code and data availability”
Holds: README, license file, environment (pyproject.toml, requirements.txt), tests, documentation
Not found: CITATION.cff, continuous integration
Tools: NumPy (11 files), scikit-learn (7 files), TensorFlow (6 files), MNE-Python (4 files), Keras (3 files), Matplotlib (3 files), pandas (3 files), seaborn (3 files), SciPy (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
32 files
At the source: github.com/evansnyanney/EEG-Artifact-Detection-DLCNN

Zenodo 19554507

License: MIT
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: DataCite
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (11 files), scikit-learn (7 files), TensorFlow (6 files), MNE-Python (4 files), Keras (3 files), Matplotlib (3 files), pandas (3 files), seaborn (3 files), SciPy (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers (HTTP 200)
  • 30 September 2026: the link answers (HTTP 200)
32 files
At the source: doi.org/10.5281/zenodo.19554507

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

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

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:

Read it in the paper: doi.org/10.1016/j.cnp.2026.03.005.

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, pages, dates, 4 authors, 6 keywords, 21 references.

Cite

This paper

Nyanney, E., Thirumala, P. D., Visweswaran, S., & Geng, Z. (2026). A lightweight deep convolutional neural network for detecting artifacts in continuous EEG signals. Clinical neurophysiology practice, 11, 208-215. https://doi.org/10.1016/j.cnp.2026.03.005

BibTeX

@article{nyanney2026lightweight,
author = {Nyanney, Evans and Thirumala, Parthasarathy D and Visweswaran, Shyam and Geng, Zhaohui},
title = {{A lightweight deep convolutional neural network for detecting artifacts in continuous EEG signals}},
journal = {Clinical neurophysiology practice},
year = {2026},
month = mar,
volume = {11},
pages = {208--215},
publisher = {Elsevier},
issn = {2467-981X},
doi = {10.1016/j.cnp.2026.03.005},
url = {https://doi.org/10.1016/j.cnp.2026.03.005},
pmid = {41953081},
pmcid = {PMC13054435}
}

RIS

TY - JOUR
AU - Nyanney, Evans
AU - Thirumala, Parthasarathy D
AU - Visweswaran, Shyam
AU - Geng, Zhaohui
TI - A lightweight deep convolutional neural network for detecting artifacts in continuous EEG signals
T2 - Clinical neurophysiology practice
J2 - Clin Neurophysiol Pract
PY - 2026
DA - 2026/03/24
VL - 11
SP - 208
EP - 215
SN - 2467-981X
PB - Elsevier
DO - 10.1016/j.cnp.2026.03.005
UR - https://doi.org/10.1016/j.cnp.2026.03.005
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.cnp.2026.03.005",
"type": "article-journal",
"title": "A lightweight deep convolutional neural network for detecting artifacts in continuous EEG signals",
"container-title": "Clinical neurophysiology practice",
"author": [
{
"family": "Nyanney",
"given": "Evans"
},
{
"family": "Thirumala",
"given": "Parthasarathy D"
},
{
"family": "Visweswaran",
"given": "Shyam"
},
{
"family": "Geng",
"given": "Zhaohui"
}
],
"container-title-short": "Clin Neurophysiol Pract",
"volume": "11",
"page": "208-215",
"DOI": "10.1016/j.cnp.2026.03.005",
"PMID": "41953081",
"PMCID": "PMC13054435",
"ISSN": "2467-981X",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.cnp.2026.03.005",
"language": "en",
"issued": {
"date-parts": [
[
2026,
3,
24
]
]
}
}

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.1186/s40708-024-00239-6 [code]
Advancing EEG prediction with deep learning and uncertainty estimation.
Journal: Brain informatics
In common: MNE-Python, Keras, TensorFlow, 6 other tools, EEG, 2 references
[2] doi:10.1038/s41598-025-18479-9 [code]
Epileptic seizure detection from electroencephalogram signals based on 1D CNN-LSTM deep learning model using discrete wavelet transform.
Journal: Scientific reports
In common: MNE-Python, Keras, TensorFlow, 5 other tools, EEG, 2 references
[3] doi:10.1002/hbm.26417 [code]
Sex-related patterns in the electroencephalogram and their relevance in machine learning classifiers.
Journal: Human brain mapping
In common: MNE-Python, Keras, TensorFlow, 6 other tools, EEG, 1 reference
[4] doi:10.1097/js9.0000000000003143 [code]
Multimodal deep learning to predict postoperative major adverse cardiac and cerebrovascular events after noncardiac surgery.
Journal: International journal of surgery (London, England)
In common: Keras, TensorFlow, seaborn, 5 other tools, clinical / translational, 2 references
[5] doi:10.1038/s42003-025-08464-3 [code]
How EEG preprocessing shapes decoding performance.
Journal: Communications biology
In common: MNE-Python, seaborn, scikit-learn, 4 other tools, EEG, 3 references
[6] doi:10.1523/eneuro.0160-22.2022 [code]
Improved Manual Annotation of EEG Signals through Convolutional Neural Network Guidance.
Journal: eNeuro
In common: MNE-Python, scikit-learn, pandas, 3 other tools, EEG, 3 references
[7] doi:10.1038/s41597-022-01524-x [code]
EPIC: Annotated epileptic EEG independent components for artifact reduction.
Journal: Scientific data
In common: Keras, TensorFlow, NumPy, EEG, 4 references
[8] doi:10.1038/s41597-026-07120-7 [code]
PhysioMotion Artifact: A task-driven EEG dataset with point-wise motion artifact annotations.
Journal: Scientific data
In common: MNE-Python, scikit-learn, pandas, 2 other tools, EEG, 3 references
[9] doi:10.3390/s25010231 [code]
DHCT-GAN: Improving EEG Signal Quality with a Dual-Branch Hybrid CNN-Transformer Network.
Journal: Sensors (Basel, Switzerland)
In common: Keras, TensorFlow, scikit-learn, 3 other tools, EEG, 2 references
[10] doi:10.1371/journal.pcbi.1010863 [code]
maxATAC: Genome-scale transcription-factor binding prediction from ATAC-seq with deep neural networks.
Journal: PLoS computational biology
In common: Keras, TensorFlow, seaborn, 5 other tools, 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.cnp.2026.03.005.svg)](https://openscicode.org/badge/doi/10.1016/j.cnp.2026.03.005)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.1016/j.cnp.2026.03.005.svg
   :target: https://openscicode.org/badge/doi/10.1016/j.cnp.2026.03.005
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.1016/j.cnp.2026.03.005"><img src="https://openscicode.org/badge/doi/10.1016/j.cnp.2026.03.005.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.