OSCR

Sensory-guided human-machine joint learning accelerates the acquisition of motor imagery brain computer interface control.

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 of them tie a paragraph to a whole file, not to given lines: a weak match, whose lines are not tinted
  1. [1] § Methods › Joint learning framework and sample reweighting algorithm ↔ onlineFeedback.py, the whole file · a weak match · score 0.63 · 4–40 Hz, bandpass filtered, downsampled, online, window, EEG
  2. [2] § Methods › Joint learning framework and sample reweighting algorithm ↔ updateModel.py, lines 701–735 · score 0.55 · linear discriminant, LDA, CSP, score, probability, filters
  3. [3] § Methods › Joint learning framework and sample reweighting algorithm ↔ updateModel.py, lines 995–1089 · score 0.50 · bandpass filtered, 4–40 Hz, window, training

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 · 1,138 lines · 35 KB · MIT · 2 matches

  1. """
  2. Update Weighted EEGNet from public-release MATLAB runData files.
  4. Expected MATLAB structure:
  5. runData.trialSignal : samples x channels x trials
  6. runData.trialTargetClass : samples x trials, or one label per trial
  8. This script replaces the old updateWeightedEEGNet.py workflow that loaded .dat files directly.
  9. It does not use BCI2kReader and does not read raw .dat files.
  11. The user edits the parameters in the __main__ section and runs this script directly.
  12. """
  14. import re
  15. from pathlib import Path
  16. from typing import Any, Dict, List, Optional, Tuple
  18. import numpy as np
  19. import scipy.io as sio
  20. import scipy.signal as signal
  21. import torch
  22. from scipy.stats import rankdata
  23. from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
  24. from sklearn.metrics import accuracy_score
  25. from torch import nn
  26. from torch.utils.data import Dataset, DataLoader
  27. from torch.utils.data.dataloader import default_collate
  29. from resources.CSP import CSP
  30. from resources.eegnet import EEGNetv4
  33. # -------------------------
  34. # Dataset wrappers
  35. # -------------------------
  37. class CustomDataset(Dataset):
  38. def __init__(self, data: np.ndarray, labels: np.ndarray):
  39. self.data = data
  40. self.labels = labels
  42. def __len__(self) -> int:
  43. return len(self.data)
  45. def __getitem__(self, index: int):
  46. return self.data[index], self.labels[index]
  49. class WeightedDataset(Dataset):
  50. def __init__(self, data: np.ndarray, labels: np.ndarray, sample_weights: np.ndarray):
  51. self.data = data
  52. self.labels = labels
  53. self.sample_weights = sample_weights
  55. def __len__(self) -> int:
  56. return len(self.data)
  58. def __getitem__(self, index: int):
  59. return self.data[index], self.labels[index], self.sample_weights[index]
  62. # -------------------------
  63. # MATLAB loading utilities
  64. # -------------------------
  66. def _mat_struct_to_dict(obj: Any) -> Any:
  67. """
  68. Recursively convert scipy.io MATLAB mat_struct objects to Python dictionaries.
  70. Important:
  71. This function preserves numpy structured arrays because hdf5storage can load
  72. MATLAB structs as numpy arrays with dtype.names.
  73. """
  74. if isinstance(obj, np.ndarray) and obj.dtype.names is not None:
  75. return obj
  77. if isinstance(obj, np.void) and obj.dtype.names is not None:
  78. return obj
  80. if hasattr(obj, "_fieldnames"):
  81. out = {}
  82. for name in obj._fieldnames:
  83. out[name] = _mat_struct_to_dict(getattr(obj, name))
  84. return out
  86. if isinstance(obj, np.ndarray) and obj.dtype == object:
  87. if obj.size == 1:
  88. return _mat_struct_to_dict(obj.item())
  89. return np.array([_mat_struct_to_dict(x) for x in obj.flat], dtype=object).reshape(obj.shape)
  91. return obj
  94. def load_mat_file(path: str) -> Dict[str, Any]:
  95. """
  96. Load MATLAB .mat file.
  98. Tries:
  99. 1. scipy.io.loadmat
  100. 2. mat73
  101. 3. hdf5storage
  103. Public release files saved as MATLAB -v7.3 may require mat73 or hdf5storage.
  104. """
  105. path = str(path)
  107. try:
  108. mat = sio.loadmat(path, squeeze_me=True, struct_as_record=False)
  109. return {k: _mat_struct_to_dict(v) for k, v in mat.items() if not k.startswith("__")}
  110. except NotImplementedError:
  111. pass
  112. except ValueError as exc:
  113. if "Unknown mat file type" not in str(exc) and "Please use HDF reader" not in str(exc):
  114. raise
  116. try:
  117. import mat73 # type: ignore
  118. return mat73.loadmat(path)
  119. except Exception:
  120. pass
  122. try:
  123. import hdf5storage # type: ignore
  124. return hdf5storage.loadmat(path)
  125. except Exception as exc:
  126. raise RuntimeError(
  127. "Could not load this .mat file. If it was saved with MATLAB -v7.3, "
  128. "install one of: pip install mat73, or pip install hdf5storage.\n"
  129. f"File: {path}\nOriginal error: {exc}"
  130. )
  133. def squeeze_item(x: Any) -> Any:
  134. """
  135. Squeeze simple arrays, but preserve structured arrays.
  137. Do not call .item() on structured arrays, otherwise dtype field names may be lost.
  138. """
  139. if isinstance(x, np.ndarray):
  140. if x.dtype.names is not None:
  141. return np.squeeze(x)
  143. x = np.squeeze(x)
  145. if x.shape == ():
  146. try:
  147. return x.item()
  148. except Exception:
  149. return x
  151. return x
  154. def list_mat_fields(obj: Any) -> List[str]:
  155. """
  156. List fields from MATLAB struct loaded as dict, mat_struct,
  157. numpy structured array, numpy void, or nested object array.
  158. """
  159. obj = squeeze_item(obj)
  161. if isinstance(obj, dict):
  162. return list(obj.keys())
  164. if hasattr(obj, "__dict__"):
  165. return [k for k in obj.__dict__.keys() if not k.startswith("_")]
  167. if isinstance(obj, np.void) and obj.dtype.names is not None:
  168. return list(obj.dtype.names)
  170. if isinstance(obj, np.ndarray):
  171. obj = np.squeeze(obj)
  173. if obj.dtype.names is not None:
  174. return list(obj.dtype.names)
  176. if obj.size == 1:
  177. try:
  178. return list_mat_fields(obj.item())
  179. except Exception:
  180. return []
  182. return []
  185. def get_mat_field(obj: Any, field_name: str) -> Any:
  186. """
  187. Robust field getter for MATLAB structs loaded as:
  188. - dict
  189. - scipy mat_struct
  190. - numpy structured array
  191. - numpy void
  192. - numpy object array containing one struct
  193. """
  194. obj = squeeze_item(obj)
  196. if isinstance(obj, dict):
  197. if field_name in obj:
  198. return squeeze_item(obj[field_name])
  199. raise KeyError(f"Field '{field_name}' not found. Available fields: {list(obj.keys())}")
  201. if hasattr(obj, field_name):
  202. return squeeze_item(getattr(obj, field_name))
  204. if hasattr(obj, "__dict__") and field_name in obj.__dict__:
  205. return squeeze_item(obj.__dict__[field_name])
  207. if isinstance(obj, np.void) and obj.dtype.names is not None:
  208. if field_name in obj.dtype.names:
  209. return squeeze_item(obj[field_name])
  210. raise KeyError(f"Field '{field_name}' not found. Available fields: {obj.dtype.names}")
  212. if isinstance(obj, np.ndarray):
  213. obj = np.squeeze(obj)
  215. if obj.dtype.names is not None:
  216. if field_name in obj.dtype.names:
  217. return squeeze_item(obj[field_name])
  218. raise KeyError(f"Field '{field_name}' not found. Available fields: {obj.dtype.names}")
  220. if obj.size == 1:
  221. return get_mat_field(obj.item(), field_name)
  223. raise KeyError(
  224. f"Field '{field_name}' not found. "
  225. f"Object type: {type(obj)}. "
  226. f"Available fields: {list_mat_fields(obj)}"
  227. )
  230. def has_mat_field(obj: Any, field_name: str) -> bool:
  231. try:
  232. get_mat_field(obj, field_name)
  233. return True
  234. except Exception:
  235. return False
  238. def get_nested(d: Dict[str, Any], keys: List[str], default: Any = None) -> Any:
  239. cur = d
  240. for key in keys:
  241. if isinstance(cur, dict) and key in cur:
  242. cur = cur[key]
  243. else:
  244. return default
  245. return cur
  248. def to_string_list(x: Any) -> List[str]:
  249. """
  250. Convert MATLAB string / cellstr / char-array-ish objects to list[str].
  251. If selected_channels is not parsed cleanly, training is not affected.
  252. """
  253. if x is None:
  254. return []
  256. try:
  257. x = squeeze_item(x)
  259. if isinstance(x, str):
  260. return [x]
  262. if isinstance(x, bytes):
  263. return [x.decode()]
  265. arr = np.asarray(x)
  267. if arr.dtype.kind in {"U", "S"}:
  268. return [str(v) for v in arr.ravel().tolist()]
  270. if arr.dtype == object:
  271. out = []
  272. for v in arr.ravel():
  273. if isinstance(v, bytes):
  274. out.append(v.decode())
  275. elif isinstance(v, str):
  276. out.append(v)
  277. elif isinstance(v, np.ndarray):
  278. out.append("".join(v.astype(str).ravel().tolist()))
  279. else:
  280. out.append(str(v))
  281. return out
  283. return [str(v) for v in arr.ravel().tolist()]
  285. except Exception:
  286. return []
  289. # -------------------------
  290. # Public runData extraction
  291. # -------------------------
  293. def _as_numeric_array(x: Any) -> np.ndarray:
  294. arr = np.asarray(x)
  295. if arr.dtype == object:
  296. raise ValueError("Expected numeric array but got object array/cell array.")
  297. return arr.astype(np.float64)
  300. def _cell_to_trials(cell_obj: Any) -> np.ndarray:
  301. """
  302. Convert MATLAB cell array of trial matrices into trials x channels x samples.
  304. This is not recommended for the update pipeline unless all trials have the same length.
  305. Public EEGNet-style update files should usually be numeric arrays, not cells.
  306. """
  307. arr = np.asarray(cell_obj, dtype=object)
  308. trials = []
  310. for item in arr.ravel():
  311. trial = np.asarray(item, dtype=np.float64)
  313. if trial.ndim != 2:
  314. trial = np.squeeze(trial)
  316. if trial.ndim != 2:
  317. raise ValueError("Each trialSignal cell must be a 2D matrix: samples x channels or channels x samples.")
  319. # Public data stores cells as trialLength x channels.
  320. if trial.shape[0] >= trial.shape[1]:
  321. trial = trial.T # channels x samples
  323. trials.append(trial)
  325. lengths = {t.shape[1] for t in trials}
  326. channels = {t.shape[0] for t in trials}
  328. if len(lengths) != 1 or len(channels) != 1:
  329. raise ValueError(
  330. "trialSignal is a variable-length cell array. Weighted update needs fixed-length EEGNet-style trials. "
  331. "Use fixed-length runData files or add a padding/cropping rule."
  332. )
  334. return np.stack(trials, axis=0) # trials x channels x samples
  337. def trial_signal_to_numpy(trial_signal: Any) -> np.ndarray:
  338. """
  339. Convert runData.trialSignal to trials x channels x samples.
  341. Expected fixed-length public format:
  342. samples x channels x trials
  343. """
  344. arr = np.asarray(trial_signal)
  346. if arr.dtype == object:
  347. return _cell_to_trials(arr)
  349. arr = arr.astype(np.float64)
  350. arr = np.squeeze(arr)
  352. if arr.ndim != 3:
  353. raise ValueError(f"trialSignal must be 3D numeric array or cell array. Got shape {arr.shape}.")
  355. # Most public EEGNet-style data:
  356. # samples x channels x trials, e.g. 5000 x 62 x 30.
  357. # Convert to trials x channels x samples.
  358. if arr.shape[0] > arr.shape[1] and arr.shape[2] < arr.shape[0]:
  359. return np.transpose(arr, (2, 1, 0))
  361. # If already trials x channels x samples.
  362. if arr.shape[2] > arr.shape[1] and arr.shape[0] < arr.shape[2]:
  363. return arr
  365. # Conservative fallback: assume samples x channels x trials.
  366. return np.transpose(arr, (2, 1, 0))
  369. def _mode_or_mean_label(v: np.ndarray) -> int:
  370. v = v[np.isfinite(v)]
  372. if v.size == 0:
  373. raise ValueError("Empty target label vector.")
  375. rounded = np.rint(v).astype(int)
  376. vals, counts = np.unique(rounded, return_counts=True)
  378. return int(vals[np.argmax(counts)])
  381. def target_class_to_labels(trial_target_class: Any, n_trials: int) -> np.ndarray:
  382. """
  383. Convert runData.trialTargetClass into one label per trial.
  385. Common fixed-length format:
  386. samples x trials
  387. """
  388. arr = np.asarray(trial_target_class)
  390. if arr.dtype == object:
  391. labels = []
  392. for item in arr.ravel():
  393. v = np.asarray(item, dtype=np.float64).ravel()
  394. labels.append(_mode_or_mean_label(v))
  395. return np.asarray(labels, dtype=int)
  397. arr = np.squeeze(arr.astype(np.float64))
  399. if arr.ndim == 1:
  400. if arr.size == n_trials:
  401. return np.rint(arr).astype(int)
  402. raise ValueError(f"1D trialTargetClass length {arr.size} does not match n_trials {n_trials}.")
  404. if arr.ndim != 2:
  405. raise ValueError(f"trialTargetClass must be 1D/2D/cell. Got shape {arr.shape}.")
  407. # samples x trials
  408. if arr.shape[1] == n_trials:
  409. return np.asarray([_mode_or_mean_label(arr[:, i]) for i in range(n_trials)], dtype=int)
  411. # trials x samples
  412. if arr.shape[0] == n_trials:
  413. return np.asarray([_mode_or_mean_label(arr[i, :]) for i in range(n_trials)], dtype=int)
  415. raise ValueError(f"Cannot align trialTargetClass shape {arr.shape} with n_trials {n_trials}.")
  418. def extract_structured_runData_field(run_data: np.ndarray, field_name: str) -> Any:
  419. """
  420. Extract a field from structured ndarray runData.
  422. Example current format:
  423. runData shape: (1,)
  424. runData dtype.names includes trialSignal
  425. runData["trialSignal"][0] has shape 5000 x 62 x trials
  426. """
  427. if not isinstance(run_data, np.ndarray) or run_data.dtype.names is None:
  428. raise TypeError("run_data is not a numpy structured array.")
  430. if field_name not in run_data.dtype.names:
  431. raise KeyError(f"runData.{field_name} not found. Available fields: {run_data.dtype.names}")
  433. out = run_data[field_name]
  435. if out.shape[0] == 1:
  436. out = out[0]
  438. return out
  441. def parse_meta_from_structured_runData(run_data: np.ndarray) -> Tuple[float, List[str]]:
  442. """
  443. Extract sampling_rate_hz and selected_channels from structured runData.meta if possible.
  444. If parsing fails, return fs=1000 and empty channel list.
  445. """
  446. fs = 1000.0
  447. selected_channels: List[str] = []
  449. if not isinstance(run_data, np.ndarray) or run_data.dtype.names is None:
  450. return fs, selected_channels
  452. if "meta" not in run_data.dtype.names:
  453. return fs, selected_channels
  455. try:
  456. meta = run_data["meta"][0]
  458. if isinstance(meta, np.ndarray) and meta.dtype.names is not None:
  459. if "sampling_rate_hz" in meta.dtype.names:
  460. fs_raw = meta["sampling_rate_hz"]
  462. if isinstance(fs_raw, np.ndarray):
  463. fs_raw = np.squeeze(fs_raw)
  464. if fs_raw.shape == ():
  465. fs = float(fs_raw.item())
  466. else:
  467. fs = float(np.asarray(fs_raw).ravel()[0])
  468. else:
  469. fs = float(fs_raw)
  471. if "selected_channels" in meta.dtype.names:
  472. try:
  473. selected_channels = to_string_list(meta["selected_channels"])
  474. except Exception:
  475. selected_channels = []
  477. elif isinstance(meta, np.void) and meta.dtype.names is not None:
  478. if "sampling_rate_hz" in meta.dtype.names:
  479. fs = float(np.asarray(meta["sampling_rate_hz"]).squeeze())
  481. if "selected_channels" in meta.dtype.names:
  482. try:
  483. selected_channels = to_string_list(meta["selected_channels"])
  484. except Exception:
  485. selected_channels = []
  487. except Exception as exc:
  488. print(f"Warning: could not parse meta cleanly: {exc}")
  489. fs = 1000.0
  490. selected_channels = []
  492. if not np.isfinite(fs) or fs <= 0:
  493. fs = 1000.0
  495. return fs, selected_channels
  498. def load_runData_trials(mat_path: str) -> Tuple[np.ndarray, np.ndarray, List[str], float, Dict[int, int]]:
  499. """
  500. Load already segmented runData file.
  502. Returns:
  503. sig: trials x channels x samples
  504. labels_zero_based: trials
  505. selected_channels: list[str]
  506. sampling_rate_hz: float
  507. label_mapping: dict from original label -> zero-based label
  508. """
  509. mat = load_mat_file(mat_path)
  511. if "runData" not in mat:
  512. raise KeyError(f"File does not contain runData: {mat_path}. Available keys: {list(mat.keys())}")
  514. run_data = mat["runData"]
  516. print("Top-level mat keys:", list(mat.keys()))
  517. print("runData type:", type(run_data))
  519. # if isinstance(run_data, np.ndarray):
  520. # print("runData shape:", run_data.shape)
  521. # print("runData dtype:", run_data.dtype)
  522. # print("runData dtype.names:", run_data.dtype.names)
  523. # print("runData ndim:", run_data.ndim)
  525. # Case 1: hdf5storage loaded MATLAB struct as structured ndarray.
  526. if isinstance(run_data, np.ndarray) and run_data.dtype.names is not None:
  527. trial_signal = extract_structured_runData_field(run_data, "trialSignal")
  528. trial_target_class = extract_structured_runData_field(run_data, "trialTargetClass")
  529. sampling_rate_hz, selected_channels = parse_meta_from_structured_runData(run_data)
  531. # Case 2: runData loaded as dict / mat_struct.
  532. else:
  533. if not isinstance(run_data, dict):
  534. run_data = _mat_struct_to_dict(run_data)
  536. if isinstance(run_data, dict):
  537. if "trialSignal" not in run_data:
  538. raise KeyError(f"runData.trialSignal not found. Available fields: {list(run_data.keys())}")
  540. if "trialTargetClass" not in run_data:
  541. raise KeyError(
  542. f"runData.trialTargetClass not found. Available fields: {list(run_data.keys())}. "
  543. "This update script is for EEGNet-style runData files."
  544. )
  546. trial_signal = run_data["trialSignal"]
  547. trial_target_class = run_data["trialTargetClass"]
  549. meta = run_data.get("meta", {}) if isinstance(run_data.get("meta", {}), dict) else {}
  550. selected_channels = to_string_list(meta.get("selected_channels", []))
  551. sampling_rate_hz = float(np.asarray(meta.get("sampling_rate_hz", 1000)).squeeze())
  553. else:
  554. trial_signal = get_mat_field(run_data, "trialSignal")
  555. trial_target_class = get_mat_field(run_data, "trialTargetClass")
  557. selected_channels = []
  558. sampling_rate_hz = 1000.0
  560. if has_mat_field(run_data, "meta"):
  561. meta = get_mat_field(run_data, "meta")
  563. if has_mat_field(meta, "sampling_rate_hz"):
  564. sampling_rate_hz = float(np.asarray(get_mat_field(meta, "sampling_rate_hz")).squeeze())
  566. if has_mat_field(meta, "selected_channels"):
  567. selected_channels = to_string_list(get_mat_field(meta, "selected_channels"))
  569. if not np.isfinite(sampling_rate_hz) or sampling_rate_hz <= 0:
  570. sampling_rate_hz = 1000.0
  572. sig = trial_signal_to_numpy(trial_signal)
  573. labels = target_class_to_labels(trial_target_class, sig.shape[0])
  575. # Convert arbitrary integer labels to contiguous 0..C-1 for PyTorch NLLLoss.
  576. unique_labels = sorted([int(x) for x in np.unique(labels)])
  577. label_mapping = {old: new for new, old in enumerate(unique_labels)}
  578. labels_zero_based = np.asarray([label_mapping[int(x)] for x in labels], dtype=np.int64)
  580. return sig, labels_zero_based, selected_channels, sampling_rate_hz, label_mapping
  583. # -------------------------
  584. # Signal preprocessing
  585. # -------------------------
  587. def bandpass_filter_trials(sig: np.ndarray, fs: float, low: float = 4.0, high: float = 40.0) -> np.ndarray:
  588. """Butterworth bandpass on trials x channels x samples."""
  589. nyq = fs / 2.0
  591. if high >= nyq:
  592. high = nyq - 1.0
  594. if low <= 0 or high <= low:
  595. raise ValueError(f"Invalid bandpass range: low={low}, high={high}, fs={fs}")
  597. b, a = signal.butter(4, [low, high], btype="bandpass", fs=fs)
  598. return signal.filtfilt(b, a, sig, axis=-1)
  601. def slice_trials(
  602. sig: np.ndarray,
  603. labels: np.ndarray,
  604. fs: float,
  605. window_sec: float = 1.0,
  606. step_sec: float = 0.04,
  607. start_sec: float = 0.5,
  608. end_sec: float = 4.5,
  609. ) -> Tuple[np.ndarray, np.ndarray]:
  610. """
  611. Slice trials into sliding 1-second windows from 0.5 to 4.5 s with 40 ms step.
  613. Input:
  614. sig: trials x channels x samples
  616. Output:
  617. windows x channels x window_samples
  618. """
  619. n_trials, n_ch, n_samples = sig.shape
  621. start = int(round(start_sec * fs))
  622. stop = int(round(end_sec * fs))
  623. win = int(round(window_sec * fs))
  624. step = int(round(step_sec * fs))
  626. if stop > n_samples:
  627. stop = n_samples
  629. if start < 0 or start + win > stop:
  630. raise ValueError(
  631. f"Invalid slicing window. n_samples={n_samples}, fs={fs}, "
  632. f"start={start}, stop={stop}, win={win}."
  633. )
  635. n_slices = int(np.floor((stop - start - win) / step) + 1)
  637. out = np.zeros((n_trials * n_slices, n_ch, win), dtype=np.float64)
  638. out_labels = np.zeros(n_trials * n_slices, dtype=np.int64)
  640. k = 0
  641. for i in range(n_trials):
  642. for j in range(n_slices):
  643. s = start + j * step
  644. out[k] = sig[i, :, s:s + win]
  645. out_labels[k] = labels[i]
  646. k += 1
  648. out = out - np.mean(out, axis=2, keepdims=True)
  650. return out, out_labels
  653. def resample_trials(sig: np.ndarray, fs_in: float, fs_out: float = 100.0) -> Tuple[np.ndarray, float]:
  654. if abs(fs_in - fs_out) < 1e-6:
  655. return sig, fs_in
  657. from fractions import Fraction
  659. frac = Fraction(fs_out / fs_in).limit_denominator(1000)
  660. resampled = signal.resample_poly(sig, up=frac.numerator, down=frac.denominator, axis=-1)
  662. return resampled, fs_out
  665. # -------------------------
  666. # Weighting utilities
  667. # -------------------------
  669. def cal_init_weight(train_data: np.ndarray, train_label: np.ndarray) -> np.ndarray:
  670. """CSP + LDA initial sample weights for binary labels."""
  671. train_label = np.ravel(train_label.astype(int))
  673. csp = CSP(m_filters=4)
  674. _, eig_vec = csp.fit(train_data, train_label)
  676. features = np.zeros((train_data.shape[0], 2 * csp.m_filters))
  678. for i in range(train_data.shape[0]):
  679. features[i, :] = csp.transform(train_data[i, :, :], eig_vec)
  681. lda = LinearDiscriminantAnalysis()
  682. lda.fit(features, train_label)
  684. pred_prob = lda.predict_proba(features)
  685. pred_label = lda.predict(features)
  687. acc = accuracy_score(pred_label, train_label)
  688. print(f"CSP TrainAcc: {acc:.4f}")
  690. weights = np.zeros(train_data.shape[0], dtype=np.float64)
  692. for i in range(train_data.shape[0]):
  693. if pred_label[i] == train_label[i]:
  694. weights[i] = np.max(pred_prob[i, :])
  695. else:
  696. weights[i] = np.min(pred_prob[i, :])
  698. return weights
  701. def cal_init_weight_2d(train_data: np.ndarray, train_label: np.ndarray) -> np.ndarray:
  702. """One-vs-rest CSP + LDA initial weights for multiclass labels."""
  703. train_label = np.ravel(train_label.astype(int))
  704. weights = np.zeros(train_data.shape[0], dtype=np.float64)
  705. classes = np.unique(train_label)
  707. for cls in classes:
  708. tmp_label = np.ones_like(train_label)
  709. cls_idx = np.where(train_label == cls)[0]
  710. tmp_label[cls_idx] = 0
  712. csp = CSP(m_filters=4)
  713. _, eig_vec = csp.fit(train_data, tmp_label)
  715. features = np.zeros((train_data.shape[0], 2 * csp.m_filters))
  717. for i in range(train_data.shape[0]):
  718. features[i, :] = csp.transform(train_data[i, :, :], eig_vec)
  720. lda = LinearDiscriminantAnalysis()
  721. lda.fit(features, tmp_label)
  723. pred_prob = lda.predict_proba(features)
  724. pred_tmp = lda.predict(features)
  726. acc = accuracy_score(pred_tmp, tmp_label)
  727. print(f"CSP one-vs-rest class {cls} TrainAcc: {acc:.4f}")
  729. for idx in cls_idx:
  730. if pred_tmp[idx] == tmp_label[idx]:
  731. weights[idx] = np.max(pred_prob[idx, :])
  732. else:
  733. weights[idx] = np.min(pred_prob[idx, :])
  735. return weights
  738. def select_init_data(data: np.ndarray, labels: np.ndarray, weights: np.ndarray, init_size: float):
  739. n = max(1, int(np.floor(init_size * labels.shape[0])))
  740. chosen = np.argsort(weights)[-n:][::-1]
  742. chosen_weight = np.zeros_like(weights)
  743. chosen_weight[chosen] = weights[chosen]
  745. return data[chosen], labels[chosen], weights[chosen], chosen_weight
  748. def select_init_data_2d(data: np.ndarray, labels: np.ndarray, weights: np.ndarray, init_size: float):
  749. chosen_weight = np.zeros_like(weights)
  750. classes = np.unique(labels)
  752. n_per_class = max(1, int(np.floor(init_size * (labels.shape[0] / len(classes)))))
  754. for cls in classes:
  755. cls_idx = np.where(labels == cls)[0]
  756. local = np.argsort(weights[cls_idx])[-n_per_class:][::-1]
  757. chosen_weight[cls_idx[local]] = weights[cls_idx[local]]
  759. mask = chosen_weight > 0
  761. return data[mask], labels[mask], weights[mask], chosen_weight
  764. def get_data_weight_round(
  765. model,
  766. loss_fn,
  767. dataset,
  768. train_data,
  769. train_label,
  770. round_size,
  771. device,
  772. ):
  773. all_loss = []
  774. all_weight = np.zeros(train_label.shape[0], dtype=np.float64)
  776. model.eval()
  778. loader = DataLoader(dataset, batch_size=len(dataset), shuffle=False)
  780. with torch.no_grad():
  781. for x, y in loader:
  782. x = x.to(device=device, dtype=torch.float32)
  783. y = torch.squeeze(y).to(device=device).long()
  785. pred = model(x)
  786. sample_loss = loss_fn(pred, y)
  788. all_loss.extend(sample_loss.detach().cpu().numpy().tolist())
  790. norm_loss = rankdata(all_loss, nan_policy="omit") / len(all_loss)
  792. for i, norm_val in enumerate(norm_loss):
  793. if norm_val <= round_size:
  794. if round_size >= 1:
  795. epsilon = 1e-2
  796. all_weight[i] = np.log(norm_val + epsilon) / np.log(epsilon)
  797. else:
  798. numerator = norm_val + 1 - round_size
  799. denominator = np.log(1 - round_size)
  801. if numerator > 0 and denominator != 0:
  802. all_weight[i] = np.log(numerator) / denominator
  803. else:
  804. all_weight[i] = 0.0
  806. all_weight = np.nan_to_num(all_weight, nan=0.0, posinf=0.0, neginf=0.0)
  807. all_weight[all_weight < 0] = 0.0
  809. wmax = np.nanmax(all_weight)
  811. if not np.isfinite(wmax) or wmax == 0:
  812. print("Warning: round weights are all zero; using constant 0.1 weights.")
  813. all_weight[:] = 0.1
  814. else:
  815. all_weight /= wmax
  817. mask = all_weight > 0
  819. return train_data[mask], train_label[mask], all_weight[mask], all_weight
  822. # -------------------------
  823. # Training
  824. # -------------------------
  826. def train_weighted(
  827. model,
  828. loss_fn,
  829. max_epoch,
  830. train_dataset,
  831. device,
  832. lr=0.005,
  833. wd=1e-4,
  834. batch_size=128,
  835. ):
  836. model.to(device)
  837. model = model.to(torch.float32)
  839. optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=wd)
  840. scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, max(max_epoch - 1, 1))
  842. last_loss = torch.tensor(float("nan"), device=device)
  844. for epoch in range(max_epoch):
  845. model.train()
  847. loader = DataLoader(
  848. train_dataset,
  849. batch_size=batch_size,
  850. shuffle=True,
  851. drop_last=False,
  852. collate_fn=lambda x: [y.to(device) for y in default_collate(x)],
  853. )
  855. for data, label, sample_weight in loader:
  856. optimizer.zero_grad()
  858. data = data.to(torch.float32)
  859. label = torch.squeeze(label).long()
  860. sample_weight = sample_weight.to(torch.float32)
  862. pred = model(data)
  864. loss_per_sample = loss_fn(pred, label)
  865. denom = torch.sum(sample_weight).clamp_min(1e-8)
  866. loss = torch.sum(loss_per_sample * sample_weight) / denom
  868. loss.backward()
  869. optimizer.step()
  871. last_loss = loss.detach()
  873. scheduler.step()
  875. print(f"Epoch {epoch + 1:03d}/{max_epoch}, Train Loss: {last_loss.item():.6f}")
  877. return model
  880. def fit_weighted_eegnet(
  881. train_data: np.ndarray,
  882. train_label: np.ndarray,
  883. previous_model_path: Optional[str] = None,
  884. init_size: float = 0.2,
  885. rounds: int = 8,
  886. max_epoch_per_round: int = 30,
  887. device: Optional[str] = None,
  888. ):
  889. train_label = np.asarray(train_label, dtype=np.int64).ravel()
  891. classes = np.unique(train_label)
  893. if classes.min() != 0 or classes.max() != len(classes) - 1:
  894. raise ValueError(f"Labels must be contiguous 0..C-1. Got {classes}.")
  896. if device is None:
  897. device = "cuda" if torch.cuda.is_available() else "cpu"
  899. device_obj = torch.device(device)
  901. print(f"Using device: {device_obj}")
  902. print(f"Training data shape: {train_data.shape}")
  903. print(f"Training labels: {classes}")
  905. all_weight_log = []
  907. if len(classes) <= 2:
  908. init_weight = cal_init_weight(train_data, train_label)
  909. round_data, round_label, round_weight, all_weight = select_init_data(
  910. train_data,
  911. train_label,
  912. init_weight,
  913. init_size,
  914. )
  915. else:
  916. init_weight = cal_init_weight_2d(train_data, train_label)
  917. round_data, round_label, round_weight, all_weight = select_init_data_2d(
  918. train_data,
  919. train_label,
  920. init_weight,
  921. init_size,
  922. )
  924. all_dataset = CustomDataset(train_data, train_label)
  926. model = EEGNetv4(
  927. train_data.shape[1],
  928. len(classes),
  929. n_times=train_data.shape[2],
  930. add_log_softmax=True,
  931. kernel_length=min(50, train_data.shape[2]),
  932. )
  934. if previous_model_path:
  935. print(f"Loading previous model: {previous_model_path}")
  936. state = torch.load(previous_model_path, map_location=device_obj)
  937. model.load_state_dict(state)
  939. loss_fn = nn.NLLLoss(reduction="none")
  941. for round_idx in range(rounds):
  942. if round_idx == 0:
  943. round_size = init_size
  944. print(f"Init with {init_size}")
  945. else:
  946. round_size = (1 - init_size) / (rounds - 1) * round_idx + init_size
  948. if round_size > 1 - 1e-2:
  949. round_size = 1.0
  951. print(f"Round {round_idx + 1}/{rounds}, round size: {round_size:.4f}")
  953. round_data, round_label, round_weight, all_weight = get_data_weight_round(
  954. model,
  955. loss_fn,
  956. all_dataset,
  957. train_data,
  958. train_label,
  959. round_size,
  960. device_obj,
  961. )
  963. all_weight_log.append(all_weight.copy())
  965. train_dataset = WeightedDataset(
  966. round_data,
  967. round_label,
  968. round_weight.astype(np.float32),
  969. )
  971. model = train_weighted(
  972. model,
  973. loss_fn,
  974. max_epoch_per_round,
  975. train_dataset,
  976. device_obj,
  977. )
  979. return model, all_weight_log
  982. # -------------------------
  983. # Main
  984. # -------------------------
  986. def derive_run_name(mat_path: str) -> str:
  987. base = Path(mat_path).stem
  989. # S001_sess01_run02 -> sess01_run02
  990. m = re.match(r"S\d{3}_(.+)$", base)
  992. return m.group(1) if m else base
  995. def main(
  996. mat_path,
  997. save_dir=r".\Parameter",
  998. previous_model_path="",
  999. output_prefix="",
  1000. apply_bandpass=True,
  1001. target_fs=100.0,
  1002. init_size=0.2,
  1003. rounds=8,
  1004. epochs=30,
  1005. device=None,
  1006. ):
  1007. save_dir = Path(save_dir)
  1008. save_dir.mkdir(parents=True, exist_ok=True)
  1010. print(f"MAT file: {mat_path}")
  1011. print(f"Previous model: {previous_model_path if previous_model_path else '[none]'}")
  1012. print(f"Save directory: {save_dir}")
  1014. sig, label, channel_names, fs, label_mapping = load_runData_trials(mat_path)
  1016. print(f"Loaded trialSignal: {sig.shape} [trials x channels x samples]")
  1017. print(f"Original sampling rate: {fs}")
  1018. print(f"Label mapping original->zero-based: {label_mapping}")
  1020. if channel_names:
  1021. print(f"Channels: {len(channel_names)}")
  1023. if apply_bandpass:
  1024. print("Applying 4-40 Hz bandpass filter.")
  1025. sig = bandpass_filter_trials(sig, fs=fs, low=4.0, high=40.0)
  1026. else:
  1027. print("Bandpass filtering disabled.")
  1029. sig, label = slice_trials(
  1030. sig,
  1031. label,
  1032. fs=fs,
  1033. window_sec=1.0,
  1034. step_sec=0.04,
  1035. start_sec=0.5,
  1036. end_sec=4.5,
  1037. )
  1039. print(f"After sliding-window slicing: {sig.shape}")
  1041. sig, fs_out = resample_trials(sig, fs_in=fs, fs_out=target_fs)
  1043. print(f"After resampling to {fs_out:g} Hz: {sig.shape}")
  1045. model, all_weight_log = fit_weighted_eegnet(
  1046. train_data=sig,
  1047. train_label=label,
  1048. previous_model_path=previous_model_path if previous_model_path else None,
  1049. init_size=init_size,
  1050. rounds=rounds,
  1051. max_epoch_per_round=epochs,
  1052. device=device,
  1053. )
  1055. prefix = output_prefix if output_prefix else derive_run_name(mat_path)
  1057. model_path = save_dir / f"{prefix}Model.pth"
  1058. weight_path = save_dir / f"{prefix}WeightLog.mat"
  1059. mapping_path = save_dir / f"{prefix}LabelMapping.mat"
  1061. torch.save(model.state_dict(), model_path)
  1063. sio.savemat(
  1064. weight_path,
  1065. {
  1066. "AllWeightLog": np.asarray(all_weight_log, dtype=object)
  1067. }
  1068. )
  1070. sio.savemat(
  1071. mapping_path,
  1072. {
  1073. "original_labels": np.array(list(label_mapping.keys())),
  1074. "zero_based_labels": np.array(list(label_mapping.values())),
  1075. }
  1076. )
  1078. print(f"Saved model: {model_path}")
  1079. print(f"Saved weight log: {weight_path}")
  1080. print(f"Saved label mapping: {mapping_path}")
  1082. return {
  1083. "model_path": str(model_path),
  1084. "weight_path": str(weight_path),
  1085. "mapping_path": str(mapping_path),
  1086. "label_mapping": label_mapping,
  1087. "fs_out": fs_out,
  1088. "data_shape": sig.shape,
  1089. }
  1092. if __name__ == "__main__":
  1094. # ============================================================
  1095. # User parameters: edit these directly
  1096. # ============================================================
  1098. mat_path = r"D:\Tactile\PublicRelease_Final\JointLearning\S001\S001_sess04_run03.mat"
  1100. save_dir = r".\Parameter"
  1102. # First run: use ""
  1103. # Later run: use previous model, for example:
  1104. # previous_model_path = r".\Parameter\sess01_run01Model.pth"
  1105. previous_model_path = ""
  1107. # If empty, output prefix is derived from mat filename.
  1108. output_prefix = ""
  1110. apply_bandpass = True
  1111. target_fs = 100.0
  1112. init_size = 0.2
  1113. rounds = 9
  1114. epochs = 30
  1116. # None = cuda if available, otherwise cpu.
  1117. # Or set "cuda" / "cpu".
  1118. device = None
  1120. # ============================================================
  1121. # Run update
  1122. # ============================================================
  1124. result = main(
  1125. mat_path=mat_path,
  1126. save_dir=save_dir,
  1127. previous_model_path=previous_model_path,
  1128. output_prefix=output_prefix,
  1129. apply_bandpass=apply_bandpass,
  1130. target_fs=target_fs,
  1131. init_size=init_size,
  1132. rounds=rounds,
  1133. epochs=epochs,
  1134. device=device,
  1135. )
  1137. print("Finished.")
  1138. print(result)

