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.

5 blocks of code here have a permanent identifier (oscr:b:…), listed with the matches below: citable for good, with a page of its own. Select a match and press Cite to copy it. What a block identifier is.

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

Paper

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

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.1101/2025.01.11.632388 [code]
Neural signatures of model-based and model-free reinforcement learning across prefrontal cortex and striatum
Journal: bioRxiv (preprint)
In common: scikit-image, statsmodels, scikit-learn, 4 other tools, non-human primate, 26 references, 2 authors
[2] doi:10.1038/s41593-023-01535-w
Distributional reinforcement learning in prefrontal cortex.
Journal: Nature neuroscience
In common: non-human primate, 10 references, 4 authors
[3] doi:10.1002/hbm.25988
Reinforcement learning with associative or discriminative generalization across states and actions: fMRI at 3 T and 7 T.
Journal: Human brain mapping
In common: cognitive, 15 references
[4] doi:10.1073/pnas.2206067119 [code]
Prospective and retrospective values integrated in frontal cortex drive predictive choice.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: scikit-learn, Matplotlib, NumPy, 13 references
[5] doi:10.1038/s41467-025-56731-y [code]
Exploring replay.
Journal: Nature communications
In common: SciPy, Matplotlib, NumPy, cognitive, 8 references, author Peter Dayan
[6] 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
[7] doi:10.1038/s41467-025-63995-x [code]
Thalamic regulation of reinforcement learning strategies across prefrontal-striatal networks.
Journal: Nature communications
In common: statsmodels, scikit-learn, pandas, 3 other tools, 9 references
[8] doi:10.1038/s41467-024-45127-z [code]
Grid-like entorhinal representation of an abstract value space during prospective decision making.
Journal: Nature communications
In common: statsmodels, scikit-learn, pandas, 2 other tools, cognitive, 9 references
[9] doi:10.1371/journal.pcbi.1012383 [code]
Understanding dual process cognition via the minimum description length principle.
Journal: PLoS computational biology
In common: Matplotlib, NumPy, cognitive, 10 references
[10] doi:10.1038/s41586-025-09885-0 [code]
Evidence accumulation from experience and observation in the cingulate cortex.
Journal: Nature
In common: statsmodels, scikit-learn, pandas, 3 other tools, non-human primate, 7 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.

Add the badge to the code's README

OSCR: the badge of this paper

If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.

Markdown
<!-- oscr-badge:start -->
[![OSCR](https://openscicode.org/badge/doi/10.7554/elife.106032.svg)](https://openscicode.org/badge/doi/10.7554/elife.106032)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.7554/elife.106032.svg
   :target: https://openscicode.org/badge/doi/10.7554/elife.106032
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.7554/elife.106032"><img src="https://openscicode.org/badge/doi/10.7554/elife.106032.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->

On GitHub, open the README, choose Edit (the pencil), paste the snippet under the title, then "Commit changes".

If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge 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: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.

Report a mismatch between the code and the paper · Report a code error (signed in)

Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.

Report a reproduction failure (signed in)

Versions of its code: the releases of its code tied to a version of this paper (the preprint, the accepted manuscript, the version of record…), each with the tracing map versioned with it.

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