# Model parameters kappa = 0.08 # Maximal contrast difference value sigma = 0.04 # Perceptual sensitivity # Initialize task and agent objects # --------------------------------- # Task parameters in TaskVars object task_vars = TaskVars() task_vars.T = T task_vars.B = 1 task = Task(task_vars) # Agent parameters in AgentVars object agent_vars = AgentVars() agent_vars.agent = 1 agent_vars.sigma = sigma agent_vars.task_agent_analysis = False agent = Agent(agent_vars) agent.d_t = 0 # Fix perceptual decision to d_t = 0 agent.a_t = 0 # Fix action to a_t = 0 # Sampling-based approximation object p_hat = PHat(n_bins) # Number of variables x number of samples x number of time points sample matrix S = np.full([5, n_samples, T], np.nan) # Simulation scenarios / observed random variable values # ------------------------------------------------------
def gb_simulation(n_trials, n_blocks, sigma, agent, beta, task_agent_analysis=False, eval_ana=True): """ This function runs the simulations for model demonstration :param n_trials: Number of trials :param n_blocks: Number of blocks :param sigma: Perceptual sensitivity :param agent: Agent-based computational model :param beta: Inverse temperature parameter :param task_agent_analysis: Indicates if use for data analysis or not :param eval_ana: Evaluate agent analytically :return: df_subj: Data frame containing simulated data """ # Parameter definition # -------------------- # Task parameters in GbTaskVars.py object task_vars = TaskVars() task_vars.T = n_trials task_vars.B = n_blocks task_vars.experiment = 3 # Agent parameters in GbAgentVars.py object agent_vars = AgentVars() agent_vars.sigma = sigma agent_vars.beta = beta agent_vars.c0 = np.array([1]) agent_vars.kappa = task_vars.kappa agent_vars.agent = agent agent_vars.lambda_param = np.nan agent_vars.task_agent_analysis = task_agent_analysis agent_vars.eval_ana = eval_ana # Simulation parameters in GbSimVars.py object sim_vars = SimVars() # Initialize data frame for simulation df_subj = pd.DataFrame() sleep(0.1) print('\nSimulating data for agent demonstration:') sleep(0.1) pbar = tqdm(total=task_vars.B) # Cycle over task blocks for b in range(0, task_vars.B): # Update progress bar pbar.update(1) # Block number definition sim_vars.block = b sim_vars.take_pd = 0 # Single block task-agent-interaction simulation df_block = gb_task_agent_int(task_vars, agent_vars, sim_vars) # Add data to data frame df_subj = df_subj.append(df_block, ignore_index=True) # Close progress bar pbar.close() return df_subj
def perc_model(self, exp_data): """ This function estimates the perceptual choice model :param exp_data: Experimental data :return results_list: Results of evaluation and/or estimation procedure """ # Control random number generator for reproducible results random.seed(123) # Agent parameters in GbAgentVars.py object agent_vars = AgentVars() # Add trial as index exp_data.loc[:, 'trial'] = np.linspace(0, len(exp_data) - 1, len(exp_data)) exp_data = exp_data.set_index('trial') # Initialize values min_llh = 1e10 # unrealistically high likelihood min_x = np.nan # no parameter estimate # Cycle over starting points for r in range(0, self.n_sp): # Starting point if self.rand_sp: x0 = [random.uniform(self.s_bnds[0], self.s_bnds[1])] else: x0 = np.array([self.s_fixedsp]) # Parameter boundary bnds = [self.s_bnds, ] # Run the estimation res = minimize(self.d_llh, x0, args=(exp_data, agent_vars), method='L-BFGS-B', bounds=bnds) # Extract optimization output maximum likelihood x = res.x # parameter estimate llh = res.fun # minimized negative log likelihood # Check if cumulated negative log likelihood is lower than the previous # one and select the lowest if llh < min_llh: min_llh = llh min_x = x # Add ID to results to check if participant order is maintained during parallelization self.id = np.array(list(set(exp_data['id']))) # Compute BIC with free parameter bic_d = self.compute_bic(min_llh, 1) # Initialize and fill list with results min_x = min_x.tolist() results_list = list() results_list.append(np.float(min_llh)) results_list.append(np.float(bic_d)) results_list.append(np.float(self.id)) results_list = results_list + min_x return results_list
def edm_l_model(self, exp_data, est_vars, sub_params, est_params=1, save_plot=0): """ This function computes the likelihood of the models that include economic decision making Used for both, evaluation with fixed parameters and estimation with free parameters. :param exp_data: Data of current experiment :param est_vars: Variables that are used for estimation and evaluation :param sub_params: Participants' parameter estimates :param est_params: Indicates if we evaluate model or additionally estimate a free parameter :param save_plot: Indicates if we save plot of model evaluation :return: results: Results of evaluation and estimation procedure """ # Control random number generator for reproducible results random.seed(123) # Agent parameters in GbAgentVars.py object agent_vars = AgentVars() # Select current agent agent_vars.agent = est_vars.agent self.agent = est_vars.agent # eventuell reset_index() anstatt andere Lösung. # --> https://cmdlinetips.com/2018/04/how-to-reset-index-in-pandas-dataframe/ # Reset index for perceptual parameter estimation exp_data.loc[:, 'trial'] = np.linspace(0, len(exp_data)-1, len(exp_data)) exp_data = exp_data.set_index('trial') # Evaluate likelihood of perceptual decisions f_llh_d = self.d_llh(sub_params['sigma'], exp_data, agent_vars) # Reset index for additional parameter estimation exp_data.loc[:, 'trial'] = np.tile(np.linspace(0, self.T-1, self.T), self.B) exp_data = exp_data.set_index('trial') # Add ID to results to check if participant order is maintained during parallelization self.id = np.array(list(set(exp_data['id']))) # Estimate free parameters if est_params: # Initialize values min_llh = 1e10 # unrealistically high likelihood min_x = np.nan # no parameter estimate # Cycle over starting points for r in range(0, self.n_sp): # Estimate parameters if self.agent == 1 or self.agent == 2: if self.rand_sp: x0 = [random.uniform(self.b_bnds[0], self.b_bnds[1])] else: x0 = np.array([self.b_fixedsp]) # Parameter boundary bounds = [self.b_bnds, ] elif self.agent == 3: # Starting point if self.rand_sp: x0 = [random.uniform(self.l_bnds[0], self.l_bnds[1]), random.uniform(self.b_bnds[0], self.b_bnds[1])] else: x0 = [self.l_fixedsp, self.b_fixedsp] # Parameter boundary bounds = [self.l_bnds, self.b_bnds] elif self.agent == 4 or self.agent == 5: if self.rand_sp: x0 = [random.uniform(self.b_bnds[0], self.b_bnds[1]), random.uniform(self.a_bnds[0], self.a_bnds[1])] else: x0 = [self.b_fixedsp, self.a_fixedsp] # Parameter boundary bounds = [self.b_bnds, self.a_bnds] else: if self.rand_sp: x0 = [random.uniform(self.l_bnds[0], self.l_bnds[1]), random.uniform(self.a_bnds[0], self.a_bnds[1]), random.uniform(self.b_bnds[0], self.b_bnds[1])] else: x0 = [self.l_fixedsp, self.a_fixedsp, self.b_fixedsp] # Parameter boundary bounds = [self.l_bnds, self.a_bnds, self.b_bnds] # Run the estimation res = minimize(self.a_llh, x0, args=(exp_data, sub_params, agent_vars, est_params), method='L-BFGS-B', bounds=bounds) # Extract maximum likelihood parameter estimate x = res.x # Extract minimized negative log likelihood llh = res.fun # Check if cumulated negative log likelihood is lower than the previous # one and select the lowest if llh < min_llh: min_llh = llh min_x = x # Compute BIC for economic decision if self.agent == 1 or self.agent == 2: bic_a = self.compute_bic(min_llh, 1) elif self.agent == 3 or self.agent == 4 or self.agent == 5: bic_a = self.compute_bic(min_llh, 2) else: bic_a = self.compute_bic(min_llh, 3) else: # Evaluate the model if self.agent == 1: min_llh = self.a_llh(sub_params['beta_A1'], exp_data, sub_params, agent_vars, est_params, save_plot=save_plot) elif self.agent == 2: min_llh = self.a_llh(sub_params['beta_A2'], exp_data, sub_params, agent_vars, est_params, save_plot=save_plot) elif self.agent == 3: min_llh = self.a_llh([sub_params['lambda_A3'], sub_params['beta_A3']], exp_data, sub_params, agent_vars, est_params, save_plot=save_plot) elif self.agent == 4: min_llh = self.a_llh([sub_params['beta_A4'], sub_params['alpha_A4']], exp_data, sub_params, agent_vars, est_params, save_plot=save_plot) elif self.agent == 5: min_llh = self.a_llh([sub_params['beta_A5'], sub_params['alpha_A5']], exp_data, sub_params, agent_vars, est_params, save_plot=save_plot) elif self.agent == 6: min_llh = self.a_llh([sub_params['lambda_A6'], sub_params['alpha_A6'], sub_params['beta_A6']], exp_data, sub_params, agent_vars, est_params, save_plot=save_plot) else: # A0 min_llh = self.a_llh(np.nan, exp_data, sub_params, agent_vars, est_params, save_plot=save_plot) # Compute BIC bic_a = self.compute_bic(min_llh, 0) # Compute BIC for perceptual decision without free parameters bic_d = self.compute_bic(f_llh_d, 0) # Initialize and fill list with results results_list = list() results_list.append(np.float(min_llh)) results_list.append(np.float(bic_d)) results_list.append(np.float(bic_a)) results_list.append(np.float(self.id)) results_list.append(np.float(self.agent)) if est_params: min_x = min_x.tolist() results_list = results_list + min_x return results_list
def recovsim(task_vars, sim_vars, exp_data, **kwargs): """ This function runs the simulations for parameter and model recovery :param task_vars: Variables to initialize the task object :param sim_vars: Variables to initialize the simulation object :param exp_data: Experimental data :param kwargs: Optionally; participant parameters :return: df_recov: Data-frame with simulated data """ # Extract the optionally provided parameters opt_params = kwargs.get('opt_params', None) # Agent parameters agent_vars = AgentVars() agent_vars.agent = sim_vars.agent # Initialize data frame for data that will be recovered df_recov = pd.DataFrame() # Initialize counter for simulation order sleep(0.1) print('\nSimulating data for recovery | Agent A%s:' % sim_vars.agent) sleep(0.1) pbar = tqdm(total=len(opt_params)) # Initialize array that indicates the ID of data set used for simulations which_id = np.full(len(opt_params), np.nan) # Cycle over parameters for m in range(0, len(opt_params)): # Randomly determine current data set which_id[m] = randint(0, sim_vars.N - 1) # For experiment 2 and 3 we additionally use participant parameters if task_vars.experiment == 2: agent_vars.sigma = opt_params['sigma'][m] elif task_vars.experiment == 3: agent_vars.sigma = opt_params['sigma'][m] if sim_vars.agent == 1: agent_vars.beta = opt_params['beta_A1'][m] elif sim_vars.agent == 2: agent_vars.beta = opt_params['beta_A2'][m] elif sim_vars.agent == 3: agent_vars.beta = opt_params['beta_A3'][m] agent_vars.lambda_param = opt_params['lambda_A3'][m] elif sim_vars.agent == 4: agent_vars.beta = opt_params['beta_A4'][m] agent_vars.alpha = opt_params['alpha_A4'][m] elif sim_vars.agent == 5: agent_vars.beta = opt_params['beta_A5'][m] agent_vars.alpha = opt_params['alpha_A5'][m] elif sim_vars.agent == 6: agent_vars.beta = opt_params['beta_A6'][m] agent_vars.alpha = opt_params['alpha_A6'][m] agent_vars.lambda_param = opt_params['lambda_A6'][m] # Cycle over task blocks for b in range(0, task_vars.B): # Extract data of current block exp_data_block = exp_data[(exp_data['id'] == which_id[m]) & (exp_data['b_t'] == b)].copy() # Add trial as index exp_data_block.loc[:, 'trial'] = np.linspace(0, len(exp_data_block) - 1, len(exp_data_block)) exp_data_block = exp_data_block.set_index('trial') # Block number definition sim_vars.block = b # Single block task-agent-interaction simulation df_block = gb_task_agent_int(task_vars, agent_vars, sim_vars, real_outc=exp_data_block) df_block['id'] = m df_block['blockNumber'] = b df_block['agent'] = sim_vars.agent # Add data to data frame df_recov = df_recov.append(df_block, ignore_index=True) # Update progress bar pbar.update(1) if task_vars.experiment == 2 or task_vars.experiment == 3: # Check if this is consistent across scripts # This could be adjusted at the global level df_recov = df_recov.rename(index=str, columns={"corr": "decision2.corr"}) df_recov['a_t'] = df_recov['a_t'] + 1 # Close progress par pbar.close() return df_recov
ax_0 = plt.subplot2grid((1, 3), (0, 0), colspan=1, rowspan=1) # Define colormap cmap = truncate_colormap(plt.get_cmap('bone'), 0.1, 0.9) # Create range of colors for range of contrast differences cval_ind = range(10) c_norm = colors.Normalize(vmin=0, vmax=cval_ind[-1]) scalar_map = cmx.ScalarMappable(norm=c_norm, cmap=cmap) # -------------------------------------------- # 2. Plot example of no perceptual uncertainty # -------------------------------------------- # Create agent object agent_vars = AgentVars() agent_vars.agent = 1 agent = Agent(agent_vars) # Example of \pi_0 = 1, \pi_1 = 0 agent, ax_0, v_a_t_hs, _, _, _ = plot_pmu(agent, 1, 0, cval_ind, scalar_map, ax_0) # Adjust properties of the plots ax_0.set_ylabel(r'$p_t(\mu)$') ax_0.set_xlabel(r'$\mu$') ax_0.set_title('No perceptual uncertainty') ax_0.set_ylim([-0.1, 10.1]) # ---------------------------------------------- # 3. Plot example of high perceptual uncertainty