OSCR

Interpretable metrics for evaluating fidelity, diversity, and privacy in synthetic EEG data

Code ↔ Paper

25 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 25 matches
  1. [1] § Proposed metrics on EEG synthetic data › Fidelity › Time › Frequency ↔ src/frequency_fidelity.py, lines 16–56 · score 0.94 · power spectral densities, fast ripple, dominant frequency, spectral coherence, frequency domain, Frequency fidelity
  2. [2] § Proposed metrics on EEG synthetic data › Diversity ↔ src/diversity.py, lines 11–55 · score 0.92 · Diversity evaluation, Geometric diversity, Intrinsic diversity, pairwise distances, UMAP, synthetic EEG
  3. [3] § Proposed metrics on EEG synthetic data › Fidelity › Complexity ↔ src/complexity_fidelity.py, lines 12–65 · score 0.90 · Lempel Ziv complexity, Multifractal Detrended Fluctuation, Multifractal Detrended Cross, Detrended Cross Correlation, permutation entropy, sample entropy
  4. [4] § Proposed metrics on EEG synthetic data › Fidelity › Time ↔ src/time_fidelity.py, lines 13–38 · score 0.80 · translation invariant, standard deviation, Mahalanobis distance, Wasserstein distance, Hjorth, mobility
  5. [5] § Proposed metrics on EEG synthetic data › Fidelity › Time-frequency ↔ src/time_frequency_fidelity.py, lines 827–961 · score 0.77 · duty cycle, burst statistics, peak, frequency fidelity, envelopes, duration
  6. [6] § Proposed metrics on EEG synthetic data › Privacy › Nearest-neighbours ↔ src/privacy.py, lines 139–195 · score 0.75 · closely synthetic signals, Nearest neighbour, NN distances, Warping, L2, DTW
  7. [7] § Proposed metrics on EEG synthetic data › Fidelity › Spatial ↔ src/evaluation_score.py, lines 611–660 · score 0.73 · channel correlation matrix, cross channel, Spatial fidelity, SD normalised, deviation, RS
  8. [8] § Validation results ↔ src/complexity_fidelity.py, lines 955–1030 · score 0.71 · PermEn, SampEn, RR RS, SS distributions, LZC, entropy
  9. [9] § Proposed metrics on EEG synthetic data › Fidelity › Spatial ↔ src/spatial_fidelity.py, lines 4–26 · score 0.71 · channel dependency structure, correlation matrices, Spatial fidelity, Frobenius, variability, SS
  10. [10] § Proposed metrics on EEG synthetic data › Privacy › Membership inference ↔ src/privacy.py, lines 139–195 · score 0.69 · Membership inference risk, modified entropy, prediction, MIR, confidence, training
  11. [11] § Proposed metrics on EEG synthetic data › Fidelity › Spatial › Fidelity score ↔ src/evaluation_score.py, lines 664–729 · score 0.69 · global fidelity score, Adaptive weights, weighted geometric, aggregation, component, entropy
  12. [12] § Proposed metrics on EEG synthetic data › Fidelity › Time-frequency ↔ src/time_frequency_fidelity.py, lines 25–67 · score 0.68 · Continuous Wavelet Transform, scalogram represents, frequency fidelity, CWT, synthetic signals, metric
  13. [13] § Proposed metrics on EEG synthetic data › Fidelity › Complexity › Complexity metrics interpretation ↔ src/complexity_fidelity.py, lines 12–65 · score 0.67 · correlation coefficients, cross fluctuation, complexity metrics, exponents, Multifractal, entropy
  14. [14] § Proposed metrics on EEG synthetic data › Fidelity › Time › Time fidelity score ↔ src/evaluation_score.py, lines 60–138 · score 0.67 · Hjorth Activity, SD normalised WD, Mahalanobis distance, Mobility, synthetic signals, score
  15. [15] § Proposed metrics on EEG synthetic data › Fidelity › Time-frequency › Visual element ↔ src/time_frequency_fidelity.py, lines 653–717 · score 0.66 · db_ref, freq_scale, vmax, vmin, Intensity, log
  16. [16] § Proposed metrics on EEG synthetic data › Privacy › Nearest-neighbours ↔ src/diversity.py, lines 260–372 · score 0.65 · distance computation, Nearest neighbour, NN distances, Euclidean, globally, synthetic
  17. [17] § Validation results ↔ src/validation/complexity_validation.py, lines 236–307 · score 0.64 · PermEn, phase randomised, SampEn, LZC, Validation, entropy
  18. [18] § Proposed metrics on EEG synthetic data › Privacy › Privacy score ↔ src/evaluation_score.py, lines 812–911 · score 0.62 · Cohen style, NN distances, attacks, accuracy, mapped, components
  19. [19] § Proposed metrics on EEG synthetic data › Fidelity › Time ↔ src/evaluation_score.py, lines 60–138 · score 0.58 · Hjorth activity, Mahalanobis distance, mobility, synthetic signals, covariance, WD
  20. [20] § Proposed metrics on EEG synthetic data › Diversity › Diversity score ↔ src/evaluation_score.py, lines 733–808 · score 0.56 · diversity components, compensation, aggregation, ratios, weights, coverage
  21. [21] § Proposed metrics on EEG synthetic data › Fidelity › Complexity › Visual element ↔ src/complexity_fidelity.py, lines 683–830 · score 0.55 · cross Hurst exponent, singularity spectrum, width, MFDCCA, multifractal
  22. [22] § Validation results ↔ src/diversity.py, lines 11–55 · score 0.55 · Nearest neighbour distances, UMAP, uniqueness, pairwise, coverage, Diversity
  23. [23] § Proposed metrics on EEG synthetic data › Fidelity › Time › Frequency fidelity score ↔ src/evaluation_score.py, lines 140–223 · score 0.54 · band power, dominant frequency, synthetic signals, Coherence, scores, spectral
  24. [24] § Methods › Validation ↔ src/validation/complexity_validation.py, lines 33–160 · score 0.53 · fractal metrics, theoretically, exception, surrogate, Validation, noise
  25. [25] § Proposed metrics on EEG synthetic data › Fidelity › Complexity › Complexity fidelity score ↔ src/complexity_fidelity.py, lines 683–830 · score 0.53 · cross Hurst exponents, real synthetic, width, multifractal, spectrum, fidelity

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 · 911 lines · 29 KB · LGPL-3.0 · 7 matches

  2. from time_fidelity import *
  3. from frequency_fidelity import *
  4. from time_frequency_fidelity import *
  5. from complexity_fidelity import *
  6. from spatial_fidelity import *
  7. from diversity import *
  8. from privacy import *
  10. def _sim(a, b, eps=1e-12):
  11. """Normalised absolute-difference similarity in [0,1]."""
  12. return 1.0 - np.abs(a - b) / (np.abs(a) + np.abs(b) + eps)
  14. def _entropy_weights(values, eps=1e-12):
  15. """
  16. Compute entropy-based adaptive weights.
  17. Higher variability → lower entropy → higher weight.
  19. Parameters
  20. ----------
  21. values : list or array-like
  22. Vector of metric values across domains.
  24. Returns
  25. -------
  26. np.ndarray
  27. Normalized weights summing to 1.
  28. """
  29. x = np.asarray(values, dtype=float)
  31. # Normalize to positive probabilities
  32. x = np.clip(x, eps, None)
  33. p = x / np.sum(x)
  35. # Shannon entropy
  36. H = -np.sum(p * np.log(p + eps))
  37. H_max = np.log(len(p))
  39. # Information utility (1 - normalized entropy)
  40. utility = 1 - (H / H_max)
  42. # If all equal → fallback to uniform weights
  43. if not np.isfinite(utility) or utility <= 0:
  44. return np.ones_like(x) / len(x)
  46. # Weight proportional to deviation from uniformity
  47. w = p * utility
  48. w = np.clip(w, eps, None)
  49. return w / np.sum(w)
  51. def _weighted_geometric_mean(x, w=None, eps=1e-12):
  52. x = np.asarray(x, dtype=float)
  53. x = np.clip(x, eps, 1.0)
  54. if w is None:
  55. w = np.ones_like(x) / x.size
  56. w = np.asarray(w, dtype=float)
  57. w = w / (np.sum(w) + eps)
  58. return float(np.prod(x ** w))
  60. def compute_time_fidelity_score(real_data, synthetic_data, weights=None):
  61. """
  62. Compute a time-domain fidelity score between real and synthetic signals
  63. using Hjorth parameter statistics.
  65. Integrated components (each mapped as S = 1/(1 + distance)):
  66. 1. Normalised WD for Hjorth Activity
  67. 2. Normalised WD for Hjorth Mobility
  68. 3. Normalised WD for Hjorth Complexity
  69. 4. Mahalanobis distance between Hjorth means
  71. All distances are in SD units:
  72. - Hjorth WDs are normalised by the real-data SD.
  73. - Mahalanobis is inherently scale-normalised via the covariance.
  75. Parameters
  76. ----------
  77. real_data : np.ndarray or list
  78. Real signals of shape [n_signals, n_samples].
  79. synthetic_data : np.ndarray or list
  80. Synthetic signals with the same shape as real_data.
  81. weights : dict, optional
  82. Weights for the components. Keys:
  83. {'activity','mobility','complexity','mahalanobis'}.
  84. Default: equal weights across all provided components 0.25 each.
  86. Returns
  87. -------
  88. float
  89. Composite time-domain fidelity score in [0, 1].
  90. """
  91. # Defaults (auto-balance across 4 components)
  92. if weights is None:
  93. w = 1.0 / 4.0
  94. weights = {
  95. 'activity': w, 'mobility': w, 'complexity': w, 'mahalanobis': w
  96. }
  97. # Ensure all keys exist; missing ones default to 0 (excluded from sum)
  98. for k in ('activity', 'mobility', 'complexity', 'mahalanobis'):
  99. weights.setdefault(k, 0.0)
  101. # Compute base Hjorth metrics
  102. tf = TimeFidelity()
  103. hj = tf.compute_hjorth_metrics(real_data, synthetic_data, verbose=False)
  105. import numpy as _np
  107. # distance (in SD units) -> similarity
  108. def _sim(d):
  109. d = float(d)
  110. if not _np.isfinite(d) or d < 0:
  111. return 0.0
  112. return 1.0 / (1.0 + d)
  114. # Use SD-normalised WDs for Hjorth parameters
  115. activity_score = _sim(hj['WD_Activity_normSD'])
  116. mobility_score = _sim(hj['WD_Mobility_normSD'])
  117. complexity_score = _sim(hj['WD_Complexity_normSD'])
  119. # Mahalanobis is already scale-normalised
  120. mahalanobis_score = _sim(hj['Mahalanobis'])
  122. # Weighted combination
  123. time_fidelity_score = (
  124. weights['activity'] * activity_score +
  125. weights['mobility'] * mobility_score +
  126. weights['complexity'] * complexity_score +
  127. weights['mahalanobis'] * mahalanobis_score
  128. )
  130. # Print components
  131. print(f"Time Fidelity Score : {time_fidelity_score:.3f}")
  132. print("Time Fidelity Components:")
  133. print(f" Activity (norm WD): {activity_score:.3f}")
  134. print(f" Mobility (norm WD): {mobility_score:.3f}")
  135. print(f" Complexity (norm WD): {complexity_score:.3f}")
  136. print(f" Mahalanobis : {mahalanobis_score:.3f}")
  138. return time_fidelity_score
  140. def compute_frequency_fidelity_score(real_data, synthetic_data, fs, weights=None):
  141. """
  142. Compute a similarity score between real and synthetic signals that blends
  143. spectral-band power, dominant frequency, coherence and a PSD–Wasserstein
  144. similarity term.
  146. Parameters
  147. ----------
  148. real_data : list | np.ndarray
  149. List/array of real signals (shape: [n_signals, n_samples] or 1-D).
  150. synthetic_data : list | np.ndarray
  151. List/array of synthetic signals (shape: [n_signals, n_samples] or 1-D).
  152. fs : int
  153. Sampling frequency (Hz).
  154. weights : dict, optional
  155. Weights for the four sub-scores. Must contain the keys:
  156. {'relative', 'dom_freq', 'psd_coherence', 'wasserstein'}
  157. Defaults to: {'relative': 0.40,
  158. 'dom_freq': 0.20,
  159. 'psd_coherence': 0.20,
  160. 'wasserstein': 0.20}
  162. Example usage:
  163. --------------
  165. real_data = np.random.randn(10, 2048) # 10 real signals, each 2048 samples
  166. synthetic_data = np.random.randn(10, 2048) # 10 synthetic signals, each 2048 samples
  168. evaluation_score.compute_frequency_fidelity_score(real_data, synthetic_data, fs=2048)
  170. Returns
  171. -------
  172. float
  173. Composite frequency-domain fidelity score in the range (0, 1].
  174. """
  176. # Helper: robust scalar casting
  177. def _as_float(x, default=np.nan):
  178. """
  179. Best-effort conversion of metric outputs (float/array/dict) into a scalar float.
  180. """
  181. if isinstance(x, (int, float, np.floating)):
  182. return float(x)
  184. if isinstance(x, np.generic):
  185. return float(x)
  187. if isinstance(x, (list, tuple, np.ndarray)):
  188. arr = np.asarray(x, dtype=float)
  189. if arr.size == 0:
  190. return float(default)
  191. return float(np.nanmean(arr))
  193. if isinstance(x, dict):
  194. # Try common summary paths used across your metric API
  195. candidates = [
  196. ("RS Summary", "Global Mean"),
  197. ("RS Summary", "Mean"),
  198. ("Summary", "Global Mean"),
  199. ("Summary", "Mean"),
  200. ("Global Mean",),
  201. ("Mean",),
  202. ("wd",),
  203. ("WD",),
  204. ("distance",),
  205. ("value",),
  206. ]
  207. for path in candidates:
  208. v = x
  209. ok = True
  210. for k in path:
  211. if isinstance(v, dict) and k in v:
  212. v = v[k]
  213. else:
  214. ok = False
  215. break
  216. if ok:
  217. return _as_float(v, default=default)
  218. return float(default)
  220. try:
  221. return float(x)
  222. except Exception:
  223. return float(default)
  226. # Default values definition
  228. analysis_band = (0.5, 500.0) # Hz
  229. win_seconds = 4.0 # Welch window length (s)
  230. window = 'hann'
  231. detrend = 'constant'
  232. overlap = 0.5 # 50%
  234. # Keep analysis band under Nyquist
  235. nyq = fs / 2.0
  236. analysis_band = (analysis_band[0], min(analysis_band[1], nyq))
  238. # Initialize FrequencyFidelity class
  239. frequency_fidelity = FrequencyFidelity(
  240. fs,
  241. analysis_band=analysis_band,
  242. win_seconds=win_seconds,
  243. window=window,
  244. detrend=detrend,
  245. overlap=overlap
  246. )
  249. # Weights
  250. if weights is None:
  251. weights = {
  252. 'relative': 0.40,
  253. 'dom_freq': 0.20,
  254. 'psd_coherence': 0.20,
  255. 'wasserstein': 0.20
  256. }
  258. # Fallback – add any missing keys with zero weight
  259. for k in ('relative', 'dom_freq', 'psd_coherence', 'wasserstein'):
  260. weights.setdefault(k, 0.0)
  262. # Optionally normalize weights to sum to 1 (prevents accidental scaling)
  263. wsum = float(sum(weights.values()))
  264. if wsum > 0:
  265. weights = {k: float(v) / wsum for k, v in weights.items()}
  268. # Shape handling
  269. if isinstance(real_data, np.ndarray) and real_data.ndim == 1:
  270. real_data = [real_data]
  271. if isinstance(synthetic_data, np.ndarray) and synthetic_data.ndim == 1:
  272. synthetic_data = [synthetic_data]
  275. # 1) Relative power
  276. freqs_r, psd_r, rel_power_r, dominant_freq_r = frequency_fidelity.compute_relative_power(
  277. real_data,
  278. analysis_band=analysis_band,
  279. win_seconds=win_seconds,
  280. window=window,
  281. detrend=detrend,
  282. overlap=overlap
  283. )
  284. freqs_s, psd_s, rel_power_s, dominant_freq_s = frequency_fidelity.compute_relative_power(
  285. synthetic_data,
  286. analysis_band=analysis_band,
  287. win_seconds=win_seconds,
  288. window=window,
  289. detrend=detrend,
  290. overlap=overlap
  291. )
  293. band_names = ["Delta", "Theta", "Alpha", "Beta", "Gamma"]
  294. real_mean_rel_power = np.array([np.nanmean(rel_power_r[b]) for b in band_names], dtype=float)
  295. synth_mean_rel_power = np.array([np.nanmean(rel_power_s[b]) for b in band_names], dtype=float)
  297. mean_band_diff = np.nanmean(np.abs(real_mean_rel_power - synth_mean_rel_power) * 100.0) # %
  298. # Map diff → similarity (clipped ≥ 0.2 to avoid 0 in extreme cases)
  299. relative_power_score = max(0.2, 1.0 - mean_band_diff / 20.0)
  300. relative_power_score = float(np.clip(relative_power_score, 0.0, 1.0))
  303. # 2) Dominant frequency
  304. freq_diff = abs(np.nanmean(dominant_freq_r) - np.nanmean(dominant_freq_s))
  305. dominant_freq_score = max(0.2, 1.0 - freq_diff / 3.0)
  306. dominant_freq_score = float(np.clip(dominant_freq_score, 0.0, 1.0))
  308. # 3) Coherence
  309. coh = frequency_fidelity.spectral_coherence(
  310. real_data, synthetic_data,
  311. mode="all_vs_all",
  312. per_band=False,
  313. analysis_band=analysis_band,
  314. win_seconds=2.0,
  315. window=window,
  316. detrend=detrend,
  317. overlap=overlap
  318. )
  320. # Robustly extract and validate coherence scalar
  321. coh_val = coh.get("RS Summary", {}).get("Global Mean", np.nan) if isinstance(coh, dict) else np.nan
  322. coh_val = _as_float(coh_val, default=np.nan)
  324. mean_coherence = 0.0
  325. if np.isfinite(coh_val):
  326. mean_coherence = float(np.clip(coh_val, 0.0, 1.0))
  328. # 4) Spectral Wasserstein distance
  329. wd_psd_raw = frequency_fidelity.spectral_wasserstein_distance(
  330. real_data, synthetic_data,
  331. fmin=analysis_band[0],
  332. fmax=analysis_band[1],
  333. mode="pairmean",
  334. per_band=False
  335. )
  337. # Robustly extract scalar WD
  338. wd_psd = _as_float(wd_psd_raw, default=np.nan)
  340. # Map distance → similarity
  341. wasserstein_score = 0.2
  342. if np.isfinite(wd_psd):
  343. wasserstein_score = float(1.0 / (1.0 + wd_psd))
  344. wasserstein_score = float(np.clip(wasserstein_score, 0.0, 1.0))
  346. # Composite score
  347. frequency_fidelity_score = (
  348. weights['relative'] * relative_power_score +
  349. weights['dom_freq'] * dominant_freq_score +
  350. weights['psd_coherence'] * mean_coherence +
  351. weights['wasserstein'] * wasserstein_score
  352. )
  354. frequency_fidelity_score = float(np.clip(frequency_fidelity_score, 0.0, 1.0))
  356. print(f"Frequency Fidelity Score: {frequency_fidelity_score:.2f}")
  358. return frequency_fidelity_score
  362. def compute_time_frequency_fidelity_score(real_data, synthetic_data, fs, *, weights=None, mode: str = "auto",
  363. pad: bool = True, rr_zip_strategy: str = "consecutive", ss_zip_strategy: str = "consecutive",return_sd: bool = False,
  364. return_per_pair: bool = False, verbose: bool = True):
  365. """
  366. Composite time frequnecy similarity for 1-D or 2-D inputs.
  367. Reuses `compute_scalogram_similarity_metrics` and combines RS per-pair metrics:
  369. score_i = w_cssim * SSIM_i
  370. + w_rmse * (1 / (1 + nRMSE_i))
  371. + w_cos * Cosine_i
  373. Parameters
  374. ----------
  375. real_data, synthetic_data : array_like
  376. 1-D (T,) or 2-D (N, T). Only these are required.
  377. weights : dict, optional
  378. {'color_ssim':0.4, 'rmse':0.3, 'cosine_similarity':0.3} by default.
  379. mode : {"auto","zip","all_vs_all"}, default "auto"
  380. - "auto": use "zip" if both inputs are 1-D or both are 2-D with the same N; else "all_vs_all".
  381. - "zip": index-wise pairing.
  382. - "all_vs_all": every real vs every synthetic.
  383. pad : bool, default True
  384. Right-pad signals to a common length before CWT.
  385. rr_zip_strategy, ss_zip_strategy : {"consecutive","halves"}
  386. Zip strategies for within-set RR/SS in the metrics method.
  387. return_sd : bool, default False
  388. Also return SD of per-pair scores.
  389. return_per_pair : bool, default False
  390. Also return list of per-pair scores.
  391. verbose : bool, default True
  392. Print a brief summary.
  394. Example usage:
  395. --------------
  397. real_data = np.random.randn(10, 2048) # 10 real signals, each 2048 samples
  398. synthetic_data = np.random.randn(10, 2048) # 10 synthetic signals, each 2048 samples
  400. evaluation_score.compute_scalogram_fidelity_score(real_data, synthetic_data, fs=2048)
  402. Returns
  403. -------
  404. mean_score : float
  405. (sd_score) : float, optional if return_sd=True
  406. (per_pair_scores) : list[float], optional if return_per_pair=True
  407. """
  409. if weights is None:
  410. weights = {'color_ssim': 0.4, 'rmse': 0.3, 'cosine_similarity': 0.3}
  411. w_cssim = float(weights.get('color_ssim', 0.4))
  412. w_rmse = float(weights.get('rmse', 0.3))
  413. w_cos = float(weights.get('cosine_similarity', 0.3))
  415. # Normalize inputs: auto-wrap 1-D → (1, T)
  416. R = np.asarray(real_data, dtype=float)
  417. S = np.asarray(synthetic_data, dtype=float)
  419. if R.ndim == 1:
  420. R = R[None, :] # shape (1, T)
  421. if S.ndim == 1:
  422. S = S[None, :] # shape (1, T)
  424. # Auto-select pairing if requested
  426. if mode == "auto":
  427. if R.shape[0] == S.shape[0]:
  428. eff_mode = "zip" # pairwise 1–1
  429. else:
  430. eff_mode = "all_vs_all" # every real vs every synthetic
  431. else:
  432. eff_mode = mode
  434. scalo = TimeFrequencyFidelity(fs=fs)
  436. # Reuse your metrics method (does RS, RR, SS under the same mode/strategies)
  437. metrics = scalo.compute_scalogram_similarity_metrics(
  438. R, S,
  439. mode=eff_mode, pad=pad,
  440. rr_zip_strategy=rr_zip_strategy, ss_zip_strategy=ss_zip_strategy,
  441. )
  443. # RS per-pair lists → composite per-pair scores
  444. ssim_list = metrics.get("Per-pair SSIM (RS)", [])
  445. nrmse_list = metrics.get("Per-pair NRMSE (RS)", [])
  446. cos_list = metrics.get("Per-pair Cosine (RS)", [])
  448. scores = []
  449. for ssim_i, nrmse_i, cos_i in zip(ssim_list, nrmse_list, cos_list):
  450. cos_i = max(-1.0, min(1.0, float(cos_i))) # safety
  451. sim_rmse = 1.0 / (1.0 + float(nrmse_i)) # maps to (0,1]
  452. score_i = w_cssim*float(ssim_i) + w_rmse*sim_rmse + w_cos*cos_i
  453. scores.append(float(score_i))
  455. if not scores:
  456. mean_score = float('nan'); sd_score = float('nan')
  457. else:
  458. arr = np.asarray(scores, dtype=float)
  459. mean_score = float(np.mean(arr))
  460. sd_score = float(np.std(arr, ddof=1)) if arr.size > 1 else float('nan')
  462. if verbose:
  463. label = eff_mode if eff_mode != "zip" else f"zip"
  464. print(f"Time-frequency Fidelity Score: {mean_score:.3f} | mode: {label}, pairs: {len(scores)}")
  466. #out = (mean_score,)
  467. #if return_sd:
  468. #out += (sd_score,)
  469. #if return_per_pair:
  470. #out += (scores,)
  471. #return out if len(out) > 1 else out[0]
  474. def compute_complexity_fidelity_score(
  475. real_data,
  476. synthetic_data,
  477. q_range=np.arange(-5, 5, 0.1),
  478. weights=None
  479. ):
  480. """
  481. Complexity fidelity score combining fractal and entropy/complexity similarities.
  483. Final aggregation: weighted geometric mean over available (finite) subscores.
  484. This penalizes collapse in any single complexity component.
  486. Subscores (mapped to [0,1], higher = closer match):
  487. - dcca, mfdfa, mfdcca, sampen, permen, lzc
  488. """
  490. # Default: equal weights across ALL subscores (6 components)
  491. if weights is None:
  492. weights = {
  493. 'dcca': 1/6, 'mfdfa': 1/6, 'mfdcca': 1/6,
  494. 'sampen': 1/6, 'permen': 1/6, 'lzc': 1/6
  495. }
  497. # Wrap 1D arrays
  498. if isinstance(real_data, np.ndarray) and real_data.ndim == 1:
  499. real_data = [real_data]
  500. if isinstance(synthetic_data, np.ndarray) and synthetic_data.ndim == 1:
  501. synthetic_data = [synthetic_data]
  503. # Helpers
  504. def _sim_range(a, b, lo, hi):
  505. d = min(abs(float(a) - float(b)), hi - lo)
  506. return 1.0 - d / (hi - lo)
  508. def _mean_Hq(signals, q_range, get_scales):
  509. Hqs = []
  510. for x in signals:
  511. scales = get_scales(len(x))
  512. if len(scales) < 4:
  513. continue
  514. _, info = nk.fractal_dfa(x, scale=scales, multifractal=True, q=q_range, show=False)
  515. Hq = np.asarray(info["H"])
  516. if np.all(np.isfinite(Hq)):
  517. Hqs.append(Hq)
  518. if not Hqs:
  519. return None
  520. return np.nanmean(np.vstack(Hqs), axis=0)
  523. # Fractality scores
  526. fs_dcca = ComplexityFidelity(real_data, synthetic_data, method='DCCA', q_range=q_range)
  527. fs_dcca.compute_fractal_metrics()
  528. H_rr, H_rs = fs_dcca.means[:2]
  529. F_DCCA = _sim_range(H_rr, H_rs, lo=0.3, hi=1.2)
  531. fs_mfdfa = ComplexityFidelity(real_data, synthetic_data, method='MFDFA', q_range=q_range)
  532. fs_mfdfa.compute_fractal_metrics()
  533. H_r, H_s = fs_mfdfa.means
  534. S_H_mfdfa = _sim_range(H_r, H_s, lo=0.3, hi=1.2)
  536. dummy = ComplexityFidelity(real_data, synthetic_data, method='MFDFA', q_range=q_range)
  537. Hq_r = _mean_Hq(real_data, q_range, dummy._get_win_sizes)
  538. Hq_s = _mean_Hq(synthetic_data, q_range, dummy._get_win_sizes)
  539. if Hq_r is not None and Hq_s is not None:
  540. rmse = float(np.sqrt(np.nanmean((Hq_r - Hq_s) ** 2)))
  541. tau = 0.15
  542. S_Hq = float(np.exp(-rmse / tau))
  543. else:
  544. S_Hq = np.nan
  546. F_MFDFA = S_H_mfdfa if np.isnan(S_Hq) else 0.5 * S_H_mfdfa + 0.5 * S_Hq
  548. fs_mfdcca = ComplexityFidelity(real_data, synthetic_data, method='MFDCCA', q_range=q_range)
  549. fs_mfdcca.compute_fractal_metrics()
  550. Hc_rr, Hc_rs = fs_mfdcca.means[:2]
  551. Da_rr, Da_rs = fs_mfdcca.deltaAlpha_means[:2]
  553. S_H_mfdcca = _sim_range(Hc_rr, Hc_rs, lo=0.3, hi=1.2)
  554. S_Dalpha = _sim_range(Da_rr, Da_rs, lo=0.0, hi=0.5)
  555. F_MFDCCA = 0.7 * S_H_mfdcca + 0.3 * S_Dalpha
  558. # Entropy / algorithmic scores
  560. cf_entropy = ComplexityFidelity(real_data, synthetic_data, method='MFDFA', q_range=q_range)
  561. e = cf_entropy.compute_entropy_complexity_metrics(
  562. real_data, synthetic_data,
  563. sampen_m=2, sampen_r=None,
  564. permen_m=3, permen_tau=1,
  565. lzc_threshold=None,
  566. n_surrogates=0,
  567. verbose=False
  568. )
  570. def _to_sim(wd_norm):
  571. return np.nan if not np.isfinite(wd_norm) else 1.0 / (1.0 + float(wd_norm))
  573. S_SampEn = _to_sim(e.get("WD_SampEn_norm", np.nan))
  574. S_PermEn = _to_sim(e.get("WD_PermEn_norm", np.nan))
  575. S_LZC = _to_sim(e.get("WD_LZC_norm", np.nan))
  577. subscores = {
  578. 'dcca': F_DCCA,
  579. 'mfdfa': F_MFDFA,
  580. 'mfdcca': F_MFDCCA,
  581. 'sampen': S_SampEn,
  582. 'permen': S_PermEn,
  583. 'lzc': S_LZC
  584. }
  586. # Keep only finite subscores
  587. keys = [k for k, v in subscores.items() if np.isfinite(v)]
  588. if not keys:
  589. raise RuntimeError("Complexity fidelity score could not be computed (all subscores NaN).")
  591. vals = np.array([subscores[k] for k in keys], dtype=float)
  593. # Collect weights for valid keys, renormalize
  594. w = np.array([float(weights.get(k, 0.0)) for k in keys], dtype=float)
  596. if float(np.sum(w)) <= 0:
  597. w = np.ones_like(vals) / vals.size
  598. else:
  599. w = w / float(np.sum(w))
  601. score = _weighted_geometric_mean(vals, w)
  603. # Printing
  604. print(f"Complexity Score: {score:0.3f}\n")
  605. for k, v, wi in zip(keys, vals, w):
  606. print(f"{k.upper():8s}: {v:0.3f} | weight = {wi:0.3f}")
  609. return float(np.clip(score, 0.0, 1.0))
  611. def compute_spatial_fidelity_score(real_data, synthetic_data):
  612. """
  613. Compute spatial fidelity score based on cross-channel
  614. correlation matrix similarity.
  616. The score is derived from the SD-normalised deviation:
  618. z_SC = (μ_RS - μ_RR) / σ_RR
  619. F_spatial = 1 / (1 + |z_SC|)
  621. Parameters
  622. ----------
  623. real_data : array-like
  624. Shape (N, C, T) or (C, T)
  625. synthetic_data : array-like
  626. Shape (N, C, T) or (C, T)
  628. Returns
  629. -------
  630. float
  631. Spatial fidelity score in [0,1]
  632. """
  634. real_data = np.asarray(real_data)
  635. synthetic_data = np.asarray(synthetic_data)
  637. if real_data.ndim == 2:
  638. # ambiguous: could be (C,T) or (N,T)
  639. # spatial fidelity is only valid if axis 0 == channels
  640. if real_data.shape[0] < 2:
  641. raise ValueError("Need at least 2 channels for spatial fidelity.")
  642. # optional: enforce expected C
  643. # if real_data.shape[0] != expected_C: raise ...
  644. elif real_data.ndim == 3:
  645. if real_data.shape[1] < 2:
  646. raise ValueError("Need at least 2 channels for spatial fidelity.")
  647. else:
  648. raise ValueError(f"Invalid real_data shape {real_data.shape}; expected 2D or 3D.")
  650. spatial_eval = SpatialFidelity()
  651. results = spatial_eval.evaluate(real_data, synthetic_data)
  653. spatial_score = results.get("F_spatial", np.nan)
  655. # Safety clip
  656. spatial_score = float(np.clip(spatial_score, 0.0, 1.0))
  658. print(f"Spatial Fidelity Score: {spatial_score:.3f}")
  660. return spatial_score
  662. use_adaptive_weights = False
  664. def compute_fidelity_score(real_data, synthetic_data, fs):
  665. """
  666. Computes global fidelity score using entropy-adaptive weighting
  667. and weighted geometric aggregation.
  669. Parameters
  670. ----------
  671. real_data : list or np.ndarray
  672. List of real signals.
  673. synthetic_data : list or np.ndarray
  674. List of synthetic signals.
  675. fs : int
  676. Sampling frequency of the signals.
  678. Returns
  679. -------
  680. float
  681. Fidelity score in [0,1] (higher ⇒ closer match).
  683. Example usage:
  684. --------------
  686. real_data = np.random.randn(10, 2048) # 10 real signals, each 2048 samples
  687. synthetic_data = np.random.randn(10, 2048) # 10 synthetic signals, each 2048 samples
  689. evaluation_score.compute_fidelity_score(real_data, synthetic_data, fs=2048)
  690. """
  691. time_sim = compute_time_fidelity_score(real_data, synthetic_data)
  692. freq_sim = compute_frequency_fidelity_score(real_data, synthetic_data, fs)
  693. scalogram_sim = compute_time_frequency_fidelity_score(real_data, synthetic_data, fs)
  694. fractal_sim = compute_complexity_fidelity_score(real_data, synthetic_data)
  695. spatial_sim = compute_spatial_fidelity_score(real_data,synthetic_data)
  697. components = np.array([
  698. time_sim,
  699. freq_sim,
  700. scalogram_sim,
  701. fractal_sim,
  702. spatial_sim
  703. ], dtype=float)
  705. # Compute weights
  706. if use_adaptive_weights:
  707. weights = _entropy_weights(components)
  708. else:
  709. weights = np.ones(4) / 4.0
  711. # Weighted geometric mean (penalizes collapse)
  712. eps = 1e-12
  713. fidelity_score = np.prod(
  714. np.clip(components, eps, 1.0) ** weights
  715. )
  717. fidelity_score = float(np.clip(fidelity_score, 0.0, 1.0))
  719. print(f"\nGlobal Fidelity Score: {fidelity_score:.3f}")
  720. print("Domain Scores:")
  721. print(f" Time : {time_sim:.3f}")
  722. print(f" Frequency : {freq_sim:.3f}")
  723. print(f" Time-Freq : {scalogram_sim:.3f}")
  724. print(f" Complexity : {fractal_sim:.3f}")
  725. print(f" Spatial : {spatial_sim:.3f}")
  726. print("Adaptive Weights:")
  727. print(f" {weights}")
  729. return fidelity_score
  733. def compute_diversity_score(real_data, synthetic_data, weights=None, n_components=2):
  734. """
  735. Composite diversity score in [0,1].
  737. Aggregation:
  738. - If `weights` is provided: weighted geometric mean using those weights.
  739. - Else: entropy-adaptive weights + weighted geometric mean.
  741. This avoids linear compensation across heterogeneous diversity components.
  742. """
  744. def normalize_ratio(ratio):
  745. if not np.isfinite(ratio) or ratio <= 0:
  746. return np.nan
  747. return float(np.exp(-abs(np.log(ratio))))
  749. div = Diversity(n_components=n_components)
  750. m_cov = div.compute_coverage_diversity(real_data, synthetic_data)
  751. m_geom = div.compute_geometric_diversity(real_data, synthetic_data)
  752. m_intr = div.compute_intrinsic_diversity(real_data, synthetic_data)
  754. # 1) Coverage / Outliers
  755. C_cov = float(m_cov['Coverage'])
  756. O_out = float(m_cov['Outliers'])
  758. # 2) Geometric diversity
  759. LM_PCA = float(m_geom['PCA_LabelMixingScore'])
  760. LM_UM = float(m_geom['UMAP_LabelMixingScore'])
  761. D_PCA = float(m_geom['PCA_OverlapMahalanobis'])
  762. D_UM = float(m_geom['UMAP_OverlapMahalanobis'])
  763. CS_PCA = float(m_geom['PCA_CovShape'])
  764. CS_UM = float(m_geom['UMAP_CovShape'])
  766. # 3) Intrinsic ratios (normalized)
  767. U_NN = normalize_ratio(m_intr['Uniqueness_NN'])
  768. G_glob = normalize_ratio(m_intr['Global_Diversity'])
  769. L_loc_P10 = normalize_ratio(m_intr['Local_Diversity_P10'])
  770. L_loc_P50 = normalize_ratio(m_intr['Local_Diversity_P50'])
  772. comps = np.array([
  773. C_cov, O_out,
  774. LM_PCA, LM_UM,
  775. D_PCA, D_UM,
  776. CS_PCA, CS_UM,
  777. U_NN, G_glob,
  778. L_loc_P10, L_loc_P50
  779. ], dtype=float)
  781. names = [
  782. "coverage", "outliers",
  783. "pca_labelmix", "umap_labelmix",
  784. "pca_overlap", "umap_overlap",
  785. "pca_covshape", "umap_covshape",
  786. "uniqueness", "global_div",
  787. "local_div_p10", "local_div_p50"
  788. ]
  790. # Drop NaNs
  791. valid = np.isfinite(comps)
  792. comps_v = comps[valid]
  793. names_v = [n for n, ok in zip(names, valid) if ok]
  795. if comps_v.size == 0:
  796. raise RuntimeError("Diversity score could not be computed (all submetrics NaN).")
  798. # Entropy weights
  799. w = _entropy_weights(comps_v)
  801. diversity_score = _weighted_geometric_mean(comps_v, w)
  803. # Printing
  804. print(f"Final Diversity Score: {diversity_score:0.3f}\n")
  805. for n, v, wi in zip(names_v, comps_v, w):
  806. print(f"{n:16s}: {v:0.3f} | weight = {wi:0.3f}")
  808. return float(np.clip(diversity_score, 0.0, 1.0))
  812. def compute_privacy_score(
  813. real_data,
  814. synthetic_data,
  815. y_real: np.ndarray | None = None,
  816. *,
  817. normalize: str | None = "zscore_global",
  818. length_normalize: bool = True,
  819. weights: dict | None = None,
  820. ) -> tuple[float, dict]:
  821. """
  822. Composite privacy score in [0, 1]; higher = safer.
  824. Components (all mapped to [0,1] safety scores):
  826. - L2 effect size d_L2 (from NN distances, R–S vs R–R)
  827. - DTW effect size d_DTW (same)
  828. - Optional: MIR (1 - attack accuracy),
  829. if y_real (labels) is provided.
  830. """
  831. pr = Privacy()
  834. # 1) Distance-based effect sizes (Cohen-style)
  836. eff = pr.compute_distance_effect_sizes(
  837. real_data,
  838. synthetic_data,
  839. normalize=normalize,
  840. length_normalize=length_normalize,
  841. )
  843. d_l2 = eff["l2"]["effect_size_d"]
  844. d_dtw = eff["dtw"]["effect_size_d"]
  846. def effect_size_to_safety(d: float,
  847. low: float = 0.0,
  848. high: float = 0.8) -> float:
  849. """Map effect size d to [0,1] safety."""
  850. if np.isnan(d):
  851. return np.nan
  852. if d <= low:
  853. return 0.0
  854. if d >= high:
  855. return 1.0
  856. return float((d - low) / (high - low))
  858. scores = {
  859. "l2": effect_size_to_safety(d_l2),
  860. "dtw": effect_size_to_safety(d_dtw),
  861. }
  863. # 2) Optional MIR component (requires true labels)
  865. scores["mir"] = None
  866. if y_real is not None:
  867. mir = pr.compute_mir_metrics(
  868. real_data,
  869. synthetic_data,
  870. y_real=y_real,
  871. normalize=normalize,
  872. verbose=False,
  873. )
  875. # You could also take max / mean of all attacks here
  876. attack_acc = float(mir["confidence_attack_acc"])
  877. attack_acc = max(0.5, min(1.0, attack_acc)) # clip to [0.5,1]
  878. scores["mir"] = 2.0 * (1.0 - attack_acc)
  881. # 3) Weights + aggregate
  883. base_w = {
  884. "l2": 1.0,
  885. "dtw": 1.0,
  886. "mir": (1.0 if scores["mir"] is not None else 0.0),
  887. }
  889. if weights is not None:
  890. base_w.update(weights)
  892. # Remove MIR weight if MIR is None
  893. if scores["mir"] is None:
  894. base_w.pop("mir", None)
  896. # Normalise weights
  897. tot = sum(base_w.values())
  898. base_w = {k: v / tot for k, v in base_w.items()}
  900. # Aggregate privacy score
  901. privacy_score = sum(base_w[k] * scores[k] for k in base_w)
  903. print(f"Privacy Score (0–1, higher = safer): {privacy_score:.2f}")
  904. print(f" - L2 safety score : {scores['l2']:.2f} (from d_L2 = {d_l2:.2f})")
  905. print(f" - DTW safety score : {scores['dtw']:.2f} (from d_DTW = {d_dtw:.2f})")
  906. if scores["mir"] is not None:
  907. print(f" - MIR safety score : {scores['mir']:.2f}")
  908. else:
  909. print(" - MIR safety score : n/a (labels not provided)")
  911. return privacy_score, scores

