OSCR

PyLossless: A non-destructive EEG processing pipeline.

Code ↔ Paper

18 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 18 matches · 1 of them tie a paragraph to a whole file, not to given lines: a weak match, whose lines are not tinted
  1. [1] § Materials and methods › Pipeline steps › Flag bridged sensors ↔ notebooks/pipeline_algorithms.ipynb, lines 446–527 · score 0.89 · flagging bridged sensors, high median correlation, inter quantile range, low IQR, bridging threshold, bridge indicator
  2. [2] § Materials and methods › Pipeline steps › Filtering ↔ examples/plot_0_implementation.py, lines 394–404 · score 0.84 · low frequency drifts, 1–100 Hz, notch filter, ICLabel, trained, classifier
  3. [3] § Materials and methods › Pipeline steps › Flag uncorrelated sensors ↔ notebooks/pipeline_algorithms.ipynb, lines 558–642 · score 0.77 · lower quantile range, low correlation, rejecting sensors, define epoch, sensors dimension, uncorrelated
  4. [4] § Materials and methods › Pipeline steps › Notation ↔ examples/plot_0_implementation.py, lines 1–53 · score 0.75 · lowercase letters, capital letters, subscripts, superscripts, scalars, denote
  5. [5] § Materials and methods › Pipeline steps › Flag noisy sensors ↔ pylossless/pipeline.py, lines 1034–1063 · score 0.71 · voltage variance, detect outlier, standard deviation, Flag noisy, outlying, threshold
  6. [6] § Materials and methods › Pipeline steps › Flag uncorrelated epochs ↔ pylossless/pipeline.py, lines 1418–1498 · score 0.65 · flag uncorrelated epochs, high impedance, neighboring, thresholds, EEG
  7. [7] § Materials and methods › Pipeline steps › Initial ICA and flagging of outlying independent component (IC) ↔ pylossless/pipeline.py, lines 1418–1498 · score 0.64 · flag_noisy_ics, flag noisy epochs, ICLabel, ICA, EEG, pipeline
  8. [8] § Materials and methods › Pipeline steps › Applying the PyLossless decisions ↔ pylossless/config/rejection.py, lines 13–56 · score 0.63 · RejectionPolicy, subtract, brain, confidence, EOG, class
  9. [9] § Materials and methods › Pipeline steps › Flag noisy sensors ↔ examples/plot_0_implementation.py, lines 210–225 · score 0.59 · right tail, spread, multiply, UQR, median, deviation
  10. [10] § Materials and methods › Pipeline steps › Saving the pipeline output ↔ pylossless/flagging.py, lines 252–330 · score 0.59 · MNE ICALabel, independent component, TSV, derivatives, root, preprocessing
  11. [11] § Materials and methods › Pipeline steps › Initial ICA and flagging of outlying independent component (IC) ↔ examples/plot_0_implementation.py, lines 394–404 · score 0.58 · ICLabel, ICA decompositions, flag noisy, classifier, epochs, pipeline
  12. [12] § Materials and methods › Pipeline steps › Flag bridged sensors ↔ pylossless/pipeline.py, lines 1136–1165 · score 0.56 · flagging bridged, bridged channel, IQR, median, correlation, pipeline
  13. [13] § Materials and methods › Licence and dependencies ↔ pylossless/datasets/datasets.py, the whole file · a weak match · score 0.56 · optional dependency, MNE BIDS, installation, PyLossless, EEG, pipeline
  14. [14] § Materials and methods › Pipeline steps › Saving the pipeline output ↔ pylossless/dash/qcgui.py, lines 48–87 · score 0.55 · project_root, PyLossless pipeline, derivatives, BIDS, MNE, Python
  15. [15] § Materials and methods › Pipeline steps › Final ICA and IC classification ↔ pylossless/flagging.py, lines 252–330 · score 0.55 · MNE ICALabel, independent component, classifier, ICLabel
  16. [16] § Materials and methods › Pipeline steps › Notation ↔ examples/plot_0_implementation.py, lines 1–53 · score 0.54 · single sensor, single epoch, denote, Notation, matrices, dimension
  17. [17] § Materials and methods › Pipeline steps › Flag the rank sensor ↔ notebooks/pipeline_algorithms.ipynb, lines 536–556 · score 0.54 · highest median, correlation coefficient, good sensors, rank, flags, channels
  18. [18] § Materials and methods › Pipeline steps › Flag noisy time periods ↔ examples/plot_0_implementation.py, lines 227–246 · score 0.53 · matrix indicates, standard deviation, vectors, outlier, thresholds, sensors

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 · 750 lines · 25 KB · MIT · 6 matches

  1. r"""
  3. PyLossless Algorithms
  4. =====================
  6. This tutorial explains the calculations that PyLossless performs at each step of the
  7. pipeline. We will use example EEG data to demonstrate the
  8. calculations.
  10. .. note::
  11. You can open this notebook in
  12. `Google Colab <https://colab.research.google.com/drive/1ecyNo10oFgpbVNuD7Ztgr2fs8XkpfOYo?usp=sharing>`_!
  14. .. _notation:
  16. Notation
  17. --------
  18. Before we begin, we define some notation that will be used throughout the text:
  20. - We start with a 3D matrix of EEG data,
  21. :math:`X \in \mathbb{R}^{S_\mathcal{G} \times E_\mathcal{G} \times T}`,
  22. where :math:`S_\mathcal{G}` and :math:`E_\mathcal{G}` are the sets of good sensors and
  23. epochs, respectively, and :math:`T`, is the number of samples(i.e. time-points).
  25. - ``s``, ``e``, and ``t`` are sensor, epochs, and samples, respectively.
  27. - We use superscripts to denote operations across a dimension, and we use subscripts to
  28. denote indexing a dimension.
  30. - We refer to a single sensor :math:`i` as
  31. :math:`X\big|_{s=i} \in \mathbb{R}^{E_\mathcal{G} \times T}`,
  32. with :math:`i \in S_\mathcal{G}`.
  34. - We refer to a single epoch :math:`j` as
  35. :math:`X\big|_{e=j} \in \mathbb{R}^{S_\mathcal{G} \times T}`,
  36. with :math:`j \in E_\mathcal{G}`.
  38. - We denote sensor-specific thresholds for rejecting epochs as
  39. :math:`\tau^e_i \in \mathbb{R}^{S_\mathcal{G}}`
  41. - We denote epoch-specific thresholds for rejecting sensors as
  42. :math:`\tau^s_j \in \mathbb{R}^{E_\mathcal{G}}`
  44. - We denote *quantiles* as :math:`Q\#^{dim}`: i.e. :math:`Q75^s` is the 75th *quantile*
  45. along the sensor dimension. The function :math:`Q75^s(X)` computes the 75th quantile
  46. along the :math:`s` dimension of matrix :math:`X`, resulting in a matrix noted
  47. :math:`X^{Q75^s} \in \mathbb{R}^{E \times T}`.
  49. Throughout the text, we use capital letters for matrices and lowercase letters for
  50. scalars. For example, the data point for sensor :math:`i`, epoch :math:`j`, and
  51. time :math:`k` is denoted as :math:`X\big|_{s=i; e=j; t=k} = x_{ijk} \in \mathbb{R}`,
  52. and :math:`X=\{x_{ijk}\}`.
  53. """
  55. # %%
  56. # Imports and data loading
  57. # ------------------------
  58. from pathlib import Path
  60. import numpy as np
  62. import mne
  63. from mne.datasets import sample
  65. import pylossless as ll
  67. # Load example mne data
  68. raw = ll.datasets.load_simulated_raw()
  70. # %%
  71. # Load a PyLossless configuration file
  72. # ------------------------------------
  73. # Let's load a PyLossless configuration file. This file contains the parameters that
  74. # will be used for each step of the pipeline. For example, the ``noisy_channels``
  75. # section contains the parameters for the :ref:`noisy_sensors` step. We can modify
  76. # these parameters to change the behavior of the pipeline. For example, we can change
  77. # the percent of epochs that a sensor must be noisy for it to be flagged via the
  78. # ``flag_crit`` parameter.
  79. config = ll.config.Config()
  80. config.load_default()
  81. config["noisy_channels"]["outliers_kwargs"]["lower"] = 0.25 # lower quantile
  82. config["noisy_channels"]["outliers_kwargs"]["upper"] = 0.75 # upper quantile
  83. config["noisy_channels"]["flag_crit"] = 0.30 # percent of epochs that a sensor must be noisy
  84. config.save("test_config.yaml")
  86. # %%
  87. # Create a pipeline instance
  88. # --------------------------
  89. pipeline = ll.LosslessPipeline("test_config.yaml")
  90. pipeline.raw = raw
  91. raw.plot()
  93. # %%
  94. # Input Data
  95. # ----------
  96. #
  97. # First, we epoch the data to be used for subsequent steps.
  98. # Let our 3D matrix below be defined as :math:`X \in \mathbb{R}^{S \times E \times T}`
  99. # where :math:`X` is a matrix of real numbers and of dimension :math:`S` sensors
  100. # :math:`\times$ E` epochs `\times T` times.
  101. #
  102. epochs = pipeline.get_epochs()
  104. # %%
  105. #
  106. # Let's convert our epochs object into a named :class:`xarray.DataArray` object.
  107. from pylossless.pipeline import epochs_to_xr
  109. #
  110. epochs_xr = epochs_to_xr(epochs, kind="ch")
  111. epochs_xr # 277 epochs, 50 sensors, 602 samples per epoch
  114. # %%
  115. # .. _robust_reference:
  116. #
  117. # Robust Average Reference
  118. # ------------------------
  119. #
  120. # .. figure:: https://raw.githubusercontent.com/scott-huberty/wip_pipeline-figures/main/robust_rereference.png
  121. # :align: center
  122. # :alt: Robust Average Reference graphic.
  123. #
  124. # Robust Average Reference. The figure shows the steps for robust average referencing.
  125. # See the text below for descriptions of mathematical notation.
  126. #
  127. # Before the pipeline can begin, we must average reference the data. This is because
  128. # the pipeline uses data distributions to identify noisy sensors, and For EEG data that
  129. # uses an online reference to a single electrode, sensors that are further from the
  130. # reference will have a higher voltage variance, and the pipeline will be biased to
  131. # flag these sensors as noisy. The average reference, which subtracts the average
  132. # signal across sensors from each individual sensor, will ensure an even playing field.
  133. # Howeer, we dont want to include noisy sensors in the average reference signal. So we
  134. # will identify noisy sensors and and leave them out of the average reference signal.
  136. # %%
  137. sample_std = epochs_xr.std("time")
  138. q25_ch = sample_std.quantile(0.25, dim="ch")
  139. q50_ch = sample_std.median(dim="ch")
  140. q75_ch = sample_std.quantile(0.75, dim="ch")
  141. ch_dist = sample_std - q50_ch # center the data
  142. ch_dist /= q75_ch - q25_ch # shape (chans, epoch)
  144. mean_ch_dist = ch_dist.mean(dim="epoch") # shape (chans)
  146. # find the median and 25 and 75 percentiles
  147. # of the mean of the channel distributions
  148. mdn = np.median(mean_ch_dist)
  149. deviation = np.diff(np.quantile(mean_ch_dist, [0.25, 0.75]))
  151. leave_out = mean_ch_dist.ch[mean_ch_dist > mdn + 6 * deviation].values.tolist()
  152. leave_out
  154. # %%
  155. ref_chans = [ch for ch in epochs.pick("eeg").ch_names if ch not in leave_out]
  156. pipeline.raw.set_eeg_reference(ref_channels=ref_chans)
  158. # %%
  159. #
  160. # .. _noisy_sensors:
  161. #
  162. # Flag Noisy Sensors
  163. # ------------------
  164. # .. figure:: https://raw.githubusercontent.com/scott-huberty/wip_pipeline-figures/main/Flag_noisy_sensors.png
  165. # :align: center
  166. # :alt: Flag Noisy Sensors graphic.
  167. #
  168. # Flag Noisy Sensors. The figure shows the steps for flagging noisy sensors. See the text below
  169. # for descriptions of mathematical notation.
  170. #
  172. # %%
  173. # Since we applied a robust average reference to the raw data, we will need to re-epoch
  174. # the data:
  175. epochs = pipeline.get_epochs()
  176. epochs_xr = epochs_to_xr(epochs, kind="ch")
  178. # First we take standard deviation of
  179. # :math:`X \in \mathbb{R}^{S \times E \times T}` across the samples dimension :math:`t`
  180. # resulting in a 2D matrix :math:`X^{\sigma_{t}} \in \mathbb{R}^{S \times E}`
  181. trim_ch_sd = epochs_xr.std("time")
  182. trim_ch_sd
  184. # %%
  185. # a) Take the 50th and 75th quantile across dimension sensor of :math:`X^{\sigma_{t}}`
  186. # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  187. #
  188. # This operation results in two 1D vectors of size :math:`E`:
  189. #
  190. # .. math::
  191. # X^{{\sigma}_t{Q50^s}} = Q50^s(X^{\sigma_{t}}) \in \mathbb{R}^{E}
  192. # .. math::
  193. # X^{{\sigma}_t{Q75^s}} = Q75^s(X^{\sigma_{t}}) \in \mathbb{R}^{E}
  195. # %%
  196. q50, q75 = trim_ch_sd.quantile([0.5, 0.75], dim="ch")
  197. q50 # a 1D array of median standard deviation values across channels for each epoch
  199. # %%
  200. # b) Define an Upper Quantile Range as :math:`Q75 - Q50`
  201. # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  202. #
  203. # .. math::
  204. # UQR^s = X^{{\sigma}_T{Q75}^s} - X^{{\sigma}_T{Q50}^s}
  205. #
  206. # This operation results in a 1D vector of size :math:`E`.
  207. uqr = q75 - q50
  208. uqr
  210. # %%
  211. # c) Identify outlier Indices :math:`(i, j)`
  212. # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  213. #
  214. # We multiply a constant :math:`k` by the :math:`UQR` to define a measure for the
  215. # spread of the right tail of the distribution of :math:`X^{\sigma_{t}}` values and
  216. # add it to the median of :math:`X^{\sigma_{t}}` to obtain epoch-specific standard
  217. # deviation threshold for outliers:
  218. #
  219. # .. math::
  220. # \tau^s_j = X^{{\sigma}_T{Q50}^S} + UQR^s\times k
  221. #
  222. # That is, :math:`\tau^s_j` is the epoch-specific threshold for the epoch :math:`j`
  223. k = 3
  224. upper_threshold = q50 + q75 * k
  225. upper_threshold # epoch specific thresholds
  227. # %%
  228. # Now, we compare our 2D standard deviation matrix to the threshold vector of
  229. # :math:`\tau^e_j`:
  230. #
  231. # .. math::
  232. # X^{\sigma_{t}} \big|_{e=j} > \tau^s_j
  233. #
  234. # resulting in the indicator matrix :math:`C \in \{0, 1\}^{S \times E}=\{c_{ij}\}`:
  235. #
  236. # .. math::
  237. # c_{ij} =
  238. # \begin{cases}
  239. # 0 & \text{if } x^{\sigma_{t}}_{ij} < \tau^s_j \\
  240. # 1 & \text{if } x^{\sigma_{t}}_{ij} \geq \tau^s_j
  241. # \end{cases}
  242. #
  243. # Each element of this matrix indicates whether sensor :math:`i` is an outlier at an epoch
  244. # :math:`j`.
  245. outlier_mask = trim_ch_sd > upper_threshold
  246. outlier_mask
  248. # %%
  249. # d) Identify noisy sensors part 1
  250. # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  251. #
  252. # To identify outlier sensors, we average across the epoch dimension of our indicator
  253. # matrix :math:`C` and obtain :math:`C^{\mu_e} \in \mathbb{R}^{S_\mathcal{G}}`, which
  254. # is a vector of fractional numbers :math:`c^{\mu_e}_i` representing the percentage of
  255. # epochs for which that sensor is an outlier.
  256. percent_outliers = outlier_mask.astype(float).mean("epoch")
  257. percent_outliers # percent of epochs that sensor is an outlier
  259. # %%
  260. # e) Identify noisy sensors part 2
  261. # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  262. #
  263. # Next, we define a threshold :math:`\tau^{p}` (:math:`p` for percentile;
  264. # default, ``.20``) as a cutoff point for determining if a sensor should be marked
  265. # artifactual. The sensor :math:`i` is flagged as noisy if
  266. # :math:`c^{\mu_e}_i > \tau^{p}`. That is, if the sensor is an outlier for more than
  267. # :math:`\tau^{p}` percent of the epochs, it is flagged as noisy.
  268. p_threshold = config["noisy_channels"]["flag_crit"] # 0.3, or 30%
  269. noisy_chs = percent_outliers[percent_outliers > p_threshold].coords.to_index().values
  270. noisy_chs
  272. # %%
  273. # f) Add the noisy sensors to the pipeline flags
  274. # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  275. #
  276. # Let's add the noisy sensors to the pipeline flags.
  277. pipeline.flags["ch"].add_flag_cat(kind="noisy", bad_ch_names=noisy_chs)
  278. pipeline.raw.info["bads"].extend(pipeline.flags["ch"]["noisy"].tolist())
  279. pipeline.flags["ch"]
  281. # %%
  282. #
  283. # .. _noisy_epochs:
  284. #
  285. # Flag Noisy Epochs
  286. # -----------------
  287. #
  288. # This step closely resembles the :ref:`noisy_sensors` step. For the sake of brevity
  289. # we will be more concise in the documentation.
  291. # %%
  292. #
  293. # .. figure:: https://raw.githubusercontent.com/scott-huberty/wip_pipeline-figures/main/Flag_noisy_epochs.png
  294. # :align: center
  295. #
  296. # Flag Noisy Epochs. The figure shows the steps for flagging noisy epochs. See the text below
  297. # for descriptions of mathematical notation.
  298. #
  300. # %%
  301. # a) Take standard deviation across the samples dimension :math:`t`
  302. # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  303. #
  304. # Take a moment below to notice that the sensors flagged in the prior setp are not in
  305. # ``epochs_xr`` below:
  306. epochs = pipeline.get_epochs()
  307. # Let's make our epochs array into a named Array
  308. epochs_xr = epochs_to_xr(epochs, kind="ch")
  309. trim_ch_sd = epochs_xr.std("time")
  310. trim_ch_sd.coords["ch"]
  312. # %%
  313. # b) Compute 50th and 75th quantile across epochs and the UQR
  314. # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  315. #
  316. # Like before, We Take the median and 70th quantile, but now we operate across epochs,
  317. # resulting in two 1D vector's of size ``n_good_sensors`` :math:`S_\mathcal{G}`
  318. #
  319. # .. math::
  320. # X^{{\sigma}_t{Q50^e}} = Q50^e(X^{\sigma_{t}}) \in \mathbb{R}^{S_\mathcal{G}}
  321. # .. math::
  322. # X^{{\sigma}_t{Q75^e}} = Q75^e(X^{\sigma_{t}}) \in \mathbb{R}^{S_\mathcal{G}}
  323. # .. math::
  324. # UQR^e = (X^{{\sigma}_T{Q75}^e} - X^{{\sigma}_T{Q50}^e})
  327. # %%
  328. # c) Define sensor-specific thresholds for rejecting epochs :math:`\tau^e_i`
  329. # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  330. #
  331. # Our sensor-specifc threshold for rejecting epochs is defined by:
  332. #
  333. # .. math::
  334. # \tau^e_i = X^{{\sigma}_T{Q50}^e} + UQR^e\times k
  335. q50, q75 = trim_ch_sd.quantile([0.5, 0.75], dim="epoch")
  336. uqr_epoch = q75 - q50
  337. uqr_epoch
  339. # %%
  340. k = 8
  341. upper_threshold = q50 + uqr_epoch * k
  342. upper_threshold
  344. # %%
  345. # d) Identify Outlier indices
  346. # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  347. #
  348. # The indicator matrix is defined by:
  349. #
  350. # .. math::
  351. # c_{ij} =
  352. # \begin{cases}
  353. # 0 & \text{if } x^{\sigma_{t}}_{ij} < \tau^e_i \\
  354. # 1 & \text{if } x^{\sigma_{t}}_{ij} \geq \tau^e_i
  355. # \end{cases}
  356. #
  357. #
  358. # To identify outlier **epochs**, we average across the **sensor** dimension of our
  359. # indicator matrix :math:`C` and obtain
  360. # :math:`C^{\mu_s} \in \mathbb{R}^{E_\mathcal{G}}`, which is a vector of numbers
  361. # :math:`c^{\mu_s}_j` representing the percentage of **sensors** for which that epoch
  362. # is an outlier.
  363. outlier_mask = trim_ch_sd > upper_threshold
  364. outlier_mask
  366. # %%
  367. percent_outliers = outlier_mask.astype(float).mean("ch")
  368. percent_outliers
  370. # %%
  371. # e) Identify noisy epochs
  372. # ^^^^^^^^^^^^^^^^^^^^^^^^
  373. #
  374. # Next, we define a fractional threshold :math:`\tau^{p}` as a cutoff point for
  375. # determining if a epoch should be marked artifactual. The epoch :math:`j` is flagged
  376. # as noisy if :math:`c^{\mu_s}_j > \tau^{p}`.
  377. bad_epochs = percent_outliers[percent_outliers > p_threshold].coords.to_index().values
  378. bad_epochs
  380. # %%
  381. # f) Add the noisy epochs to the pipeline flags
  382. # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  383. #
  384. # Let's add the outlier epochs to our flags
  385. # These will be added directly as :class:`mne.Annotations` to the raw data.
  386. pipeline.flags["epoch"].add_flag_cat(
  387. kind="noisy", bad_epoch_inds=bad_epochs, epochs=epochs
  388. )
  389. pipeline.raw.annotations.description
  391. # %%
  392. pipeline.raw.plot()
  394. # %%
  395. # Filtering
  396. # ---------
  397. #
  398. # After flagging noisy sensors and epochs, we filter the data. By default,
  399. # The pipeline uses a 1-100Hz bandpass filter. This is because 1), ICA decompositions
  400. # are more stable when low frequency drifts are removed, and 2) the ICLabel classifier
  401. # is trained on data that has been filtered between 1-100Hz. A notch filter can also be
  402. # optionally specified.
  403. pipeline.config["filtering"]["notch_filter_args"]["freqs"] = [50]
  404. pipeline.filter()
  406. # %%
  407. # Find Nearest Neighbours & return Maximum Correlation
  408. # ----------------------------------------------------
  409. #
  410. # .. figure:: https://raw.githubusercontent.com/scott-huberty/wip_pipeline-figures/main/Nearest_neighbors.png
  411. # :align: center
  412. # :alt: Nearest Neighbors graphic.
  413. #
  414. # Nearest Neighbors. The figure shows the steps for finding nearest neighbors. See the text below
  415. # for descriptions of mathematical notation.
  416. #
  418. # %%
  419. # Whereas :ref:`noisy_sensors` and :ref:`noisy_epochs` operated on a 2D matrix of
  420. # standard deviation values, The next few steps will operate on correlation
  421. # coefficients. Here we describe the procedure for defining the 2D matrix of correlation
  422. # coefficients.
  424. # %%
  425. from pylossless.pipeline import chan_neighbour_r
  427. # %%
  428. #
  429. # Notice that our flagged epochs are dropped.
  430. epochs = pipeline.get_epochs()
  432. # %%
  433. # a) Calculate Correlation Coefficients between each Sensor and its neighboring eighbors
  434. # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  435. #
  436. # - For each good sensor $i$ in :math:`S_{\mathcal{G}}`, we select its :math:`N` nearest
  437. # neighbors. I.e. the :math:`N` sensors that are closest to it.
  438. #
  439. # - We call the sensor :math:`i` the *origin*, and its nearest neighbors :math`\hat{s_l}`
  440. # with :math:`l \in \{1, 2, \ldots, N\}`
  441. #
  442. # - Then, for each epoch :math:`j`, we calculate the correlation coefficient
  443. # :math:`\rho^t_{(i,\hat{s_l}),j}` between origin sensor :math:`i` and each neighbor
  444. # :math:`\hat{s_l}` across dimension :math:`t` (samples), returning a 3D matrice of
  445. # correlation coefficients:
  446. #
  447. # .. math::
  448. # \mathrm{P}^t = \{\rho^t_{(i, \hat{s_l}),j}\} \in \mathbb{R}^{S_G \times E_G \times n}
  449. #
  450. # Finally, we select the maximum correlation coefficient across the neighbor dimension
  451. # :math:`n`:
  452. #
  453. # .. math::
  454. # \mathrm{P}^{t,{\text{max}}^n}= \max\limits_{\hat{s_l}} \rho^t_{(i, \hat{s_l}),j}
  455. #
  456. # Returning a 2D matrix where each value at :math:`(i, j)` is the maximum correlation
  457. # coefficient between sensor :math:`i` and its :math:`N` nearest neighbors, at each epoch
  458. # :math:`j`
  460. # %%
  461. data_r_ch = chan_neighbour_r(epochs, nneigbr=3, method="max")
  462. # maximum correlation out of correlations between ch and its 3 neighbors
  463. data_r_ch
  465. # %%
  466. # This matrix :math:`\mathrm{P}^{t,{\text{max}}^n}` will be used in the steps below.
  468. # %%
  469. # Flag Bridged Sensors
  470. # --------------------
  471. #
  472. # .. figure:: https://raw.githubusercontent.com/scott-huberty/wip_pipeline-figures/main/Flag_bridged_sensors.png
  473. # :align: center
  474. # :alt: Flag Bridged Sensors graphic.
  475. #
  476. # Flag Bridged Sensors. The figure shows the steps for flagging bridged sensors.
  477. # See the text below for descriptions of mathematical notation.
  478. #
  480. # %%
  481. # a) Calculate the 50th, 75th quantile and IQR across epochs
  482. # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  483. #
  484. # .. math::
  485. # IQR^e = \mathrm{P}^{t,{\text{max}}^nQ75^e} - \mathrm{P}^{t,{\text{max}}^nQ25^e}
  486. #
  487. # For each sensor, divide the median across epochs by the IQR across epochs. Bridged
  488. # channels should have a high median correlation but a low IQR of the correlation.
  489. # We call this measure the bridge-indicator.
  490. #
  491. # .. math::
  492. # \mathcal{B}_s = \frac{\mathrm{P}^{t,{\text{max}}^nQ50^e}}{IQR^e}
  493. #
  494. # b) Define a bridging threshold
  495. # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  496. # Now, take the 25th, 50th, and 75th quantile of :math:`\mathcal{B}_s` across sensors,
  497. # And calculate the :math:`IQR^s`. A channel :math:`i` is bridged if
  498. #
  499. # .. math::
  500. # \mathcal{B}_i > B^{Q50^s} +k \times IQR^s
  501. #
  503. # %%
  504. import scipy
  505. from functools import partial
  507. # %%
  508. msr = data_r_ch.median("epoch") / data_r_ch.reduce(scipy.stats.iqr, dim="epoch")
  509. # msr is a 1D vector of size n_sensors
  510. config_trim = 40
  511. config_bridge_z = 6
  512. #
  513. trim = config_trim
  514. if trim >= 1:
  515. trim /= 100
  516. trim /= 2 # .20 and will be used as (.20, .20)
  517. #
  518. trim_mean = partial(scipy.stats.mstats.trimmed_mean, limits=(trim, trim))
  519. trim_std = partial(scipy.stats.mstats.trimmed_std, limits=(trim, trim))
  520. #
  521. z_val = config_bridge_z # 6
  522. mask = msr > msr.reduce(trim_mean, dim="ch") + z_val * msr.reduce(
  523. trim_std, dim="ch"
  524. ) # bridged chans
  525. #
  526. bridged_ch_names = data_r_ch.ch.values[mask]
  527. bridged_ch_names
  529. # %%
  530. # Let's add the outlier channels to our flags
  531. bad_chs = bridged_ch_names
  532. pipeline.flags["ch"].add_flag_cat(kind="bridged", bad_ch_names=bad_chs)
  533. pipeline.flags["ch"]
  535. # %%
  536. # Identify the Rank Channel
  537. # -------------------------
  538. #
  539. # Because the pipeline uses an average reference before the ICA decomposition, it is
  540. # necessary to account for rank deficiency (i.e., every sensor in the montage is
  541. # linearly dependent on the other channels due to the common average reference). To
  542. # account for this, the pipeline flags the sensor (out of the remaining good sensors)
  543. # with the highest median of the max correlation coefficient with its neighbors
  544. # (across epochs):
  545. #
  546. # .. math::
  547. # \begin{equation}
  548. # i = \text{arg}\max\limits_i \rho_{i}^{t,{\text{max}}^n,median^j}
  549. # \end{equation}
  550. #
  551. # This sensor has the least unique time-series out of the remaining set of good sensors
  552. # :math:`S_\mathcal{G}` and is flagged by the pipeline as ``”rank”``. Note that this
  553. # sensor is not flagged because it contains artifact, but only because one of the
  554. # remaining sensors needs to be removed to address rank deficiency before ICA
  555. # decomposition is performed. By choosing this sensor, we are likely to lose little
  556. # information because of its high correlation with its neighbors. This sensor can be
  557. # reintroduced after the ICA has been applied for artifact corrections.
  559. # %%
  560. good_chs = [
  561. ch for ch in data_r_ch.ch.values if ch not in pipeline.flags["ch"].get_flagged()
  562. ]
  563. data_r_ch_good = data_r_ch.sel(ch=good_chs)
  565. flag_ch = [str(data_r_ch_good.median("epoch").idxmax(dim="ch").to_numpy())]
  566. pipeline.flags["ch"].add_flag_cat(kind="rank", bad_ch_names=flag_ch)
  567. pipeline.flags["ch"]
  569. # %%
  570. # Flag low correlation Epochs
  571. # ---------------------------
  572. #
  573. # This step is designed to identify time periods in which many sensors are
  574. # uncorrelated with neighboring sensors. It is similar to the :ref:`noisy_sensors` step,
  575. #
  576. # Again we calculate the 25th and 50th quantile
  577. # of :math:`\mathrm{P}^{t,{\text{max}}^n}`, across the epochs dimension, and calculate
  578. # the lower quantile range :math:`LQR^s`. This results in vectors
  579. # :math:`\mathrm{P}^{t,{\text{max}}^nQ25^e}` and
  580. # :math:`\mathrm{P}^{t,{\text{max}}^nQ50^e}` of size :math:`S_\mathcal{G}`. As for previous
  581. # steps, we define sensor-specific thresholds for flagging epochs:
  582. #
  583. # .. math::
  584. # \begin{equation}
  585. # \tau^e = \mathrm{P}^{t,{\text{max}}^nQ50^e} - LQR^e\times k
  586. # \end{equation}
  587. #
  588. # And the corresponding indicator matrix:
  589. #
  590. # .. math::
  591. # \begin{equation}
  592. # c_{ij} =
  593. # \begin{cases}
  594. # 1 & \text{if } \rho^{t,{\text{max}}^n}_{ij} < \tau^e_i \\
  595. # 0 & \text{if } \rho^{t,{\text{max}}^n}_{ij} \geq \tau^e_i
  596. # \end{cases}
  597. # \end{equation}
  598. #
  599. # We average the indicator matrix across sensors and obtain a vector :math:`C^{\mu_s}`
  600. # that we use to flag uncorrelated epochs using the following criterion:
  601. #
  602. # .. math::
  603. # c^{\mu_e}_i > \tau^{p}.
  604. #
  606. # %%
  607. # Step a
  608. q25, q50 = data_r_ch.quantile([0.25, 0.5], dim="epoch")
  609. #
  610. # Define the LQR
  611. lqr = q50 - q25
  612. #
  613. # define a threshold
  614. k = 3
  615. lower_threshold = q50 - lqr * k
  616. #
  617. outlier_mask = data_r_ch < lower_threshold
  618. #
  619. percent_outliers = outlier_mask.astype(float).mean("ch")
  620. #
  621. p_threshold = 0.2
  622. bad_epochs = percent_outliers[percent_outliers > p_threshold].coords.to_index().values
  623. #
  624. # Add the outlier epochs to our flags
  625. pipeline.flags["epoch"].add_flag_cat(
  626. kind="uncorrelated", bad_epoch_inds=bad_epochs, epochs=epochs
  627. )
  628. pipeline.raw.annotations.description
  630. # %%
  631. # in this case, no epochs were flagged as uncorrelated.
  632. #
  634. # %%
  635. # Flag low correlation Sensors
  636. # -----------------------------
  637. #
  638. # .. figure:: https://raw.githubusercontent.com/scott-huberty/wip_pipeline-figures/main/Flag_uncorrelated_sensors.png
  639. # :align: center
  640. # :alt: Flag Uncorrelated Sensors graphic.
  641. #
  642. # Flag Uncorrelated Sensors. The figure shows the steps for flagging uncorrelated
  643. # sensors. See the text below for descriptions of mathematical notation.
  644. #
  645. # This step is designed to identify sensors that have an unusually low correlation with
  646. # neighboring sensors. The operations involved by this step are similar to those of the
  647. # :ref:`noisy_sensors` step, except we use maximal nearest neighbor correlations instead
  648. # of dispersion and the left instead of the right tail of the distribution to set
  649. # the threshold for outliers.
  651. # %%
  652. # a) Take lower quantile range and defined sensor-specific thresholds
  653. # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  654. #
  655. # We get the indicator matrix as described previously, using
  656. #
  657. # .. math::
  658. # \tau^e_i = \mathrm{P}^{t,{\text{max}}^nQ50^e} - LQR^e\times k
  659. #
  660. # and
  661. #
  662. # .. math::
  663. # c_{ij} =
  664. # \begin{cases}
  665. # 1 & \text{if } \rho^{t,{\text{max}}^n}_{ij} < \tau^e_i \\
  666. # 0 & \text{if } \rho^{t,{\text{max}}^n}_{ij} \geq \tau^e_i
  667. # \end{cases}
  669. # %%
  670. # b) Identify uncorrelated sensors
  671. # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  672. #
  673. # We define a threshold as we did in the previous step and flag uncorrelated epochs
  674. # :math:`j` if :math:`c^{\mu_s}_j > \tau^{p}`.
  676. # %%
  677. q25, q50 = data_r_ch.quantile([0.25, 0.5], dim="ch")
  678. #
  679. # Define LQR
  680. lqr = q50 - q25
  681. #
  682. # define a threshold
  683. k = 3
  684. lower_threshold = q50 - lqr * k
  685. #
  686. # Identify correlations less than the threshold
  687. outlier_mask = data_r_ch < lower_threshold
  688. percent_outliers = outlier_mask.astype(float).mean("epoch")
  689. #
  690. p_threshold = 0.2
  691. bad_chs = percent_outliers[percent_outliers > p_threshold].coords.to_index().values
  692. #
  693. # Add the outlier channels to our flags
  694. pipeline.flags["ch"].add_flag_cat(kind="uncorrelated", bad_ch_names=bad_chs)
  695. pipeline.flags["ch"]
  697. # %%
  698. # In this case, no sensors were flagged as uncorrelated.
  700. # %%
  701. # Run Initial ICA
  702. # ---------------
  703. #
  704. # The pipeline by runs ICA two times. The first ICA is only used to identify
  705. # noisy periods in its IC activation time-series. For this reason, the pipeline
  706. # uses the FastICA algorithm for speed.
  708. # %%
  709. pipeline.run_ica("run1")
  711. # %%
  712. # Flag Noisy IC Activation time-periods
  713. # -------------------------------------
  714. #
  715. # This step follows the same procedure as the :ref:`noisy_sensors` step, except that
  716. # the data is now the IC activation time-series. thus we start with a 3D matrix
  717. # :math:`X_{ica} \in \mathbb{R}^{I_\mathcal{G} \times E_\mathcal{G} \times T}` of
  718. # IC time-courses rather than scalp EEG data and where :math:`I` is the set of
  719. # independent components.
  720. #
  722. # %%
  723. pipeline.flag_noisy_ics()
  725. # %%
  726. pipeline.raw.annotations.description
  728. # %%
  729. # Run Final ICA
  730. # -------------
  731. #
  732. # Now The pipeline runs the final ICA decomposition, this time using the extended
  733. # Infomax algorithm. Note that any sensors or time-periods that have been flagged
  734. # up to this point will not be passed into the ICA decomposition. For the sake of
  735. # time, we will not run the second ICA here, as there are no more pipeline calculations.
  737. # %%
  738. # Run ICLabel Classifier
  739. # ----------------------
  740. #
  741. # The pipeline will run the ICLabel classifier on the final ICA, which will produce a
  742. # label for each IC, one of ``"brain"``, ``"muscle"``, ``"eog"`` (eye), ``"ecg"``
  743. # (heart), ``line_noise``, or ``"channel_noise"``.
  744. #
  745. #
  746. # Conclusion
  747. # ----------
  748. # And that's all! See the other pylossless tutorials for brief examples on running the
  749. # pipeline on your own data, and rejecting the flagged data.
  750. #

