OSCR

Intracortical brain-computer interface for navigation in virtual reality in macaque monkeys.

Code ↔ Paper

10 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 10 matches
  1. [1] § MATERIALS AND METHODS › Statistical analysis › Offline decoding analysis per cortical region ↔ src/analysis.py, lines 76–171 · score 0.78 · cortical areas, Online Simulation, offline decoding, Online Decoding, Wilcoxon, pairwise
  2. [2] § MATERIALS AND METHODS › Statistical analysis › Within-session adaptation analysis ↔ src/analysis.py, lines 555–621 · score 0.67 · linear regression, monkey task, slope, classified, decline, smoothed
  3. [3] § RESULTS › Offline decoding reveals regional contributions and the importance of closed-loop dynamics ↔ src/analysis.py, lines 76–171 · score 0.64 · Online Simulation, Offline decoding, Online Decoding, median, Wilcoxon, IQR
  4. [4] § MATERIALS AND METHODS › Statistical analysis › Influence of sEMG on decoded velocity ↔ src/analysis.py, lines 487–519 · score 0.64 · Spearman correlation, velocity components, polynomial, MSE, R2, cross
  5. [5] § RESULTS › Influence of surface electromyography and eye movements on decoded velocities ↔ src/metrics.py, lines 39–59 · score 0.63 · square error, velocity components, MSE, R2, Cross, models
  6. [6] § RESULTS › Offline decoding reveals regional contributions and the importance of closed-loop dynamics ↔ scripts/run_offline_brain_area_analysis.py, lines 26–62 · score 0.63 · brain area, Online Simulation, Online Decoding, offline, matched, M1
  7. [7] § MATERIALS AND METHODS › Statistical analysis › Offline decoding analysis per cortical region ↔ scripts/run_offline_brain_area_analysis.py, lines 1–18 · score 0.62 · cortical areas, offline decoding, Online Simulation, Monkey
  8. [8] § MATERIALS AND METHODS › Statistical analysis › Offline decoding analysis per cortical region ↔ scripts/run_offline_brain_area_analysis.py, lines 1–18 · score 0.56 · cortical area, brain area, offline, online, decoding, monkeys
  9. [9] § MATERIALS AND METHODS › Statistical analysis › Reaction time ↔ src/metrics.py, lines 122–150 · score 0.56 · target jump, tangents, reaction, deviation, target position, threshold
  10. [10] § MATERIALS AND METHODS › Statistical analysis › Influence of eye movements on decoded velocity ↔ src/analysis.py, lines 437–485 · score 0.56 · eye movement, velocity components, Spearman correlation, segmented, monkey

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 · 698 lines · 31 KB · MIT · 5 matches

  1. from typing import List, Tuple
  2. import numpy as np
  3. import pandas as pd
  4. from scipy.stats import linregress
  5. from src.load import load_files
  6. from src.utils import is_within_target_window, is_within_target_window_3D, make_df_structure, process_emg_data, process_eyemovement_data
  7. from src.metrics import spearman_correlation, linear_regression, polynomial_regression
  8. from src.load import load_emg_eyemovement_files
  9. from src.metrics import combined_p_value, compute_iqr
  10. from scipy.stats import ttest_ind, shapiro, mannwhitneyu
  11. from src.plots import plot_3D_endpoints_density_plots, plot_success_rates_offline_decoding
  12. import matplotlib.pyplot as plt
  13. import seaborn as sns
  14. import matplotlib as mpl
  15. from collections import defaultdict
  16. from scipy.stats import wilcoxon
  17. mpl.rcParams['svg.fonttype'] = 'none'
  19. def compute_offline_success_rate(trials, allPredictions, task, execution):
  20. success_count = 0
  21. failure_reasons = defaultdict(int)
  22. total_trials = len(trials)
  23. dt = 0.05
  24. for trial_index in range(total_trials):
  25. trial = trials[trial_index]
  26. predictions = allPredictions[trial_index]
  28. if execution == "offline":
  29. # Compute positions from predictions
  30. x_positions_pred = [0.0]
  31. y_positions_pred = [0.0]
  32. z_positions_pred = [0.0]
  34. for j in range(1, len(predictions)):
  35. if isinstance(predictions[j], int):
  36. continue # Skip if the prediction is an integer
  37. prev_x, prev_y, prev_z = x_positions_pred[-1], y_positions_pred[-1], z_positions_pred[-1]
  38. current_x_velocity = float(predictions[j]['x'])
  39. current_y_velocity = float(predictions[j]['y'])
  40. current_z_velocity = float(predictions[j]['z'])
  41. new_x_position = prev_x + current_x_velocity * dt
  42. new_y_position = prev_y + current_y_velocity * dt
  43. new_z_position = prev_z + current_z_velocity * dt
  44. x_positions_pred.append(new_x_position)
  45. y_positions_pred.append(new_y_position)
  46. z_positions_pred.append(new_z_position)
  47. else:
  48. x_positions_pred = trial.avatarTrajectory['x']
  49. y_positions_pred = trial.avatarTrajectory['y']
  50. z_positions_pred = trial.avatarTrajectory['z']
  51. # Check if computed trajectory is within target window
  52. target = [trial.targetPosition[0], trial.targetPosition[2]]
  53. if task == "Navigation_sphere_3D":
  54. target = [trial.targetPosition[0], trial.targetPosition[1], trial.targetPosition[2]]
  55. is_success = is_within_target_window_3D(
  56. list(zip(x_positions_pred,y_positions_pred, z_positions_pred)),
  57. target,
  58. task,
  59. )
  60. else:
  61. is_success, reason = is_within_target_window(
  62. list(zip(x_positions_pred, z_positions_pred)),
  63. target,
  64. task,
  65. )
  67. # === Count outcome ===
  68. if is_success:
  69. success_count += 1
  70. else:
  71. failure_reasons[reason] += 1
  73. success_rate = success_count / total_trials if total_trials > 0 else 0
  74. return success_rate, dict(failure_reasons)
  76. def compare_success_rate_between_areas_vs_online_simulation(all_success_rates, monkey, experiment):
  77. """
  78. Compare normalized success rates between cortical areas and online decoding simulations.
  80. Args:
  81. all_success_rates (dict): Dictionary of session-level success rates. Each entry should be:
  82. {
  83. 'session_id': {
  84. 'PMv': ..., 'PMd': ..., 'M1': ...,
  85. 'PMv+PMd': ..., 'M1+PMd': ..., 'M1+PMv': ..., 'All': ..., 'Online_simulation': ...
  86. },
  87. ...
  88. }
  90. Returns:
  91. dict: Contains median, IQR-normalized stats, session-wise deltas, Wilcoxon p-values, and raw values.
  92. """
  94. # Prepare containers
  95. region_labels = ['PMv', 'PMd', 'M1', 'PMv+PMd', 'M1+PMd', 'M1+PMv', 'All']
  96. norm_results = {region: [] for region in region_labels}
  97. raw_results = {region: [] for region in region_labels + ['Online']}
  99. # Pairwise deltas of interest
  100. session_deltas = {
  101. 'PMv-M1': [], 'PMv-PMd': [], 'PMd-M1': [],
  102. 'PMv+PMd-Online': [], 'M1+PMd-Online': [], 'M1+PMv-Online': [], 'All-Online': [],
  103. 'PMv-Online': [], 'PMd-Online': [], 'M1-Online': [],
  104. 'PMv+PMd-M1+PMd': [], 'PMv+PMd-M1+PMv': [], 'M1+PMd-M1+PMv': [],
  105. 'PMv+PMd-All': [], 'M1+PMd-All': [], 'M1+PMv-All': []
  106. }
  108. # Populate results
  109. for session, rates in all_success_rates.items():
  110. if all(k in rates for k in ['Online_simulation'] + region_labels):
  111. online = rates['Online_simulation']
  113. # Normalize
  114. for region in region_labels:
  115. norm_results[region].append(rates[region] / online)
  116. raw_results[region].append(rates[region])
  117. raw_results['Online'].append(online)
  119. # Deltas
  120. session_deltas['PMv-M1'].append(rates['PMv'] - rates['M1'])
  121. session_deltas['PMv-PMd'].append(rates['PMv'] - rates['PMd'])
  122. session_deltas['PMd-M1'].append(rates['PMd'] - rates['M1'])
  124. for key in ['PMv+PMd', 'M1+PMd', 'M1+PMv', 'All', 'PMv', 'PMd', 'M1']:
  125. session_deltas[f'{key}-Online'].append(rates[key] - online)
  127. session_deltas['PMv+PMd-M1+PMd'].append(rates['PMv+PMd'] - rates['M1+PMd'])
  128. session_deltas['PMv+PMd-M1+PMv'].append(rates['PMv+PMd'] - rates['M1+PMv'])
  129. session_deltas['M1+PMd-M1+PMv'].append(rates['M1+PMd'] - rates['M1+PMv'])
  131. session_deltas['PMv+PMd-All'].append(rates['PMv+PMd'] - rates['All'])
  132. session_deltas['M1+PMd-All'].append(rates['M1+PMd'] - rates['All'])
  133. session_deltas['M1+PMv-All'].append(rates['M1+PMv'] - rates['All'])
  135. # Summary stats (median ± IQR)
  136. norm_stats = {
  137. region: (np.median(vals), np.percentile(vals, 25), np.percentile(vals, 75))
  138. for region, vals in norm_results.items()
  139. }
  141. # Wilcoxon tests
  142. def pval(delta_key):
  143. return wilcoxon(session_deltas[delta_key], alternative='two-sided', method='approx').pvalue
  145. pvals = {
  146. 'PMv_vs_M1': pval('PMv-M1'),
  147. 'PMd_vs_M1': pval('PMd-M1'),
  148. 'PMd_vs_PMv': pval('PMv-PMd'),
  149. 'PMv+PMd_vs_M1+PMd': pval('PMv+PMd-M1+PMd'),
  150. 'PMv+PMd_vs_M1+PMv': pval('PMv+PMd-M1+PMv'),
  151. 'M1+PMd_vs_M1+PMv': pval('M1+PMd-M1+PMv'),
  152. 'PMv+PMd_vs_Online': pval('PMv+PMd-Online'),
  153. 'M1+PMd_vs_Online': pval('M1+PMd-Online'),
  154. 'M1+PMv_vs_Online': pval('M1+PMv-Online'),
  155. 'All_vs_Online': pval('All-Online'),
  156. 'PMv_vs_Online': pval('PMv-Online'),
  157. 'PMd_vs_Online': pval('PMd-Online'),
  158. 'M1_vs_Online': pval('M1-Online'),
  159. 'PMv+PMd_vs_All': pval('PMv+PMd-All'),
  160. 'M1+PMd_vs_All': pval('M1+PMd-All'),
  161. 'M1+PMv_vs_All': pval('M1+PMv-All')
  162. }
  164. plot_success_rates_offline_decoding(norm_results, pvals, monkey, experiment)
  166. return {
  167. "normalized_stats": norm_stats,
  168. "session_deltas": session_deltas,
  169. "p_values": pvals,
  170. "raw_success_rates": raw_results
  171. }
  173. def compute_significance_time_to_target(df_trials: pd.DataFrame, experiment_name: str) -> dict:
  174. """
  175. Perform Mann-Whitney U test to compare time-to-target across different conditions
  176. based on the specified experiment name.
  178. Args:
  179. df_trials (pd.DataFrame): DataFrame containing trial-level data with columns for condition, correctness,
  180. timeToTarget, and session identifiers.
  181. experiment_name (str): Name of the experiment. Must be one of: '3D Center-out', 'Respawn', or 'Obstacle'.
  183. Returns:
  184. dict: Dictionary containing test results, including z-score, U statistic, p-value, number of trials,
  185. and group-wise mean time-to-target.
  186. """
  187. df_trials = df_trials[df_trials['correct'] == True]
  189. if experiment_name == "3D Center-out":
  190. group1 = df_trials[df_trials['targetLevel'] == 'upper']['timeToTarget']
  191. group2 = df_trials[df_trials['targetLevel'] == 'lower']['timeToTarget']
  192. group_key = 'targetLevel'
  193. elif experiment_name == "Respawn":
  194. group1 = df_trials[df_trials['respawn'] == True]['timeToTarget']
  195. group2 = df_trials[df_trials['respawn'] == False]['timeToTarget']
  196. group_key = 'respawn'
  197. elif experiment_name == "Obstacle":
  198. group1 = df_trials[df_trials['obstacle'] == 'offPath']['timeToTarget']
  199. group2 = df_trials[df_trials['obstacle'] == 'onPath']['timeToTarget']
  200. group_key = 'obstacle'
  201. else:
  202. raise ValueError("Unsupported experiment name. Must be one of: '3D Center-out', 'Respawn', 'Obstacle'.")
  204. # Mann-Whitney U test
  205. result_mwu = mannwhitneyu(group1, group2, alternative='two-sided')
  206. n1, n2 = len(group1), len(group2)
  207. mu_U = n1 * n2 / 2
  208. sigma_U = np.sqrt(n1 * n2 * (n1 + n2 + 1) / 12)
  209. z_score = (result_mwu.statistic - mu_U) / sigma_U
  211. group_means = df_trials.groupby(group_key)['timeToTarget'].mean().to_dict()
  213. results = {
  214. "z_score": z_score,
  215. "U_statistic": result_mwu.statistic,
  216. "p_value": result_mwu.pvalue,
  217. "N_trials": n1 + n2,
  218. "group_means": group_means,
  219. }
  220. print(results)
  221. return results
  223. def compute_chance_level(trials, experiment, num_permutations=1000):
  224. """
  225. Estimate chance level by shuffling targets and checking success.
  226. Supports both 2D and 3D experiments.
  227. """
  228. def is_within_target_window_2D(states, target, window_size, min_consecutive=10):
  229. half_window = window_size / 2.0
  230. count = 0
  231. for x, z in states:
  232. if (target[0] - half_window <= x <= target[0] + half_window and
  233. target[1] - half_window <= z <= target[1] + half_window):
  234. count += 1
  235. if count >= min_consecutive:
  236. return True
  237. else:
  238. count = 0
  239. return False
  241. def is_within_target_window_3D(states, target, window_size=4.2, min_consecutive=10):
  242. half_window = window_size / 2.0
  243. half_height = 0.75 + 0.45
  244. count = 0
  245. for x, y, z in states:
  246. if (target[0] - half_window <= x <= target[0] + half_window and
  247. target[1] - half_height <= y <= target[1] + half_height and
  248. target[2] - half_window <= z <= target[2] + half_window):
  249. count += 1
  250. if count >= min_consecutive:
  251. return True
  252. else:
  253. count = 0
  254. return False
  256. def calculate_success(states, targs, is_3d, is_continuous_navigation):
  257. results = []
  258. for s, t in zip(states, targs):
  259. if is_3d:
  260. s = np.array(s) + np.array([0, 0.25, 0])
  261. results.append(is_within_target_window_3D(s, t))
  262. else:
  263. s = np.array(s)[:, [0, 2]] # x, z
  264. t_2d = [t[0], t[2]]
  265. if is_continuous_navigation:
  266. results.append(is_within_target_window_2D(s, t_2d, window_size=5.6))
  267. else:
  268. results.append(is_within_target_window_2D(s, t_2d, window_size=4.2))
  269. return np.mean(results)
  271. is_3d = "3D" in experiment
  272. is_continuous_navigation = "Continuous Navigation" in experiment
  273. conc_trials = [item for sublist in trials for item in sublist]
  274. states_data = [list(zip(trial.avatarTrajectory['x'],
  275. trial.avatarTrajectory['y'],
  276. trial.avatarTrajectory['z'])) for trial in conc_trials]
  277. targets = [trial.targetPosition for trial in conc_trials]
  278. observed = calculate_success(states_data, targets, is_3d, is_continuous_navigation)
  279. null_distribution = [
  280. calculate_success(states_data, np.random.permutation(targets), is_3d, is_continuous_navigation)
  281. for _ in range(num_permutations)
  282. ]
  283. return np.mean(null_distribution), observed, null_distribution
  285. def compute_session_accuracy(correct_trials, incorrect_trials, monkey, task=None):
  286. """
  287. Computes session-level success rates or parameter-split accuracy based on the task.
  289. Args:
  290. correct_trials (list of list): Correct trials per session
  291. incorrect_trials (list of list): Incorrect trials per session
  292. monkey (str): Monkey name (unused here but kept for compatibility)
  293. task (str): Optional task string. If includes 'Obstacle', 'Respawn', or '3D Center-out',
  294. computes split accuracy based on relevant parameter.
  296. Returns:
  297. If matched task: (accuracy_group1, accuracy_group2)
  298. Else: full-session accuracy list
  299. """
  300. def compute_parameter_accuracy(correct_trials, incorrect_trials, parameter):
  301. def compute_accuracy(correct, incorrect):
  302. return [len(c) / (len(c) + len(i)) * 100 if len(c) + len(i) > 0 else np.nan
  303. for c, i in zip(correct, incorrect)]
  305. def split_respawn_trials(trials):
  306. respawn = [t for t in trials if not np.all(np.isnan(t.targetJumpPosition))]
  307. norespawn = [t for t in trials if np.all(np.isnan(t.targetJumpPosition))]
  308. return respawn, norespawn
  310. def split_obstacle_trials(trials):
  311. target_positions = [(-7.0, 0.75, 6.0), (-3.5, 0.75, 8.5), (0.0, 0.75, 9.2), (3.5, 0.75, 8.5), (7.0, 0.75, 6.0)]
  312. obstacle_positions = [(-3.5, 0, 3), (-1.75, 0, 4.25), (0, 0, 4.6), (3.5, 0, 3), (1.75, 0, 4.25)]
  314. def obstacle_status(target, obstacle):
  315. t_idx = next((i for i, pos in enumerate(target_positions) if np.array_equal(pos, target)), -1)
  316. o_idx = next((i for i, pos in enumerate(obstacle_positions) if np.array_equal(pos, obstacle)), -1)
  317. return "onPath" if t_idx == o_idx and t_idx != -1 else "offPath"
  319. on_path = [t for t in trials if obstacle_status(t.targetPosition, t.obstaclePosition) == "onPath"]
  320. off_path = [t for t in trials if obstacle_status(t.targetPosition, t.obstaclePosition) == "offPath"]
  321. return on_path, off_path
  323. def split_3D_trials(trials):
  324. upper = [t for t in trials if t.targetPosition[1] == 2.35]
  325. lower = [t for t in trials if t.targetPosition[1] == 0.75]
  326. return upper, lower
  328. # Select splitter and condition names
  329. if task == "Respawn":
  330. splitter = split_respawn_trials
  331. name1, name2 = "Respawn", "No Respawn"
  332. elif task == "Obstacle":
  333. splitter = split_obstacle_trials
  334. name1, name2 = "Obstacle on Path", "Obstacle off Path"
  335. elif task == "3D Center-out":
  336. splitter = split_3D_trials
  337. name1, name2 = "Upper targets", "Lower targets"
  338. else:
  339. full_accuracy = compute_accuracy(correct_trials, incorrect_trials)
  340. return {"All": full_accuracy}
  342. # Apply splitter per session
  343. all_c1, all_c2, all_i1, all_i2 = [], [], [], []
  344. for correct, incorrect in zip(correct_trials, incorrect_trials):
  345. c1, c2 = splitter(correct)
  346. i1, i2 = splitter(incorrect)
  347. all_c1.append(c1)
  348. all_c2.append(c2)
  349. all_i1.append(i1)
  350. all_i2.append(i2)
  352. acc1 = compute_accuracy(all_c1, all_i1)
  353. acc2 = compute_accuracy(all_c2, all_i2)
  355. return {
  356. name1: acc1,
  357. name2: acc2
  358. }
  360. # Check task type
  361. if task in ["Obstacle", "Respawn", "3D Center-out"]:
  362. return compute_parameter_accuracy(correct_trials, incorrect_trials, task)
  363. else:
  364. return [len(c) / (len(c) + len(i)) * 100 if len(c) + len(i) > 0 else np.nan
  365. for c, i in zip(correct_trials, incorrect_trials)]
  367. def compute_target_accuracy(correct_trials, incorrect_trials, monkey, experiment_name):
  368. """
  369. Computes success rate per target and returns a flat list of dicts with Task, Target, Category, SuccessRate.
  371. Args:
  372. correct_trials (list of list): Correct trials per session.
  373. incorrect_trials (list of list): Incorrect trials per session.
  374. monkey (str): Monkey name.
  375. experiment_name (str): Task name.
  377. Returns:
  378. list of dict: [{'Task': ..., 'Target': ..., 'Category': ..., 'SuccessRate': ...}, ...]
  379. """
  380. def target_category(target):
  381. x, _, z = target
  382. key = (round(x, 1), round(z, 1))
  383. if key in {(-7.0, 6.0), (0.0, 9.2), (7.0, 6.0), (-6.0, 7.0), (6.0, 7.0)}:
  384. return "Pretrained"
  385. elif key in {(-3.5, 8.5), (3.5, 8.5), (-3.0, 8.7), (3.0, 8.7)}:
  386. return "New"
  387. else:
  388. return "Other"
  390. target_answers = defaultdict(list)
  391. for correct, incorrect in zip(correct_trials, incorrect_trials):
  392. for trial in correct:
  393. target = tuple(trial.targetPosition)
  394. target_answers[target].append(1)
  395. for trial in incorrect:
  396. target = tuple(trial.targetPosition)
  397. target_answers[target].append(0)
  399. summary = []
  400. for target, answers in target_answers.items():
  401. if answers:
  402. rate = sum(answers) / len(answers)
  403. summary.append({
  404. "Task": experiment_name,
  405. "Target": target,
  406. "Category": target_category(target),
  407. "SuccessRate": rate * 100
  408. })
  410. return summary
  412. def post_hoc_testing(all_trials, experiment, monkey):
  413. df_trials = make_df_structure(all_trials, experiment, monkey)
  414. if experiment == "3D Center-out":
  415. # Define the upper and lower target groups
  416. df_trials['targetLevel'] = df_trials['targetPosition'].apply(lambda x: 'upper' if x[1] > 1 else 'lower')
  417. # Compute time-to-target
  418. print(f"Significant difference in time-to-target({experiment} & {monkey}):")
  419. compute_significance_time_to_target(df_trials, experiment)
  420. elif experiment == "Respawn":
  421. print(f"Significant difference in time-to-target({experiment} & {monkey}):")
  422. compute_significance_time_to_target(df_trials, experiment)
  423. elif experiment == "Obstacle":
  424. print(f"Significant difference in time-to-target({experiment} & {monkey}):")
  425. compute_significance_time_to_target(df_trials, experiment)
  426. return None
  428. def significant_difference_distribution_endpoints(monkey, lower_trials, upper_trials):
  429. endpoints_upper_trials = np.array([trial.avatarTrajectory['y'][-10] for trial in upper_trials])
  430. endpoints_lower_trials = np.array([trial.avatarTrajectory['y'][-10] for trial in lower_trials])
  431. # Mann-Whitney U test
  432. u_stat, p_value_mannwhitney = mannwhitneyu(endpoints_upper_trials, endpoints_lower_trials)
  433. print(f"Mann-Whitney U test: U-statistic = {u_stat}, p-value = {p_value_mannwhitney}")
  434. # Plot density plots
  435. plot_3D_endpoints_density_plots(monkey, endpoints_upper_trials, endpoints_lower_trials)
  437. def summarize_emg_eyemovement_results(monkey, experiments, analysis, base_dir, coordinate = None):
  438. correlation_results = []
  439. linear_results = []
  440. nonlinear_results = []
  442. for experiment in experiments:
  443. data, velocityData, _ = load_emg_eyemovement_files(experiment, monkey, analysis, base_dir, coordinate)
  444. if len(data) == 0:
  445. continue
  446. if analysis == "eyemovement":
  447. eyemovementData = [[segment['eyeMovement'] for segment in trial] for trial in data]
  448. corr_df, reg_df = analyze_eyemovement(eyemovementData, velocityData, experiment)
  449. else:
  450. corr_df, reg_df = analyze_emg(data, velocityData, experiment)
  452. for velocity in corr_df['Velocity Component'].unique():
  453. corr_data = corr_df[(corr_df['Experiment'] == experiment) & (corr_df['Velocity Component'] == velocity)]
  454. regression_data = reg_df[(reg_df['Experiment'] == experiment) & (reg_df['Velocity Component'] == velocity)]
  456. correlation_results.append({
  457. 'Task': experiment,
  458. 'Velocity': velocity,
  459. 'Mean ± STD Spearman Correlation': f"{corr_data['Spearman Correlation'].mean():.7f} ± {corr_data['Spearman Correlation'].std():.7f}",
  460. 'Combined p (Correlation)': combined_p_value(corr_data['p-value'].tolist())
  461. })
  463. linear_results.append({
  464. 'Task': experiment,
  465. 'Velocity': velocity,
  466. 'Linear R²': f"{regression_data['Linear R²'].median():.7f} [{compute_iqr(regression_data['Linear R²']):.7f}]",
  467. 'Linear MSE': f"{regression_data['Linear MSE'].median():.7f} [{compute_iqr(regression_data['Linear MSE']):.7f}]",
  468. 'Combined p (Linear)': combined_p_value(regression_data['Linear p-value'].tolist())
  469. })
  471. nonlinear_results.append({
  472. 'Task': experiment,
  473. 'Velocity': velocity,
  474. 'Non-Linear R²': f"{regression_data['Polynomial R²'].median():.7f} [{compute_iqr(regression_data['Polynomial R²']):.7f}]",
  475. 'Non-Linear MSE': f"{regression_data['Polynomial MSE'].median():.7f} [{compute_iqr(regression_data['Polynomial MSE']):.7f}]",
  476. 'Combined p (Non-Linear)': combined_p_value(regression_data['Polynomial p-value'].tolist())
  477. })
  479. # Merge summaries
  480. df_corr = pd.DataFrame(correlation_results)
  481. df_lin = pd.DataFrame(linear_results)
  482. df_nonlin = pd.DataFrame(nonlinear_results)
  483. final_table = df_corr.merge(df_lin, on=['Task', 'Velocity']).merge(df_nonlin, on=['Task', 'Velocity'])
  485. return final_table
  487. def analyze_eyemovement(eyemovementData, velocityData, experiment_name):
  488. correlation_list = []
  489. linear_regression_list = []
  490. poly_regression_list = []
  491. # Process EMG and velocity data across all trials
  492. all_sessions_emg, all_sessions_velocity = process_eyemovement_data(eyemovementData, velocityData, sampling_rate = 20)
  493. for session_emg, session_velocity in zip(all_sessions_emg, all_sessions_velocity):
  494. # Perform the analyses
  495. spearman_results = spearman_correlation(session_emg, session_velocity, experiment_name)
  496. linear_results = linear_regression(session_emg, session_velocity, experiment_name)
  497. poly_results = polynomial_regression(session_emg, session_velocity, experiment_name=experiment_name)
  499. # Append the results from each session to the final lists
  500. correlation_list.extend(spearman_results)
  501. linear_regression_list.extend(linear_results)
  502. poly_regression_list.extend(poly_results)
  504. # Return DataFrames for the tables and mutual information results
  505. correlation_df = pd.DataFrame(correlation_list)
  506. regression_df = pd.DataFrame({
  507. 'Experiment': [res['Experiment'] for res in linear_regression_list],
  508. 'Velocity Component': [res['Velocity Component'] for res in linear_regression_list],
  509. 'Linear R²': [res['R² Score'] for res in linear_regression_list],
  510. 'Linear MSE': [res['MSE'] for res in linear_regression_list],
  511. 'Cross-validated Linear MSE': [res['Cross-Validated MSE'] for res in linear_regression_list],
  512. 'Linear p-value': [res['p-value'] for res in linear_regression_list],
  513. 'Polynomial R²': [res['R² Score (Polynomial)'] for res in poly_regression_list],
  514. 'Polynomial MSE': [res['MSE (Polynomial)'] for res in poly_regression_list],
  515. 'Polynomial p-value': [res['p-value (Polynomial)'] for res in poly_regression_list],
  516. 'Degree': [res['Degree'] for res in poly_regression_list]
  517. })
  519. return correlation_df, regression_df
  521. def analyze_emg(emgData, velocityData, experiment_name):
  522. correlation_list = []
  523. linear_regression_list = []
  524. poly_regression_list = []
  525. # Process EMG and velocity data across all trials
  526. all_sessions_emg, all_sessions_velocity = process_emg_data(emgData, velocityData, sampling_rate = 20)
  527. for session_emg, session_velocity in zip(all_sessions_emg, all_sessions_velocity):
  528. # Perform the analyses
  529. spearman_results = spearman_correlation(session_emg, session_velocity, experiment_name)
  530. linear_results = linear_regression(session_emg, session_velocity, experiment_name)
  531. poly_results = polynomial_regression(session_emg, session_velocity, experiment_name=experiment_name)
  533. # Append the results from each session to the final lists
  534. correlation_list.extend(spearman_results)
  535. linear_regression_list.extend(linear_results)
  536. poly_regression_list.extend(poly_results)
  538. # Return DataFrames for the tables and mutual information results
  539. correlation_df = pd.DataFrame(correlation_list)
  540. regression_df = pd.DataFrame({
  541. 'Experiment': [res['Experiment'] for res in linear_regression_list],
  542. 'Velocity Component': [res['Velocity Component'] for res in linear_regression_list],
  543. 'Linear R²': [res['R² Score'] for res in linear_regression_list],
  544. 'Linear MSE': [res['MSE'] for res in linear_regression_list],
  545. 'Cross-validated Linear MSE': [res['Cross-Validated MSE'] for res in linear_regression_list],
  546. 'Linear p-value': [res['p-value'] for res in linear_regression_list],
  547. 'Polynomial R²': [res['R² Score (Polynomial)'] for res in poly_regression_list],
  548. 'Polynomial MSE': [res['MSE (Polynomial)'] for res in poly_regression_list],
  549. 'Polynomial p-value': [res['p-value (Polynomial)'] for res in poly_regression_list],
  550. 'Degree': [res['Degree'] for res in poly_regression_list]
  551. })
  553. return correlation_df, regression_df
  555. def analyze_within_session_trends(monkeys, experiments, base_dir):
  556. """
  557. Analyze within-session performance trends (adaptation) using all trials.
  558. Returns a DataFrame with slope, p-value, R², number of trials, and trend classification for each session.
  559. """
  560. limited_monkeys_tasks = {"3D Center-out", "Respawn", "Obstacle"}
  561. all_data = []
  563. def is_success(answer):
  564. if answer == 1:
  565. return 1
  566. elif answer in [3, 5, 6]:
  567. return 0
  568. else:
  569. return None
  571. def classify_trend(slope, p_value):
  572. if p_value < 0.05:
  573. if slope > 0:
  574. return "Improvement"
  575. elif slope < 0:
  576. return "Decline"
  577. return "Constant"
  579. for experiment in experiments:
  580. session_data = []
  581. if experiment in limited_monkeys_tasks:
  582. task_monkeys = [m for m in monkeys if m != "Monkey 1"]
  583. else:
  584. task_monkeys = monkeys
  586. for monkey in task_monkeys:
  587. all_trials, correct, incorrect, all_training_trials, all_channels, *_ = load_files(experiment, monkey, base_dir)
  589. for session_idx, session in enumerate(all_trials):
  590. answers = [trial.answer for trial in session]
  591. binary_success = np.array([is_success(a) for a in answers if is_success(a) is not None])
  593. if len(binary_success) < 7:
  594. continue # skip short sessions
  596. # Moving average smoothing
  597. window_size = 7
  598. moving_avg = np.convolve(binary_success, np.ones(window_size)/window_size, mode='valid')
  599. x_vals = np.arange(len(moving_avg))
  601. # Linear regression
  602. slope, intercept, r_value, p_value, std_err = linregress(x_vals, moving_avg)
  604. trend = classify_trend(slope, p_value)
  606. session_data.append({
  607. "Monkey": monkey,
  608. "Task": experiment,
  609. "Session": session_idx + 1,
  610. "Trials": len(binary_success),
  611. "Slope": slope,
  612. "p_value": p_value,
  613. "R_squared": r_value**2,
  614. "Trend": trend
  615. })
  617. df_sessions = pd.DataFrame(session_data)
  618. all_data.append(df_sessions)
  620. df_all_sessions = pd.concat(all_data, ignore_index=True)
  621. return df_all_sessions
  623. def compute_parameter_accuracy(correct_trials: List[List], incorrect_trials: List[List], parameter: str) -> Tuple[List[float], List[float]]:
  624. """
  625. Computes per-session success rate split by task-specific parameters (e.g., Respawn vs No Respawn,
  626. Obstacle On-path vs Off-path, 3D Upper vs Lower targets).
  628. Args:
  629. correct_trials (List[List]): List of sessions containing correct trials.
  630. incorrect_trials (List[List]): List of sessions containing incorrect trials.
  631. parameter (str): Task type ('Respawn', 'Obstacle', or '3D').
  633. Returns:
  634. Tuple[List[float], List[float]]: Success rates for parameter 1 group and parameter 2 group.
  635. """
  637. def split_respawn(trials):
  638. respawn = [t for t in trials if not np.all(np.isnan(t.targetJumpPosition))]
  639. no_respawn = [t for t in trials if np.all(np.isnan(t.targetJumpPosition))]
  640. return respawn, no_respawn
  642. def split_obstacle(trials):
  643. def is_on_path(target, obstacle):
  644. target_positions = [(-7.0, 0.75, 6.0), (-3.5, 0.75, 8.5), (0.0, 0.75, 9.2), (3.5, 0.75, 8.5), (7.0, 0.75, 6.0)]
  645. obstacle_positions = [(-3.5, 0, 3), (-1.75, 0, 4.25), (0, 0, 4.6), (3.5, 0, 3), (1.75, 0, 4.25)]
  646. ti = next((i for i, p in enumerate(target_positions) if np.allclose(p, target)), -1)
  647. oi = next((i for i, p in enumerate(obstacle_positions) if np.allclose(p, obstacle)), -1)
  648. return ti == oi and ti != -1
  650. on_path = [t for t in trials if is_on_path(t.targetPosition, t.obstaclePosition)]
  651. off_path = [t for t in trials if not is_on_path(t.targetPosition, t.obstaclePosition)]
  652. return on_path, off_path
  654. def split_3D(trials):
  655. upper = [t for t in trials if t.targetPosition[1] == 2.35]
  656. lower = [t for t in trials if t.targetPosition[1] == 0.75]
  657. return upper, lower
  659. def compute_session_rates(group1, group2):
  660. rates1 = [len(g1) / (len(g1) + len(g2)) * 100 if (len(g1) + len(g2)) > 0 else 0
  661. for g1, g2 in zip(group1, group2)]
  662. return rates1
  664. group1_correct = []
  665. group2_correct = []
  666. group1_incorrect = []
  667. group2_incorrect = []
  669. if parameter == "Respawn":
  670. for c, i in zip(correct_trials, incorrect_trials):
  671. c1, c2 = split_respawn(c)
  672. i1, i2 = split_respawn(i)
  673. group1_correct.append(c1)
  674. group2_correct.append(c2)
  675. group1_incorrect.append(i1)
  676. group2_incorrect.append(i2)
  677. elif parameter == "Obstacle":
  678. for c, i in zip(correct_trials, incorrect_trials):
  679. c1, c2 = split_obstacle(c)
  680. i1, i2 = split_obstacle(i)
  681. group1_correct.append(c1)
  682. group2_correct.append(c2)
  683. group1_incorrect.append(i1)
  684. group2_incorrect.append(i2)
  685. elif parameter == "3D":
  686. for c, i in zip(correct_trials, incorrect_trials):
  687. c1, c2 = split_3D(c)
  688. i1, i2 = split_3D(i)
  689. group1_correct.append(c1)
  690. group2_correct.append(c2)
  691. group1_incorrect.append(i1)
  692. group2_incorrect.append(i2)
  693. else:
  694. raise ValueError("Unsupported parameter type. Use 'Respawn', 'Obstacle', or '3D'.")
  696. acc1 = compute_session_rates(group1_correct, group1_incorrect)
  697. acc2 = compute_session_rates(group2_correct, group2_incorrect)
  698. return acc1, acc2

