OSCR

Assistive algorithms influence neural representations in motor brain-computer interfaces.

Code ↔ Paper

11 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 11 matches · 1 of them tie a paragraph to a whole file, not to given lines: a weak match, whose lines are not tinted
  1. [1] § Methods › Data analysis › Rank-ordered neuron adding curve ↔ neural_data_analysis/compactness.ipynb, lines 142–234 · score 0.85 · normalized prediction accuracy, early days, ranked units, Adding Curve, late days, scores
  2. [2] § Methods › Model › Arm model ↔ model/src/TorqueBasedArm.cpp, lines 88–124 · score 0.83 · end effector acceleration, friction matrix, end effector velocity, end effector position, inertia, torques
  3. [3] § Results › Credit assignment to readout units during long-term learning with adaptive decoders ↔ neural_data_analysis/credit_assignment.ipynb, lines 141–207 · score 0.67 · cross validation, logistic regression, credit assignment, predict, accuracies, neural
  4. [4] § Methods › Data analysis › Logistic regression model ↔ neural_data_analysis/compactness.ipynb, lines 142–234 · score 0.65 · max iters, late days, L2, Logistic, regression, accuracy
  5. [5] § Methods › Experiment › BCI control with adaptive decoders ↔ model/params/bci-model-clda0.5/copy_sim_bci_model.cpp, lines 1–14 · score 0.62 · closed loop decoder, velocity Kalman filter, KF, BCI, adaptation, trained
  6. [6] § Methods › Experiment › BCI control with adaptive decoders ↔ model/params/bci_model1/copy_sim_bci_model.cpp, lines 1–14 · score 0.62 · closed loop decoder, velocity Kalman filter, KF, BCI, adaptation, trained
  7. [7] § Methods › Model › Analysis of the model ↔ model/analysis/plot_weight_change.py, lines 102–175 · score 0.60 · weight change, recurrent weight, linregress, scatter, fixed decoder, seed
  8. [8] § Methods › Data analysis › Logistic regression model ↔ neural_data_analysis/credit_assignment.ipynb, lines 141–207 · score 0.59 · logistic regression, flattened, scored, splits, predict, accuracy
  9. [9] § Methods › Experiment › BCI control with adaptive decoders ↔ model/params/bci-model-clda0.5/copy_sim_bci_model.cpp, lines 1–14 · score 0.54 · unit swaps, closed loop, KF, BCI, loss, decoder
  10. [10] § Methods › Experiment › BCI control with adaptive decoders ↔ model/params/bci_model1/copy_sim_bci_model.cpp, lines 1–14 · score 0.54 · unit swaps, closed loop, KF, BCI, loss, decoder
  11. [11] § Methods › Model › Network model ↔ model/params/arm_model/copy_sim_arm_model.cpp, the whole file · a weak match · score 0.54 · activation function, weight matrix, membrane, ReLU, recurrent, RNN

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

