OSCR

Neural signatures of model-based and model-free reinforcement learning across prefrontal cortex and striatum.

Code ↔ Paper

7 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 7 matches
  1. [1] § Materials and methods › Decoding analysis ↔ Fig7. ExploreExploit.py, lines 26–171 · score 0.82 · cross validation, sklearn.svm.LinearSVC, scikit-learn, folds, stratified, selection
  2. [2] § Materials and methods › Population-level encoding ↔ Maths.py, lines 72–141 · score 0.72 · reduced model, full model, design matrix, SSE, variance, squared
  3. [3] § Materials and methods › Decoding analysis ↔ Fig6. Choice encoding.py, lines 71–141 · score 0.72 · cross validation, scikit-learn, folds, stratified, sklearn, selection
  4. [4] § Results › ACC and caudate encoded MB value estimates ↔ Fig4. Qvalue Coding.py, lines 101–136 · score 0.62 · PicA, PicB, peak CPD, MF, MB, Figure 4
  5. [5] § Results › Explore/exploit strategy modulates encoding of first-stage choice ↔ Fig7. ExploreExploit.py, lines 26–171 · score 0.58 · consecutive high rewards, medium rewards, exploit, decoder, split, permutations
  6. [6] § Results › ACC and caudate encoded MB value estimates ↔ Fig4. Qvalue Coding.py, lines 101–136 · score 0.58 · PicA, PicB, peak CPD, population, MF, MB
  7. [7] § Results › Caudate value estimates remapped following a rare transition ↔ ImportData.py, lines 240–334 · score 0.55 · unchosen option, hybrid, models, behaviour, transition, encoding

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 · 331 lines · 13 KB · MIT · 2 matches

  1. import os
  2. import sys
  3. import inspect
  4. import numpy as np
  5. import sklearn.model_selection
  6. import sklearn.svm
  7. import matplotlib.pyplot as plt
  8. import matplotlib
  9. import time
  10. import Details as D
  11. import ImportData
  12. import Plot
  13. import Maths
  15. # Configuration
  16. N_SPLITS = 5
  17. N_REPEATS = 1
  18. N_SAMPLES = 20
  19. RESOLUTION = 1 # Take every nth time point
  20. RANDOM_SEED = 0 # Seed for reproducibility
  22. # Set random seed for reproducibility
  23. np.random.seed(RANDOM_SEED)
  26. class NeuralDecoder:
  27. """Handles neural decoding analysis for explore/exploit conditions."""
  29. def __init__(self, n_splits=N_SPLITS, n_repeats=N_REPEATS):
  30. self.decoder = sklearn.svm.LinearSVC(max_iter=25000)
  31. self.n_splits = n_splits
  32. self.n_repeats = n_repeats
  34. def prepare_data(self, data, task_variable, resolution=RESOLUTION):
  35. """
  36. Prepare neural and behavioral data for decoding.
  38. Args:
  39. data: ImportData object containing neural recordings
  40. task_variable: String indicating which behavioral variable to decode ('c1dir' or 'c1chosen')
  41. resolution: Temporal resolution (take every nth time point)
  43. Returns:
  44. neural_data_all: List of neural responses per cell
  45. labels_all: List of behavioral labels per cell
  46. high_reward_masks: List of boolean masks for high reward trials
  47. low_reward_masks: List of boolean masks for low/medium reward trials
  48. min_trials: Minimum number of trials per condition
  49. """
  50. min_trials = 10000
  51. neural_data_all = []
  52. labels_all = []
  53. high_reward_masks = []
  54. low_reward_masks = []
  56. for cell_idx in range(data.n):
  57. trial_data = data.behavdata[cell_idx]
  59. # Define high reward (2 consecutive high rewards) and low reward conditions
  60. high_reward_mask = (trial_data.previousreward == 2) & (trial_data.previouspreviousreward == 2)
  61. low_reward_mask = (trial_data.previousreward != 2) & (trial_data.previouspreviousreward != 2)
  63. # Get neural responses and task labels
  64. neural_response = data.generate_epoch_norm(cell_idx, D.sc_choice1made)
  65. neural_response = neural_response[:, ::resolution]
  67. if task_variable == 'c1dir':
  68. labels = trial_data.c1dir
  69. elif task_variable == 'c1chosen':
  70. labels = trial_data.c1chosen
  71. else:
  72. raise ValueError(f"Unknown task variable: {task_variable}")
  74. # Calculate minimum trials per condition
  75. high_min = min([np.sum(labels[high_reward_mask] == label)
  76. for label in np.unique(labels)])
  77. low_min = min([np.sum(labels[low_reward_mask] == label)
  78. for label in np.unique(labels)])
  79. cell_min_trials = min(high_min, low_min)
  81. if cell_min_trials < min_trials:
  82. min_trials = cell_min_trials
  84. neural_data_all.append(neural_response)
  85. labels_all.append(labels)
  86. high_reward_masks.append(high_reward_mask)
  87. low_reward_masks.append(low_reward_mask)
  89. return neural_data_all, labels_all, high_reward_masks, low_reward_masks, min_trials
  91. def run_cross_validated_decoding(self, data, neural_data_all, labels_all,
  92. high_reward_masks, low_reward_masks,
  93. min_trials, n_samples=N_SAMPLES):
  94. """
  95. Run cross-validated decoding for multiple random samples.
  97. Args:
  98. data: ImportData object
  99. neural_data_all: List of neural responses
  100. labels_all: List of behavioral labels
  101. high_reward_masks: List of high reward trial masks
  102. low_reward_masks: List of low reward trial masks
  103. min_trials: Minimum trials to use per condition
  104. n_samples: Number of random samples to run
  106. Returns:
  107. high_reward_accuracy: Accuracy for high reward (exploit) trials
  108. low_reward_accuracy: Accuracy for low reward (explore) trials
  109. """
  110. n_timepoints = data.numTimepoints // RESOLUTION
  111. n_unique_labels = len(np.unique(labels_all[0]))
  113. high_reward_accuracy = np.empty((n_timepoints, n_samples))
  114. low_reward_accuracy = np.empty((n_timepoints, n_samples))
  116. for sample_idx in range(n_samples):
  117. cv_splitter = sklearn.model_selection.RepeatedStratifiedKFold(
  118. n_splits=self.n_splits,
  119. n_repeats=self.n_repeats,
  120. random_state=sample_idx
  121. )
  123. print(f' Sample {sample_idx + 1}/{n_samples}')
  125. # Prepare population data
  126. high_reward_pop = np.empty((data.n, n_unique_labels, min_trials, n_timepoints))
  127. low_reward_pop = np.empty((data.n, n_unique_labels, min_trials, n_timepoints))
  128. label_array = np.empty((data.n, n_unique_labels, min_trials))
  130. for cell_idx in range(data.n):
  131. high_mask = high_reward_masks[cell_idx]
  132. low_mask = low_reward_masks[cell_idx]
  134. for condition_mask, population_array in [(high_mask, high_reward_pop),
  135. (low_mask, low_reward_pop)]:
  136. neural_response = neural_data_all[cell_idx][condition_mask]
  137. labels = labels_all[cell_idx][condition_mask]
  139. for label_idx, label_value in enumerate(np.unique(labels)):
  140. # Randomly sample trials for this label
  141. matching_trials = neural_response[labels == label_value]
  142. # Use deterministic random seed based on sample index
  143. rng = np.random.RandomState(RANDOM_SEED + sample_idx)
  144. random_indices = rng.permutation(len(matching_trials))[:min_trials]
  146. population_array[cell_idx, label_idx] = matching_trials[random_indices]
  147. label_array[cell_idx, label_idx] = label_idx
  149. # Reshape for decoding
  150. labels_flat = label_array.reshape(data.n, -1)[0, :]
  151. high_reward_pop = high_reward_pop.reshape(data.n, -1, n_timepoints)
  152. low_reward_pop = low_reward_pop.reshape(data.n, -1, n_timepoints)
  154. # Decode at each timepoint
  155. for time_idx in range(n_timepoints):
  156. high_features = high_reward_pop[..., time_idx].T
  157. low_features = low_reward_pop[..., time_idx].T
  159. high_scores = sklearn.model_selection.cross_val_score(
  160. self.decoder, high_features, labels_flat,
  161. cv=cv_splitter, n_jobs=D.n_cores
  162. )
  163. low_scores = sklearn.model_selection.cross_val_score(
  164. self.decoder, low_features, labels_flat,
  165. cv=cv_splitter, n_jobs=D.n_cores
  166. )
  168. high_reward_accuracy[time_idx, sample_idx] = np.mean(high_scores)
  169. low_reward_accuracy[time_idx, sample_idx] = np.mean(low_scores)
  171. return high_reward_accuracy, low_reward_accuracy
  174. def plot_results(explore_accuracy, exploit_accuracy, data):
  175. # Plot configuration
  176. matplotlib.rc('xtick', labelsize=12)
  177. matplotlib.rc('ytick', labelsize=12)
  179. fig = plt.figure(figsize=(13.2, 8.8), dpi=200)
  181. height_ratios = [1, 0.5, 1, 0.2, 1]
  182. width_ratios = [1, 0.2, 1, 0.3, 1]
  183. gs = plt.GridSpec(len(height_ratios), len(width_ratios),
  184. height_ratios=height_ratios, width_ratios=width_ratios,
  185. hspace=0, wspace=0)
  187. # Create axes
  188. axes = [None, None, None,
  189. fig.add_subplot(gs[2, 0]), fig.add_subplot(gs[2, 2]), fig.add_subplot(gs[2, 4]),
  190. fig.add_subplot(gs[4, 0]), fig.add_subplot(gs[4, 2]), fig.add_subplot(gs[4, 4])]
  192. # Format axes
  193. for ax in axes[3:]:
  194. Plot.set_xlim(data, ax, -600, 600, offset=-600, res=300)
  195. ax.spines['right'].set_visible(False)
  196. ax.spines['top'].set_visible(False)
  197. ax.axvline(60, ls='--', c='k', lw=0.5, zorder=-1)
  199. for ax in axes[6:]:
  200. ax.set_xlabel('Time (ms) post choice 1', fontsize=13)
  202. # Add panel letters
  203. Plot.let(axes[3], 0, -0.15, 1.15, fontsize=14)
  204. Plot.let(axes[4], 1, -0.125, 1.15, fontsize=14)
  205. Plot.let(axes[5], 2, -0.15, 1.15, fontsize=14)
  206. Plot.let(axes[6], 3, -0.125, fontsize=14)
  207. Plot.let(axes[7], 4, -0.125, fontsize=14)
  208. Plot.let(axes[8], 5, -0.15, fontsize=14)
  210. # Plot data for each brain area
  211. for area_idx, area_name in enumerate(D.areas[1:]):
  212. color = f'C{area_idx}'
  214. # CUE IDENTITY: Explore (Panel A)
  215. explore_cue = explore_accuracy['cue'][area_idx].T * 100
  216. avg, sem = Plot.AvgSem(explore_cue, axes[4], label=area_name,
  217. showleg=False, c=color, lw=2.5)
  219. # CUE IDENTITY: Exploit (Panel B)
  220. exploit_cue = exploit_accuracy['cue'][area_idx].T * 100
  221. avg_exploit, sem_exploit = Plot.AvgSem(exploit_cue, axes[3], label=area_name,
  222. showleg=False, c=color, lw=2.5)
  224. # CUE IDENTITY: Difference (Panel C)
  225. difference_cue = exploit_cue - explore_cue
  226. avg_diff, sem_diff = Plot.AvgSem(difference_cue, axes[5], label=area_name,
  227. showleg=False, c=color, lw=2.5)
  229. # DIRECTION: Explore (Panel D)
  230. explore_dir = explore_accuracy['direction'][area_idx].T * 100
  231. avg_dir_explore, _ = Plot.AvgSem(explore_dir, axes[7], label=area_name,
  232. showleg=False, c=color, lw=2.5)
  234. # DIRECTION: Exploit (Panel E)
  235. exploit_dir = exploit_accuracy['direction'][area_idx].T * 100
  236. avg_dir_exploit, _ = Plot.AvgSem(exploit_dir, axes[6], label=area_name,
  237. showleg=False, c=color, lw=2.5)
  239. # DIRECTION: Difference (Panel F)
  240. difference_dir = exploit_dir - explore_dir
  241. avg_diff_dir, sem_diff_dir = Plot.AvgSem(difference_dir, axes[8], label=area_name,
  242. showleg=False, c=color, lw=2.5)
  244. # Format cue identity panels (top row)
  245. axes[3].axhline(50, color='gray', zorder=0, lw=0.5)
  246. axes[4].axhline(50, color='gray', zorder=0, lw=0.5)
  247. axes[3].set_ylabel('Accuracy (%)', fontsize=13)
  248. axes[3].set_ylim(40, 100)
  249. axes[4].set_ylim(40, 100)
  250. axes[5].set_ylabel('Difference', fontsize=13)
  251. axes[5].set_ylim(-20, 40)
  252. axes[5].axhline(0, lw=0.5, c='gray', zorder=-1)
  254. axes[3].set_title("Exploit (after 2 high rewards)")
  255. axes[4].set_title("Explore (after 2 low/med. rewards)")
  256. axes[5].set_title("Explore - Exploit")
  257. axes[3].text(2, 85, 'Cue\nchosen', fontsize=12,
  258. horizontalalignment='left', verticalalignment='center')
  260. # Format direction panels (bottom row)
  261. axes[6].axhline(33, color='gray', zorder=0, lw=0.5)
  262. axes[7].axhline(33, color='gray', zorder=0, lw=0.5)
  263. axes[6].set_ylabel('Accuracy (%)', fontsize=13)
  264. axes[6].set_ylim(25, 90)
  265. axes[7].set_ylim(25, 90)
  266. axes[8].set_ylabel('Difference', fontsize=13)
  267. axes[8].set_ylim(-20, 40)
  268. axes[8].axhline(0, lw=0.5, c='gray', zorder=-1)
  269. axes[6].text(2, 70, 'Direction\nchosen', fontsize=12,
  270. horizontalalignment='left', verticalalignment='center')
  272. axes[6].legend(loc='lower left', bbox_to_anchor=[0, 1.15], ncol=4)
  274. plt.show()
  277. def main():
  278. decoder = NeuralDecoder()
  280. # Storage for results
  281. explore_accuracy = {'direction': [], 'cue': []}
  282. exploit_accuracy = {'direction': [], 'cue': []}
  284. # Analyze each brain area
  285. for area_idx, area_name in enumerate(D.areas[1:]):
  286. print(f"Processing area: {area_name}")
  288. data = ImportData.EntireArea(area_name, 600, 600)
  290. # DIRECTION DECODING
  291. print("\nDirection decoding:")
  292. start_time = time.time()
  293. neural_data, labels, high_masks, low_masks, min_trials = decoder.prepare_data(
  294. data, 'c1dir', RESOLUTION
  295. )
  297. exploit_dir, explore_dir = decoder.run_cross_validated_decoding(
  298. data, neural_data, labels, high_masks, low_masks, min_trials, N_SAMPLES
  299. )
  300. print(f"Completed in {time.time() - start_time:.1f} seconds")
  302. # CUE IDENTITY DECODING
  303. print("\nCue identity decoding:")
  304. start_time = time.time()
  305. neural_data, labels, high_masks, low_masks, min_trials = decoder.prepare_data(
  306. data, 'c1chosen', RESOLUTION
  307. )
  309. exploit_cue, explore_cue = decoder.run_cross_validated_decoding(
  310. data, neural_data, labels, high_masks, low_masks, min_trials, N_SAMPLES
  311. )
  312. print(f"Completed in {time.time() - start_time:.1f} seconds")
  314. # Store results
  315. explore_accuracy['direction'].append(explore_dir)
  316. exploit_accuracy['direction'].append(exploit_dir)
  317. explore_accuracy['cue'].append(explore_cue)
  318. exploit_accuracy['cue'].append(exploit_cue)
  320. # Convert to arrays
  321. for key in explore_accuracy:
  322. explore_accuracy[key] = np.array(explore_accuracy[key])
  323. exploit_accuracy[key] = np.array(exploit_accuracy[key])
  325. data = ImportData.EntireArea('ACC', 600, 600)
  327. plot_results(explore_accuracy, exploit_accuracy, data)
  330. if __name__ == '__main__':
  331. main()

