OSCR

Neural similarity between choice options predicts group-level context effects.

Code ↔ Paper

18 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 18 matches
  1. [1] § Methods › Computational modeling ↔ code/behavioral_computational/computational_models.ipynb, lines 256–316 · score 0.74 · computational models, cross validation, predicted decoy, fmin, optimization, scipy
  2. [2] § Methods › Representational Similarity Analysis regression › Neural RDM regressions › Out-of-sample predictions ↔ code/mri/fig2_predictions.ipynb, lines 158–220 · score 0.70 · Lasso regression, cross validation, hyperparameter, inner, held, fold
  3. [3] § Results › The decoy effect is predicted by the similarity of neural representations ↔ code/behavioral_computational/computational_models.ipynb, lines 256–316 · score 0.66 · square error, cross validation, computational model, models prediction, fold, RMSE
  4. [4] § Methods › Explicit attribute representation analysis › Whole-brain attribute representation levels ↔ code/mri/fig3_attribute_representation_levels.ipynb, lines 177–222 · score 0.64 · posterior anterior coordinate, attribute representation, quadratic, parcel, fitted
  5. [5] § Methods › Representational Similarity Analysis regression › Pre-defined regions of interest ↔ code/mri/fig4_rep_geometry.ipynb, lines 112–166 · score 0.64 · vmPFC, vSTR, ACC, M1, PCC, V1
  6. [6] § Methods › Behavioral tasks › Lottery evaluation task ↔ code/behavioral_computational/read_files.py, lines 335–379 · score 0.63 · remaining budget, behavioral sample, BDM, win, blocks
  7. [7] § Methods › Representational Similarity Analysis regression › Pre-defined regions of interest ↔ code/mri/fig2_fitting.ipynb, lines 26–30 · score 0.63 · vmPFC, vSTR, ACC, M1, PCC, V1
  8. [8] § Results › The decoy effect is predicted by the similarity of neural representations ↔ code/mri/fig2_predictions.ipynb, lines 158–220 · score 0.62 · square error, Lasso regression, cross validation, fold, RMSE, trained
  9. [9] § Results › The decoy effect is predicted by the similarity of neural representations ↔ code/mri/fig3_attribute_representation_levels.ipynb, lines 177–222 · score 0.59 · quadratic fit, attribute RDM, attribute representation, anterior, posterior, parcel
  10. [10] § Methods › Representational Similarity Analysis regression › Neural RDM regressions › Data fitting ↔ code/mri/utils/stepwise_rdm.py, lines 14–48 · score 0.58 · forward stepwise regression, stepwise procedure, fitted, ROIs, RDMs, models
  11. [11] § Methods › Computational modeling › Evidence accumulation (drift-diffusion) models ↔ code/behavioral_computational/ddms/ddms_model_eval.ipynb, lines 12–17 · score 0.56 · Mutual Inhibition, Selective Integration, competitor, fit, models, decoy
  12. [12] § Results › Mixture of explicit and latent attributes in neural representations predicts the decoy effect ↔ code/mri/fig3_attribute_representation_levels.ipynb, lines 35–61 · score 0.56 · lower triangles, attribute RDM, neural RDM, attribute representation, correlated, ROIs
  13. [13] § Results › The decoy effect is predicted by the similarity of neural representations ↔ code/behavioral_computational/computational_models.ipynb, lines 148–223 · score 0.54 · Recurrent Divisive Normalization, computational model, error, probability, prediction, decoy
  14. [14] § Methods › Computational modeling › Evidence accumulation (drift-diffusion) models ↔ code/behavioral_computational/ddms/ddms_model_eval.ipynb, lines 12–17 · score 0.53 · Mutual Inhibition, Selective Integration, models, decoy
  15. [15] § Results › The decoy effect is predicted by the similarity of neural representations ↔ code/mri/fig4_rep_geometry.ipynb, lines 361–431 · score 0.53 · biweight midcorrelation, effective dimensionality, networks, attribute representation, parcel, Figure 4
  16. [16] § Results › The decoy effect is predicted by the similarity of neural representations ↔ code/mri/utils/stepwise_rdm.py, lines 14–48 · score 0.52 · forward stepwise regression, RDM regressions, FDR, fit, ROIs, model
  17. [17] § Results › Low explicit attribute representation is tied to higher effective dimensionality ↔ code/mri/fig4_rep_geometry.ipynb, lines 112–166 · score 0.52 · vSTR, effective dimensionality, ACC, PCC, V1, MT
  18. [18] § Methods › Attributes-based models ↔ code/mri/utils/rdm_regression.py, lines 1–15 · score 0.51 · linear regression, neural RDM regression, fitted, predictions, decoy

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