Jupyter notebook · 289 lines · 11 KB · no license · 2 matches

  1. # %%
  2. import os
  3. import numpy as np
  4. import pickle
  5. from tqdm import tqdm
  6. import pandas as pd
  7. import seaborn as sns
  8. import matplotlib.pyplot as plt
  9. import copy
  12. from sklearn.utils import resample, shuffle
  13. from sklearn.model_selection import PredefinedSplit
  14. from sklearn.pipeline import Pipeline
  15. from sklearn.model_selection import PredefinedSplit
  16. from sklearn.preprocessing import StandardScaler
  17. from sklearn import model_selection
  18. from sklearn import linear_model
  21. # %%
  22. # functions
  23. ###### helper functions #######
  24. def pkl_read(file_to_read, write_dir):
  25. this = pickle.load(open(os.path.join(write_dir,file_to_read), "rb"))
  26. # print(this)
  27. return this
  29. def pkl_write(file_to_write, values_to_dump, write_dir):
  30. os.chdir(write_dir)
  31. with open(os.path.join(write_dir,file_to_write), 'wb') as pickle_file:
  32. pickle.dump(values_to_dump, pickle_file)
  34. def getdata_day(data,id,data_day):
  35. if id == 1:
  36. # var_name = data[0:data_day[id]+1,:,:]
  37. var_name = data[0:data_day[id],:,:]
  38. else:
  39. day_idx = np.where(np.array(list(data_day))== id)[0].astype(int) - 1
  40. #print(day_idx[0])
  41. prev_day_id = list(data_day)[day_idx[0]]
  42. #print(prev_day_id)
  43. var_name = data[data_day[prev_day_id]:data_day[id],:,:]
  44. return var_name
  46. def gettarget_day(target_direction, id, day):
  47. if id == 1:
  48. target = target_direction[:day[id]]
  49. else:
  50. day_idx = np.where(np.array(list(day))== id)[0].astype(int) - 1
  51. #print(day_idx[0])
  52. prev_day_id = list(day)[day_idx[0]]
  53. target = target_direction[day[prev_day_id]:day[id]]
  54. return target
  56. def get_numtrials_perday(datasize_day):
  57. '''
  58. datasize_day: dictionary with key as day and value as end trial index for that day . Comes from getdata_day()
  59. '''
  60. num_trials_perday = np.zeros(len(datasize_day))
  61. num_trials_perday[0] = np.array(list(datasize_day.values()))[0]
  62. num_trials_perday[1:] = np.diff(np.array(list(datasize_day.values())))
  63. # print(num_trials_perday)
  64. return num_trials_perday
  66. def trial_concatenate_data(data):
  67. '''
  68. data is on shape n_trials x n_units x n_bins
  69. '''
  70. n,u,t = data.shape
  71. new_arr = np.transpose(data, (0,2,1))
  72. new_arr = new_arr.reshape(n*t, u)
  73. # print(new_arr.shape)
  74. return new_arr
  76. ###### LR analysis functions #########
  78. def get_equal_target_dist_predefinedsplit(idx, target, n_samples_per_target):
  79. random_idx = []
  80. for it in range(8):
  81. this_idx = np.where(target== it+1)
  83. r_idx = np.random.choice(this_idx[0], n_samples_per_target, replace = False)
  84. # print(r_idx)
  85. random_idx.append(r_idx)
  86. # print(np.shape(random_idx))
  87. rand_idx = np.array(random_idx).reshape(n_samples_per_target*8)
  88. ps = np.zeros(len(target))
  89. ps[rand_idx] = -1 # index for training
  90. # ps[ps == 0] = 1 # index for test set
  92. # to genereate 2 fold cross validation
  93. test_idx = np.argwhere(~np.in1d(np.arange(len(ps)), rand_idx))
  94. first_fold = test_idx[:len(test_idx)//2]
  95. second_fold = test_idx[len(test_idx)//2:]
  96. ps[first_fold] = 0 # index for test set for fold 1
  97. ps[second_fold] = 1 # index for test set for fold 2
  98. # print(ps[ps == -1].shape, ps[ps == 0].shape, ps[ps == 1].shape)
  99. return ps
  101. def flatten_data(data):
  102. # Flattens the last two dimensions of the data
  103. return data.reshape(data.shape[0], -1)
  106. def matrix_similarity(A, B):
  107. """
  108. Compute the R^2 similarity between two matrices by treating them as vectors.
  110. Args:
  111. - A: First 2D matrix.
  112. - B: Second 2D matrix.
  114. Returns:
  115. - R^2 value representing the similarity between the matrices.
  116. """
  117. assert A.shape == B.shape, "Matrices must have the same shape"
  119. # Flatten the matrices to vectors
  120. A_flat = A.ravel()
  121. B_flat = B.ravel()
  123. # Compute the correlation coefficient
  124. correlation_matrix = np.corrcoef(A_flat, B_flat)
  125. r = correlation_matrix[0, 1]
  127. # Square the correlation coefficient to get R^2 value
  128. r2 = r #**2
  129. return r2
  133. # %%
  134. neural_recordings = pkl_read('neural_data.pkl', './example_data/') # Shape: n_tr x n_units x n_timebins; top 16 units are readouts
  135. target_direction = pkl_read('target_labels.pkl', './example_data/')
  136. datasize_day = pkl_read('trial_day_label.pkl', './example_data/')
  138. days = np.arange(2,18) # just for example. In the paper, we considered all days that had a minimum of 25 trials of successful reaches per target direction, minimum 200 trials in total.
  139. n_readouts = 20
  142. # %%
  143. # ranked unit adding curve with readout units only
  145. early_day = days[1]
  146. late_day = days[-1]
  148. n_neurons = n_readouts
  149. neural_recordings = neural_recordings[:,:n_readouts, :]
  151. # 2) Load neural data belonging to the days we want to check
  152. days_to_check = (early_day, late_day)
  154. n_bs = 10 # 100
  156. accuracy_inc_days_bs = np.zeros((len(days_to_check), n_bs, n_neurons)) # Individual unit accuracy : n_days x n_bs x n_sortedunits
  157. n_cont_idx_days_bs = np.zeros((len(days_to_check), n_bs, n_neurons))
  158. accuracy_ndc_days_bs = np.zeros((len(days_to_check), n_bs, n_neurons)) # Accuracy from ranked unit adding
  160. for i_, i in enumerate(days_to_check):
  161. data = getdata_day(neural_recordings,i, datasize_day )
  162. target = gettarget_day(target_direction, i, datasize_day)
  164. for j in tqdm(range(n_bs)):
  165. # Bootstrap trails with equal distribution of all targets and define train-test set
  166. idx = np.arange(0,len(data),1)
  167. test_fold = get_equal_target_dist_predefinedsplit(idx,target, 25) # function that returns 200 random trials ids with equal distribution of target directions in the dataset
  168. ps = PredefinedSplit(test_fold)
  170. # Get prediction accuracy for each neuron
  171. accuracy_inc = []
  172. for iN in range(n_neurons):
  173. sample_data = data[:,iN,:]
  174. data_train = np.squeeze(sample_data)
  175. data_flat = flatten_data(data_train)
  176. outcome_train = np.squeeze(target)
  178. # Logistic Regression Model
  179. my_model = linear_model.LogisticRegression(penalty = 'l2', max_iter=1000, C = 1)
  181. # Creating a pipeline
  182. pipe = Pipeline([
  183. ('scale', StandardScaler()),
  184. ('logistic', my_model)
  185. ])
  187. cv_results = model_selection.cross_validate(pipe, data_flat, outcome_train, cv= ps, return_estimator=True)
  188. results = cv_results['test_score']
  189. accuracy_inc.append(results)
  191. # print('inc')
  192. inc_mean = np.mean(accuracy_inc,1) # mean across 2 fold
  193. # print(inc_mean.shape)
  194. n_idx = np.argsort(inc_mean)[::-1] # sort units based on individual unit accuracy
  195. # print(n_idx)
  196. accuracy_inc_days_bs[i_, j, :] = inc_mean[n_idx] # days_to_check x n_bs x n_units
  197. n_cont_idx_days_bs[i_,j, :] = n_idx
  200. # Run unit adding curve based on rank from above
  201. for iN in range(1,n_neurons+1):
  202. neuron_idx = n_idx[:iN]
  203. sample_data = data[:,neuron_idx,:]
  204. data_train = np.squeeze(sample_data)
  205. data_flat = flatten_data(data_train) # Concatenating the third dimension
  206. outcome_train = np.squeeze(target)
  208. # Logistic Regression Model
  209. my_model = linear_model.LogisticRegression(penalty = 'l2', max_iter=1000, C = 1)
  211. # Creating a pipeline
  212. pipe = Pipeline([
  213. ('scale', StandardScaler()),
  214. ('logistic', my_model)
  215. ])
  216. #cross validate coef
  217. cv_results = model_selection.cross_validate(pipe, data_flat, outcome_train, cv= ps, return_estimator=True)
  218. # accuracy_draw[id] = cv_results['test_score']
  219. results = cv_results['test_score']
  220. accuracy_ndc_days_bs[i_,j,iN-1] = np.mean(results)
  222. acc_early = accuracy_ndc_days_bs[0,:,:]
  223. m_a_early = np.mean(acc_early,axis = 0) # mean along bootstrap
  224. norm_acc_early =( m_a_early - np.min(m_a_early)) /(np.max(m_a_early)- np.min(m_a_early))
  225. print(acc_early.shape)
  227. acc_late = accuracy_ndc_days_bs[1,:,:]
  228. m_a_late = np.mean(acc_late,axis = 0)
  229. norm_acc_late =( m_a_late - np.min(m_a_late)) / (np.max(m_a_late)- np.min(m_a_late))
  230. print(acc_late.shape)
  232. compactness_early = np.argwhere(norm_acc_early > 0.8)[0][0]
  233. compactness_late = np.argwhere(norm_acc_late > 0.8)[0][0]
  234. print(f'No. of units to reach 80% normalized prediction during early day is {compactness_early} and late day is {compactness_late}')
  237. # %%
  238. print(accuracy_inc_days_bs.shape) # n_days x n_bs x n_rankedunits
  240. sns.set_context('paper')
  241. sns.set_style('ticks')
  242. plt.figure(figsize=(2.2,1.5))
  243. plt.errorbar(np.arange(n_neurons)+1,np.mean(accuracy_inc_days_bs[0,:,:], axis = 0), yerr = np.std(accuracy_inc_days_bs[0,:,:], axis = 0), color = 'tab:cyan', label = 'early', linewidth = 1.0)
  244. plt.errorbar(np.arange(n_neurons)+1,np.mean(accuracy_inc_days_bs[1,:,:], axis = 0), yerr = np.std(accuracy_inc_days_bs[1,:,:], axis = 0), color = 'tab:purple', label = 'late', linewidth = 1.0)
  245. plt.ylabel('Classification accuracy', fontsize = 8)
  246. plt.xlabel('Ranked units', fontsize = 8)
  247. plt.legend(frameon = False, labelcolor = 'linecolor')
  248. plt.xticks(fontsize = 8)
  249. plt.yticks(fontsize = 8)
  250. sns.despine()
  253. plt.figure(figsize=(2.2,1.5))
  254. sns.set_context('paper')
  255. sns.set_style('ticks')
  256. plt.errorbar(np.arange(n_neurons)+1,np.mean(accuracy_ndc_days_bs[0,:,:], axis = 0), yerr = np.std(accuracy_ndc_days_bs[0,:,:], axis = 0), color = 'tab:cyan', label = 'early', linewidth = 1.0)
  257. plt.errorbar(np.arange(n_neurons)+1,np.mean(accuracy_ndc_days_bs[1,:,:], axis = 0), yerr = np.std(accuracy_ndc_days_bs[1,:,:], axis = 0), color = 'tab:purple', label = 'late', linewidth = 1.0)
  258. plt.ylabel('Classification accuracy', fontsize = 8)
  259. plt.xlabel('# of ranked units', fontsize = 8)
  260. plt.legend(frameon = False, labelcolor = 'linecolor', fontsize = 8)
  261. plt.xticks(fontsize = 8)
  262. plt.yticks(fontsize = 8)
  263. sns.despine()
  264. # f_name = os.path.join(PLOTS_DIR, 'RankOrderedNDC_all_paper.pdf')
  265. # plt.savefig(f_name, dpi = 300)
  267. # Normalizing to align
  268. sns.set_context('paper')
  269. sns.set_style('ticks')
  270. plt.figure(figsize=(2.2, 1.5))
  271. acc_early = accuracy_ndc_days_bs[0,:,:]
  272. m_a_early = np.mean(acc_early,axis = 0) # mean along bootstrap
  273. norm_acc_early =( m_a_early - np.min(m_a_early)) /(np.max(m_a_early)- np.min(m_a_early))
  274. print(acc_early.shape)
  276. acc_late = accuracy_ndc_days_bs[1,:,:]
  277. m_a_late = np.mean(acc_late,axis = 0)
  278. norm_acc_late =( m_a_late - np.min(m_a_late)) / (np.max(m_a_late)- np.min(m_a_late))
  279. print(acc_late.shape)
  281. plt.errorbar(np.arange(n_neurons)+1, norm_acc_early, yerr=np.std(acc_early,axis =0) ,color = 'tab:cyan', label = 'early')
  282. plt.errorbar(np.arange(n_neurons)+1, norm_acc_late, yerr=np.std(acc_late,axis =0), color = 'tab:purple', label = 'late')
  283. plt.axhline(y = 0.8, color = 'k', alpha = 0.8, linestyle = '-.')
  284. plt.legend(frameon = False, labelcolor = 'linecolor')
  285. plt.xlabel('# of ranked units')
  286. plt.ylabel('Classification accuracy \n normalized')
  287. plt.title('Rank Ordered NAC')
  288. sns.despine()

compactness.ipynb at commit 571dfc0, no license · at the source

Overview

Authors: Pavithra Rajeswaran1, Alexandre Payeur2,3, Guillaume Lajoie2,3, Amy L Orsborn1,4,5
ORCID iDs: Pavithra Rajeswaran, Alexandre Payeur, Guillaume Lajoie, Amy L Orsborn
  1. Department of Bioengineering, University of Washington, Seattle, WA USA
  2. Department of Mathematics and Statistics, Université de Montréal, Montréal, QC Canada
  3. Mila - Québec Artificial Intelligence Institute, Montréal, QC Canada
  4. Department of Electrical and Computer Engineering, University of Washington, Seattle, WA USA
  5. Washington National Biomedical Research Center, Seattle, WA USA
Institutions: University of Washington (United States); Mila - Quebec Artificial Intelligence Institute (Canada); Université de Montréal (Canada)
Journal: Nature communications, volume 17, issue 1, article 9832
Dates: received 25 April 2025; accepted 20 July 2026; published online 15 September 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41467-026-76109-y · PMID 42744792 · PMCID PMC13578456 · OpenAlex W7213337904
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: non-human primate (organism), systems (subfield)
Methods: Statistics, Smoothing, state filtering, decompositions, Machine learning, Preprocessing, Single-unit activity, calcium imaging
Keywords: Brain-machine interface, Motor cortex, Neural decoding, Learning algorithms
MeSH: Algorithms*, Brain-Computer Interfaces*, Motor Cortex*, Animals, Learning, Macaca mulatta, Male, Models, Neurological, Movement, Neural Networks, Computer, Neurons (* major topic)
Topic: EEG and Brain-Computer Interfaces (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: NICHD NIH HHS (K12 HD073945); Canada First Research Excellence Fund (Fonds d'excellence en recherche Apog&ée Canada) (IVADO postdoctoral fellowship); NINDS NIH HHS (R01 NS134634); Simons Foundation (898220); U.S. Department of Health & Human Services | NIH | National Institute of Neurological Disorders and Stroke (NINDS) (NS134634); National Science Foundation (NSF) (Accelnet INBIC fellowship); U.S. Department of Health & Human Services | NIH | Eunice Kennedy Shriver National Institute of Child Health and Human Development (NICHD) (K12HD073945); Canadian Network for Research and Innovation in Machining Technology, Natural Sciences and Engineering Research Council of Canada (NSERC Canadian Network for Research and Innovation in Machining Technology) (RGPIN-2018-04821)
Citations: not cited yet (Europe PMC); 82 references in the paper

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repository

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

pavi-rajes/assistive-sensory-motor-perturbations-influence-learned-neural-representations

License: none: the authors keep all their rights
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: 571dfc0479b74a21f4b95bfda5671cf27d2ba36c, 1 May 2024
Languages: C++ (40), Python (7), Jupyter (3), Shell (2)
Size: 109 files, 52 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, environment (neural_data_analysis/requirements.txt, model/analysis/environment.yml), 3 notebooks
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: Matplotlib (10 files), NumPy (10 files), seaborn (10 files), SciPy (5 files), scikit-learn (4 files), pandas (3 files), Numba (1 file)
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
53 files
At the source: github.com/pavi-rajes/Assistive-sensory-motor-perturbations-influence-learned-neural-representations/tree/main

Code availability statement

The paper has a code availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1038/s41467-026-76109-y.

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;
  • 52 scripts, each with its path and the digest of its content;
  • 11 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.

Code and data availability statement

The paper has a code and data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1038/s41467-026-76109-y.

Versions

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

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 4 authors, 4 keywords, 11 MeSH terms, 8 funders, 73 references.

Cite

This paper

Rajeswaran, P., Payeur, A., Lajoie, G., & Orsborn, A. L. (2026). Assistive algorithms influence neural representations in motor brain-computer interfaces. Nature communications, 17(1), 9832. https://doi.org/10.1038/s41467-026-76109-y

BibTeX

@article{rajeswaran2026assistive,
author = {Rajeswaran, Pavithra and Payeur, Alexandre and Lajoie, Guillaume and Orsborn, Amy L},
title = {{Assistive algorithms influence neural representations in motor brain-computer interfaces}},
journal = {Nature communications},
year = {2026},
month = sep,
volume = {17},
number = {1},
pages = {9832},
publisher = {Nature Publishing Group},
issn = {2041-1723},
doi = {10.1038/s41467-026-76109-y},
url = {https://doi.org/10.1038/s41467-026-76109-y},
pmid = {42744792},
pmcid = {PMC13578456}
}

RIS

TY - JOUR
AU - Rajeswaran, Pavithra
AU - Payeur, Alexandre
AU - Lajoie, Guillaume
AU - Orsborn, Amy L
TI - Assistive algorithms influence neural representations in motor brain-computer interfaces
T2 - Nature communications
J2 - Nat Commun
PY - 2026
DA - 2026/09/15
VL - 17
IS - 1
SP - 9832
SN - 2041-1723
PB - Nature Publishing Group
DO - 10.1038/s41467-026-76109-y
UR - https://doi.org/10.1038/s41467-026-76109-y
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41467-026-76109-y",
"type": "article-journal",
"title": "Assistive algorithms influence neural representations in motor brain-computer interfaces",
"container-title": "Nature communications",
"author": [
{
"family": "Rajeswaran",
"given": "Pavithra"
},
{
"family": "Payeur",
"given": "Alexandre"
},
{
"family": "Lajoie",
"given": "Guillaume"
},
{
"family": "Orsborn",
"given": "Amy L"
}
],
"container-title-short": "Nat Commun",
"volume": "17",
"issue": "1",
"page": "9832",
"DOI": "10.1038/s41467-026-76109-y",
"PMID": "42744792",
"PMCID": "PMC13578456",
"ISSN": "2041-1723",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41467-026-76109-y",
"language": "en",
"issued": {
"date-parts": [
[
2026,
9,
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.1371/journal.pone.0351053 [code]
Distinct roles of neuronal phenotypes during neurofeedback adaptation.
Journal: PloS one
In common: seaborn, scikit-learn, pandas, 3 other tools, non-human primate, 9 references
[2] doi:10.1126/sciadv.adw3876 [code]
Intracortical brain-computer interface for navigation in virtual reality in macaque monkeys.
Journal: Science advances
In common: seaborn, scikit-learn, pandas, 3 other tools, non-human primate, systems, 8 references
[3] doi:10.1371/journal.pone.0321830
Long-term neuron tracking reveals balance of stability and plasticity in functional properties.
Journal: PloS one
In common: 8 references
[4] doi:10.1371/journal.pbio.3003684 [code]
The retrieval of previously learned motor memories is facilitated by the reinstatement of default mode network manifold structures.
Journal: PLoS biology
In common: seaborn, scikit-learn, pandas, 3 other tools, 5 references
[5] doi:10.1038/s41467-026-74466-2 [code]
Neuromorphic hierarchical modular reservoirs.
Journal: Nature communications
In common: Numba, seaborn, scikit-learn, 4 other tools, author Guillaume Lajoie
[6] doi: [code]
Real-time closed-loop feedback system for mouse mesoscale cortical signal and movement control
Journal: eLife
In common: Numba, seaborn, scikit-learn, 4 other tools, 3 references
[7] doi:10.1016/j.neuron.2026.07.016 [code]
Inferring brain-wide interactions using data-constrained recurrent neural network models.
Journal: Neuron
In common: Matplotlib, NumPy, systems, 6 references
[8] doi:10.3390/biomimetics11080569 [code]
Pretraining of Embodied Recurrent Networks Bridges the Gap Between Artificial and Cortical Neural Activities.
Journal: Biomimetics (Basel, Switzerland)
In common: scikit-learn, SciPy, Matplotlib, 1 other tool, systems, 4 references
[9] doi:10.7554/elife.111876 [code]
Distinct sensorimotor encoding in tuft dendrites and somata associated with action, correction, and learning.
Journal: eLife
In common: seaborn, scikit-learn, pandas, 3 other tools, 3 references
[10] doi:10.1038/s41467-026-71725-0 [code]
Interactions across hemispheres in prefrontal cortex reflect global cognitive processing.
Journal: Nature communications
In common: scikit-learn, pandas, SciPy, 2 other tools, non-human primate, 3 references

Contribute

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

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

Request its removal

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

Discussion, reproductions, activity

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

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

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