def psychometric_choicefamily_2D(model_dir, rule, lesion_units=None, n_coh=8, n_stim_loc=20, coh_range=0.1): # Generate task parameters for choice tasks # coh_range = 0.2 # coh_range = 0.05 cohs = np.linspace(-coh_range, coh_range, n_coh) batch_size = n_stim_loc * n_coh**2 batch_shape = (n_stim_loc, n_coh, n_coh) ind_stim_loc, ind_stim_mod1, ind_stim_mod2 = np.unravel_index( range(batch_size), batch_shape) # Looping target location stim1_locs = 2 * np.pi * ind_stim_loc / n_stim_loc stim2_locs = (stim1_locs + np.pi) % (2 * np.pi) stim_mod1_cohs = cohs[ind_stim_mod1] stim_mod2_cohs = cohs[ind_stim_mod2] params_dict = dict() params_dict['dm1'] = \ {'stim1_locs' : stim1_locs, 'stim2_locs' : stim2_locs, 'stim1_strengths' : 1 + stim_mod1_cohs, # Just use mod 1 value 'stim2_strengths' : 1 - stim_mod1_cohs, 'stim_time' : 800 } params_dict['dm2'] = params_dict['dm1'] params_dict['contextdm1'] = \ {'stim1_locs' : stim1_locs, 'stim2_locs' : stim2_locs, 'stim1_mod1_strengths' : 1 + stim_mod1_cohs, 'stim2_mod1_strengths' : 1 - stim_mod1_cohs, 'stim1_mod2_strengths' : 1 + stim_mod2_cohs, 'stim2_mod2_strengths' : 1 - stim_mod2_cohs, 'stim_time' : 800 } params_dict['contextdm2'] = params_dict['contextdm1'] params_dict['contextdelaydm1'] = params_dict['contextdm1'] params_dict['contextdelaydm1']['stim_time'] = 800 params_dict['contextdelaydm2'] = params_dict['contextdelaydm1'] params_dict['multidm'] = \ {'stim1_locs' : stim1_locs, 'stim2_locs' : stim2_locs, 'stim1_mod1_strengths' : 1 + stim_mod1_cohs, 'stim2_mod1_strengths' : 1 - stim_mod1_cohs, 'stim1_mod2_strengths' : 1 + stim_mod1_cohs, # Same as Mod 1 'stim2_mod2_strengths' : 1 - stim_mod1_cohs, 'stim_time' : 800 } params_dict['contextdelaydm1'] = \ {'stim1_locs' : stim1_locs, 'stim2_locs' : stim2_locs, 'stim1_mod1_strengths' : 1 + stim_mod1_cohs, 'stim2_mod1_strengths' : 1 - stim_mod1_cohs, 'stim1_mod2_strengths' : 1 + stim_mod2_cohs, 'stim2_mod2_strengths' : 1 - stim_mod2_cohs, 'stim_time' : 800 } model = Model(model_dir) hp = model.hp with tf.Session() as sess: model.restore() model.lesion_units(sess, lesion_units) params = params_dict[rule] trial = generate_trials(rule, hp, 'psychometric', params=params) feed_dict = tools.gen_feed_dict(model, trial, hp) y_sample, y_loc_sample = sess.run([model.y_hat, model.y_hat_loc], feed_dict=feed_dict) # Compute the overall performance. # Importantly, discard trials where no decision was made loc_cor = trial.y_loc[-1] # last time point, correct locations loc_err = (loc_cor + np.pi) % (2 * np.pi) choose_cor = (get_dist(y_loc_sample[-1] - loc_cor) < THETA).sum() choose_err = (get_dist(y_loc_sample[-1] - loc_err) < THETA).sum() perf = choose_cor / (choose_cor + choose_err) # Compute the proportion of choosing choice 1 and maintain the batch_shape stim1_locs_ = np.reshape(stim1_locs, batch_shape) stim2_locs_ = np.reshape(stim2_locs, batch_shape) y_loc_sample = np.reshape(y_loc_sample[-1], batch_shape) choose1 = (get_dist(y_loc_sample - stim1_locs_) < THETA).sum(axis=0) choose2 = (get_dist(y_loc_sample - stim2_locs_) < THETA).sum(axis=0) prop1s = choose1 / (choose1 + choose2) return perf, prop1s, cohs
def lesions(self): labels = self.labels from network import get_perf from task import generate_trials # The first will be the intact network lesion_units_list = [None] for il, l in enumerate(self.unique_labels): ind_l = np.where(labels == l)[0] # In original indices lesion_units_list += [self.ind_active[ind_l]] perfs_store_list = list() perfs_changes = list() cost_store_list = list() cost_changes = list() for i, lesion_units in enumerate(lesion_units_list): model = Model(self.model_dir) hp = model.hp with tf.Session() as sess: model.restore() model.lesion_units(sess, lesion_units) perfs_store = list() cost_store = list() for rule in self.rules: n_rep = 16 batch_size_test = 256 batch_size_test_rep = int(batch_size_test / n_rep) clsq_tmp = list() perf_tmp = list() for i_rep in range(n_rep): trial = generate_trials(rule, hp, 'random', batch_size=batch_size_test_rep) feed_dict = tools.gen_feed_dict(model, trial, hp) y_hat_test, c_lsq = sess.run( [model.y_hat, model.cost_lsq], feed_dict=feed_dict) # Cost is first summed over time, and averaged across batch and units # We did the averaging over time through c_mask # IMPORTANT CHANGES: take overall mean perf_test = np.mean(get_perf(y_hat_test, trial.y_loc)) clsq_tmp.append(c_lsq) perf_tmp.append(perf_test) perfs_store.append(np.mean(perf_tmp)) cost_store.append(np.mean(clsq_tmp)) perfs_store = np.array(perfs_store) cost_store = np.array(cost_store) perfs_store_list.append(perfs_store) cost_store_list.append(cost_store) if i > 0: perfs_changes.append(perfs_store - perfs_store_list[0]) cost_changes.append(cost_store - cost_store_list[0]) perfs_changes = np.array(perfs_changes) cost_changes = np.array(cost_changes) return perfs_changes, cost_changes
def load_data(model_dir=None, sigma_rec=0, lesion_units=None, n_rep=1): """Generate model data into standard format. Returns: data: standard format, list of dict of arrays/dict list is over neurons dict is for response array and task variable dict response array has shape (n_trial, n_time) """ if model_dir is None: model_dir = './mantetemp' # TEMPORARY SETTING # Get rules and regressors rules = ['contextdm1', 'contextdm2'] n_rule = len(rules) data = list() model = Model(model_dir, sigma_rec=sigma_rec) hp = model.hp with tf.Session() as sess: model.restore() if lesion_units is not None: model.lesion_units(sess, lesion_units) # Generate task parameters used # Target location stim1_loc_list = np.arange(0, 2*np.pi, 2*np.pi/12) for stim1_loc in stim1_loc_list: params, batch_size = _gen_taskparams(stim1_loc=stim1_loc, n_rep=n_rep) stim1_locs_tmp = np.tile(params['stim1_locs'], n_rule) x = list() # Network input y_loc = list() # Network target output location # Start computing the neural activity for i, rule in enumerate(rules): # Generating task information trial = generate_trials(rule, hp, 'psychometric', params=params, noise_on=True) x.append(trial.x) y_loc.append(trial.y_loc) x = np.concatenate(x, axis=1) y_loc = np.concatenate(y_loc, axis=1) # Coherences stim_mod1_cohs = params['stim1_mod1_strengths'] - params[ 'stim2_mod1_strengths'] stim_mod2_cohs = params['stim1_mod2_strengths'] - params[ 'stim2_mod2_strengths'] stim_mod1_cohs /= stim_mod1_cohs.max() stim_mod2_cohs /= stim_mod2_cohs.max() # Get neural activity fetches = [model.h, model.y_hat, model.y_hat_loc] H, y_sample, y_sample_loc = sess.run( fetches, feed_dict={model.x: x}) # Downsample in time dt_new = 50 every_t = int(dt_new / hp['dt']) # Only analyze the target epoch epoch = trial.epochs['stim1'] H = H[epoch[0]:epoch[1], ...][int(every_t / 2)::every_t, ...] # Get performance and choices # perfs = get_perf(y_sample, y_loc) # y_choice is 1 for choosing stim1_loc, otherwise -1 y_actual_choice = 2*(get_dist(y_sample_loc[-1]-stim1_loc)<np.pi/2)-1 y_target_choice = 2*(get_dist(y_loc[-1]-stim1_loc)<np.pi/2)-1 # Get task variables task_var = dict() task_var['targ_dir'] = y_actual_choice task_var['stim_dir'] = np.tile(stim_mod1_cohs, n_rule) task_var['stim_col2dir'] = np.tile(stim_mod2_cohs, n_rule) task_var['context'] = np.repeat([1, -1], batch_size) task_var['correct'] = (y_actual_choice == y_target_choice).astype(int) task_var['stim_dir_sign'] = (task_var['stim_dir']>0).astype(int)*2-1 task_var['stim_col2dir_sign'] = (task_var['stim_col2dir']>0).astype(int)*2-1 n_unit = H.shape[-1] for i_unit in range(n_unit): unit_dict = { 'rate': H[:, :, i_unit].T, # standard format (n_trial, n_time) 'task_var': copy.deepcopy(task_var) } data.append(unit_dict) return data