Jupyter notebook · 372 lines · 17 KB · CC-BY-4.0 · 3 matches

  1. # %% [markdown]
  2. # # Computational models of the decoy effect
  3. #
  4. # Fits and compares standard context-effect models: Adaptive Gain, Divisive Normalization, Range Normalization, to the empirical per-set decoy effects.
  5. # Each model predicts the trinary-vs-binary change in target choice share from the lottery attributes.
  6. # Leave-one-lottery-out cross-validated predictions are reported via MSE. Fitting results are reported as R^2.
  8. # %%
  9. import glob
  10. import os
  11. import tqdm
  12. import pandas as pd
  13. import numpy as np
  14. import matplotlib.pyplot as plt
  15. import matplotlib
  16. import scipy
  17. from scipy import optimize
  18. import read_files
  19. from copy import deepcopy
  20. from sklearn.metrics import mean_squared_error
  21. import warnings
  22. warnings.simplefilter(action='ignore', category=RuntimeWarning)
  24. # %%
  25. choice_stimuli = pd.read_csv('../../stimuli/stimuli_trinary.csv')
  26. trinary_stimuli = choice_stimuli
  27. binary_stimuli = pd.read_csv('../../stimuli/stimuli_binary.csv')
  29. # %%
  30. decoy_effects = pd.read_csv('../../results/decoy_table.csv')
  31. y = decoy_effects.decoy_effect_A.values
  33. # %% [markdown]
  34. # ### Fit computational models: Adaptive Gain
  36. # %% [markdown]
  37. # #### min-max scaling of amount and probabilities
  39. # %%
  40. binary_stimuli = trinary_stimuli.drop(['amountC', 'probC', 'trinary_id'], axis=1)
  41. binary_stimuli.loc[:, 'avg_amounts'] = np.mean(binary_stimuli.loc[:, ['amountA', 'amountB']], 1)
  42. binary_stimuli.loc[:, 'avg_probs'] = np.mean(binary_stimuli.loc[:, ['probA', 'probB']], 1)
  43. binary_stimuli = binary_stimuli.loc[binary_stimuli.binary_id < 28, :] # remove catch trials
  44. trinary_stimuli = trinary_stimuli.drop(['binary_id'], axis=1)
  45. trinary_stimuli.loc[:, 'avg_amounts'] = np.mean(trinary_stimuli.loc[:, ['amountA', 'amountB', 'amountC']], 1)
  46. trinary_stimuli.loc[:, 'avg_probs'] = np.mean(trinary_stimuli.loc[:, ['probA', 'probB', 'probC']], 1)
  47. trinary_stimuli = trinary_stimuli.loc[trinary_stimuli.trinary_id < 28] # remove catch trials
  49. # %%
  50. min_amount = 4
  51. max_amount = 79
  52. min_prob = 0
  53. max_prob = 100
  54. all_EVs = np.concatenate([trinary_stimuli.EVA.unique(), trinary_stimuli.EVB.unique(), trinary_stimuli.EVC.unique()])
  55. min_EV = np.min(all_EVs)
  56. max_EV = np.max(all_EVs)
  57. to_scale_cols = ['amountA', 'probA', 'amountB', 'probB', 'amountC', 'probC', 'EVA', 'EVB', 'EVC', 'avg_amounts', 'avg_probs']
  58. trinary_stimuli_norm = trinary_stimuli.copy()
  59. trinary_stimuli_norm.loc[:, 'amountA'] = (trinary_stimuli_norm.amountA - min_amount) / (max_amount - min_amount)
  60. trinary_stimuli_norm.loc[:, 'amountB'] = (trinary_stimuli_norm.amountB - min_amount) / (max_amount - min_amount)
  61. trinary_stimuli_norm.loc[:, 'amountC'] = (trinary_stimuli_norm.amountC - min_amount) / (max_amount - min_amount)
  62. trinary_stimuli_norm.loc[:, 'probA'] = (trinary_stimuli_norm.probA - min_prob) / (max_prob - min_prob)
  63. trinary_stimuli_norm.loc[:, 'probB'] = (trinary_stimuli_norm.probB - min_prob) / (max_prob - min_prob)
  64. trinary_stimuli_norm.loc[:, 'probC'] = (trinary_stimuli_norm.probC - min_prob) / (max_prob - min_prob)
  65. trinary_stimuli_norm.loc[:, 'EVA'] = (trinary_stimuli_norm.EVA - min_EV) / (max_EV - min_EV)
  66. trinary_stimuli_norm.loc[:, 'EVB'] = (trinary_stimuli_norm.EVB - min_EV) / (max_EV - min_EV)
  67. trinary_stimuli_norm.loc[:, 'EVC'] = (trinary_stimuli_norm.EVC - min_EV) / (max_EV - min_EV)
  68. trinary_stimuli_norm.loc[:, 'avg_amounts'] = trinary_stimuli_norm.loc[:, ['amountA', 'amountB', 'amountC']].mean(axis=1)
  69. trinary_stimuli_norm.loc[:, 'avg_probs'] = trinary_stimuli_norm.loc[:, ['probA', 'probB', 'probC']].mean(axis=1)
  71. binary_stimuli_norm = binary_stimuli.copy()
  72. binary_stimuli_norm.loc[:, 'amountA'] = (binary_stimuli_norm.amountA - min_amount) / (max_amount - min_amount)
  73. binary_stimuli_norm.loc[:, 'amountB'] = (binary_stimuli_norm.amountB - min_amount) / (max_amount - min_amount)
  74. binary_stimuli_norm.loc[:, 'probA'] = (binary_stimuli_norm.probA - min_prob) / (max_prob - min_prob)
  75. binary_stimuli_norm.loc[:, 'probB'] = (binary_stimuli_norm.probB - min_prob) / (max_prob - min_prob)
  76. binary_stimuli_norm.loc[:, 'EVA'] = (binary_stimuli_norm.EVA - min_EV) / (max_EV - min_EV)
  77. binary_stimuli_norm.loc[:, 'EVB'] = (binary_stimuli_norm.EVB - min_EV) / (max_EV - min_EV)
  78. binary_stimuli_norm.loc[:, 'avg_amounts'] = binary_stimuli_norm.loc[:, ['amountA', 'amountB']].mean(axis=1)
  79. binary_stimuli_norm.loc[:, 'avg_probs'] = binary_stimuli_norm.loc[:, ['probA', 'probB']].mean(axis=1)
  81. # %% [markdown]
  82. # #### read choice file per set, instead of per subject
  84. # %%
  85. raw_choices = pd.DataFrame()
  86. raw_files = glob.glob('../../data/behavioral_experiment/raw_choices_per_set/*.csv')
  87. for i in range(len(raw_files)):
  88. set_choices = pd.read_csv(raw_files[i])
  89. raw_choices = pd.concat([raw_choices, set_choices], axis=0)
  90. # remove catch trials
  91. raw_choices = raw_choices[raw_choices.binary_id<28]
  92. raw_choices = raw_choices[raw_choices.subject_id.str.contains('-')]
  94. # %%
  95. # add the lotteries' attributes to the choices
  96. binary_raw_choices = raw_choices[raw_choices.trinary_group==0]
  97. trinary_raw_choices = raw_choices[raw_choices.trinary_group==1]
  98. trinary_raw_choices_stimuli = trinary_raw_choices.merge(trinary_stimuli_norm, left_on='trinary_id', right_on='trinary_id', how='outer')
  99. binary_raw_choices_stimuli = binary_raw_choices.merge(binary_stimuli_norm, left_on='binary_id', right_on='binary_id', how='outer')
  101. # %%
  102. raw_choices_stimuli = pd.concat([binary_raw_choices_stimuli, trinary_raw_choices_stimuli], axis=0)
  104. # %%
  105. def trinary_neg_log_likelihood(p_all, choices):
  106. """
  107. Compute negative log-likelihood for trinary choice data.
  109. Parameters:
  110. - p_all: np.ndarray of shape (n_trials, 3), model predicted probabilities for [A, B, C]
  111. - choices: np.ndarray of shape (n_trials,), with values in {'A', 'B', 'C'}
  113. Returns:
  114. - neg_log_like: scalar, sum of negative log-likelihood over trials
  115. """
  116. # Map choices to indices
  117. choice_map = {'A': 0, 'B': 1, 'C': 2}
  118. choice_indices = np.vectorize(choice_map.get)(choices)
  120. # Extract the predicted probability assigned to the chosen option
  121. chosen_p = p_all[np.arange(len(choices)), choice_indices]
  123. # Avoid log(0)
  124. chosen_p = np.clip(chosen_p, 1e-5, 1 - 1e-5)
  126. # Compute NLL
  127. neg_log_like = -np.nansum(np.log(chosen_p))
  129. return neg_log_like
  131. # %%
  132. def softmax(x, tau=1):
  133. """
  134. Compute softmax probabilities for a given input vector x and temperature tau.
  136. Parameters:
  137. - x: np.ndarray, input vector of values
  138. - tau: float, temperature parameter
  140. Returns:
  141. - np.ndarray, softmax probabilities
  142. """
  143. exp_u = np.exp(tau*x)
  144. softmax_denominator = np.nansum(exp_u, axis=1, keepdims=True)
  145. p_all = exp_u / softmax_denominator
  146. return p_all
  148. # %%
  149. def run_model(params, df, model_type='AG', return_p=0):
  150. """
  151. Evaluate a context-effect model on a batch of choice trials or stimuli.
  153. Supports three families of models, each combining attribute-level
  154. normalization with a softmax decision rule and an amount/probability
  155. weighting ``w``:
  156. - 'AG' (Adaptive Gain): sigmoidal squashing of each attribute
  157. around the contextual mean with slope parameters.
  158. - 'DN' (Divisive Normalization): attribute divided by a
  159. weighted contextual sum plus a saturation constant.
  160. - 'RDN' (Recurrent Divisive Normalization): attribute divided by
  161. itself plus the contextual sum plus a saturation constant.
  163. Parameters:
  164. params: tuple of model parameters in the order documented above
  165. for each ``model_type``.
  166. df: DataFrame with columns ``amountA/B[/C]``, ``probA/B[/C]``,
  167. and the contextual means ``avg_amounts`` and ``avg_probs``.
  168. If ``target_choice`` or ``actual_choice`` is present the
  169. function returns the negative log-likelihood of the choices.
  170. model_type: 'AG', 'DN' or 'RDN'.
  171. return_p: if truthy, return the predicted ``P(A) / (P(A)+P(B))``
  172. instead of the negative log-likelihood (used to derive the
  173. model-predicted decoy effect from stimuli without choices).
  175. Returns:
  176. Either the predicted A-vs-B choice probabilities (when
  177. ``return_p`` is truthy) or the summed negative log-likelihood of
  178. the observed choices under the model.
  179. """
  180. # df could be subjects raw choices, or dataframe of stimuli (amounts, probs) without choices
  181. if 'amountC' in df.columns:
  182. amounts = df[['amountA', 'amountB', 'amountC']]
  183. probs = df[['probA', 'probB', 'probC']]
  184. else:
  185. amounts = df[['amountA', 'amountB']]
  186. probs = df[['probA', 'probB']]
  187. n_amounts = amounts.shape[1]
  188. avg_amounts_mat = np.vstack([df.avg_amounts.values]*n_amounts).transpose()
  189. avg_probs_mat = np.vstack([df.avg_probs.values]*n_amounts).transpose()
  191. if model_type=='RDN':
  192. # recurrent divisive normalization
  193. c_amount, c_prob, tau, w = params
  194. u_amounts = amounts / (amounts + avg_amounts_mat + c_amount)
  195. u_probs = probs / (probs + avg_probs_mat + c_prob)
  196. elif model_type=='DN':
  197. # divisive normalization
  198. c_amount, c_prob, tau, omega_amount, omega_prob, w = params
  199. u_amounts = amounts / (omega_amount*avg_amounts_mat + c_amount)
  200. u_probs = probs / (omega_prob*avg_probs_mat + c_prob)
  201. elif model_type=='AG':
  202. # adaptive gain
  203. c_amount, c_prob, tau, slope_amount, slope_prob, w = params
  204. u_amounts = 1 / (1 + np.exp(-1 * (amounts - avg_amounts_mat - c_amount) / slope_amount))
  205. u_probs = 1 / (1 + np.exp(-1 * (probs - avg_probs_mat - c_prob) / slope_prob))
  206. else:
  207. raise ValueError('model_type must be "AG" (adaptive gain), "RDN" or "DN" ([recurrent] devisive normalization)')
  209. u_all = w*u_amounts.values + (1-w)*u_probs.values
  210. p_all = softmax(u_all, tau=tau)
  211. p_A = p_all[:, 0]
  212. p_B = p_all[:, 1]
  213. p_C = p_all[:, 2] if n_amounts == 3 else np.zeros_like(p_A)
  214. p_A[p_A==0] = 1e-5
  215. p_B[p_B==0] = 1e-5
  216. p_C[p_C==0] = 1e-5
  217. if return_p:
  218. return p_A / (p_A + p_B)
  219. if 'target_choice' in df.columns:
  220. choose_A = df.target_choice.values
  221. neg_log_like = -1 * np.sum(choose_A * np.log(p_A) + (1-choose_A)*np.log(p_B))
  222. neg_log_like = trinary_neg_log_likelihood(p_all, df.actual_choice.values) if n_amounts == 3 else neg_log_like
  223. return neg_log_like
  225. # %%
  226. # c_amount, c_prob, tau, slope, w
  227. AG_init_params = np.array([0. , 0, 0.1 , 0.1, 0.1, 0.5])
  228. # c_amount, c_prob, tau, w
  229. RDN_init_params = np.array([0. , 0, 0.1 , 0.5 ])
  230. DN_init_params = AG_init_params
  232. # %% [markdown]
  233. # ### out of sample predictions (leave-one-set-out)
  235. # %%
  236. os.chdir('../mri')
  237. from utils import load_params
  238. behavior_results = load_params.load_behavior_results()
  239. set_objs = load_params.load_sets(behavior_results)
  240. folds = []
  241. for i, set_out in enumerate(set_objs):
  242. test_sets = []
  243. test_ind = []
  244. train_sets = []
  245. train_ind = []
  246. for j, set_obj in enumerate(set_objs):
  247. if set_obj.overlapping_with(set_out):
  248. test_sets.append(set_obj)
  249. test_ind.append(j)
  250. else:
  251. train_sets.append(set_obj)
  252. train_ind.append(j)
  253. if (train_ind, test_ind) not in folds:
  254. folds.append((train_ind, test_ind))
  256. # %%
  257. def cv_comp_model(folds, model_type='AG', init_params=AG_init_params):
  258. """
  259. Leave-one-set-out cross-validation of a computational choice model.
  261. For each fold the model parameters are fit to the pooled raw
  262. choices of the training sets (group-level fit), then used to
  263. predict the held-out sets' decoy effect as the difference between
  264. model-predicted target shares in the trinary and binary stimuli.
  266. Parameters:
  267. folds: iterable of (train_indices, test_indices) tuples over
  268. lottery-set indices (0-based).
  269. model_type: 'AG', 'DN' or 'RDN' (see :func:`run_model`).
  270. init_params: initial parameter vector for ``scipy.optimize.fmin``.
  272. Returns:
  273. Tuple ``(cv_rmse, cv_corr, train_rmse)`` of per-fold arrays
  274. with the out-of-sample RMSE, Spearman correlation between
  275. predicted and observed decoy effects, and the training
  276. RMSE for reference.
  277. """
  278. cv_rmse = np.zeros(len(folds))
  279. cv_corr = np.zeros(len(folds))
  280. train_rmse = np.zeros(len(folds))
  281. fold_i = 0
  282. for train_ind, test_ind in tqdm.tqdm(folds):
  283. # train test split
  284. y_train, y_test = y[train_ind], y[test_ind]
  285. train_set_inds = np.array(train_ind) + 1
  286. test_set_inds = np.array(test_ind) + 1
  287. train_raw_choices = raw_choices_stimuli[raw_choices_stimuli.trinary_id.isin(train_set_inds)]
  288. test_raw_choices = raw_choices_stimuli[raw_choices_stimuli.trinary_id.isin(test_set_inds)]
  289. # fit params to group level choices
  290. group_params = optimize.fmin(run_model, init_params, args=(train_raw_choices, model_type), maxiter=1e4, disp=False)
  291. loglike = -1 * run_model(group_params, test_raw_choices, model_type)
  292. # apply to test choices
  293. test_trinary_stimuli = trinary_stimuli_norm.loc[trinary_stimuli_norm.trinary_id.isin(test_set_inds)]
  294. test_binary_stimuli = binary_stimuli_norm.loc[binary_stimuli_norm.binary_id.isin(test_set_inds)]
  295. # calculate predicted decoy effects (average trinary minus average binary)
  296. trinary_ratio_pred = run_model(group_params, test_trinary_stimuli, model_type, return_p=1)
  297. binary_ratio_pred = run_model(group_params, test_binary_stimuli, model_type, return_p=1)
  298. decoy_pred = trinary_ratio_pred - binary_ratio_pred
  299. decoy_pred = np.nan_to_num(decoy_pred)
  300. # evaluate predictions
  301. cv_rmse[fold_i] = np.sqrt(mean_squared_error(y_test, decoy_pred))
  302. corr = scipy.stats.spearmanr(decoy_pred, y_test)[0]
  303. cv_corr[fold_i] = corr if ~np.isnan(corr) else 0
  305. # calcualte train metrics, for sanity
  306. train_trinary_stimuli = trinary_stimuli_norm.loc[trinary_stimuli_norm.trinary_id.isin(train_set_inds)]
  307. train_binary_stimuli = binary_stimuli_norm.loc[binary_stimuli_norm.binary_id.isin(train_set_inds)]
  308. train_trinary_ratio_pred = run_model(group_params, train_trinary_stimuli, model_type, return_p=1)
  309. train_binary_ratio_pred = run_model(group_params, train_binary_stimuli, model_type, return_p=1)
  310. train_decoy_pred = train_trinary_ratio_pred - train_binary_ratio_pred
  311. try:
  312. train_rmse[fold_i] = np.sqrt(mean_squared_error(y_train, train_decoy_pred))
  313. except ValueError:
  314. train_rmse[fold_i] = np.nan
  315. fold_i += 1
  316. return cv_rmse, cv_corr, train_rmse
  318. # %%
  319. AG_cv_rmse, AG_cv_corr, AG_train_rmse = cv_comp_model(folds, model_type='AG', init_params=AG_init_params)
  321. # %%
  322. RDN_cv_rmse, RDN_cv_corr, RDN_train_rmse = cv_comp_model(folds, model_type='RDN', init_params=RDN_init_params)
  324. # %%
  325. DN_cv_rmse, DN_cv_corr, DN_train_rmse = cv_comp_model(folds, model_type='DN', init_params=DN_init_params)
  327. # %%
  328. pd.DataFrame({ 'train_rmse': [np.nanmean(AG_train_rmse), np.mean(RDN_train_rmse), np.mean(DN_train_rmse)],
  329. 'rmse': [np.nanmean(AG_cv_rmse), np.mean(RDN_cv_rmse), np.mean(DN_cv_rmse)],
  330. 'r': [np.nanmean(AG_cv_corr), np.mean(RDN_cv_corr), np.mean(DN_cv_corr)]},
  331. index=['AG', 'RDN', 'DN'])
  333. # %% [markdown]
  334. # ### fitting
  336. # %%
  337. AG_group_params = optimize.fmin(run_model, AG_init_params, args=(raw_choices_stimuli, 'AG', 0),
  338. maxiter=1e4, disp=False)
  339. RDN_group_params = optimize.fmin( run_model, RDN_init_params, args=(raw_choices_stimuli, 'RDN'),
  340. maxiter=1e4, disp=False)
  341. DN_group_params = optimize.fmin( run_model, DN_init_params, args=(raw_choices_stimuli, 'DN'),
  342. maxiter=1e4, disp=False)
  344. # %%
  345. def get_fitted_decoy_effects(group_params, model_type='AG'):
  346. """
  347. Return the in-sample model-predicted decoy effects per lottery set.
  349. Applies the fitted ``group_params`` to the normalized trinary and
  350. binary stimuli, computes ``P(A)`` in each, and returns a DataFrame
  351. with one row per set containing ``P_a_trinary``, ``P_a_binary`` and
  352. the resulting predicted decoy effect column ``decoy_{model_type}``.
  353. """
  354. trinary_P_a = run_model(group_params, trinary_stimuli_norm, model_type=model_type, return_p=1)
  355. binary_P_a = run_model(group_params, binary_stimuli_norm, model_type=model_type,return_p=1)
  356. decoys = trinary_P_a - binary_P_a
  357. fitted_decoys = pd.DataFrame({'trinary_id': trinary_stimuli.trinary_id,
  358. 'P_a_trinary': trinary_P_a,
  359. 'P_a_binary': binary_P_a,
  360. f'decoy_{model_type}':decoys})
  361. return fitted_decoys
  363. # %%
  364. AG_fitted_decoys = get_fitted_decoy_effects(AG_group_params, model_type='AG')
  365. RDN_fitted_decoys = get_fitted_decoy_effects(RDN_group_params, model_type='RDN')
  366. DN_fitted_decoys = get_fitted_decoy_effects(DN_group_params, model_type='DN')
  368. # %%
  369. pd.DataFrame({ 'AG': AG_fitted_decoys.decoy_AG.values,
  370. 'RDN': RDN_fitted_decoys.decoy_RDN.values,
  371. 'DN': DN_fitted_decoys.decoy_DN.values,
  372. 'actual': decoy_effects.decoy_effect_A.values}).corr()