updateModel.py at commit 57710f7, under MIT · at the source

Overview

Authors: Hanwen Wang1, Yisha Zhang1, Maxim Karrenbach2, Yidan Ding1, Bin He1,2,3
ORCID iDs: Hanwen Wang, Maxim Karrenbach, Yidan Ding, Bin He
  1. Department of Biomedical Engineering, Carnegie Mellon University,Pittsburgh, PA USA
  2. Department of Electrical and Computer Engineering, Carnegie Mellon University,Pittsburgh, PA USA
  3. Neuroscience Institute, Carnegie Mellon University,Pittsburgh, PA USA
Institutions: Carnegie Mellon University (United States)
Journal: Nature communications, volume 17, issue 1, article 6177
Dates: received 20 October 2025; accepted 23 June 2026; published online 15 July 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41467-026-75435-5 · PMID 42457692 · PMCID PMC13373212 · OpenAlex W7168376136
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: EEG (modality), human (organism)
Methods: Spectral & time-frequency, Preprocessing, Connectivity, Statistics, Smoothing, state filtering, decompositions, Machine learning
Keywords: Brain-machine interface, Biomedical engineering, Touch receptors, Information technology, Electroencephalography - EEG
MeSH: Brain-Computer Interfaces*, Imagination*, Machine Learning*, Adaptive Algorithms, Adult, Algorithms, Electroencephalography, Female, Humans, Learning, Male, Neuronal Plasticity, Reinforcement Machine Learning, Young Adult (* major topic)
Topic: EEG and Brain-Computer Interfaces (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: NINDS (NS124564, NS131069, NS127849, NS096761); U.S. Department of Health & Human Services | NIH | National Institute of Biomedical Imaging and Bioengineering (NIBIB) (EB029365)
Citations: cited by 1 paper (Europe PMC); 76 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.

Repositories

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

bfinl/SensoryGuidedJointLearning

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 57710f76a5ddd6f9a3aad28566ca55776a424400, 2 June 2026
Languages: Python (6)
Size: 8 files, 6 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: PyTorch (5 files), NumPy (4 files), SciPy (3 files), MNE-Python (1 file), scikit-learn (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
8 files
At the source: github.com/bfinl/SensoryGuidedJointLearning/

Zenodo 20480141

License: MIT
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
Tools: PyTorch (5 files), NumPy (4 files), SciPy (3 files), MNE-Python (1 file), scikit-learn (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
  • 27 September 2026: the link answers (HTTP 200)
8 files
At the source:

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-75435-5.

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;
  • 12 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

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

  • no repository, dataset or request procedure was recognized in it

Read it in the paper: doi.org/10.1038/s41467-026-75435-5.

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, 5 authors, 5 keywords, 14 MeSH terms, 2 funders, 74 references.

Cite

This paper

Wang, H., Zhang, Y., Karrenbach, M., Ding, Y., & He, B. (2026). Sensory-guided human-machine joint learning accelerates the acquisition of motor imagery brain computer interface control. Nature communications, 17(1), 6177. https://doi.org/10.1038/s41467-026-75435-5

BibTeX

@article{wang2026sensory,
author = {Wang, Hanwen and Zhang, Yisha and Karrenbach, Maxim and Ding, Yidan and He, Bin},
title = {{Sensory-guided human-machine joint learning accelerates the acquisition of motor imagery brain computer interface control}},
journal = {Nature communications},
year = {2026},
month = jul,
volume = {17},
number = {1},
pages = {6177},
publisher = {Nature Publishing Group},
issn = {2041-1723},
doi = {10.1038/s41467-026-75435-5},
url = {https://doi.org/10.1038/s41467-026-75435-5},
pmid = {42457692},
pmcid = {PMC13373212}
}

RIS

TY - JOUR
AU - Wang, Hanwen
AU - Zhang, Yisha
AU - Karrenbach, Maxim
AU - Ding, Yidan
AU - He, Bin
TI - Sensory-guided human-machine joint learning accelerates the acquisition of motor imagery brain computer interface control
T2 - Nature communications
J2 - Nat Commun
PY - 2026
DA - 2026/07/15
VL - 17
IS - 1
SP - 6177
SN - 2041-1723
PB - Nature Publishing Group
DO - 10.1038/s41467-026-75435-5
UR - https://doi.org/10.1038/s41467-026-75435-5
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41467-026-75435-5",
"type": "article-journal",
"title": "Sensory-guided human-machine joint learning accelerates the acquisition of motor imagery brain computer interface control",
"container-title": "Nature communications",
"author": [
{
"family": "Wang",
"given": "Hanwen"
},
{
"family": "Zhang",
"given": "Yisha"
},
{
"family": "Karrenbach",
"given": "Maxim"
},
{
"family": "Ding",
"given": "Yidan"
},
{
"family": "He",
"given": "Bin"
}
],
"container-title-short": "Nat Commun",
"volume": "17",
"issue": "1",
"page": "6177",
"DOI": "10.1038/s41467-026-75435-5",
"PMID": "42457692",
"PMCID": "PMC13373212",
"ISSN": "2041-1723",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41467-026-75435-5",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
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-69853-8 [code]
Transcranial focused ultrasound induces source localizable cortical activation in resting state humans when applied concurrently with transcranial electric stimulation.
Journal: Nature communications
In common: MNE-Python, SciPy, NumPy, EEG, 2 authors
[2] doi:10.1186/s12984-026-02041-3 [code]
Mental tasks induce common modulations of oscillations in cortex and spinal cord.
Journal: Journal of neuroengineering and rehabilitation
In common: EEG, 6 references
[3] doi:10.1371/journal.pcbi.1014112 [code]
Opposing cortical forces: Alpha slowing and sensorimotor mu acceleration during motor-related BCI training.
Journal: PLoS computational biology
In common: EEG, 6 references
[4] doi:10.1073/pnas.2510015122 [code]
Mapping epileptogenic brain using a unified spatial–temporal–spectral source imaging framework
Journal: n/a
In common: EEG, 2 references, author Bin He
[5] doi:10.1038/s44385-026-00098-2 [code]
Cross-region neural signal reconstruction to lift electrode placement constraints in SSVEP brain-computer interfaces.
Journal: npj biomedical innovations
In common: EEG, 5 references
[6] doi:10.3390/s26134045
Brain Signal for Secure EEG Biometric Authentication: A Comprehensive Survey.
Journal: Sensors (Basel, Switzerland)
In common: EEG, 6 references
[7] doi:10.1162/imag.a.1259 [code]
Neuronal avalanches as a predictive biomarker for guiding tailored BCI training programs.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: MNE-Python, scikit-learn, SciPy, 1 other tool, EEG, 2 references
[8] doi:10.1007/s10916-026-02374-5 [code]
Attention-Enhanced U-Net for Sensor-Efficient High-Density EEG Reconstruction in Wearable Brain Monitoring Systems.
Journal: Journal of medical systems
In common: MNE-Python, PyTorch, scikit-learn, 2 other tools, EEG, 2 references
[9] doi:10.1038/s41593-026-02258-4 [code]
Laminar organization of cellular microcircuits modulating human interictal epileptiform discharges.
Journal: Nature neuroscience
In common: MNE-Python, scikit-learn, SciPy, 1 other tool, EEG, 2 references
[10] doi:10.1186/s13634-026-01330-2 [code]
Leednet: a lightweight network for event detection in EEG signals.
Journal: Journal on advances in signal processing
In common: MNE-Python, PyTorch, scikit-learn, 2 other tools, EEG, 2 references

Contribute

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

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

Request its removal

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

Discussion, reproductions, activity

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

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

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