OSCR

Activity-dependent adaptive deep brain stimulation improves gait in Parkinson's disease.

Code ↔ Paper

3 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 3 matches
  1. [1] § Methods › Decoding algorithms of locomotor activities › Balancing of classes ↔ neurodecode/decoder/trainer.py, lines 1–62 · score 0.76 · Random Forest classifier, scikit learn, sklearn, training, errors
  2. [2] § Methods › Neural decoding framework ↔ neurodecode/decoder/trainer.py, lines 1–62 · score 0.66 · scikit learn, Random Forest, cross validation, training, decoder
  3. [3] § Methods › Decoding algorithms of locomotor activities › Balancing of classes ↔ neurodecode/decoder/trainer.py, lines 464–557 · score 0.51 · confusion matrices, cross validation, class, score

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 · 702 lines · 28 KB · gnu · 3 matches

  1. from __future__ import print_function, division
  3. """
  4. trainer.py
  6. Perform cross-validation and train a classifier.
  7. See run() to see the overall flow.
  9. When you add more classifiers, modify "CLASSIFIERS" variable to include your classifier.
  11. Kyuhwa Lee, 2018
  12. Swiss Federal Institute of Technology Lausanne (EPFL)
  14. This program is free software: you can redistribute it and/or modify
  15. it under the terms of the GNU General Public License as published by
  16. the Free Software Foundation, either version 3 of the License, or
  17. (at your option) any later version.
  19. This program is distributed in the hope that it will be useful,
  20. but WITHOUT ANY WARRANTY; without even the implied warranty of
  21. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  22. GNU General Public License for more details.
  24. You should have received a copy of the GNU General Public License
  25. along with this program. If not, see <http://www.gnu.org/licenses/>.
  27. """
  29. import os
  30. import sys
  31. import mne
  32. import mne.io
  33. import platform
  34. import numpy as np
  35. import multiprocessing as mp
  36. import sklearn.metrics as skmetrics
  37. import neurodecode.utils.q_common as qc
  38. import neurodecode.utils.pycnbi_utils as pu
  39. import neurodecode.decoder.features as features
  40. from builtins import input
  41. from sklearn.ensemble import RandomForestClassifier
  42. from sklearn.ensemble import GradientBoostingClassifier
  43. from xgboost import XGBClassifier
  44. from lightgbm import LGBMClassifier
  45. from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
  46. from neurodecode.decoder.rlda import rLDA
  47. from neurodecode import logger
  48. from neurodecode.triggers.trigger_def import trigger_def
  50. # supported classifiers: add this part as you add more classifiers
  51. CLASSIFIERS = {'RF':RandomForestClassifier, 'GB':GradientBoostingClassifier, 'XGB':XGBClassifier,
  52. 'LGB':LGBMClassifier, 'LDA':LDA, 'rLDA':rLDA}
  54. # scikit-learn old version compatibility
  55. try:
  56. from sklearn.model_selection import StratifiedShuffleSplit, LeaveOneOut
  57. SKLEARN_OLD = False
  58. except ImportError:
  59. from sklearn.cross_validation import StratifiedShuffleSplit, LeaveOneOut
  60. SKLEARN_OLD = True
  61. mne.set_log_level('ERROR')
  62. os.environ['OMP_NUM_THREADS'] = '1' # actually improves performance for multitaper
  64. def check_config(cfg):
  65. critical_vars = {
  66. 'COMMON': ['TRIGGER_FILE',
  67. 'TRIGGER_DEF',
  68. 'EPOCH',
  69. 'DATA_PATH',
  70. 'PICKED_CHANNELS',
  71. 'SP_FILTER',
  72. 'TP_FILTER',
  73. 'NOTCH_FILTER',
  74. 'FEATURES',
  75. 'CLASSIFIER',
  76. 'CV_PERFORM'],
  77. 'RF': ['n_estimators'],
  78. 'GB': ['n_estimators', 'learning_rate'],
  79. 'XGB': ['n_estimators', 'learning_rate'],
  80. 'LGB': ['n_estimators', 'learning_rate'],
  81. 'LDA': [],
  82. 'rLDA': ['reg_cov'],
  83. 'StratifiedShuffleSplit': ['test_ratio', 'folds', 'seed', 'export_result'],
  84. 'LeaveOneOut': ['export_result']
  85. }
  87. # optional variables with default values
  88. optional_vars = {
  89. 'MULTIPLIER': 1,
  90. 'EXPORT_GOOD_FEATURES': False,
  91. 'FEAT_TOPN': 10,
  92. 'EXPORT_CLS': False,
  93. 'REREFERENCE': None,
  94. 'N_JOBS': None,
  95. 'EXCLUDED_CHANNELS': None,
  96. 'LOAD_EVENTS': None,
  97. 'CV': {'IGNORE_THRES': None, 'DECISION_THRES': None, 'BALANCE_SAMPLES': False},
  98. }
  100. for v in critical_vars['COMMON']:
  101. if not hasattr(cfg, v):
  102. logger.error('%s not defined in config.' % v)
  103. raise KeyError
  105. for key in optional_vars:
  106. if not hasattr(cfg, key):
  107. setattr(cfg, key, optional_vars[key])
  108. logger.warning('Setting undefined parameter %s=%s' % (key, getattr(cfg, key)))
  110. if 'decim' not in cfg.FEATURES['PSD']:
  111. cfg.FEATURES['PSD']['decim'] = 1
  113. # classifier parameters check
  114. selected_classifier = cfg.CLASSIFIER['selected']
  115. if selected_classifier not in cfg.CLASSIFIER:
  116. logger.error('"%s" not defined in your config.' % selected_classifier)
  117. raise KeyError
  118. for v in critical_vars[selected_classifier]:
  119. if v not in cfg.CLASSIFIER[selected_classifier]:
  120. logger.error('parameter %s must be defined for %s classifier.' % (v, selected_classifier))
  121. raise KeyError
  123. cv_selected = cfg.CV_PERFORM['selected']
  124. if cfg.CV_PERFORM[cv_selected] is not None:
  125. if cv_selected not in cfg.CV_PERFORM:
  126. logger.error('"%s" not defined in config.' % cv_selected)
  127. raise KeyError
  128. for v in critical_vars[cv_selected]:
  129. if v not in cfg.CV_PERFORM[cv_selected]:
  130. logger.error('parameter %s must be defined for %s.' % (v, cv_selected))
  131. raise KeyError
  132. if cfg.N_JOBS is None:
  133. cfg.N_JOBS = mp.cpu_count()
  135. return cfg
  138. def balance_samples(X, Y, balance_type, verbose=False):
  139. if balance_type == 'OVER':
  140. """
  141. Oversample from classes that lack samples
  142. """
  143. label_set = np.unique(Y)
  144. max_set = []
  145. X_balanced = np.array(X)
  146. Y_balanced = np.array(Y)
  148. # find a class with maximum number of samples
  149. for c in label_set:
  150. yl = np.where(Y == c)[0]
  151. if len(max_set) == 0 or len(yl) > max_set[1]:
  152. max_set = [c, len(yl)]
  153. for c in label_set:
  154. if c == max_set[0]: continue
  155. yl = np.where(Y == c)[0]
  156. extra_samples = max_set[1] - len(yl)
  157. extra_idx = np.random.choice(yl, extra_samples)
  158. X_balanced = np.append(X_balanced, X[extra_idx], axis=0)
  159. Y_balanced = np.append(Y_balanced, Y[extra_idx], axis=0)
  160. elif balance_type == 'UNDER':
  161. """
  162. Undersample from classes that are excessive
  163. """
  164. label_set = np.unique(Y)
  165. min_set = []
  167. # find a class with minimum number of samples
  168. for c in label_set:
  169. yl = np.where(Y == c)[0]
  170. if len(min_set) == 0 or len(yl) < min_set[1]:
  171. min_set = [c, len(yl)]
  172. yl = np.where(Y == min_set[0])[0]
  173. X_balanced = np.array(X[yl])
  174. Y_balanced = np.array(Y[yl])
  175. for c in label_set:
  176. if c == min_set[0]: continue
  177. yl = np.where(Y == c)[0]
  178. reduced_idx = np.random.choice(yl, min_set[1])
  179. X_balanced = np.append(X_balanced, X[reduced_idx], axis=0)
  180. Y_balanced = np.append(Y_balanced, Y[reduced_idx], axis=0)
  181. elif balance_type is None or balance_type is False:
  182. return X, Y
  183. else:
  184. logger.error('Unknown balancing type %s' % balance_type)
  185. raise ValueError
  187. logger.info_green('\nNumber of samples after %ssampling' % balance_type.lower())
  188. for c in label_set:
  189. logger.info('%s: %d -> %d' % (c, len(np.where(Y == c)[0]), len(np.where(Y_balanced == c)[0])))
  191. return X_balanced, Y_balanced
  194. def crossval_epochs(cv, epochs_data, labels, cls, label_names=None, do_balance=None, n_jobs=None, ignore_thres=None, decision_thres=None):
  195. """
  196. Epoch-based cross-validation used by cross_validate().
  198. Params
  199. ======
  200. cv: scikit-learn cross-validation object
  201. epochs_data: np.array of shape [epochs x samples x features]
  202. labels: np.array of shape [epochs x samples]
  203. cls: classifier
  204. label_names: associated label names {0:'Left', 1:'Right', ...}
  205. do_balance: oversample or undersample to match the number of samples among classes
  207. """
  209. scores = []
  210. f1s = []
  211. cnum = 1
  212. cm_sum = 0
  213. label_set = np.unique(labels)
  214. num_labels = len(label_set)
  215. if label_names is None:
  216. label_names = {l:'%s' % l for l in label_set}
  218. if n_jobs is None:
  219. n_jobs = mp.cpu_count()
  221. if n_jobs > 1:
  222. logger.info('crossval_epochs(): Using %d cores' % n_jobs)
  223. pool = mp.Pool(n_jobs)
  224. results = []
  226. # for classifier itself, single core is usually faster
  227. cls.n_jobs = 1
  229. if SKLEARN_OLD:
  230. splits = cv
  231. else:
  232. splits = cv.split(epochs_data, labels[:, 0])
  233. for train, test in splits:
  234. X_train = np.concatenate(epochs_data[train])
  235. X_test = np.concatenate(epochs_data[test])
  236. Y_train = np.concatenate(labels[train])
  237. Y_test = np.concatenate(labels[test])
  238. if do_balance:
  239. X_train, Y_train = balance_samples(X_train, Y_train, do_balance)
  240. X_test, Y_test = balance_samples(X_test, Y_test, do_balance)
  242. if n_jobs > 1:
  243. results.append(pool.apply_async(fit_predict_thres,
  244. [cls, X_train, Y_train, X_test, Y_test, cnum, label_set, ignore_thres, decision_thres]))
  245. else:
  246. score, cm, f1 = fit_predict_thres(cls, X_train, Y_train, X_test, Y_test, cnum, label_set, ignore_thres, decision_thres)
  247. scores.append(score)
  248. f1s.append(f1)
  249. cm_sum += cm
  250. cnum += 1
  252. if n_jobs > 1:
  253. pool.close()
  254. pool.join()
  256. for r in results:
  257. score, cm, f1 = r.get()
  258. scores.append(score)
  259. f1s.append(f1)
  260. cm_sum += cm
  262. # confusion matrix
  263. cm_sum = cm_sum.astype('float')
  264. if cm_sum.shape[0] != cm_sum.shape[1]:
  265. # we have decision thresholding condition
  266. assert cm_sum.shape[0] < cm_sum.shape[1]
  267. cm_sum_all = cm_sum
  268. cm_sum = cm_sum[:, :cm_sum.shape[0]]
  269. underthres = np.array([r[-1] / sum(r) for r in cm_sum_all])
  270. else:
  271. underthres = None
  273. cm_rate = np.zeros(cm_sum.shape)
  274. for r_in, r_out in zip(cm_sum, cm_rate):
  275. rs = sum(r_in)
  276. if rs > 0:
  277. r_out[:] = r_in / rs
  278. else:
  279. assert min(r) == max(r) == 0
  280. if underthres is not None:
  281. cm_rate = np.concatenate((cm_rate, underthres[:, np.newaxis]), axis=1)
  283. cm_txt = 'Y: ground-truth, X: predicted\n'
  284. max_chars = 12
  285. tpl_str = '%%-%ds ' % max_chars
  286. tpl_float = '%%-%d.2f ' % max_chars
  287. for l in label_set:
  288. cm_txt += tpl_str % label_names[l][:max_chars]
  289. if underthres is not None:
  290. cm_txt += tpl_str % 'Ignored'
  291. cm_txt += '\n'
  292. for r in cm_rate:
  293. for c in r:
  294. cm_txt += tpl_float % c
  295. cm_txt += '\n'
  296. cm_txt += 'Average accuracy: %.2f\n' % np.mean(scores)
  297. cm_txt += 'Average F1 score: %.2f\n' % np.mean(f1s)
  299. return np.array(scores), cm_txt
  302. def balance_tpr(cfg, featdata):
  303. """
  304. Find the threshold of class index 0 that yields equal number of true positive samples of each class.
  305. Currently only available for binary classes.
  307. Params
  308. ======
  309. cfg: config module
  310. feetdata: feature data computed using compute_features()
  311. """
  313. n_jobs = cfg.N_JOBS
  314. if n_jobs is None:
  315. n_jobs = mp.cpu_count()
  316. if n_jobs > 1:
  317. logger.info('balance_tpr(): Using %d cores' % n_jobs)
  318. pool = mp.Pool(n_jobs)
  319. results = []
  321. # Init a classifier
  322. selected_classifier = cfg.CLASSIFIER[cfg.CLASSIFIER['selected']]
  323. if selected_classifier not in CLASSIFIERS:
  324. logger.error('Unsupported classifier %s' % selected_classifier)
  325. raise ValueError
  326. params = cfg.CLASSIFIER[selected_classifier]
  327. cls = CLASSIFIERS[selected_classifier](**params)
  329. # Setup features
  330. X_data = featdata['X_data']
  331. Y_data = featdata['Y_data']
  332. wlen = featdata['wlen']
  333. if cfg.CLASSIFIER['PSD']['wlen'] is None:
  334. cfg.CLASSIFIER['PSD']['wlen'] = wlen
  336. # Choose CV type
  337. ntrials, nsamples, fsize = X_data.shape
  338. selected_CV = cfg.CV_PERFORM[cfg.CV_PERFORM['selected']]
  339. if cselected_CV == 'LeaveOneOut':
  340. logger.info_green('\n%d-fold leave-one-out cross-validation' % ntrials)
  341. if SKLEARN_OLD:
  342. cv = LeaveOneOut(len(Y_data))
  343. else:
  344. cv = LeaveOneOut()
  345. elif selected_CV == 'StratifiedShuffleSplit':
  346. logger.info_green('\n%d-fold stratified cross-validation with test set ratio %.2f' % (cfg.CV_PERFORM[selected_CV]['folds'], cfg.CV_PERFORM[selected_CV]['test_ratio']))
  347. if SKLEARN_OLD:
  348. cv = StratifiedShuffleSplit(Y_data[:, 0], cfg.CV_PERFORM[selected_CV]['folds'], test_size=cfg.CV_PERFORM[selected_CV]['test_ratio'], random_state=cfg.CV_PERFORM[selected_CV]['random_seed'])
  349. else:
  350. cv = StratifiedShuffleSplit(n_splits=cfg.CV_PERFORM[selected_CV]['folds'], test_size=cfg.CV_PERFORM[selected_CV]['test_ratio'], random_state=cfg.CV_PERFORM[selected_CV]['random_seed'])
  351. else:
  352. logger.error('%s is not supported yet. Sorry.' % selected_CV)
  353. raise NotImplementedError
  354. logger.info('%d trials, %d samples per trial, %d feature dimension' % (ntrials, nsamples, fsize))
  356. # For classifier itself, single core is usually faster
  357. cls.n_jobs = 1
  358. Y_preds = []
  360. if SKLEARN_OLD:
  361. splits = cv
  362. else:
  363. splits = cv.split(X_data, Y_data[:, 0])
  364. for cnum, (train, test) in enumerate(splits):
  365. X_train = np.concatenate(X_data[train])
  366. X_test = np.concatenate(X_data[test])
  367. Y_train = np.concatenate(Y_data[train])
  368. Y_test = np.concatenate(Y_data[test])
  369. if n_jobs > 1:
  370. results.append(pool.apply_async(get_predict_proba, [cls, X_train, Y_train, X_test, Y_test, cnum+1]))
  371. else:
  372. Y_preds.append(get_predict_proba(cls, X_train, Y_train, X_test, Y_test, cnum+1))
  373. cnum += 1
  375. # Aggregate predictions
  376. if n_jobs > 1:
  377. pool.close()
  378. pool.join()
  379. for r in results:
  380. Y_preds.append(r.get())
  381. Y_preds = np.concatenate(Y_preds, axis=0)
  383. # Find threshold for class index 0
  384. Y_preds = sorted(Y_preds)
  385. mid_idx = int(len(Y_preds) / 2)
  386. if len(Y_preds) == 1:
  387. return 0.5 # should not reach here in normal conditions
  388. elif len(Y_preds) % 2 == 0:
  389. thres = Y_preds[mid_idx-1] + (Y_preds[mid_idx] - Y_preds[mid_idx-1]) / 2
  390. else:
  391. thres = Y_preds[mid_idx]
  392. return thres
  395. def cva_features(datadir):
  396. """
  397. (DEPRECATED FUNCTION)
  398. """
  399. for fin in qc.get_file_list(datadir, fullpath=True):
  400. if fin[-4:] != '.gdf': continue
  401. fout = fin + '.cva'
  402. if os.path.exists(fout):
  403. logger.info('Skipping', fout)
  404. continue
  405. logger.info("cva_features('%s')" % fin)
  406. qc.matlab("cva_features('%s')" % fin)
  409. def get_predict_proba(cls, X_train, Y_train, X_test, Y_test, cnum):
  410. """
  411. All likelihoods will be collected from every fold of a cross-validaiton. Based on these likelihoods,
  412. a threshold will be computed that will balance the true positive rate of each class.
  413. Available with binary classification scenario only.
  414. """
  415. timer = qc.Timer()
  416. cls.fit(X_train, Y_train)
  417. Y_pred = cls.predict_proba(X_test)
  418. logger.info('Cross-validation %d (%d tests) - %.1f sec' % (cnum, Y_pred.shape[0], timer.sec()))
  419. return Y_pred[:,0]
  422. def fit_predict_thres(cls, X_train, Y_train, X_test, Y_test, cnum, label_list, ignore_thres=None, decision_thres=None):
  423. """
  424. Any likelihood lower than a threshold is not counted as classification score
  425. Confusion matrix, accuracy and F1 score (macro average) are computed.
  427. Params
  428. ======
  429. ignore_thres:
  430. if not None or larger than 0, likelihood values lower than ignore_thres will be ignored
  431. while computing confusion matrix.
  433. """
  434. timer = qc.Timer()
  435. cls.fit(X_train, Y_train)
  436. assert ignore_thres is None or ignore_thres >= 0
  437. if ignore_thres is None or ignore_thres == 0:
  438. Y_pred = cls.predict(X_test)
  439. score = skmetrics.accuracy_score(Y_test, Y_pred)
  440. cm = skmetrics.confusion_matrix(Y_test, Y_pred, labels=label_list)
  441. f1 = skmetrics.f1_score(Y_test, Y_pred, average='macro')
  442. else:
  443. if decision_thres is not None:
  444. logger.error('decision threshold and ignore_thres cannot be set at the same time.')
  445. raise ValueError
  446. Y_pred = cls.predict_proba(X_test)
  447. Y_pred_labels = np.argmax(Y_pred, axis=1)
  448. Y_pred_maxes = np.array([x[i] for i, x in zip(Y_pred_labels, Y_pred)])
  449. Y_index_overthres = np.where(Y_pred_maxes >= ignore_thres)[0]
  450. Y_index_underthres = np.where(Y_pred_maxes < ignore_thres)[0]
  451. Y_pred_overthres = np.array([cls.classes_[x] for x in Y_pred_labels[Y_index_overthres]])
  452. Y_pred_underthres = np.array([cls.classes_[x] for x in Y_pred_labels[Y_index_underthres]])
  453. Y_pred_underthres_count = np.array([np.count_nonzero(Y_pred_underthres == c) for c in label_list])
  454. Y_test_overthres = Y_test[Y_index_overthres]
  455. score = skmetrics.accuracy_score(Y_test_overthres, Y_pred_overthres)
  456. cm = skmetrics.confusion_matrix(Y_test_overthres, Y_pred_overthres, labels=label_list)
  457. cm = np.concatenate((cm, Y_pred_underthres_count[:, np.newaxis]), axis=1)
  458. f1 = skmetrics.f1_score(Y_test_overthres, Y_pred_overthres, average='macro')
  460. logger.info('Cross-validation %d (%.3f) - %.1f sec' % (cnum, score, timer.sec()))
  461. return score, cm, f1
  464. def cross_validate(cfg, featdata, cv_file=None):
  465. """
  466. Perform cross validation
  467. """
  468. # Init a classifier
  469. selected_classifier = cfg.CLASSIFIER['selected']
  470. if selected_classifier not in CLASSIFIERS:
  471. logger.error('Unsupported classifier %s' % selected_classifier)
  472. raise ValueError
  473. params = cfg.CLASSIFIER[selected_classifier]
  474. cls = CLASSIFIERS[selected_classifier](**params)
  476. # Setup features
  477. X_data = featdata['X_data']
  478. Y_data = featdata['Y_data']
  479. wlen = featdata['wlen']
  481. # Choose CV type
  482. ntrials, nsamples, fsize = X_data.shape
  483. selected_cv = cfg.CV_PERFORM['selected']
  484. if selected_cv == 'LeaveOneOut':
  485. logger.info_green('%d-fold leave-one-out cross-validation' % ntrials)
  486. if SKLEARN_OLD:
  487. cv = LeaveOneOut(len(Y_data))
  488. else:
  489. cv = LeaveOneOut()
  490. elif selected_cv == 'StratifiedShuffleSplit':
  491. logger.info_green('%d-fold stratified cross-validation with test set ratio %.2f' % (cfg.CV_PERFORM[selected_cv]['folds'], cfg.CV_PERFORM[selected_cv]['test_ratio']))
  492. if SKLEARN_OLD:
  493. cv = StratifiedShuffleSplit(Y_data[:, 0], cfg.CV_PERFORM[selected_cv]['folds'], test_size=cfg.CV_PERFORM[selected_cv]['test_ratio'], random_state=cfg.CV_PERFORM[selected_cv]['seed'])
  494. else:
  495. cv = StratifiedShuffleSplit(n_splits=cfg.CV_PERFORM[selected_cv]['folds'], test_size=cfg.CV_PERFORM[selected_cv]['test_ratio'], random_state=cfg.CV_PERFORM[selected_cv]['seed'])
  496. else:
  497. logger.error('%s is not supported yet. Sorry.' % cfg.CV_PERFORM[cfg.CV_PERFORM['selected']])
  498. raise NotImplementedError
  499. logger.info('%d trials, %d samples per trial, %d feature dimension' % (ntrials, nsamples, fsize))
  501. # Do it!
  502. timer_cv = qc.Timer()
  503. scores, cm_txt = crossval_epochs(cv, X_data, Y_data, cls, cfg.tdef.by_value, cfg.CV['BALANCE_SAMPLES'], n_jobs=cfg.N_JOBS,
  504. ignore_thres=cfg.CV['IGNORE_THRES'], decision_thres=cfg.CV['DECISION_THRES'])
  505. t_cv = timer_cv.sec()
  507. # Export results
  508. txt = 'Cross validation took %d seconds.\n' % t_cv
  509. txt += '\n- Class information\n'
  510. txt += '%d epochs, %d samples per epoch, %d feature dimension (total %d samples)\n' %\
  511. (ntrials, nsamples, fsize, ntrials * nsamples)
  512. for ev in np.unique(Y_data):
  513. txt += '%s: %d trials\n' % (cfg.tdef.by_value[ev], len(np.where(Y_data[:, 0] == ev)[0]))
  514. if cfg.CV['BALANCE_SAMPLES']:
  515. txt += 'The number of samples was balanced using %ssampling.\n' % cfg.BALANCE_SAMPLES.lower()
  516. txt += '\n- Experiment condition\n'
  517. txt += 'Sampling frequency: %.3f Hz\n' % featdata['sfreq']
  518. txt += 'Spatial filter: %s\n' % cfg.SP_FILTER
  519. txt += 'Spectral filter: %s\n' % cfg.TP_FILTER[cfg.TP_FILTER['selected']]
  520. txt += 'Notch filter: %s\n' % cfg.NOTCH_FILTER[cfg.NOTCH_FILTER['selected']]
  521. #txt += 'Channels: ' + ','.join([str(featdata['ch_names'][p]) for p in featdata['picks']]) + '\n'
  522. txt += 'Channels: %s\n' % featdata['ch_names']
  523. txt += 'PSD range: %.1f - %.1f Hz\n' % (cfg.FEATURES['PSD']['fmin'], cfg.FEATURES['PSD']['fmax'])
  524. txt += 'Window step: %.2f msec\n' % (1000.0 * cfg.FEATURES['PSD']['wstep'] / featdata['sfreq'])
  525. if type(wlen) is list:
  526. for i, w in enumerate(wlen):
  527. txt += 'Window size: %.1f msec\n' % (w * 1000.0)
  528. txt += 'Epoch range: %s sec\n' % (cfg.EPOCH[i])
  529. else:
  530. txt += 'Window size: %.1f msec\n' % (cfg.FEATURES['PSD']['wlen'] * 1000.0)
  531. txt += 'Epoch range: %s sec\n' % (cfg.EPOCH)
  532. txt += 'Decimation factor: %d\n' % cfg.FEATURES['PSD']['decim']
  534. # Compute stats
  535. cv_mean, cv_std = np.mean(scores), np.std(scores)
  536. txt += '\n- Average CV accuracy over %d epochs (random seed=%s)\n' % (ntrials, cfg.CV_PERFORM[cfg.CV_PERFORM['selected']]['seed'])
  537. if cfg.CV_PERFORM[cfg.CV_PERFORM['selected']] in ['LeaveOneOut', 'StratifiedShuffleSplit']:
  538. txt += "mean %.3f, std: %.3f\n" % (cv_mean, cv_std)
  539. txt += 'Classifier: %s, ' % selected_classifier
  540. txt += ', '.join(['%s=%s' % (k, params[k]) for k in params]) + '\n'
  541. if cfg.CV['IGNORE_THRES'] is not None:
  542. txt += 'Decision threshold: %.2f\n' % cfg.CV['IGNORE_THRES']
  543. txt += '\n- Confusion Matrix\n' + cm_txt
  544. logger.info(txt)
  546. # Export to a file
  547. if 'export_result' in cfg.CV_PERFORM[selected_cv] and cfg.CV_PERFORM[selected_cv]['export_result'] is True:
  548. if cv_file is None:
  549. if cfg.EXPORT_CLS is True:
  550. qc.make_dirs('%s/classifier' % cfg.DATA_PATH)
  551. fout = open('%s/classifier/cv_result.txt' % cfg.DATA_PATH, 'w')
  552. else:
  553. fout = open('%s/cv_result.txt' % cfg.DATA_PATH, 'w')
  554. else:
  555. fout = open(cv_file, 'w')
  556. fout.write(txt)
  557. fout.close()
  560. def train_decoder(cfg, featdata, feat_file=None):
  561. """
  562. Train the final decoder using all data
  563. """
  564. # Init a classifier
  565. selected_classifier = cfg.CLASSIFIER['selected']
  566. if selected_classifier not in CLASSIFIERS:
  567. logger.error('Unsupported classifier %s' % selected_classifier)
  568. raise ValueError
  569. params = cfg.CLASSIFIER[selected_classifier]
  570. cls = CLASSIFIERS[selected_classifier](**params)
  572. # Setup features
  573. X_data = featdata['X_data']
  574. Y_data = featdata['Y_data']
  575. wlen = featdata['wlen']
  576. if cfg.FEATURES['PSD']['wlen'] is None:
  577. cfg.FEATURES['PSD']['wlen'] = wlen
  578. w_frames = featdata['w_frames']
  579. ch_names = featdata['ch_names']
  580. ch_names_raw = featdata['ch_names_raw']
  581. X_data_merged = np.concatenate(X_data)
  582. Y_data_merged = np.concatenate(Y_data)
  583. if cfg.CV['BALANCE_SAMPLES']:
  584. X_data_merged, Y_data_merged = balance_samples(X_data_merged, Y_data_merged, cfg.CV['BALANCE_SAMPLES'], verbose=True)
  586. # Start training the decoder
  587. logger.info_green('Training the decoder')
  588. timer = qc.Timer()
  589. cls.n_jobs = cfg.N_JOBS
  590. cls.fit(X_data_merged, Y_data_merged)
  591. logger.info('Trained %d samples x %d dimension in %.1f sec' %\
  592. (X_data_merged.shape[0], X_data_merged.shape[1], timer.sec()))
  593. cls.n_jobs = 1 # always set n_jobs=1 for testing
  595. # Export the decoder
  596. classes = {c:cfg.tdef.by_value[c] for c in np.unique(Y_data)}
  597. if cfg.FEATURES['selected'] == 'PSD':
  598. data = dict(cls=cls, ch_names=ch_names, ch_names_raw=ch_names_raw, psde=featdata['psde'], sfreq=featdata['sfreq'],
  599. picks=featdata['picks'], classes=classes, epochs=cfg.EPOCH, w_frames=w_frames,
  600. w_seconds=cfg.FEATURES['PSD']['wlen'], wstep=cfg.FEATURES['PSD']['wstep'], spatial=cfg.SP_FILTER,
  601. spatial_ch=featdata['picks'], spectral=cfg.TP_FILTER[cfg.TP_FILTER['selected']], spectral_ch=featdata['picks'],
  602. notch=cfg.NOTCH_FILTER[cfg.NOTCH_FILTER['selected']], notch_ch=featdata['picks'], multiplier=cfg.MULTIPLIER,
  603. ref_ch=cfg.REREFERENCE[cfg.REREFERENCE['selected']], decim=cfg.FEATURES['PSD']['decim'])
  604. clsfile = '%s/classifier/classifier-%s.pkl' % (cfg.DATA_PATH, platform.architecture()[0])
  605. qc.make_dirs('%s/classifier' % cfg.DATA_PATH)
  606. qc.save_obj(clsfile, data)
  607. logger.info('Decoder saved to %s' % clsfile)
  609. # Reverse-lookup frequency from FFT
  610. fq = 0
  611. if type(cfg.FEATURES['PSD']['wlen']) == list:
  612. fq_res = 1.0 / cfg.FEATURES['PSD']['wlen'][0]
  613. else:
  614. fq_res = 1.0 / cfg.FEATURES['PSD']['wlen']
  615. fqlist = []
  616. while fq <= cfg.FEATURES['PSD']['fmax']:
  617. if fq >= cfg.FEATURES['PSD']['fmin']:
  618. fqlist.append(fq)
  619. fq += fq_res
  621. # Show top distinctive features
  622. if cfg.FEATURES['selected'] == 'PSD':
  623. logger.info_green('Good features ordered by importance')
  624. if selected_classifier in ['RF', 'GB', 'XGB', 'LGB']:
  625. keys, values = qc.sort_by_value(list(cls.feature_importances_), rev=True)
  626. elif selected_classifier in ['LDA', 'rLDA']:
  627. keys, values = qc.sort_by_value(cls.w, rev=True)
  628. keys = np.array(keys)
  629. values = np.array(values)
  631. if cfg.EXPORT_GOOD_FEATURES:
  632. if feat_file is None:
  633. gfout = open('%s/classifier/good_features.txt' % cfg.DATA_PATH, 'w')
  634. else:
  635. gfout = open(feat_file, 'w')
  637. if type(wlen) is list:
  638. ch_names = []
  639. for w in range(len(wlen)):
  640. for c in featdata['picks']:
  641. ch_names.append('w%d-%s' % (w, ch_names_raw[c]))
  643. chlist, hzlist = features.feature2chz(keys, fqlist, ch_names=ch_names)
  644. valnorm = values.copy()
  645. valsum = np.sum(valnorm)
  646. if valsum > 0:
  647. valnorm = valnorm / valsum * 100.0
  649. # show top-N features
  650. for i, (ch, hz) in enumerate(zip(chlist, hzlist)):
  651. if i >= cfg.FEAT_TOPN:
  652. break
  653. txt = '%-3s %5.1f Hz normalized importance %-6s raw importance %-6s feature %-5d' %\
  654. (ch, hz, '%.2f%%' % valnorm[i], '%.2f' % values[i], keys[i])
  655. logger.info(txt)
  657. if cfg.EXPORT_GOOD_FEATURES:
  658. gfout.write('Importance(%) Channel Frequency Index\n')
  659. for i, (ch, hz) in enumerate(zip(chlist, hzlist)):
  660. gfout.write('%.3f\t%s\t%s\t%d\n' % (valnorm[i], ch, hz, keys[i]))
  661. gfout.close()
  664. # for batch scripts
  665. def batch_run(cfg_module):
  666. cfg = pu.load_config(cfg_module)
  667. cfg = check_config(cfg)
  668. run(cfg)
  670. def run(cfg, cv_file=None, feat_file=None, logger=logger):
  671. # add tdef object
  672. cfg.tdef = trigger_def(cfg.TRIGGER_FILE)
  674. # Extract features
  675. featdata = features.compute_features(cfg)
  677. # Find optimal threshold for TPR balancing
  678. #balance_tpr(cfg, featdata)
  680. # Perform cross validation
  681. if cfg.CV_PERFORM[cfg.CV_PERFORM['selected']] is not None:
  682. cross_validate(cfg, featdata, cv_file=cv_file)
  684. # Train a decoder
  685. if cfg.EXPORT_CLS is True:
  686. train_decoder(cfg, featdata, feat_file=feat_file)
  688. def main():
  689. """
  690. Invoked from console
  691. """
  692. # Load parameters
  693. if len(sys.argv) <= 1:
  694. print('Usage: %s config_module' % os.path.basename(__file__))
  695. return
  697. cfg_module = sys.argv[1]
  698. batch_run(cfg_module)
  699. logger.info('Finished.')
  701. if __name__ == '__main__':
  702. main()