computational_models.ipynb at commit 7a034b0, under CC-BY-4.0 · at the source

Overview

Authors: Asaf Madar1, Tom Zemer1, Ido Tavor1,2, Dino J Levy1,3
ORCID iDs: Asaf Madar, Ido Tavor, Dino J Levy
  1. Sagol School of Neuroscience, Tel Aviv University, Tel Aviv, Israel
  2. Gray School of Medical Sciences, Gray Faculty of Medical & Health Sciences, Tel Aviv University, Tel Aviv, Israel
  3. Coller School of Management, Tel Aviv University, Tel Aviv, Israel
Institutions: Tel Aviv University (Israel)
Journal: Nature communications, volume 17, issue 1, article 7816
Dates: received 2 October 2025; accepted 3 June 2026; published online 21 June 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41467-026-74462-6 · PMID 42324265 · PMCID PMC13439569 · OpenAlex W7165487396
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: human (organism), cognitive (subfield)
Methods: Connectivity, Statistics, Smoothing, state filtering, decompositions, Machine learning, fMRI & imaging
Keywords: Decision, Human behaviour
MeSH: Brain*, Choice Behavior*, Brain Mapping, Decision Making, Female, Humans, Magnetic Resonance Imaging, Male (* major topic)
Topic: Neural and Behavioral Psychology Studies (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Israel Science Foundation (ISF) (1432/23)
Citations: not cited yet (Europe PMC); 72 references in the paper

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repository

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

asafmm/neuro_decoy_effect

License: CC-BY-4.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 7a034b0a235946556b5a0113e7db85a95deabbd1, 25 May 2026
Languages: Python (9), Jupyter (8)
Size: 638 files, 17 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file, environment (requirements.txt), 8 notebooks
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (17 files), pandas (16 files), Matplotlib (13 files), SciPy (8 files), scikit-learn (5 files), statsmodels (4 files), seaborn (3 files), NiBabel (2 files), Pingouin (2 files), Pillow (1 file), PyTorch (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
19 files
At the source: github.com/asafmm/neuro_decoy_effect

Code availability statement

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

Read it in the paper: doi.org/10.1038/s41467-026-74462-6.

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;
  • 17 scripts, each with its path and the digest of its content;
  • 18 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.

Code and data availability statement

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

Read it in the paper: doi.org/10.1038/s41467-026-74462-6.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 4 authors, 2 keywords, 8 MeSH terms, 1 funder, 48 references.

Cite

This paper

Madar, A., Zemer, T., Tavor, I., & Levy, D. J. (2026). Neural similarity between choice options predicts group-level context effects. Nature communications, 17(1), 7816. https://doi.org/10.1038/s41467-026-74462-6

BibTeX

@article{madar2026neural,
author = {Madar, Asaf and Zemer, Tom and Tavor, Ido and Levy, Dino J},
title = {{Neural similarity between choice options predicts group-level context effects}},
journal = {Nature communications},
year = {2026},
month = jun,
volume = {17},
number = {1},
pages = {7816},
publisher = {Nature Publishing Group},
issn = {2041-1723},
doi = {10.1038/s41467-026-74462-6},
url = {https://doi.org/10.1038/s41467-026-74462-6},
pmid = {42324265},
pmcid = {PMC13439569}
}

RIS

TY - JOUR
AU - Madar, Asaf
AU - Zemer, Tom
AU - Tavor, Ido
AU - Levy, Dino J
TI - Neural similarity between choice options predicts group-level context effects
T2 - Nature communications
J2 - Nat Commun
PY - 2026
DA - 2026/06/21
VL - 17
IS - 1
SP - 7816
SN - 2041-1723
PB - Nature Publishing Group
DO - 10.1038/s41467-026-74462-6
UR - https://doi.org/10.1038/s41467-026-74462-6
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41467-026-74462-6",
"type": "article-journal",
"title": "Neural similarity between choice options predicts group-level context effects",
"container-title": "Nature communications",
"author": [
{
"family": "Madar",
"given": "Asaf"
},
{
"family": "Zemer",
"given": "Tom"
},
{
"family": "Tavor",
"given": "Ido"
},
{
"family": "Levy",
"given": "Dino J"
}
],
"container-title-short": "Nat Commun",
"volume": "17",
"issue": "1",
"page": "7816",
"DOI": "10.1038/s41467-026-74462-6",
"PMID": "42324265",
"PMCID": "PMC13439569",
"ISSN": "2041-1723",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41467-026-74462-6",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
21
]
]
}
}

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