plot_0_implementation.py at commit 0f4bccf, under MIT · at the source

Overview

Authors: Scott Huberty1, James Desjardins2, Tyler Collins2, Mayada Elsabbagh1, Christian O’Reilly3,4,5,6
ORCID iDs: Scott Huberty, Mayada Elsabbagh, Christian O’Reilly
  1. Montreal Neurological Institute-Hospital, McGill University,Montreal, Canada
  2. Compute Ontario,St. Catharines, Canada
  3. Department of Computer Science and Engineering, University of South Carolina,Columbia, SC USA
  4. Artificial Intelligence Institute, University of South Carolina,Columbia, SC USA
  5. Carolina Autism and Neurodevelopment Research Center, Columbia, SC USA
  6. Institute for Mind and Brain, University of South Carolina,Columbia, SC USA
Institutions: McGill University (Canada); Compute Ontario (Canada); University of South Carolina (United States)
Journal: Behavior research methods, volume 58, issue 8, article 220
Dates: received 19 November 2024; accepted 19 February 2026; published online 6 July 2026; in print 2026
Type: Review · Language: English
License: CC BY
Identifiers: DOI 10.3758/s13428-026-02997-z · PMID 42410267 · PMCID PMC13337736 · OpenAlex W4390810969
Open access: hybrid, a free copy (OpenAlex)
Preprint: doi:10.1101/2024.01.12.575323
Status: code verified
Categories: EEG (modality), human (organism), methods / tools (subfield)
Methods: Spectral & time-frequency, Preprocessing, Smoothing, state filtering, decompositions, Machine learning, Physiology & signal measures
Keywords: Electroencephalography, Preprocessing, Artifact rejection, Non-destructive processing, Reproducible analysis
MeSH: Electroencephalography*, Signal Processing, Computer-Assisted*, Software*, Artifacts, Humans (* major topic)
Journal subjects: Software Review
Topic: EEG and Brain-Computer Interfaces (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: University of South Carolina
Citations: cited by 1 paper (Europe PMC); 24 references in the paper

Abstract

EEG recordings are typically long and contain large amounts of data, making manual cleaning a time-consuming and error-prone task. Automated preprocessing pipelines can facilitate the efficient and objective extraction of artifacts, enabling standardized and reproducible analyses. However, automated preprocessing pipelines typically remove data considered artifacts and return a subset of irreversibly transformed signals. This approach obfuscates preprocessing decisions and often makes it impossible to recover the original data or modify the preprocessing steps. Further, it complicates collaboration among research teams working on a common dataset, as different analyses may require specific preprocessing steps. Given the large amount of resources devoted to collecting EEG, tools that can efficiently and transparently preprocess data are greatly needed. PyLossless addresses this need by creating a non-destructive, automated preprocessing pipeline that maintains the continuous EEG structure. It offers a user-friendly API, is well documented, tested through continuous integration, easily deployable, and integrates with the popular MNE-Python environment. The pipeline also provides a browser-based quality control review (QCR) dashboard that allows researchers to visualize and edit automated artifact flags for sensors, time periods, and independent components. The end product of PyLossless is a lossless annotated data state that can be shared and used with analysis-specific artifact rejection policies, allowing for an optimal balance between flexibility and standardization.

Supplementary Information: The online version contains supplementary material available at 10.3758/s13428-026-02997-z.

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

Repository

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

lina-usc/pylossless

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 0f4bccfe2657984a5363be80ef29f00bd3c1a07a, 3 September 2026
Languages: Python (41), Jupyter (2)
Size: 149 files, 43 scripts
Software Heritage: not archived
Found in: “Code Availability”
Holds: README, license file, environment (environment.yaml, pyproject.toml, requirements.txt, requirements_qc.txt, requirements_rtd.txt, requirements_testing.txt, setup.py, docs/requirements_doc.txt), tests, continuous integration, documentation, 2 notebooks
Not found: CITATION.cff
Tools: MNE-Python (17 files), NumPy (17 files), pandas (6 files), MNE-BIDS (5 files), SciPy (4 files), Plotly (3 files), ICLabel (2 files), xarray (2 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
45 files
At the source: github.com/lina-usc/pylossless

Code Availability

Materials and analysis code are available at https://github.com/lina-usc/pylossless.

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:

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

Availability of Data and Materials

The EEG data used for this analysis is available at https://github.com/Andesha/Face13

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 2, 28 September 2026

  • Publisher: n/a → Springer Science+Business Media

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 5 authors, 5 keywords, 5 MeSH terms, 1 funder, 19 references.

Cite

This paper

Huberty, S., Desjardins, J., Collins, T., Elsabbagh, M., & O’Reilly, C. (2026). PyLossless: A non-destructive EEG processing pipeline. Behavior research methods, 58(8), 220. https://doi.org/10.3758/s13428-026-02997-z

BibTeX

@article{huberty2026pylossless,
author = {Huberty, Scott and Desjardins, James and Collins, Tyler and Elsabbagh, Mayada and O’Reilly, Christian},
title = {{PyLossless: A non-destructive EEG processing pipeline}},
journal = {Behavior research methods},
year = {2026},
month = jul,
volume = {58},
number = {8},
pages = {220},
publisher = {Springer Science+Business Media},
issn = {1554-351X},
doi = {10.3758/s13428-026-02997-z},
url = {https://doi.org/10.3758/s13428-026-02997-z},
pmid = {42410267},
pmcid = {PMC13337736}
}

RIS

TY - JOUR
AU - Huberty, Scott
AU - Desjardins, James
AU - Collins, Tyler
AU - Elsabbagh, Mayada
AU - O’Reilly, Christian
TI - PyLossless: A non-destructive EEG processing pipeline
T2 - Behavior research methods
J2 - Behav Res Methods
PY - 2026
DA - 2026/07/06
VL - 58
IS - 8
SP - 220
SN - 1554-351X
PB - Springer Science+Business Media
DO - 10.3758/s13428-026-02997-z
UR - https://doi.org/10.3758/s13428-026-02997-z
LA - en
ER -

CSL-JSON

{
"id": "10.3758/s13428-026-02997-z",
"type": "article-journal",
"title": "PyLossless: A non-destructive EEG processing pipeline",
"container-title": "Behavior research methods",
"author": [
{
"family": "Huberty",
"given": "Scott"
},
{
"family": "Desjardins",
"given": "James"
},
{
"family": "Collins",
"given": "Tyler"
},
{
"family": "Elsabbagh",
"given": "Mayada"
},
{
"family": "O’Reilly",
"given": "Christian"
}
],
"container-title-short": "Behav Res Methods",
"volume": "58",
"issue": "8",
"page": "220",
"DOI": "10.3758/s13428-026-02997-z",
"PMID": "42410267",
"PMCID": "PMC13337736",
"ISSN": "1554-351X",
"publisher": "Springer Science+Business Media",
"URL": "https://doi.org/10.3758/s13428-026-02997-z",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
6
]
]
}
}

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/s41597-025-05174-7 [code]
A large-scale MEG and EEG dataset for object recognition in naturalistic scenes
Journal: n/a
In common: MNE-BIDS, ICLabel, MNE-Python, 4 other tools, methods / tools, EEG, 4 references
[2] doi:10.1097/j.pain.0000000000004044 [code]
No effect of rhythmic visual stimulation on experimental pain perception.
Journal: Pain
In common: MNE-BIDS, ICLabel, MNE-Python, 3 other tools, EEG, 5 references
[3] doi:10.1162/imag.a.1269 [code]
From early to contemporary normative modeling: Mapping individual differences in neurophysiological signals.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: xarray, ICLabel, MNE-Python, 4 other tools, EEG, 3 references
[4] doi:10.1038/s41597-026-07350-9 [code]
An open multi-center MEG-EEG dataset for studying conscious visual perception.
Journal: Scientific data
In common: MNE-BIDS, xarray, MNE-Python, 3 other tools, EEG, 2 references
[5] doi:10.1093/cercor/bhag113 [code]
Long-term reliability and stability of parameterized resting state EEG: evidence from a five-year follow-up.
Journal: Cerebral cortex (New York, N.Y. : 1991)
In common: MNE-BIDS, ICLabel, MNE-Python, 3 other tools, methods / tools, EEG, 2 references
[6] doi:10.3390/s26134019 [code]
NeuroStat: An Open-Source EEG Connectivity Platform for Randomised Controlled Trials.
Journal: Sensors (Basel, Switzerland)
In common: ICLabel, MNE-Python, pandas, 2 other tools, EEG, 4 references
[7] doi:10.1093/nc/niag029 [code]
A data-driven approach to identifying and evaluating connectivity-based neural correlates of conscious visual perception.
Journal: Neuroscience of consciousness
In common: MNE-BIDS, xarray, MNE-Python, 3 other tools, 2 references
[8] doi:10.1038/s41597-026-07146-x [code]
Intention-Action Conflict EEG-Hand Kinematics Dataset for Unimanual Control under Congruent and Incongruent Conditions.
Journal: Scientific data
In common: ICLabel, MNE-Python, pandas, 2 other tools, methods / tools, EEG, 2 references
[9] doi:10.1016/j.dib.2026.113064 [code]
A reproducible EEG hyperscanning dataset for triadic social decision-making during an iterated 3-player Prisoner's Dilemma.
Journal: Data in brief
In common: ICLabel, MNE-Python, pandas, 2 other tools, methods / tools, EEG, 2 references
[10] doi:10.1371/journal.pcbi.1014043 [code]
EEG-Pype: An accessible MNE-Python pipeline with graphical user interface for preprocessing and analysis of resting-state electroencephalography data.
Journal: PLoS computational biology
In common: ICLabel, MNE-Python, pandas, 2 other tools, methods / tools, EEG, 2 references

Contribute

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

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

Request its removal

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

Discussion, reproductions, activity

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

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

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