trainer.py at commit 8071d09, under gnu · at the source

Overview

Authors: Stefano Scafa1,2,3, Valeria de Seta1,2, Ruijia Wang2,4, Paula Sánchez López2,4, Andrea Sánchez López1,2, Camille Varescon1,2, Icare Sakr2,4, Nadia Bérard5, Lea Bole-Feysot1,2, Céline Deschenaux1,2, Ian Enderli4, Yohann Thenaisie1,2, Morgane Burri2, Frédéric Merlos2, Vanessa Fleury6,7, Benoit Wicki8, Ettore Accolla9,10, Andria Tziakouri10, Cécile Hübsch10, Mayte Castro Jiménez10
and 7 other authorsJulien F Bally10, Alessandro Puiatti3, Kyuhwa Lee11, Henri Lorach1,2, Antoine Collomb-Clerc4, Jocelyne Bloch1,2,4,5, Eduardo M Moraud1,2,4
ORCID iDs: Stefano Scafa, Valeria de Seta, Ruijia Wang, Andrea Sánchez López, Nadia Bérard, Yohann Thenaisie, Frédéric Merlos, Cécile Hübsch, Mayte Castro Jiménez, Julien F Bally, Alessandro Puiatti, Kyuhwa Lee, Antoine Collomb-Clerc, Jocelyne Bloch, Eduardo M Moraud
  1. Department of Clinical Neurosciences, Lausanne University Hospital (CHUV) and University of Lausanne (UNIL), Lausanne, Switzerland
  2. NeuroRestore, Lausanne University Hospital (CHUV) and Ecole Polytechnique Fédérale de Lausanne (EPFL), Lausanne, Switzerland
  3. Institute of Digital Technologies for Personalized Healthcare (MeDiTech), University of Southern Switzerland (SUPSI), Viganello, Switzerland
  4. Neuro-X Institute, École Polytechnique Fédérale de Lausanne (EPFL), Geneva, Switzerland
  5. Department of Neurosurgery, Lausanne University Hospital (CHUV) and University of Lausanne (UNIL), Lausanne, Switzerland
  6. Department of Neurology, Hôpitaux Universitaires de Genève (HUG), Geneva, Switzerland
  7. Faculty of Medicine, University of Geneva, Geneva, Switzerland
  8. Department of Neurology, Hôpital du Valais, Sion, Switzerland
  9. Department of Neurology, Hôpital Fribourgeois, Fribourg, Switzerland
  10. Department of Neurology, Lausanne University Hospital (CHUV) and University of Lausanne (UNIL), Lausanne, Switzerland
  11. Wyss Center for Bio and Neuroengineering, Geneva, Switzerland