Similar papers

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

[1] doi:10.1038/s41467-026-73153-6 [code]
Latent neural architecture organising shared aesthetic evaluations of visual artworks.
Journal: Nature communications
In common: Pingouin, Pillow, PyTorch, 6 other tools, cognitive, 7 references
[2] doi:10.1038/s44220-026-00680-y [code]
The neuroimaging correlates of depression established across six large-scale population datasets.
Journal: Nature. Mental health
In common: Pillow, statsmodels, seaborn, 5 other tools, 6 references
[3] doi:10.21203/rs.3.rs-9326213/v1 [code]
Multi-task fMRI outperforms resting-state fMRI for revealing task-invariant organization of the human brain
Journal: Research Square (preprint)
In common: Pillow, NiBabel, PyTorch, 6 other tools, cognitive, 4 references
[4] doi:10.64898/2026.03.09.710558 [code]
Multi-task fMRI outperforms resting-state fMRI for revealing task-invariant organization of the human brain
Journal: bioRxiv (preprint)
In common: Pillow, NiBabel, PyTorch, 6 other tools, cognitive, 4 references
[5] doi:10.1371/journal.pbio.3003684 [code]
The retrieval of previously learned motor memories is facilitated by the reinstatement of default mode network manifold structures.
Journal: PLoS biology
In common: Pingouin, NiBabel, seaborn, 5 other tools, cognitive, 4 references
[6] doi:10.1371/journal.pbio.3003856 [code]
Aging and metabolism contribute separately to brain-body health.
Journal: PLoS biology
In common: NiBabel, statsmodels, PyTorch, 6 other tools, 4 references
[7] doi:10.1002/ana.78203 [code]
AI-Driven Mapping of Seizure Spread Patterns.
Journal: Annals of neurology
In common: Pingouin, Pillow, NiBabel, 8 other tools, 1 reference
[8] doi:10.1038/s41467-026-74466-2 [code]
Neuromorphic hierarchical modular reservoirs.
Journal: Nature communications
In common: Pingouin, NiBabel, statsmodels, 6 other tools, 3 references
[9] doi:10.1167/jov.26.5.7 [code]
Representations in vision and language converge in a shared, multidimensional space of perceived similarities.
Journal: Journal of vision
In common: Pillow, NiBabel, statsmodels, 7 other tools, cognitive, 1 reference
[10] doi:10.1002/hbm.70469 [code]
VarCoNet: A Variability-Aware Self-Supervised Framework for Functional Connectome Extraction From Resting-State fMRI.
Journal: Human brain mapping
In common: Pillow, NiBabel, PyTorch, 6 other tools, 3 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.