Fig7. ExploreExploit.py at commit ef32a40, under MIT · at the source

Overview

Authors: Bruno Miranda1,2, James L Butler3, WM Nishantha Malalasekera1, Timothy EJ Behrens4,5, Peter Dayan6,7, Steven W Kennerley1,3
ORCID iDs: Bruno Miranda, James L Butler, Timothy EJ Behrens, Peter Dayan, Steven W Kennerley
  1. Institute of Neurology, Department of Clinical and Movement Neurosciences, University College London London United Kingdom
  2. Instituto de Fisiologia, Faculdade de Medicina, Universidade de Lisboa Lisbon Portugal
  3. Department of Experimental Psychology, University of Oxford Oxford United Kingdom
  4. Wellcome Centre for Integrative Neuroimaging, University of Oxford, FMRIB, John Radcliffe Hospital Oxford United Kingdom
  5. Sainsbury Wellcome Centre for Neural Circuits and Behaviour College, University College London London United Kingdom
  6. Max Planck Institute for Biological Cybernetics Tübingen Germany
  7. University of Tübingen Tübingen Germany
Institutions: University College London (United Kingdom); University of Lisbon (Portugal); University of Oxford (United Kingdom); Max Planck Institute for Biological Cybernetics (Germany); University of Tübingen (Germany)
Journal: eLife, volume 14, article RP106032
Dates: published online 22 June 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.7554/elife.106032 · PMID 42329682 · PMCID PMC13286570 · OpenAlex W4409455318
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: non-human primate (organism), cognitive (subfield)
Methods: Connectivity, Statistics, Machine learning, fMRI & imaging, Single-unit activity, calcium imaging, Physiology & signal measures
Keywords: reinforcement learning, anterior cingulate cortex, caudate nucleus, decision-making, value encoding, Rhesus macaque
MeSH: Corpus Striatum*, Neurons*, Prefrontal Cortex*, Reinforcement, Psychology*, Animals, Decision Making, Macaca mulatta, Male, Reinforcement Machine Learning, Reward (* major topic)
Journal subjects: Neuroscience
Topic: Neural and Behavioral Psychology Studies (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Wellcome Trust (10.35802/096689, 10.35802/220296, 10.35802/219525, 10.35802/214314); Fundação para a Ciência e a Tecnologia (SFRH/BD/51711/2011); Santa Casa da Misericórdia de Lisboa (Premio Joao Lobo Antunes 2017); Astor Foundation; Gatsby Charitable Foundation (GAT3955); Jean Francois and Marie-Laure de Clermont Tonerre Foundation; Max-Planck-Gesellschaft; Alexander von Humboldt-Stiftung; BBSRC (BB/W003392/1); Rosetrees Trust
Citations: not cited yet (Europe PMC); 72 references in the paper

Abstract

Animals integrate knowledge about how the state of the environment evolves to choose actions that maximise reward. Such goal-directed behaviour – or model-based (MB) reinforcement learning (RL) – can flexibly adapt choice to changes, being thus distinct from simpler habitual – or model-free (MF) RL – strategies. Previous inactivation and neuroimaging work implicates prefrontal cortex (PFC) and the caudate striatal region in MB-RL; however, details are scarce about its implementation at the single-neuron level. Here, we recorded from two PFC regions – the dorsal anterior cingulate cortex (ACC) and dorsolateral PFC (DLPFC), and two striatal regions, caudate and putamen – while two rhesus macaques performed a sequential decision-making (two-step) task in which MB-RL involves knowledge about the statistics of reward and state transitions. All four regions, but particularly the ACC, encoded the rewards received and tracked the probabilistic state transitions that occurred. However, ACC (and to a lesser extent caudate) encoded the key variables of the task – namely the interaction between reward, transition, and choice – which underlies MB decision-making. ACC and caudate neurons also encoded MB-derived estimates of choice values. Moreover, caudate value estimates of the choice options flipped when a rare transition occurred, demonstrating value update based on structural knowledge of the task. The striatal regions were unique (relative to PFC) in encoding the current and previous rewards with opposing polarities, reminiscent of dopaminergic neurons, and indicative of an MF prediction error. Our findings provide a deeper understanding of selective and temporally dissociable neural mechanisms underlying goal-directed behaviour.

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

Repository

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

jamesbutler01/TwoStepExperiment

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: ef32a40742af500dd55584218007d8f515d6c107, 13 June 2026
Languages: Python (10)
Size: 1,959 files, 10 scripts
Software Heritage: not archived
Found in: “Data availability”
Holds: README, license file, environment (pyproject.toml)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (10 files), Matplotlib (7 files), scikit-learn (2 files), pandas (1 file), scikit-image (1 file), SciPy (1 file), statsmodels (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
12 files
At the source: github.com/jamesbutler01/TwoStepExperiment

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:

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

All data and code to reproduce figures are available at https://github.com/jamesbutler01/TwoStepExperiment, copy archived at Butler, 2026.

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

Recorded: type, language, journal, volume, pages, dates, 6 authors, 6 keywords, 10 MeSH terms, 10 funders, 70 references.

Cite

This paper

Miranda, B., Butler, J. L., Malalasekera, W. N., Behrens, T. E., Dayan, P., & Kennerley, S. W. (2026). Neural signatures of model-based and model-free reinforcement learning across prefrontal cortex and striatum. eLife, 14, RP106032. https://doi.org/10.7554/elife.106032

BibTeX

@article{miranda2026neural,
author = {Miranda, Bruno and Butler, James L and Malalasekera, WM Nishantha and Behrens, Timothy EJ and Dayan, Peter and Kennerley, Steven W},
title = {{Neural signatures of model-based and model-free reinforcement learning across prefrontal cortex and striatum}},
journal = {eLife},
year = {2026},
month = jun,
volume = {14},
pages = {RP106032},
publisher = {eLife Sciences Publications, Ltd},
issn = {2050-084X},
doi = {10.7554/elife.106032},
url = {https://doi.org/10.7554/elife.106032},
pmid = {42329682},
pmcid = {PMC13286570}
}

RIS

TY - JOUR
AU - Miranda, Bruno
AU - Butler, James L
AU - Malalasekera, WM Nishantha
AU - Behrens, Timothy EJ
AU - Dayan, Peter
AU - Kennerley, Steven W
TI - Neural signatures of model-based and model-free reinforcement learning across prefrontal cortex and striatum
T2 - eLife
J2 - eLife
PY - 2026
DA - 2026/06/22
VL - 14
SP - RP106032
SN - 2050-084X
PB - eLife Sciences Publications, Ltd
DO - 10.7554/elife.106032
UR - https://doi.org/10.7554/elife.106032
LA - en
ER -

CSL-JSON

{
"id": "10.7554/elife.106032",
"type": "article-journal",
"title": "Neural signatures of model-based and model-free reinforcement learning across prefrontal cortex and striatum",
"container-title": "eLife",
"author": [
{
"family": "Miranda",
"given": "Bruno"
},
{
"family": "Butler",
"given": "James L"
},
{
"family": "Malalasekera",
"given": "WM Nishantha"
},
{
"family": "Behrens",
"given": "Timothy EJ"
},
{
"family": "Dayan",
"given": "Peter"
},
{
"family": "Kennerley",
"given": "Steven W"
}
],
"container-title-short": "eLife",
"volume": "14",
"page": "RP106032",
"DOI": "10.7554/elife.106032",
"PMID": "42329682",
"PMCID": "PMC13286570",
"ISSN": "2050-084X",
"publisher": "eLife Sciences Publications, Ltd",
"URL": "https://doi.org/10.7554/elife.106032",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
22
]
]
}
}

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.1016/j.celrep.2026.117454 [code]
Model-based and model-free valuation signals in the human brain vary markedly in relation to individual differences in behavioral control.
Journal: Cell reports
In common: pandas, Matplotlib, NumPy, cognitive, 11 references
[2] doi:10.1111/ejn.70641
Distinct High-Gamma Signals in Primate Prefrontal Cortex Differentiate Cue Information, Preference Revision, and Expected Reward During Value-Based Decisions.
Journal: The European journal of neuroscience
In common: non-human primate, cognitive, 6 references, author Steven W Kennerley
[3] doi:10.1038/s41467-026-75706-1 [code]
Dissociable roles of prefrontal plasticity in decision-making strategy and execution of habitual behavior.
Journal: Nature communications
In common: scikit-learn, pandas, SciPy, 2 other tools, cognitive, 6 references
[4] doi:10.1038/s41467-026-74783-6 [code]
Neural and computational correlates of strategic aborting and long-run policy optimization in the dorsolateral prefrontal cortex.
Journal: Nature communications
In common: scikit-learn, pandas, SciPy, 2 other tools, non-human primate, 5 references
[5] doi:10.7554/elife.105774 [code]
Anterior cingulate cortex monitors action state and action content in complex associative learning.
Journal: eLife
In common: cognitive, 6 references
[6] doi:10.1371/journal.pbio.3003829 [code]
Identity-specific reward expectations in orbitofrontal cortex guide goal-directed choices.
Journal: PLoS biology
In common: statsmodels, pandas, SciPy, 2 other tools, cognitive, 3 references
[7] doi:10.1126/sciadv.aeb3005 [code]
Neural competition between prefrontal and auditory cortex constrains novel sound strategy learning.
Journal: Science advances
In common: 6 references
[8] doi:10.7554/elife.108023 [code]
Challenges in replay detection by TDLM in post-encoding resting state.
Journal: eLife
In common: statsmodels, scikit-learn, pandas, 3 other tools, 2 references
[9] doi:10.1093/nc/niag029 [code]
A data-driven approach to identifying and evaluating connectivity-based neural correlates of conscious visual perception.
Journal: Neuroscience of consciousness
In common: scikit-image, statsmodels, scikit-learn, 4 other tools, cognitive, 1 reference
[10] doi:10.1162/netn.a.544 [code]
Brain network reconfiguration during reward prediction error processing.
Journal: Network neuroscience (Cambridge, Mass.)
In common: statsmodels, scikit-learn, pandas, 3 other tools, cognitive, 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.