Institutions: Centre Hospitalier Universitaire Vaudois (Switzerland); École Polytechnique Fédérale de Lausanne (Switzerland); Università della Svizzera italiana (Switzerland); University of Lausanne (Switzerland); University of Geneva (Switzerland); University Hospital of Geneva (Switzerland); Hôpital du Valais (Switzerland); HFR Freiburg Kantonsspital (Switzerland); Wyss Center for Bio and Neuroengineering (Switzerland)
Journal: Nature medicine, volume 32, issue 8, pages 2815-2830
Dates: received 31 July 2025; accepted 29 April 2026; published online 15 June 2026; in print 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1038/s41591-026-04432-4 · PMID 42297979 · PMCID PMC13472876 · OpenAlex W7164830639
Open access: hybrid, a free copy (OpenAlex)
Status: code verified
Categories: human (organism), Parkinson's (population), clinical / translational (subfield)
Methods: Spectral & time-frequency, Statistics, Smoothing, state filtering, decompositions, Machine learning, Preprocessing, Connectivity, fMRI & imaging, Evoked potentials, Physiology & signal measures
Keywords: Predictive markers, Parkinson's disease, Therapeutics
MeSH: Deep Brain Stimulation*, Gait*, Parkinson Disease*, Activities of Daily Living, Humans, Subthalamic Nucleus (* major topic)
Topic: Neurological disorders and treatments (Neurology, Medicine), according to OpenAlex
Funding: Swiss National Science Foundation (TMSGI3_218471, 218471)
Citations: cited by 4 papers (Europe PMC); 83 references in the paper