analysis.py at commit 6a198ce, under MIT · at the source

Overview

Authors: Ophelie Saussus1, Sofie De Schrijver1,2, Jesus Garcia Ramirez3, Thomas Decramer3, Peter Janssen1
ORCID iDs: Ophelie Saussus, Sofie De Schrijver, Thomas Decramer, Peter Janssen
  1. Laboratory for Neuro- and Psychophysiology, Department of Neurosciences, KU Leuven and the Leuven Brain Institute, Leuven, Belgium
  2. Department of Electrical and Computer Engineering, University of Washington, Seattle, WA, USA
  3. Research Group Experimental Neurosurgery and Neuroanatomy, KU Leuven and the Leuven Brain Institute, Leuven, Belgium
Journal: Science advances, volume 12, issue 16, article eadw3876
Dates: received 30 January 2025; accepted 12 March 2026; published online 15 April 2026; in print April 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1126/sciadv.adw3876 · PMID 41984955 · PMCID PMC13082338 · OpenAlex W4410258541
Open access: gold, a free copy (OpenAlex)
Preprint: doi:10.1101/2025.05.05.652199
Status: code verified
Categories: non-human primate (organism), systems (subfield)
Methods: Spectral & time-frequency, Preprocessing, Statistics, Machine learning, Connectivity, Smoothing, state filtering, decompositions, Physiology & signal measures
MeSH: Brain*, Brain-Computer Interfaces*, Motor Cortex*, Virtual Reality*, Animals, Macaca (* major topic)
Topic: EEG and Brain-Computer Interfaces (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: KU Leuven (C14/18/100, C14/22/134); Fonds Wetenschappelijk Onderzoek (G.097422N)
Citations: cited by 2 papers (Europe PMC); 43 references in the paper

Abstract

We present an innovative intracortical brain-computer interface (BCI) to bridge the gap between laboratory settings and real-world applications. This BCI approach introduces three key advancements. First, we used neural signals from three macaque brain regions—primary motor, dorsal, and ventral premotor cortex—enabling precise and flexible decoding of real-time three-dimensional (3D) sphere/avatar velocities. Second, we developed a realistic, immersive 3D virtual reality setup with dynamic camera tracking, allowing continuous navigation and obstacle avoidance that closely mimic real-world scenarios. Last, our BCI approach is very well suited for use by paralyzed patients, featuring a brief passive fixation without overt movements and closed-loop operation without retraining of the decoder during online decoding, relying on the user’s neural plasticity and the decoder’s robust generalization across tasks. Our BCI adapted to different environments, targets, and obstacles, illustrating its potential to substantially enhance the quality of life for paralyzed patients by enabling natural, reliable, and flexible control in complex settings.

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

Zenodo 15791186

License: MIT
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Data, code, and materials availability:”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: pandas (9 files), NumPy (8 files), Matplotlib (4 files), SciPy (4 files), statsmodels (3 files), seaborn (2 files), scikit-learn (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers (HTTP 200)
  • 29 September 2026: the link answers (HTTP 200)
15 files
At the source: doi.org/10.5281/zenodo.15791186

ophelie-bci/ibci_analysis

License: MIT
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: 6a198cec614d11e54fc7bc34a47c7270c3713da0, 2 March 2026
Languages: Python (13)
Size: 65 files, 13 scripts
Software Heritage: not archived
Found in: the Zenodo archive record
Holds: README, license file, CITATION.cff, environment (requirements.txt)
Not found: tests, continuous integration, documentation
Tools: pandas (9 files), NumPy (8 files), Matplotlib (4 files), SciPy (4 files), statsmodels (3 files), seaborn (2 files), scikit-learn (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
15 files
At the source: github.com/ophelie-bci/iBCI_analysis/tree/v1.0

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

Tracing map

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

What the map holds:

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

All data and code needed to evaluate and reproduce the results in the paper are present in the paper and/or the Supplementary Materials. All processed data supporting the findings of this study are available on the Dryad Digital Repository: https://doi.org/10.5061/dryad.2bvq83c34. Analysis scripts used to reproduce the figures and statistical analyses are publicly available on Zenodo: https://doi.org/10.5281/zenodo.15791186. Additional details about the virtual environment and neural decoding framework used during the experiments are provided in Materials and Methods.

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, language, journal, volume, issue, pages, dates, 5 authors, 6 MeSH terms, 2 funders, 41 references.

Cite

This paper

Saussus, O., De Schrijver, S., Ramirez, J. G., Decramer, T., & Janssen, P. (2026). Intracortical brain-computer interface for navigation in virtual reality in macaque monkeys. Science advances, 12(16), eadw3876. https://doi.org/10.1126/sciadv.adw3876

BibTeX

@article{saussus2026intracortical,
author = {Saussus, Ophelie and De Schrijver, Sofie and Ramirez, Jesus Garcia and Decramer, Thomas and Janssen, Peter},
title = {{Intracortical brain-computer interface for navigation in virtual reality in macaque monkeys}},
journal = {Science advances},
year = {2026},
month = apr,
volume = {12},
number = {16},
pages = {eadw3876},
publisher = {American Association for the Advancement of Science},
issn = {2375-2548},
doi = {10.1126/sciadv.adw3876},
url = {https://doi.org/10.1126/sciadv.adw3876},
pmid = {41984955},
pmcid = {PMC13082338}
}

RIS

TY - JOUR
AU - Saussus, Ophelie
AU - De Schrijver, Sofie
AU - Ramirez, Jesus Garcia
AU - Decramer, Thomas
AU - Janssen, Peter
TI - Intracortical brain-computer interface for navigation in virtual reality in macaque monkeys
T2 - Science advances
J2 - Sci Adv
PY - 2026
DA - 2026/04/15
VL - 12
IS - 16
SP - eadw3876
SN - 2375-2548
PB - American Association for the Advancement of Science
DO - 10.1126/sciadv.adw3876
UR - https://doi.org/10.1126/sciadv.adw3876
LA - en
ER -

CSL-JSON

{
"id": "10.1126/sciadv.adw3876",
"type": "article-journal",
"title": "Intracortical brain-computer interface for navigation in virtual reality in macaque monkeys",
"container-title": "Science advances",
"author": [
{
"family": "Saussus",
"given": "Ophelie"
},
{
"family": "De Schrijver",
"given": "Sofie"
},
{
"family": "Ramirez",
"given": "Jesus Garcia"
},
{
"family": "Decramer",
"given": "Thomas"
},
{
"family": "Janssen",
"given": "Peter"
}
],
"container-title-short": "Sci Adv",
"volume": "12",
"issue": "16",
"page": "eadw3876",
"DOI": "10.1126/sciadv.adw3876",
"PMID": "41984955",
"PMCID": "PMC13082338",
"ISSN": "2375-2548",
"publisher": "American Association for the Advancement of Science",
"URL": "https://doi.org/10.1126/sciadv.adw3876",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
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/s41467-026-76109-y [code]
Assistive algorithms influence neural representations in motor brain-computer interfaces.
Journal: Nature communications
In common: seaborn, scikit-learn, pandas, 3 other tools, non-human primate, systems, 8 references
[2] doi:10.1038/s41591-026-04414-6 [code]
Long-term independent use of an intracortical brain-computer interface for speech and cursor control.
Journal: Nature medicine
In common: pandas, SciPy, Matplotlib, 1 other tool, 7 references
[3] doi:10.1126/sciadv.aed9309 [code]
Dynamic population coding of kinematic structure across executed and observed actions in primate premotor cortex.
Journal: Science advances
In common: non-human primate, systems, 5 references
[4] doi:10.1038/s41467-026-75455-1 [code]
Shared latent representations of speech production for cross-patient speech decoding.
Journal: Nature communications
In common: statsmodels, seaborn, scikit-learn, 4 other tools, 2 references
[5] doi:10.1016/j.celrep.2026.117420 [code]
Neural population dynamics of direct electrical stimulation of neocortex.
Journal: Cell reports
In common: statsmodels, seaborn, scikit-learn, 4 other tools, systems, 1 reference
[6] doi:10.1038/s41586-026-10691-5 [code]
Mapping the neuronal building blocks of human language with language models.
Journal: Nature
In common: statsmodels, scikit-learn, pandas, 3 other tools, 2 references
[7] doi:10.1007/s12021-026-09807-z [code]
Optimal Size of Electrocorticography Grids for Classification of Hand Movements.
Journal: Neuroinformatics
In common: seaborn, scikit-learn, pandas, 3 other tools, 2 references
[8] doi:10.1126/sciadv.aef0343 [code]
Learning induces activation-mechanism-dependent neural plasticity in an intracortical microstimulation task.
Journal: Science advances
In common: statsmodels, seaborn, scikit-learn, 4 other tools, 1 reference
[9] doi:10.1038/s41467-026-76104-3 [code]
Sensorimotor remapping drives task specialization in prefrontal cortex.
Journal: Nature communications
In common: statsmodels, seaborn, scikit-learn, 4 other tools, non-human primate, systems
[10] doi:10.1038/s41467-026-74347-8 [code]
Compositionality of social gaze in the prefrontal-amygdala circuits.
Journal: Nature communications
In common: statsmodels, seaborn, scikit-learn, 4 other tools, non-human primate, systems

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.