evaluation_score.py at commit cb00911, under LGPL-3.0 · at the source

Overview

Authors: Inês Silveira1, Luís Silva1, Dania Furk1, Beatriz Marques1, Nianfei Ao1, Sem Hoogteijling2,3, Irene Heijink2,3, Maeike Zijlmans2,3, Hugo Gamboa1
  1. LIBPhys, NOVA School of Science and Technology, Largo da Torre, 2829-516, Almada, Portugal
  2. Department of Neurology and Neurosurgery, Brain Center, University Medical Center Utrecht, Part of ERN EpiCARE, P.O. box 85500, 3508, GA Utrecht, The Netherlands
  3. Stichting Epilepsie Instellingen Nederland (SEIN), Heemstede, The Netherlands
Institutions: LIBPhys, NOVA School of Science and Technology, Largo da Torre, 2829-516, Almada, Portugal; University Medical Center Utrecht (Netherlands); Stichting Epilepsie Instellingen Nederland (Netherlands)
Journal: Research Square (preprint)
Dates: published online 16 April 2026
Type: Preprint
License: CC BY
Identifiers: DOI 10.21203/rs.3.rs-9010375/v1 · OpenAlex W7154648917
Open access: green, a free copy (OpenAlex)
Status: code verified
Categories: EEG (modality), human (organism)
Methods: Connectivity, Spectral & time-frequency, Statistics, Smoothing, state filtering, decompositions, Machine learning
Keywords: Synthetic EEG evaluation, Fidelity, Diversity, Privacy
Topic: Functional Brain Connectivity Studies (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: European Research Council (803880)
Citations: not cited yet (Europe PMC); 58 references in the paper

Abstract

The generation of synthetic electroencephalography (EEG) data offers a promising solution to the limited availability of clinical neurophysiological recordings, particularly intracranial EEG (iEEG), where acquisition is invasive, complex, and restricted to small patient cohorts. Although generative models can produce realistic signals, progress in this field is constrained by the absence of standardized and physiologically grounded evaluation protocols. Current assessment strategies rely largely on basic statistical similarity measures and fail to capture the intrinsic properties of EEG, including non-stationarity, spectral organization, and fractal dynamics. Here, we propose a comprehensive evaluation framework for synthetic (i)EEG that integrates fidelity, diversity, and privacy within a unified and interpretable protocol. The framework combines analyses across time, frequency, time–frequency, complexity, and spatial domains using established signal-processing and nonlinear-dynamics metrics. Interpretation is grounded in principled normalization strategies and effect-size conventions, and is further summarized through composite domain-level scores that enable transparent and reproducible comparison across datasets and generative models. Implemented as the open-source Python library, seege_ provides a standardized and interpretable toolkit for evaluating synthetic neurophysiological data, advancing methodological rigor in generative modeling for clinical and neuroscientific research.

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

BiosignalsLibphys/seege_

License: LGPL-3.0
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: cb009112058a01e45a8aaf2ab4d0313611bdd82c, 18 August 2026
Languages: Python (17), Jupyter (2)
Size: 28 files, 19 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file, environment (requirements.txt, setup.py), 2 notebooks
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (13 files), Matplotlib (9 files), SciPy (8 files), seaborn (6 files), pandas (4 files), scikit-learn (4 files), scikit-image (2 files), NeuroKit2 (1 file), Numba (1 file), UMAP (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
21 files
At the source: github.com/BiosignalsLibphys/seege_

Code availability

The Python library is available on Github: seege_ (https://github.com/BiosignalsLibphys/seege_).

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;
  • 19 scripts, each with its path and the digest of its content;
  • 25 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 datasets generated during and/or analysed during the current study are available in the Multicenter intracranial EEG dataset for classification of graphoelements and artifactual signals repository, https://doi.org/10.6084/m9.figshare.11734575.

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

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 29 September 2026: the first record

Recorded: type, journal, dates, 9 authors, 4 keywords, 1 funder, 48 references.

Cite

This paper

Silveira, I., Silva, L., Furk, D., Marques, B., Ao, N., Hoogteijling, S., Heijink, I., Zijlmans, M., & Gamboa, H. (2026). Interpretable metrics for evaluating fidelity, diversity, and privacy in synthetic EEG data. Research Square (preprint). https://doi.org/10.21203/rs.3.rs-9010375/v1

BibTeX

@article{silveira2026interpretable,
author = {Silveira, Inês and Silva, Luís and Furk, Dania and Marques, Beatriz and Ao, Nianfei and Hoogteijling, Sem and Heijink, Irene and Zijlmans, Maeike and Gamboa, Hugo},
title = {{Interpretable metrics for evaluating fidelity, diversity, and privacy in synthetic EEG data}},
journal = {Research Square (preprint)},
year = {2026},
month = apr,
publisher = {Research Square},
issn = {2693-5015},
doi = {10.21203/rs.3.rs-9010375/v1},
url = {https://doi.org/10.21203/rs.3.rs-9010375/v1}
}

RIS

TY - JOUR
AU - Silveira, Inês
AU - Silva, Luís
AU - Furk, Dania
AU - Marques, Beatriz
AU - Ao, Nianfei
AU - Hoogteijling, Sem
AU - Heijink, Irene
AU - Zijlmans, Maeike
AU - Gamboa, Hugo
TI - Interpretable metrics for evaluating fidelity, diversity, and privacy in synthetic EEG data
T2 - Research Square (preprint)
J2 - Res Sq
PY - 2026
DA - 2026/04/16
SN - 2693-5015
PB - Research Square
DO - 10.21203/rs.3.rs-9010375/v1
UR - https://doi.org/10.21203/rs.3.rs-9010375/v1
ER -

CSL-JSON

{
"id": "10.21203/rs.3.rs-9010375/v1",
"type": "article",
"title": "Interpretable metrics for evaluating fidelity, diversity, and privacy in synthetic EEG data",
"container-title": "Research Square (preprint)",
"author": [
{
"family": "Silveira",
"given": "Inês"
},
{
"family": "Silva",
"given": "Luís"
},
{
"family": "Furk",
"given": "Dania"
},
{
"family": "Marques",
"given": "Beatriz"
},
{
"family": "Ao",
"given": "Nianfei"
},
{
"family": "Hoogteijling",
"given": "Sem"
},
{
"family": "Heijink",
"given": "Irene"
},
{
"family": "Zijlmans",
"given": "Maeike"
},
{
"family": "Gamboa",
"given": "Hugo"
}
],
"container-title-short": "Res Sq",
"DOI": "10.21203/rs.3.rs-9010375/v1",
"ISSN": "2693-5015",
"publisher": "Research Square",
"URL": "https://doi.org/10.21203/rs.3.rs-9010375/v1",
"issued": {
"date-parts": [
[
2026,
4,
16
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.7554/elife.110588 [code]
Opening the black box toward a modular approach to spike sorting.
Journal: eLife
In common: UMAP, Numba, scikit-image, 6 other tools
[2] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: UMAP, Numba, scikit-image, 6 other tools
[3] doi:10.1093/nar/gkag706 [code]
scDifformer: diffusion-based post-training for virtual cell modeling across large-scale single-cell data.
Journal: Nucleic acids research
In common: UMAP, Numba, scikit-image, 6 other tools
[4] doi:10.1162/imag.a.1276 [code]
High-resolution whole-brain magnetic resonance spectroscopic imaging in youth at risk for psychosis.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: UMAP, Numba, scikit-image, 6 other tools
[5] doi:10.1016/j.xcrm.2026.102766 [code]
A longitudinal single-cell and spatial multiomic atlas of pediatric high-grade glioma.
Journal: Cell reports. Medicine
In common: UMAP, Numba, scikit-image, 6 other tools
[6] doi:10.1016/j.isci.2026.116825 [code]
Social hierarchy shapes behavioral and transcriptional responses to chronic stress and ketamine in male mice.
Journal: iScience
In common: UMAP, Numba, scikit-image, 6 other tools
[7] doi:10.1371/journal.pbio.3003915 [code]
Noise-invariant representations of sound emerge along the canonical cortical hierarchy.
Journal: PLoS biology
In common: UMAP, Numba, scikit-image, 6 other tools
[8] doi:10.3389/fnsys.2026.1822122 [code]
Convergence-divergence circuits for multimodal integration of innate and learned opponent valences.
Journal: Frontiers in systems neuroscience
In common: UMAP, Numba, scikit-image, 6 other tools
[9] doi:10.1038/s41467-026-72057-9 [code]
Sex-specific behavioral feedback modulates sensorimotor processing and drives flexible social behavior.
Journal: Nature communications
In common: UMAP, Numba, scikit-image, 6 other tools
[10] doi:10.3390/s26154773 [code]
EEG-Based Supported Diagnosis of ADHD Using Subject-Specific HMMs and Stationary RKHS Embeddings.
Journal: Sensors (Basel, Switzerland)
In common: Numba, seaborn, scikit-learn, 4 other tools, EEG, 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.

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.