Abstract

Parkinson’s disease leads to a spectrum of locomotor deficits that vary in severity with the nature of daily activities and the fluctuating physiology of patients. Many of these deficits remain inadequately addressed by existing deep brain stimulation therapies that rely on activity-agnostic parameters optimized for cardinal motor symptoms. By contrast, therapies embedding activity-specific parameters have the potential to better address the entire range of symptoms. Here we expose physiological principles that enable real-time decoding of ongoing locomotor activities across motor fluctuations from the neural dynamics of the subthalamic nucleus. This decoding steered activity-dependent adaptations of deep brain stimulation therapies that improved locomotor deficits while preserving efficacy for cardinal motor symptoms across activities of daily living. Our activity-dependent framework provides a blueprint for next-generation neuromodulation therapies that continuously select parameters optimized to the behavioral context and fluctuating physiology of each patient. ClinicalTrials.gov registration NCT06791902.

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

Repositories

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

dbdq/neurodecode

License: gnu
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 8071d0975910c23b8339b2660e822c68e9cd6f1f, 24 July 2026
Languages: Python (75), Java (2)
Size: 141 files, 77 scripts
Software Heritage: archived
Found in: the text, “Neural decoding framework”
Holds: README, environment (setup.py), documentation
Not found: license file, CITATION.cff, tests, continuous integration
Tools: NumPy (33 files), MNE-Python (18 files), SciPy (14 files), OpenCV (8 files), Matplotlib (4 files), scikit-learn (4 files), h5py (2 files), LightGBM (2 files), XGBoost (2 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
78 files
At the source: github.com/dbdq/neurodecode

Zenodo 19371521

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

Code availability

The custom code used in this study, including the implementation of the decoding framework, is available via Zenodo at 10.5281/zenodo.19371521 (ref. 83).

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:

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

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

Data

No dataset and no data link were found in the paper.

Data Availability Statement

All data associated with this study are present in the paper, as well as in Extended Data Figs. 1–9, Extended Data Table 1 or Supplementary Information. Anonymized datasets and scripts that support the findings of this study are available via Zenodo at 10.5281/zenodo.19371521 (ref. 83).

The custom code used in this study, including the implementation of the decoding framework, is available via Zenodo at 10.5281/zenodo.19371521 (ref. 83).

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 → Nature Portfolio

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 27 authors, 3 keywords, 6 MeSH terms, 1 funder, 78 references.

Cite

This paper

Scafa, S., de Seta, V., Wang, R., Sánchez López, P., Sánchez López, A., Varescon, C., Sakr, I., Bérard, N., Bole-Feysot, L., Deschenaux, C., Enderli, I., Thenaisie, Y., Burri, M., Merlos, F., Fleury, V., Wicki, B., Accolla, E., Tziakouri, A., Hübsch, C., . . . Moraud, E. M. (2026). Activity-dependent adaptive deep brain stimulation improves gait in Parkinson's disease. Nature medicine, 32(8), 2815-2830. https://doi.org/10.1038/s41591-026-04432-4

BibTeX

@article{scafa2026activity,
author = {Scafa, Stefano and de Seta, Valeria and Wang, Ruijia and Sánchez López, Paula and Sánchez López, Andrea and Varescon, Camille and Sakr, Icare and Bérard, Nadia and Bole-Feysot, Lea and Deschenaux, Céline and Enderli, Ian and Thenaisie, Yohann and Burri, Morgane and Merlos, Frédéric and Fleury, Vanessa and Wicki, Benoit and Accolla, Ettore and Tziakouri, Andria and Hübsch, Cécile and Castro Jiménez, Mayte and Bally, Julien F and Puiatti, Alessandro and Lee, Kyuhwa and Lorach, Henri and Collomb-Clerc, Antoine and Bloch, Jocelyne and Moraud, Eduardo M},
title = {{Activity-dependent adaptive deep brain stimulation improves gait in Parkinson's disease}},
journal = {Nature medicine},
year = {2026},
month = jun,
volume = {32},
number = {8},
pages = {2815--2830},
publisher = {Nature Portfolio},
issn = {1078-8956},
doi = {10.1038/s41591-026-04432-4},
url = {https://doi.org/10.1038/s41591-026-04432-4},
pmid = {42297979},
pmcid = {PMC13472876}
}

RIS

TY - JOUR
AU - Scafa, Stefano
AU - de Seta, Valeria
AU - Wang, Ruijia
AU - Sánchez López, Paula
AU - Sánchez López, Andrea
AU - Varescon, Camille
AU - Sakr, Icare
AU - Bérard, Nadia
AU - Bole-Feysot, Lea
AU - Deschenaux, Céline
AU - Enderli, Ian
AU - Thenaisie, Yohann
AU - Burri, Morgane
AU - Merlos, Frédéric
AU - Fleury, Vanessa
AU - Wicki, Benoit
AU - Accolla, Ettore
AU - Tziakouri, Andria
AU - Hübsch, Cécile
AU - Castro Jiménez, Mayte
AU - Bally, Julien F
AU - Puiatti, Alessandro
AU - Lee, Kyuhwa
AU - Lorach, Henri
AU - Collomb-Clerc, Antoine
AU - Bloch, Jocelyne
AU - Moraud, Eduardo M
TI - Activity-dependent adaptive deep brain stimulation improves gait in Parkinson's disease
T2 - Nature medicine
J2 - Nat Med
PY - 2026
DA - 2026/06/15
VL - 32
IS - 8
SP - 2815
EP - 2830
SN - 1078-8956
PB - Nature Portfolio
DO - 10.1038/s41591-026-04432-4
UR - https://doi.org/10.1038/s41591-026-04432-4
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41591-026-04432-4",
"type": "article-journal",
"title": "Activity-dependent adaptive deep brain stimulation improves gait in Parkinson's disease",
"container-title": "Nature medicine",
"author": [
{
"family": "Scafa",
"given": "Stefano"
},
{
"family": "de Seta",
"given": "Valeria"
},
{
"family": "Wang",
"given": "Ruijia"
},
{
"family": "Sánchez López",
"given": "Paula"
},
{
"family": "Sánchez López",
"given": "Andrea"
},
{
"family": "Varescon",
"given": "Camille"
},
{
"family": "Sakr",
"given": "Icare"
},
{
"family": "Bérard",
"given": "Nadia"
},
{
"family": "Bole-Feysot",
"given": "Lea"
},
{
"family": "Deschenaux",
"given": "Céline"
},
{
"family": "Enderli",
"given": "Ian"
},
{
"family": "Thenaisie",
"given": "Yohann"
},
{
"family": "Burri",
"given": "Morgane"
},
{
"family": "Merlos",
"given": "Frédéric"
},
{
"family": "Fleury",
"given": "Vanessa"
},
{
"family": "Wicki",
"given": "Benoit"
},
{
"family": "Accolla",
"given": "Ettore"
},
{
"family": "Tziakouri",
"given": "Andria"
},
{
"family": "Hübsch",
"given": "Cécile"
},
{
"family": "Castro Jiménez",
"given": "Mayte"
},
{
"family": "Bally",
"given": "Julien F"
},
{
"family": "Puiatti",
"given": "Alessandro"
},
{
"family": "Lee",
"given": "Kyuhwa"
},
{
"family": "Lorach",
"given": "Henri"
},
{
"family": "Collomb-Clerc",
"given": "Antoine"
},
{
"family": "Bloch",
"given": "Jocelyne"
},
{
"family": "Moraud",
"given": "Eduardo M"
}
],
"container-title-short": "Nat Med",
"volume": "32",
"issue": "8",
"page": "2815-2830",
"DOI": "10.1038/s41591-026-04432-4",
"PMID": "42297979",
"PMCID": "PMC13472876",
"ISSN": "1078-8956",
"publisher": "Nature Portfolio",
"URL": "https://doi.org/10.1038/s41591-026-04432-4",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
15
]
]
}
}

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/s41591-026-04434-2 [code]
Adaptive deep brain stimulation for dynamic gait control in Parkinson's disease: a randomized feasibility trial.
Journal: Nature medicine
In common: scikit-learn, SciPy, Matplotlib, 1 other tool, Parkinson's, clinical / translational, 10 references
[2] doi:10.1038/s44172-026-00688-3
N2G calibrator: a cross-subject adversarial learning framework for neural signal-driven gait tracking in Parkinson's disease.
Journal: Communications engineering
In common: Parkinson's, 11 references
[3] doi:10.1016/j.ebiom.2026.106293 [code]
Dynamic neural states underpin motor symptom severity in Parkinson's disease: a longitudinal analysis of chronic cortico-subthalamic nucleus recordings.
Journal: EBioMedicine
In common: SciPy, Matplotlib, NumPy, Parkinson's, 7 references
[4] doi:10.1038/s41531-026-01421-9 [code]
Cortico-pallidal beta dynamics underlie impaired turning in Parkinson's disease.
Journal: NPJ Parkinson's disease
In common: Parkinson's, 8 references
[5] doi:10.1038/s41531-026-01531-4 [code]
Inconsistent subthalamic local field potential beta activity amid in- and antiphasic neuronal bursts.
Journal: NPJ Parkinson's disease
In common: MNE-Python, h5py, scikit-learn, 3 other tools, Parkinson's, clinical / translational, 4 references
[6] doi:10.1038/s41531-026-01372-1 [code]
Varying patterns of association between cortical large-scale networks and subthalamic nucleus activity in Parkinson's disease.
Journal: NPJ Parkinson's disease
In common: MNE-Python, OpenCV, h5py, 4 other tools, Parkinson's, 3 references
[7] doi:10.1038/s41531-026-01439-z [code]
DBSsync: combining intracranial and multimodal data to investigate new biomarkers in Parkinson's disease.
Journal: NPJ Parkinson's disease
In common: MNE-Python, SciPy, Matplotlib, 1 other tool, Parkinson's, clinical / translational, 4 references
[8] doi:10.1002/ana.78206 [code]
Multimodal Image Guidance in Subthalamic Deep Brain Stimulation for Parkinson's Disease.
Journal: Annals of neurology
In common: h5py, SciPy, Matplotlib, 1 other tool, Parkinson's, clinical / translational, 5 references
[9] doi:10.64898/2026.08.12.26350419 [code]
Volitional deep brain stimulation following brain-computer interface training for Parkinson’s disease
Journal: medRxiv (preprint)
In common: SciPy, Matplotlib, NumPy, Parkinson's, clinical / translational, 5 references
[10] doi:10.21203/rs.3.rs-9901682/v1
An Implantable Digital Bridge Enables Arm And Hand Movements After Tetraplegia
Journal: Research Square (preprint)
In common: 2 authors

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.