OSCR

The retrieval of previously learned motor memories is facilitated by the reinstatement of default mode network manifold structures.

Code ↔ Paper

13 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 13 matches
  1. [1] § Materials and methods › fMRI preprocessing ↔ saveman/ventral_visual_cleanup.py, lines 1–15 · score 0.77 · defined ventral visual, nuisance regression, contamination, mitigating, signal, centroid
  2. [2] § Materials and methods › Behavioral data analysis ↔ saveman/analyses/behaviour.py, lines 675–812 · score 0.74 · baseline corrected eccentricity, Recall Ratio, angular error, permutation, behavioral, Score
  3. [3] § Materials and methods › Neuroimaging data analysis ↔ saveman/connectivity.py, lines 251–296 · score 0.63 · covariance matrix, connectivity matrices, transported, tangent, grand, Riemannian
  4. [4] § Materials and methods › fMRI preprocessing ↔ saveman/ventral_visual_cleanup.py, lines 152–244 · score 0.63 · ventral visual parcels, cerebellar parcels, regressed, PCA
  5. [5] § Materials and methods › fMRI preprocessing ↔ tutorials/plot_tutorial_02.py, lines 1–52 · score 0.62 · AFNI, FreeSurfer, FSL, fsaverage, surfaces, brain
  6. [6] § Results › Learner heterogeneity reveals different DMN-centric reinstatement profiles in fast versus slow learners ↔ saveman/analyses/behaviour.py, lines 530–564 · score 0.62 · slow learners, trial bins, learning curves, angular error, fast, Behavioral
  7. [7] § Results › Changes in manifold structure relate to individual differences in learning and relearning ↔ saveman/analyses/behaviour.py, lines 530–564 · score 0.61 · slow learner, trial bins, Learning curves, angular error, fast, behavioral
  8. [8] § Materials and methods › Behavioral data analysis ↔ saveman/analyses/fpca.py, lines 269–310 · score 0.59 · trial bins, learning curve, angular error, behavioral
  9. [9] § Materials and methods › fMRI preprocessing ↔ tutorials/plot_tutorial_02.py, lines 1–52 · score 0.58 · Brain surfaces, FreeSurfer, FSL, workflow
  10. [10] § Results › Changes in manifold structure relate to individual differences in learning and relearning ↔ saveman/analyses/behaviour.py, lines 675–812 · score 0.56 · Recall Ratio, behavioral metric, fPCA, Score, correlation, error
  11. [11] § Materials and methods › fMRI preprocessing ↔ tutorials/plot_tutorial_01.py, lines 49–95 · score 0.55 · FreeSurfer, FSL, variable, volume, surfaces
  12. [12] § Materials and methods › Behavioral data analysis ↔ saveman/analyses/fpca.py, lines 76–159 · score 0.55 · angular error, fPCs, spline, FPC1, fPCA, variance
  13. [13] § Results › Manifold structure during baseline trials ↔ saveman/analyses/reference.py, lines 44–63 · score 0.52 · cumulative variance explained, principal components, PCs, bars

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 · 815 lines · 31 KB · MIT · 4 matches

  1. """Behaviour analyses for the motor adaptation task."""
  3. from __future__ import annotations
  5. import os
  6. from typing import Optional, Tuple
  8. import numpy as np
  9. import pandas as pd
  10. import matplotlib.pyplot as plt
  11. import seaborn as sns
  12. from scipy.stats import pearsonr
  13. import pingouin as pg
  14. from matplotlib.colors import ListedColormap
  15. from matplotlib import gridspec
  16. from sklearn.decomposition import PCA
  18. from neuromaps import nulls
  19. from neuromaps.datasets import fetch_atlas
  20. from neuromaps import stats # for efficient_pearsonr (optional, used elsewhere)
  22. from saveman.config import Config
  23. from saveman.utils import get_surfaces, parse_roi_names
  24. from saveman.analyses import plotting
  25. from surfplot import Plot
  26. import cmasher as cmr
  29. # ----------------------------
  30. # Small helpers
  31. # ----------------------------
  33. def _ensure_dir(path: str) -> None:
  34. os.makedirs(path, exist_ok=True)
  36. def _savefig(fig: plt.Figure, path_no_ext: str, dpi: int = 300) -> None:
  37. """Save a figure robustly as PNG and close it."""
  38. out = path_no_ext if path_no_ext.lower().endswith("") else (path_no_ext + "")
  39. fig.savefig(out, dpi=dpi, bbox_inches="tight")
  40. plt.close(fig)
  42. def convert_pvalue_to_asterisks(pvalue: float) -> str:
  43. if pvalue <= 0.0001:
  44. return "****"
  45. if pvalue <= 0.001:
  46. return "***"
  47. if pvalue <= 0.01:
  48. return "**"
  49. if pvalue <= 0.05:
  50. return "*"
  51. return "ns"
  54. # ----------------------------
  55. # Core plotting
  56. # ----------------------------
  58. def task_behaviour_plot(data: pd.DataFrame, fig_dir: str) -> None:
  59. """Plot group-average error throughout the task (3 styles).
  61. Parameters
  62. ----------
  63. data
  64. Trial-wise behavioural data including columns: sub, ses, trial_bin, error.
  65. Units should already be in degrees if you want degree-scaled plots.
  66. fig_dir
  67. Output directory for figures.
  68. """
  69. _ensure_dir(fig_dir)
  70. color = ["darkcyan", "#FFA066"]
  72. max_trial_bin = int(data["trial_bin"].max())
  73. num_sub = int(len(data["sub"].unique()))
  74. data3 = data.copy()
  75. data3["trial_bin"] = np.tile(np.arange(1, 2 * max_trial_bin + 1), num_sub)
  77. fig, ax = plt.subplots(figsize=(12, 4))
  78. sns.lineplot(
  79. x="trial_bin",
  80. y="error",
  81. data=data3,
  82. hue="ses",
  83. palette=color,
  84. errorbar=("ci", 68),
  85. linewidth=1.5,
  86. ax=ax,
  87. )
  88. ax.set_yticks(np.arange(-20, 50, 10))
  89. ax.axhline(0, lw=1, c="k", ls="--")
  90. ax.set_xlabel("Trial Bin", fontsize=12, fontweight="bold")
  91. ax.set_ylabel("Angular error (°)", fontsize=12, fontweight="bold")
  92. sns.despine()
  93. fig.tight_layout()
  94. _savefig(fig, os.path.join(fig_dir, "task_plot"))
  97. def plot_behav_distribution(
  98. df: pd.DataFrame,
  99. fig_dir: str,
  100. name: str = "early",
  101. angle: str = "hitAngle_hand_good",
  102. auto_ticks: bool = False,
  103. seed: int = 1,
  104. ) -> None:
  105. """Show sample distribution (box + jittered points).
  107. Parameters
  108. ----------
  109. df
  110. DataFrame containing the column in `angle`.
  111. fig_dir
  112. Output directory for figures.
  113. name
  114. Label used for axis title and filename.
  115. angle
  116. Column name to plot.
  117. auto_ticks
  118. If True, suppress y-ticks.
  119. seed
  120. RNG seed for jitter reproducibility.
  121. """
  122. _ensure_dir(fig_dir)
  123. if angle not in df.columns:
  124. raise ValueError(f"Column '{angle}' not found in df.")
  126. plot_df = df.copy()
  127. plot_df["x"] = 1
  129. ymin = 15 * (np.nanmin(plot_df[angle]) // 15)
  130. ymax = 15 * (np.nanmax(plot_df[angle]) // 15)
  132. fig, ax = plt.subplots(figsize=(2, 4))
  133. box_line_color = "k"
  134. sns.boxplot(
  135. x="x",
  136. y=angle,
  137. data=plot_df,
  138. color="silver",
  139. boxprops=dict(edgecolor=box_line_color),
  140. medianprops=dict(color=box_line_color),
  141. whiskerprops=dict(color=box_line_color),
  142. capprops=dict(color=box_line_color),
  143. showfliers=False,
  144. width=0.5,
  145. ax=ax,
  146. )
  148. cmap = cmr.get_sub_cmap("RdYlGn", 0.05, 0.9)
  150. rng = np.random.default_rng(seed)
  151. jitter = rng.uniform(0.01, 0.4, len(plot_df))
  152. ax.scatter(
  153. x=plot_df["x"] + jitter,
  154. y=plot_df[angle],
  155. c=plot_df[angle],
  156. ec="k",
  157. linewidths=1,
  158. cmap=cmap,
  159. clip_on=False,
  160. )
  162. if auto_ticks:
  163. ax.set(xticks=[])
  164. else:
  165. ax.set(xticks=[], yticks=np.arange(ymin, ymax + 15, 15))
  167. ax.set_xlabel(" ")
  168. ax.set_ylabel(name, fontsize=12, fontweight="bold")
  169. sns.despine(bottom=True)
  170. fig.tight_layout()
  171. _savefig(fig, os.path.join(fig_dir, f"{name}_error_distribution"))
  174. def plot_early_error_change(df: pd.DataFrame, fig_dir: str) -> None:
  175. """Bar + paired lines for Day1 vs Day2 early error (paired test)."""
  176. _ensure_dir(fig_dir)
  177. data1 = df[["sub", "D1 early", "Savings"]].rename(columns={"D1 early": "error"})
  178. data1["day"] = 1
  179. data2 = df[["sub", "D2 early", "Savings"]].rename(columns={"D2 early": "error"})
  180. data2["day"] = 2
  181. data = pd.concat([data1, data2], axis=0)
  183. res = pg.pairwise_tests(data=data, dv="error", within="day", subject="sub")
  184. pval = float(res["p-unc"].values[0])
  185. pval_asterisks = convert_pvalue_to_asterisks(pval)
  187. fig, ax = plt.subplots(figsize=(4, 4))
  188. sns.barplot(
  189. data=data,
  190. x="day",
  191. y="error",
  192. hue="day",
  193. palette=["#80ffea", "#FFA066"],
  194. ax=ax,
  195. fill=True,
  196. alpha=0.4,
  197. lw=2,
  198. )
  199. sns.lineplot(
  200. data=data,
  201. x="day",
  202. y="error",
  203. units="sub",
  204. estimator=None,
  205. color="k",
  206. alpha=0.5,
  207. ax=ax,
  208. )
  209. ax.set_xticks([1, 2])
  210. ax.set_xticklabels(["Day1 Early", "Day2 Early"], fontsize=12, fontweight="bold")
  211. ax.set_ylabel("Angular error", fontsize=12, fontweight="bold")
  212. ax.set_xlabel("")
  213. ax.set_title(pval_asterisks, fontsize=16, fontweight="bold")
  214. sns.despine()
  215. for bar, c in zip(ax.patches, ["darkcyan", "#FFA066"]):
  216. bar.set_edgecolor(c)
  217. bar.set_linewidth(2)
  219. fig.tight_layout()
  220. _savefig(fig, os.path.join(fig_dir, "task_Day1Day2_early_error"))
  223. # ----------------------------
  224. # Eccentricity-behaviour correlation maps
  225. # ----------------------------
  227. def correlation_map(
  228. score: pd.DataFrame,
  229. gradients: pd.DataFrame,
  230. name: str,
  231. fig_dir: str,
  232. sig_style: Optional[str] = None,
  233. lateral_only: bool = False,
  234. angle: str = "hitAngle_hand_good",
  235. plot_maps: bool = True,
  236. ) -> pd.DataFrame:
  237. """Correlate a behavioural score with region eccentricity and plot a surface map.
  239. Parameters
  240. ----------
  241. score
  242. DataFrame with columns ['sub', <angle>], where <angle> is the score column.
  243. gradients
  244. DataFrame with columns ['sub', 'roi', 'roi_ix', 'distance', ...].
  245. name
  246. Prefix for outputs.
  247. fig_dir
  248. Output directory for maps.
  249. sig_style
  250. None (default): plot full r-map with FDR outline.
  251. 'uncorrected': outline uncorrected p<.05.
  252. 'corrected': show only FDR-significant r values.
  253. lateral_only
  254. If True, plot only lateral view for the main map panel.
  255. angle
  256. Column in `score` to correlate against.
  257. plot_maps
  258. If False, compute correlations but skip plotting.
  260. Returns
  261. -------
  262. pd.DataFrame
  263. ROI-wise correlation results with columns ['r', 'p', 'p_fdr'] indexed by ROI.
  264. """
  265. _ensure_dir(fig_dir)
  267. if angle not in score.columns:
  268. raise ValueError(f"Column '{angle}' not found in score DataFrame.")
  270. data = (
  271. gradients[["sub", "roi", "roi_ix", "distance"]]
  272. .pivot(index="sub", columns="roi", values="distance")
  273. )
  274. # preserve original ROI order
  275. data = data[gradients["roi"].unique().tolist()]
  277. # defensive alignment
  278. if not np.array_equal(score["sub"].values, data.index.values):
  279. raise ValueError("Subject ordering mismatch between score and gradients pivot.")
  281. res = data.apply(lambda x: pearsonr(score[angle], x), axis=0)
  282. res = res.T.rename(columns={0: "r", 1: "p"})
  283. _, res["p_fdr"] = pg.multicomp(res["p"].values, method="fdr_bh")
  285. if not plot_maps:
  286. return res
  288. # cortex-only (first 400 ROIs in this project’s ordering)
  289. res_cortex = res.iloc[:400, :].copy()
  291. config = Config()
  292. rvals = plotting.weights_to_vertices(res_cortex["r"], config.atlas)
  293. p_unc = plotting.weights_to_vertices(res_cortex["p"], config.atlas)
  294. p_unc = np.where(p_unc < 0.05, 1, 0)
  295. p_fdr = plotting.weights_to_vertices(res_cortex["p_fdr"], config.atlas)
  296. qvals = np.where(p_fdr < 0.05, 1, 0)
  298. surfaces = get_surfaces()
  299. sulc = plotting.get_sulc()
  300. sulc_params = dict(data=sulc, cmap="gray", cbar=False)
  302. vmax = float(np.nanmax(np.abs(res_cortex["r"])))
  304. cmap = ListedColormap(
  305. np.genfromtxt(os.path.join(config.resources, "colormap.csv"), delimiter=",")
  306. )
  308. if lateral_only:
  309. p1 = Plot(surfaces["lh"], surfaces["rh"], views="lateral", layout="column", size=(250, 350), zoom=1.5)
  310. else:
  311. p1 = Plot(surfaces["lh"], surfaces["rh"])
  312. p2 = Plot(surfaces["lh"], surfaces["rh"], views="dorsal", size=(150, 200), zoom=3.3)
  313. p3 = Plot(surfaces["lh"], surfaces["rh"], views="posterior", size=(150, 200), zoom=3.3)
  315. for p, suffix in zip([p1, p2, p3], ["", "_dorsal", "_posterior"]):
  316. p.add_layer(**sulc_params)
  317. cbar = True if suffix == "_dorsal" else False
  319. if sig_style is None:
  320. p.add_layer(rvals, cbar=cbar, cmap=cmap, color_range=(-vmax, vmax))
  321. p.add_layer((np.nan_to_num(rvals * qvals) != 0).astype(float), cbar=False, as_outline=True, cmap="viridis")
  322. elif sig_style == "uncorrected":
  323. p.add_layer(rvals, cbar=cbar, cmap=cmap, color_range=(-vmax, vmax))
  324. p.add_layer((np.nan_to_num(rvals * p_unc) != 0).astype(float), cbar=False, as_outline=True, cmap="binary")
  325. elif sig_style == "corrected":
  326. x = rvals * qvals
  327. vmin = float(np.nanmin(x[np.abs(x) > 0])) if np.any(np.abs(x) > 0) else -vmax
  328. p.add_layer(x, cbar=cbar, cmap=cmr.get_sub_cmap(cmap, 0.66, 1), color_range=(vmin, vmax))
  329. p.add_layer((np.nan_to_num(rvals * qvals) != 0).astype(float), cbar=False, as_outline=True, cmap="binary")
  330. else:
  331. raise ValueError("sig_style must be one of {None, 'uncorrected', 'corrected'}")
  333. if suffix == "_dorsal":
  334. cbar_kws = dict(location="bottom", decimals=2, fontsize=10, n_ticks=2, shrink=0.4, aspect=4, draw_border=False, pad=0.05)
  335. fig = p.build(cbar_kws=cbar_kws)
  336. else:
  337. fig = p.build()
  339. suffix_out = suffix + ("_corr" if sig_style is None else "")
  340. _savefig(fig, os.path.join(fig_dir, f"{name}_correlation_map{suffix_out}"))
  342. return res
  345. def network_correlation_analysis(gradients: pd.DataFrame, score: pd.DataFrame, angle: str = "hitAngle_hand_good") -> Tuple[pd.DataFrame, pd.DataFrame]:
  346. """Network-level correlation between average eccentricity and behaviour."""
  347. data = gradients.copy()
  348. network_ecc = data.groupby(["sub", "network"])["distance"].mean().reset_index()
  349. data = network_ecc.merge(score, on="sub", how="left")
  351. res = data.groupby(["network"]).apply(lambda x: pg.corr(x["distance"], x[angle]), include_groups=False)
  352. res["p_fdr"] = pg.multicomp(res["p-val"].values, method="fdr_bh")[1]
  353. return res, data
  356. def permute_maps(
  357. data: pd.DataFrame,
  358. parc,
  359. atlas: str = "fsLR",
  360. density: str = "32k",
  361. n_perm: int = 1000,
  362. seed: int = 1234,
  363. p_thresh: float = 0.05,
  364. ) -> Tuple[pd.DataFrame, pd.DataFrame]:
  365. """Perform spin permutations on parcellated correlation data and aggregate by network."""
  366. config = Config()
  367. lh_gii = os.path.join(config.resources, "lh_relabeled.gii")
  368. rh_gii = os.path.join(config.resources, "rh_relabeled.gii")
  370. data = data.reset_index().rename(columns={"index": "roi"})
  371. data["roi_ix"] = np.arange(1, 465).astype(int)
  372. data = parse_roi_names(data)
  373. data = data.iloc[:400, :] # cortex only
  375. surfaces = fetch_atlas(atlas, density)["sphere"]
  376. y = np.asarray(data["r"].values)
  378. spins = nulls.vasa(
  379. data=y,
  380. parcellation=(lh_gii, rh_gii),
  381. n_perm=n_perm,
  382. seed=seed,
  383. surfaces=surfaces,
  384. )
  386. spins_df = pd.concat([data, pd.DataFrame(spins)], axis=1)
  387. network_data = (
  388. spins_df.groupby(["network"]).agg("mean", numeric_only=True).reset_index().drop(columns="roi_ix")
  389. )
  391. nulls_dist = network_data.iloc[:, -n_perm:].values
  392. rvals = network_data["r"].values
  393. pvals = np.array([np.mean(np.abs(nulls_dist[i, :]) >= np.abs(rvals[i])) for i in range(len(rvals))])
  394. p_adj = pg.multicomp(pvals, method="fdr_bh")[1]
  396. significant_networks = p_adj < p_thresh
  397. network_data.insert(4, "pspin", pvals)
  398. network_data.insert(5, "pspin_fdr", p_adj)
  399. network_data.insert(6, "sig", significant_networks.astype(int))
  400. return spins_df, network_data
  403. def plot_behav_corr(
  404. data1: pd.DataFrame,
  405. data2: pd.DataFrame,
  406. prefix1: str,
  407. prefix2: str,
  408. out_dir: str,
  409. linecolor: str = "k",
  410. auto_xticks: bool = True,
  411. auto_yticks: bool = True,
  412. ) -> None:
  413. """Scatterplot correlation between two subject-level measures."""
  414. _ensure_dir(out_dir)
  415. data = pd.merge(data1, data2, on="sub", how="left")
  416. rval, pval = pearsonr(data.iloc[:, -2], data.iloc[:, -1])
  418. fig = sns.lmplot(
  419. x=data.columns[-2],
  420. y=data.columns[-1],
  421. data=data,
  422. scatter_kws={"color": "k", "clip_on": False},
  423. line_kws={"color": linecolor},
  424. facet_kws={"sharex": True},
  425. height=4,
  426. aspect=0.8,
  427. )
  428. if not auto_xticks:
  429. plt.xticks([0, 15, 30, 45])
  430. if not auto_yticks:
  431. plt.yticks([0, 15, 30, 45])
  433. plt.xlabel(prefix1, fontsize=12, fontweight="bold")
  434. plt.ylabel(prefix2, fontsize=12, fontweight="bold")
  435. plt.title(f"r = {rval: .2f}\np = {pval: .4f}", ha="left", fontsize=12, fontweight="bold")
  436. fig.tight_layout()
  438. out = os.path.join(out_dir, f"behavior_{prefix1}_{prefix2}_correlation")
  439. plt.savefig(out, dpi=300, bbox_inches="tight")
  440. plt.close()
  443. # ----------------------------
  444. # Behavioural metrics
  445. # ----------------------------
  447. def behav_metrics(sub_behav: pd.DataFrame, num_bins: int = 6) -> pd.DataFrame:
  448. """Compute epoch-level metrics and summary behavioural scores.
  450. Returns a wide subject table with columns:
  451. D1/D2 early/late, washout, Savings, SavingsRelative, PC1/PC2, etc.
  452. """
  453. epochs = ["early", "late", "washout-early", "washout-late"]
  454. data = sub_behav.copy()
  455. data["epoch"] = ""
  457. mask = data["trial_bin"] <= num_bins
  458. data.loc[mask, "epoch"] = "base"
  460. mask = (15 < data["trial_bin"]) & (data["trial_bin"] <= 15 + num_bins)
  461. data.loc[mask, "epoch"] = "early"
  463. mask = (56 - num_bins <= data["trial_bin"]) & (data["trial_bin"] < 56)
  464. data.loc[mask, "epoch"] = "late"
  466. mask = (56 <= data["trial_bin"]) & (data["trial_bin"] < 56 + num_bins)
  467. data.loc[mask, "epoch"] = "washout-early"
  469. mask = (70 - num_bins < data["trial_bin"]) & (data["trial_bin"] <= 70)
  470. data.loc[mask, "epoch"] = "washout-late"
  472. res = (
  473. data.groupby(["sub", "epoch", "ses"])["error"]
  474. .mean()
  475. .reset_index()
  476. .query("epoch in @epochs")
  477. )
  479. res = (
  480. res.pivot(index="sub", columns=["epoch", "ses"], values="error")
  481. .set_axis(
  482. ["D1 early", "D2 early", "D1 late", "D2 late", "WO1 early", "WO2 early", "WO1 late", "WO2 late"],
  483. axis=1,
  484. )
  485. )
  487. res["Savings"] = res["D1 early"] - res["D2 early"]
  488. res["SavingsRelative"] = (((res["D1 early"].abs()) - (res["D2 early"].abs())) / (res["D1 early"].abs())) * 100
  490. pca = PCA(n_components=2)
  491. PCs = pca.fit_transform(res)
  492. res["PC1"] = -PCs[:, 0]
  493. res["PC2"] = PCs[:, 1]
  495. # optional transformations used in downstream plots
  496. res["WO1 early"] = res["WO1 early"].abs()
  497. res["WO2 early"] = res["WO2 early"].abs()
  499. return res.reset_index()
  502. def add_recall_ratio(df: pd.DataFrame, rotation_deg: float = 45.0, eps: float = 1e-6, min_learned_deg: float = 5.0) -> pd.DataFrame:
  503. """Tsay-style recall ratio using adaptation magnitude rather than error."""
  504. e1 = df["D1 late"].abs()
  505. e2 = df["D2 early"].abs()
  507. adapt_d1_late = np.clip(rotation_deg - e1, 0.0, rotation_deg)
  508. adapt_d2_early = np.clip(rotation_deg - e2, 0.0, rotation_deg)
  510. df["Adapt_D1Late"] = adapt_d1_late
  511. df["Adapt_D2Early"] = adapt_d2_early
  513. rr = adapt_d2_early / (adapt_d1_late + eps)
  514. if min_learned_deg is not None:
  515. rr = rr.where(adapt_d1_late >= min_learned_deg, np.nan)
  517. df["RecallRatio"] = rr
  518. return df
  521. def add_learner_groups(df: pd.DataFrame, metric: str = "FPC1") -> pd.DataFrame:
  522. """Add fast vs slow learner grouping by median split on a behavioural metric."""
  523. if metric not in df.columns:
  524. raise ValueError(f"Metric '{metric}' not found in df.columns")
  525. median_val = df[metric].median()
  526. df["LearnerGroup"] = np.where(df[metric] >= median_val, "fast", "slow")
  527. return df
  530. def plot_learning_curves_by_group(sub_behav: pd.DataFrame, fig_dir: str, name: str = "task_plot_fast_vs_slow") -> None:
  531. """Plot group-average error across the task for fast vs slow learners."""
  532. _ensure_dir(fig_dir)
  533. fig, axs = plt.subplots(1, 2, figsize=(8, 4))
  534. data = sub_behav.query("ses == 'ses-01'")
  535. ax = axs[0]
  536. sns.lineplot(
  537. data=data,
  538. x="trial_bin",
  539. y="error",
  540. hue="LearnerGroup",
  541. errorbar=("ci", 68),
  542. linewidth=1.5,
  543. ax=ax,
  544. )
  545. ax.axhline(0, lw=1, c="k", ls="--")
  546. ax.set_xlabel("Trial bin", fontsize=12, fontweight="bold")
  547. ax.set_ylabel("Angular error (°)", fontsize=12, fontweight="bold")
  548. data = sub_behav.query("ses == 'ses-02'")
  549. ax = axs[1]
  550. sns.lineplot(
  551. data=data,
  552. x="trial_bin",
  553. y="error",
  554. hue="LearnerGroup",
  555. errorbar=("ci", 68),
  556. linewidth=1.5,
  557. ax=ax,
  558. )
  559. ax.axhline(0, lw=1, c="k", ls="--")
  560. ax.set_xlabel("Trial bin", fontsize=12, fontweight="bold")
  561. ax.set_ylabel("Angular error (°)", fontsize=12, fontweight="bold")
  562. sns.despine()
  563. fig.tight_layout()
  564. _savefig(fig, os.path.join(fig_dir, name))
  566. def plot_region_correlations(epoch_gradients, score, fig_dir, epoch, col='FPC1', suffix=''):
  567. """Plot scatterplot for exemplar regions
  569. Parameters
  570. ----------
  571. gradients : pd.DataFrame
  572. Subject-level gradients dataset with distance column
  573. error : _type_
  574. Subject-level median error data
  575. """
  576. # pre-determined regions
  577. rois = {
  578. 'ses-01_early-corrected': ['7Networks_RH_Default_pCunPCC_5'],
  579. 'ses-02_early-corrected': ['7Networks_RH_Default_PFCdPFCm_3'],
  580. 'ses-01_WOearly-corrected': ['7Networks_RH_Default_pCunPCC_5'],
  581. 'ses-02_WOearly-corrected': ['7Networks_RH_Default_PFCdPFCm_3']
  582. }
  584. cmap = plotting.yeo_cmap(networks=7)
  585. roi = rois[epoch]
  586. df = epoch_gradients.query("roi in @roi")
  587. df = df.merge(score, left_on='sub', right_on='sub')
  588. df['roi'] = df['roi'].str.replace('7Networks_', '')
  589. g = sns.lmplot(x='distance', y=col, col='roi', data=df, hue='network',
  590. scatter_kws={'clip_on': False}, palette=cmap, legend=False,
  591. facet_kws={'sharex': False}, height=2.3, aspect=.8, )
  592. g.set_xlabels('Eccentricity')
  593. g.set_ylabels('FPCA score')
  594. g.set(ylim=(-3, 2), yticks=np.arange(-3, 3, 1))
  595. g.tight_layout()
  596. g.savefig(os.path.join(fig_dir, f'{epoch}_example_roi_correlations{suffix}'))
  598. def plot_savings_by_group(df: pd.DataFrame, fig_dir: str, metric: str = "Savings") -> None:
  599. """Compare savings between fast and slow learners."""
  600. _ensure_dir(fig_dir)
  601. fig, ax = plt.subplots(figsize=(4, 4))
  602. sns.boxplot(
  603. data=df,
  604. x="LearnerGroup",
  605. y=metric,
  606. palette=["red", "green"],
  607. hue="LearnerGroup",
  608. showfliers=False,
  609. ax=ax,
  610. )
  611. sns.stripplot(data=df, x="LearnerGroup", y=metric, color="k", alpha=0.7, ax=ax)
  612. ax.set_xlabel("")
  613. ax.set_ylabel(metric, fontsize=12, fontweight="bold")
  614. sns.despine()
  615. fig.tight_layout()
  616. _savefig(fig, os.path.join(fig_dir, f"{metric}_fast_vs_slow"))
  618. def plot_permute_maps(data, out_dir, n_perm=1000, p_thresh=.05):
  619. """
  620. Plots permutation test results for brain network correlations.
  622. Args:
  623. data (pd.DataFrame): DataFrame containing neuroimaging stats.
  624. Expected columns include:
  625. - 'network': Names of the brain networks (e.g., Yeo 7 networks).
  626. - 'r': Observed correlation values.
  627. - 'pspin_fdr': FDR-corrected p-values from permutation testing.
  628. - Last n_perm columns: Null distribution values for each network.
  629. out_dir (str): Path (including filename and extension) where the
  630. resulting figure will be saved.
  631. n_perm (int, optional): Number of permutation columns to include from
  632. the end of the DataFrame. Defaults to 1000.
  633. p_thresh (float, optional): Significance threshold for coloring observed
  634. points. Points <= p_thresh are red; otherwise blue. Defaults to 0.05.
  636. Returns:
  637. None: The figure is saved to the specified directory.
  638. """
  639. rvals = data['r'].values
  640. pspin_fdr = data['pspin_fdr'].values
  642. # Scale and prepare null distribution data
  643. nulls = pd.DataFrame(1.8 * data.iloc[:, -n_perm:].values)
  644. nulls_dist = pd.concat([data.iloc[:, 0], nulls], axis=1)
  645. melted_data = pd.melt(pd.DataFrame(nulls_dist), id_vars='network')
  647. cmap = plotting.yeo_cmap(networks=7)
  648. fig = plt.figure(figsize=(5, 5))
  650. sns.boxplot(data=melted_data, x='network', y='value', whis=[0, 100],
  651. palette=cmap, hue='network', saturation=.8, width=.5)
  653. # Overlay real correlation values as points
  654. for i, r in enumerate(rvals):
  655. # Color based on FDR-corrected p-values
  656. color = 'red' if pspin_fdr[i] <= p_thresh else 'blue'
  657. plt.plot(i, r, color=color, marker='o', markersize=5, zorder=5)
  659. plt.axhline(0, color='blue', linestyle='dashed', zorder=-1)
  660. plt.grid(axis='x', linestyle='--', alpha=0.5)
  661. plt.xticks(range(len(data)), data['network'], rotation=90,
  662. ha='center', fontsize=12, fontweight='bold')
  664. plt.tick_params(axis='x', which='both', bottom=False, top=False)
  665. sns.despine(bottom=True)
  666. plt.xlabel('')
  667. plt.ylabel('Correlation (r)', fontsize=12, fontweight='bold')
  669. plt.tight_layout()
  670. fig.savefig(out_dir)
  671. # ----------------------------
  672. # Script entry
  673. # ----------------------------
  675. def main() -> None:
  676. config = Config()
  678. # Apply lab plotting style only when running as a script
  679. plotting.set_plotting()
  681. fig_dir = os.path.join(config.figures, "behaviour")
  682. _ensure_dir(fig_dir)
  684. sub_behav = pd.read_csv(os.path.join(config.resources, "subject_behavior_bin.csv"))
  685. sub_behav["error"] = (sub_behav["error"] * 180) / np.pi # radians -> degrees
  687. num_bins = 6
  688. df = behav_metrics(sub_behav, num_bins)
  690. fpca_score = pd.read_table(os.path.join(config.results, "fpca", "D1D2-17bases_angular_error_bin.tsv"))
  691. df = pd.merge(df, fpca_score, on="sub", how="left")
  693. df = add_recall_ratio(df) # uses D1 late, D2 early
  694. df = add_learner_groups(df, metric="FPC1") # or 'Savings'
  696. sub_behav = pd.merge(sub_behav, df[["sub", "LearnerGroup"]], on="sub", how="left")
  698. df.to_csv(os.path.join(config.results, f"behav_bin-{num_bins}bins.csv"), index=False)
  700. task_behaviour_plot(sub_behav, fig_dir)
  702. df["D1D2 early"] = df[["D1 early", "D2 early"]].mean(axis=1)
  703. plot_early_error_change(df, fig_dir)
  705. gradients = pd.read_table(os.path.join(config.results, "subject_gradients.tsv"))
  707. # Baseline eccentricity per subject, per ROI
  708. day1base = gradients.query('epoch == "base" & ses == "ses-01"')[["sub", "roi", "distance"]]
  709. day2base = gradients.query('epoch == "base" & ses == "ses-02"')[["sub", "roi", "distance"]]
  711. # Behavioural distributions & relationships
  712. plot_learning_curves_by_group(sub_behav, fig_dir)
  713. plot_savings_by_group(df, fig_dir)
  715. for col in ["FPC1", "RecallRatio"]:
  716. plot_behav_distribution(df[["sub", col]], fig_dir, name=col, angle=col, auto_ticks=True)
  718. plot_behav_corr(df[["sub", "D1 early"]], df[["sub", "D2 early"]], "D1 early", "D2 early", fig_dir, auto_xticks=False, auto_yticks=False)
  720. plot_behav_corr(df[["sub", "WO1 early"]], df[["sub", "FPC1"]], "abs WO1 early", "FPC1", fig_dir, auto_xticks=False)
  721. plot_behav_corr(df[["sub", "WO2 early"]], df[["sub", "FPC1"]], "abs WO2 early", "FPC1", fig_dir, auto_xticks=False)
  722. plot_behav_corr(df[["sub", "WO1 early"]], df[["sub", "WO2 early"]], "abs WO1 early", "abs WO2 early", fig_dir, auto_xticks=False, auto_yticks=False)
  724. plot_behav_corr(df[["sub", "D1 early"]], df[["sub", "FPC1"]], "D1 early", "FPC1", fig_dir, auto_xticks=False)
  725. plot_behav_corr(df[["sub", "D2 early"]], df[["sub", "FPC1"]], "D2 early", "FPC1", fig_dir, auto_xticks=False)
  727. plot_behav_corr(df[["sub", "Savings"]], df[["sub", "FPC1"]], "Saving", "FPC1", fig_dir)
  728. plot_behav_corr(df[["sub", "Savings"]], df[["sub", "RecallRatio"]], "Saving", "RecallRatio", fig_dir)
  729. plot_behav_corr(df[["sub", "FPC1"]], df[["sub", "RecallRatio"]], "FPC1", "RecallRatio", fig_dir)
  731. # Eccentricity–behaviour correlation maps (baseline-corrected eccentricity)
  733. n_perm = 1000
  735. # Day 1 early
  736. ses = "ses-01"
  737. epoch_gradients = gradients.query('epoch == "early" & ses == @ses').copy()
  738. epoch_gradients = epoch_gradients.merge(day1base, on=["sub", "roi"], how="left", suffixes=("", "_base"))
  739. epoch_gradients["distance"] = epoch_gradients["distance"] - epoch_gradients["distance_base"]
  740. epoch_gradients.drop(columns=["distance_base"], inplace=True)
  742. score = df[["sub", "FPC1"]]
  743. res = correlation_map(score, epoch_gradients, f"{ses}_early-corrected_fpca-score", fig_dir, angle="FPC1", sig_style="uncorrected")
  744. res.reset_index().to_csv(os.path.join(config.results, f"{ses}_early-corrected_fpca-score_correlations.tsv"), index=False, sep="\t")
  746. _, network_spins = permute_maps(res, parc=config.atlas, n_perm=n_perm)
  747. network_spins.to_csv(os.path.join(config.results, f"{ses}_early-corrected_fpca-score_spins.tsv"), index=False, sep="\t")
  748. plot_region_correlations(epoch_gradients, score, fig_dir, epoch='ses-01_early-corrected')
  749. prefix = os.path.join(fig_dir, f'{ses}_early-corrected_fpca-score_permute_maps_boxplot')
  750. plot_permute_maps(network_spins, prefix, n_perm)
  751. # Day 2 early
  752. ses = "ses-02"
  753. epoch_gradients = gradients.query('epoch == "early" & ses == @ses').copy()
  754. epoch_gradients = epoch_gradients.merge(day2base, on=["sub", "roi"], how="left", suffixes=("", "_base"))
  755. epoch_gradients["distance"] = epoch_gradients["distance"] - epoch_gradients["distance_base"]
  756. epoch_gradients.drop(columns=["distance_base"], inplace=True)
  758. res = correlation_map(score, epoch_gradients, f"{ses}_early-corrected_fpca-score", fig_dir, angle="FPC1", sig_style="uncorrected")
  759. res.reset_index().to_csv(os.path.join(config.results, f"{ses}_early-corrected_fpca-score_correlations.tsv"), index=False, sep="\t")
  761. _, network_spins = permute_maps(res, parc=config.atlas, n_perm=n_perm)
  762. network_spins.to_csv(os.path.join(config.results, f"{ses}_early-corrected_fpca-score_spins.tsv"), index=False, sep="\t")
  763. plot_region_correlations(epoch_gradients, score, fig_dir, epoch='ses-02_early-corrected')
  764. prefix = os.path.join(fig_dir, f'{ses}_early-corrected_fpca-score_permute_maps_boxplot')
  765. plot_permute_maps(network_spins, prefix, n_perm)
  767. # Day 1 WOearly
  768. ses = "ses-01"
  769. epoch_gradients = gradients.query('epoch == "washout-early" & ses == @ses').copy()
  770. epoch_gradients = epoch_gradients.merge(day1base, on=["sub", "roi"], how="left", suffixes=("", "_base"))
  771. epoch_gradients["distance"] = epoch_gradients["distance"] - epoch_gradients["distance_base"]
  772. epoch_gradients.drop(columns=["distance_base"], inplace=True)
  774. score = df[["sub", "FPC1"]]
  775. res = correlation_map(score, epoch_gradients, f"{ses}_WOearly-corrected_fpca-score", fig_dir, angle="FPC1", sig_style="uncorrected")
  776. res.reset_index().to_csv(os.path.join(config.results, f"{ses}_WOearly-corrected_fpca-score_correlations.tsv"), index=False, sep="\t")
  778. _, network_spins = permute_maps(res, parc=config.atlas, n_perm=n_perm)
  779. network_spins.to_csv(os.path.join(config.results, f"{ses}_WOearly-corrected_fpca-score_spins.tsv"), index=False, sep="\t")
  780. plot_region_correlations(epoch_gradients, score, fig_dir, epoch='ses-01_WOearly-corrected')
  781. prefix = os.path.join(fig_dir, f'{ses}_WOearly-corrected_fpca-score_permute_maps_boxplot')
  782. plot_permute_maps(network_spins, prefix, n_perm)
  783. # Day 2 WOearly
  784. ses = "ses-02"
  785. epoch_gradients = gradients.query('epoch == "washout-early" & ses == @ses').copy()
  786. epoch_gradients = epoch_gradients.merge(day2base, on=["sub", "roi"], how="left", suffixes=("", "_base"))
  787. epoch_gradients["distance"] = epoch_gradients["distance"] - epoch_gradients["distance_base"]
  788. epoch_gradients.drop(columns=["distance_base"], inplace=True)
  790. res = correlation_map(score, epoch_gradients, f"{ses}_WOearly-corrected_fpca-score", fig_dir, angle="FPC1", sig_style="uncorrected")
  791. res.reset_index().to_csv(os.path.join(config.results, f"{ses}_WOearly-corrected_fpca-score_correlations.tsv"), index=False, sep="\t")
  793. _, network_spins = permute_maps(res, parc=config.atlas, n_perm=n_perm)
  794. network_spins.to_csv(os.path.join(config.results, f"{ses}_WOearly-corrected_fpca-score_spins.tsv"), index=False, sep="\t")
  795. plot_region_correlations(epoch_gradients, score, fig_dir, epoch='ses-02_WOearly-corrected')
  796. prefix = os.path.join(fig_dir, f'{ses}_WOearly-corrected_fpca-score_permute_maps_boxplot')
  797. plot_permute_maps(network_spins, prefix, n_perm)
  798. # Recall Ratio with baseline corrected eccentricity - D1 late
  799. ses = "ses-01"
  800. epoch_gradients = gradients.query('epoch == "late" & ses == @ses').copy()
  801. epoch_gradients = epoch_gradients.merge(day1base, on=["sub", "roi"], how="left", suffixes=("", "_base"))
  802. epoch_gradients["distance"] = epoch_gradients["distance"] - epoch_gradients["distance_base"]
  803. epoch_gradients.drop(columns=["distance_base"], inplace=True)
  805. score_rr = df[["sub", "RecallRatio"]]
  806. res = correlation_map(score_rr, epoch_gradients, f"{ses}_late-corrected_recall_ratio", fig_dir, angle="RecallRatio", sig_style="uncorrected")
  807. res.reset_index().to_csv(os.path.join(config.results, f"{ses}_late-corrected_recall_ratio_correlations.tsv"), index=False, sep="\t")
  809. _, network_spins = permute_maps(res, parc=config.atlas, n_perm=n_perm)
  810. network_spins.to_csv(os.path.join(config.results, f"{ses}_late-corrected_recall_ratio_spins.tsv"), index=False, sep="\t")
  811. prefix = os.path.join(fig_dir, f'{ses}_late-corrected_recall_ratio_permute_maps_boxplot')
  812. plot_permute_maps(network_spins, prefix, n_perm)
  814. if __name__ == "__main__":
  815. main()

behaviour.py at commit d936893, under MIT · at the source

Overview

Authors: Ali Rezaei1, Corson N. Areshenkoff1,2, Daniel J. Gale1, Emily R. Oby1,3, Jonathan Smallwood1,2, J. Randall Flanagan1,2, Jeffrey D. Wammes1,2, Jason P. Gallivan1,2,3
ORCID iDs: Ali Rezaei, Jason P. Gallivan
  1. Centre for Neuroscience Studies, Queen’s University, Kingston, Ontario, Canada
  2. Department of Psychology, Queen’s University, Kingston, Ontario, Canada
  3. Department of Biomedical and Molecular Sciences, Queen’s University, Kingston, Ontario, Canada
Institutions: Queen's University (Canada)
Journal: PLoS biology, volume 24, issue 3, article e3003684
Dates: received 6 November 2025; accepted 18 February 2026; published online 10 March 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1371/journal.pbio.3003684 · PMID 41805913 · PMCID PMC12974888 · OpenAlex W7134978557
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: fMRI (modality), human (organism), cognitive (subfield)
Methods: Spectral & time-frequency, Connectivity, Statistics, Smoothing, state filtering, decompositions, Machine learning, Preprocessing, fMRI & imaging
MeSH: Brain*, Learning*, Memory*, Mental Recall*, Nerve Net*, Adult, Brain Mapping, Female, Humans, Magnetic Resonance Imaging, Male, Young Adult (* major topic)
Journal subjects: Biology and Life Sciences, Neuroscience, Cognitive Science, Cognitive Psychology, Learning, Psychology, Social Sciences, Learning and Memory, Cognition, Memory, Physical Sciences, Mathematics, Topology, Manifolds, Perception, Sensory Perception, Computer and Information Sciences, Neural Networks, Memory Recall, Learning Curves, Brain Mapping
Topic: Motor Control and Adaptation (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Canadian Institutes of Health Research (PJT175012); Natural Sciences and Engineering Research Council of Canada (RGPIN-2017-04684)
Citations: not cited yet (Europe PMC); 167 references in the paper
Research resources: RRID:SCR_001362, RRID:SCR_001847, RRID:SCR_002438, 133 RRID:SCR_002502, RRID:SCR_002823, distributed with ANTs 2.2.0 [136 RRID:SCR_004757, RRID:SCR_005927, 131 RRID:SCR_016216

Abstract

Motor learning induces alterations in neural activity that can persist long after the effects of such learning have faded. These persistent neural alterations are thought to manifest behaviorally as “savings,” or faster relearning, via access to a latent motor memory. How the human brain forms and retrieves these latent memories, and the specific neural systems involved, remains unresolved. Here, using human functional MRI and a two-day sensorimotor adaptation paradigm, we show that savings are associated with the reinstatement of a large-scale cortical manifold structure formed during initial learning. Notably, this neural reinstatement effect was not observed across sensorimotor systems but was localized to regions of the default mode network (DMN). Moreover, the specific dynamics of DMN activity were linked to inter-subject differences in patterns of learning and relearning across days. These results suggest that motor savings arises from the re-expression of DMN activity patterns associated with initial learning, establishing a key role for this network in motor memory formation and retrieval. This finding, paralleling reinstatement principles from other memory domains (episodic memory, fear conditioning) and anticipated by recent computational models of motor learning, suggests a common mechanism for the flexible recall and reuse of stored memories across diverse behavioral contexts.

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

Zenodo 18612771

License: MIT
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Data Availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (14 files), pandas (14 files), Matplotlib (11 files), seaborn (8 files), BrainSpace (4 files), Pingouin (4 files), scikit-learn (4 files), neuromaps (3 files), SciPy (3 files), Brain Connectivity Toolbox (2 files), NiBabel (2 files), Nilearn (2 files), pyRiemann (2 files), UMAP (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers (HTTP 200)
  • 30 September 2026: the link answers (HTTP 200)
21 files
At the source: doi.org/10.5281/zenodo.18612771

alirzar/motorsaving

License: MIT
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: d936893e7dd8a8c2d1807582ddaa0bbc9bacbaf8, 11 February 2026
Languages: Python (19)
Size: 22 files, 19 scripts
Software Heritage: not archived
Found in: the text, “Software”
Holds: README, license file, environment (environment.yml, setup.py)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (14 files), pandas (14 files), Matplotlib (11 files), seaborn (8 files), BrainSpace (4 files), Pingouin (4 files), scikit-learn (4 files), neuromaps (3 files), SciPy (3 files), Brain Connectivity Toolbox (2 files), NiBabel (2 files), Nilearn (2 files), pyRiemann (2 files), UMAP (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
21 files
At the source: github.com/alirzar/motorsaving

danjgale/surfplot

License: BSD-3-Clause
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 60c50008bcd0f58e1c132cb7d70aab9151911925, 18 November 2025
Languages: Python (22), Jupyter (8)
Size: 133 files, 30 scripts
Software Heritage: archived
Found in: the references
Holds: README, license file, environment (pyproject.toml, requirements.txt, docs/requirements.txt), documentation, 8 notebooks
Not found: CITATION.cff, tests, continuous integration
Tools: neuromaps (21 files), BrainSpace (9 files), Matplotlib (8 files), NumPy (7 files), NiBabel (4 files), Nilearn (3 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
32 files
At the source: github.com/danjgale/surfplot

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:

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

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

Data

Datasets cited

Data Availability

The underlying numerical data for figures are provided in S1 Data and archived on Zenodo (https://doi.org/10.5281/zenodo.18613054). Raw behavioral and imaging data (including T1w and functional scans) are openly available on OpenNeuro (https://doi.org/10.18112/openneuro.ds005598.v1.0.3). The analysis code is archived on Zenodo (DOI: https://doi.org/10.5281/zenodo.18612771).

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, 30 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 8 authors, 12 MeSH terms, 2 funders, 148 references, 8 RRIDs.

Cite

This paper

Rezaei, A., Areshenkoff, C. N., Gale, D. J., Oby, E. R., Smallwood, J., Flanagan, J. R., Wammes, J. D., & Gallivan, J. P. (2026). The retrieval of previously learned motor memories is facilitated by the reinstatement of default mode network manifold structures. PLoS biology, 24(3), e3003684. https://doi.org/10.1371/journal.pbio.3003684

BibTeX

@article{rezaei2026retrieval,
author = {Rezaei, Ali and Areshenkoff, Corson N. and Gale, Daniel J. and Oby, Emily R. and Smallwood, Jonathan and Flanagan, J. Randall and Wammes, Jeffrey D. and Gallivan, Jason P.},
title = {{The retrieval of previously learned motor memories is facilitated by the reinstatement of default mode network manifold structures}},
journal = {PLoS biology},
year = {2026},
month = mar,
volume = {24},
number = {3},
pages = {e3003684},
publisher = {PLOS},
issn = {1544-9173},
doi = {10.1371/journal.pbio.3003684},
url = {https://doi.org/10.1371/journal.pbio.3003684},
pmid = {41805913},
pmcid = {PMC12974888}
}

RIS

TY - JOUR
AU - Rezaei, Ali
AU - Areshenkoff, Corson N.
AU - Gale, Daniel J.
AU - Oby, Emily R.
AU - Smallwood, Jonathan
AU - Flanagan, J. Randall
AU - Wammes, Jeffrey D.
AU - Gallivan, Jason P.
TI - The retrieval of previously learned motor memories is facilitated by the reinstatement of default mode network manifold structures
T2 - PLoS biology
J2 - PLoS Biol
PY - 2026
DA - 2026/03/10
VL - 24
IS - 3
SP - e3003684
SN - 1544-9173
PB - PLOS
DO - 10.1371/journal.pbio.3003684
UR - https://doi.org/10.1371/journal.pbio.3003684
LA - en
ER -

CSL-JSON

{
"id": "10.1371/journal.pbio.3003684",
"type": "article-journal",
"title": "The retrieval of previously learned motor memories is facilitated by the reinstatement of default mode network manifold structures",
"container-title": "PLoS biology",
"author": [
{
"family": "Rezaei",
"given": "Ali"
},
{
"family": "Areshenkoff",
"given": "Corson N."
},
{
"family": "Gale",
"given": "Daniel J."
},
{
"family": "Oby",
"given": "Emily R."
},
{
"family": "Smallwood",
"given": "Jonathan"
},
{
"family": "Flanagan",
"given": "J. Randall"
},
{
"family": "Wammes",
"given": "Jeffrey D."
},
{
"family": "Gallivan",
"given": "Jason P."
}
],
"container-title-short": "PLoS Biol",
"volume": "24",
"issue": "3",
"page": "e3003684",
"DOI": "10.1371/journal.pbio.3003684",
"PMID": "41805913",
"PMCID": "PMC12974888",
"ISSN": "1544-9173",
"publisher": "PLOS",
"URL": "https://doi.org/10.1371/journal.pbio.3003684",
"language": "en",
"issued": {
"date-parts": [
[
2026,
3,
10
]
]
}
}

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

Similar papers

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

[1] doi:10.7554/elife.103097 [code]
Canonical neurodevelopmental trajectories of structural and functional manifolds.
Journal: eLife
In common: neuromaps, BrainSpace, Brain Connectivity Toolbox, 7 other tools, 18 references
[2] doi:10.1038/s41467-026-71151-2 [code]
Common and distinct neural correlates of social interaction processing and theory of mind in narratives.
Journal: Nature communications
In common: Brain Connectivity Toolbox, UMAP, Nilearn, 7 other tools, cognitive, 12 references
[3] doi:10.1371/journal.pbio.3003755 [code]
Action information is integrated into entorhinal representations of conceptual space and is reflected in eye movements.
Journal: PLoS biology
In common: Nilearn, NiBabel, seaborn, 4 other tools, cognitive, 15 references
[4] doi:10.1038/s41467-026-71428-6 [code]
Binding items to contexts through conjunctive neural representations with the method of loci.
Journal: Nature communications
In common: Nilearn, NiBabel, seaborn, 5 other tools, 15 references
[5] doi:10.1038/s41531-026-01354-3 [code]
Neuromodulation-induced normalization of cortical metastable dynamics signatures in Parkinson's disease.
Journal: NPJ Parkinson's disease
In common: neuromaps, BrainSpace, Nilearn, 7 other tools, 10 references
[6] doi:10.1523/eneuro.0370-25.2026 [code]
Pretraining for Large-Scale Functional Connectome Fingerprinting Supports Generalization and Transfer Learning in Functional Neuroimaging.
Journal: eNeuro
In common: Nilearn, scikit-learn, pandas, 2 other tools, fMRI, 16 references
[7] doi:10.7554/elife.107423 [code]
A context-free model of savings in motor learning.
Journal: eLife
In common: seaborn, scikit-learn, pandas, 3 other tools, 10 references
[8] doi:10.1038/s41398-026-04025-2 [code]
Brain energetic landscapes shape state dysregulation in major depressive disorder: a morphological network controllability perspective.
Journal: Translational psychiatry
In common: neuromaps, BrainSpace, Brain Connectivity Toolbox, 9 other tools, 5 references
[9] doi:10.1038/s41467-026-71270-w [code]
Spatiotemporal dynamics of the human cortical functional hierarchy across the lifespan.
Journal: Nature communications
In common: BrainSpace, Nilearn, NiBabel, 6 other tools, fMRI, 9 references
[10] doi:10.1162/netn.a.547 [code]
An evaluation of the efficacy of single-echo and multi-echo fMRI denoising strategies.
Journal: Network neuroscience (Cambridge, Mass.)
In common: Nilearn, NiBabel, seaborn, 5 other tools, fMRI, 11 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.