def sequence_rewards_errors_regression(data, perm=True): dm = data['DM'][0] firing = data['Data'][0] C = [] cpd = [] for s, sess in enumerate(dm): runs_list = [] runs_list.append(0) DM = dm[s] firing_rates = firing[s] n_trials, n_neurons, n_timepoints = firing_rates.shape choices = DM[:, 1] reward = DM[:, 2] state = DM[:, 0] cum_error = [] err = 0 for r in reward: if r == 0: err += 1 else: err = 0 cum_error.append(err) cum_reward = [] for r in reward: if r == 1: err += 1 else: err = 0 cum_reward.append(err) ones = np.ones(len(reward)) predictors_all = OrderedDict([('Reward', reward), ('Choice', choices), ('State', state), ('Errors', cum_error), ('Rewards', cum_reward), ('ones', ones)]) X = np.vstack( predictors_all.values()).T[:len(choices), :].astype(float) n_predictors = X.shape[1] y = firing_rates.reshape( [len(firing_rates), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] tstats = reg_f.regression_code(y, X) C.append(tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings cpd.append( re._CPD(X, y).reshape(n_neurons, n_timepoints, n_predictors)) cpd = np.nanmean(np.concatenate(cpd, 0), axis=0) C = np.concatenate(C, 1) high_loadings_rewards = np.where(abs(np.mean(C[4, :, :20], 1)) > 2.5)[0] high_loadings_errors = np.where(abs(np.mean(C[3, :, :20], 1)) > 2.5)[0] return high_loadings_errors, high_loadings_rewards
def within_taks_codes(data, area='HP', perm=5): dm = data['DM'][0] firing = data['Data'][0] C = [] cpd = [] cpd_perm_p = [] for s, sess in enumerate(dm): cpd_perm = [[] for i in range(perm) ] # To store permuted predictor loadings for each session. runs_list = [] runs_list.append(0) DM = dm[s] firing_rates = firing[s] n_trials, n_neurons, n_timepoints = firing_rates.shape state = DM[:, 0] choices = DM[:, 1] reward = DM[:, 2] reward_2_ago = 0.5 - reward[1:-2] reward_3_ago = 0.5 - reward[:-3] reward_prev = 0.5 - reward[2:-1] reward_current = reward[3:] # reward_o_1_ago = np.asarray(reward_prev) # reward_o_2_ago = np.asarray(reward_2_ago) # reward_o_3_ago = np.asarray(reward_3_ago) firing_rates = firing_rates[3:] choices_2_ago = 0.5 - choices[1:-2] choices_3_ago = 0.5 - choices[:-3] choices_prev = 0.5 - choices[2:-1] choices_current = choices[3:] state = state[3:] cum_reward_orth = np.vstack( [reward_current, np.ones(len(reward_current))]).T xt = np.linalg.pinv(cum_reward_orth) identity = np.identity(len(reward_current)) id_x = (identity - np.matmul(cum_reward_orth, xt)) # choice_o_1_ago = np.matmul(id_x, np.asarray(choices_prev)) # choice_o_2_ago = np.matmul(id_x, np.asarray(choices_2_ago)) # choice_o_3_ago = np.matmul(id_x, np.asarray(choices_3_ago)) ch_rew_int_1 = choices_prev * reward_prev ch_rew_int_2 = choices_2_ago * reward_2_ago ch_rew_int_3 = choices_3_ago * reward_3_ago ones = np.ones(len(choices_3_ago)) predictors_all = OrderedDict([('Reward', reward_current), ('Choice', choices_current), ('1 ago Outcome', reward_prev), ('2 ago Outcome', reward_2_ago), ('3 ago Outcome', reward_3_ago), ('1 ago Choice', choices_prev), ('2 ago Choice', choices_2_ago), ('3 ago Choice', choices_3_ago), ('1 Rew x Choice', ch_rew_int_1), ('2 Rew x Choice', ch_rew_int_2), ('3 Rew x Choice', ch_rew_int_3), ('ones', ones)]) X = np.vstack( predictors_all.values()).T[:len(choices_current), :].astype(float) rank = np.linalg.matrix_rank(X) print(rank) print(X.shape[1]) n_predictors = X.shape[1] y = firing_rates.reshape( [len(firing_rates), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] tstats = reg_f.regression_code(y, X) C.append(tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings cpd.append( re._CPD(X, y).reshape(n_neurons, n_timepoints, n_predictors)) if perm: for i in range(perm): y_perm = np.roll(y, np.random.randint(len(y)), axis=0) cpd_temp = re._CPD(X, y_perm).reshape(n_neurons, n_timepoints, n_predictors) cpd_perm[i].append(np.nanmean(cpd_temp, axis=0)) cpd_perm_p.append(np.percentile(cpd_perm, 95, axis=0)) if perm: # Evaluate P values. cpd_perm_pval = np.mean(cpd_perm_p, 0)[0] #cpd_perm_p = np.percentile(cpd_perm,95, axis = 0) C = np.concatenate(C, 1) cpd = np.nanmean(np.concatenate(cpd, 0), axis=0) plt.figure() pred = list(predictors_all.keys()) array_pvals = np.ones((cpd.shape[0], cpd.shape[1])) for i in range(cpd.shape[1]): array_pvals[(np.where(cpd[:, i] > cpd_perm_pval[:, i])[0]), i] = 0.05 ymax = np.max(cpd[:, 2:-1].T) t = np.arange(0, 121) c = wes.Darjeeling2_5.mpl_colors + wes.Mendl_4.mpl_colors + wes.GrandBudapest1_4.mpl_colors + wes.Moonrise1_5.mpl_colors for i in np.arange(cpd.shape[1]): if i > 1 and i < cpd.shape[1] - 1: plt.plot(cpd[:, i], label=pred[i], color=c[i]) y = ymax * (1 + 0.04 * i) p_vals = array_pvals[:, i] t05 = t[p_vals == 0.05] plt.plot(t05, np.ones(t05.shape) * y, '.', markersize=5, color=c[i]) plt.legend() plt.ylabel('CPD') plt.xlabel('Time in Trial') plt.xticks([24, 35, 42], ['I', 'C', 'R']) plt.legend() sns.despine() plt.title(area)
def chosen_value_reg(data, area='PFC', n=10, perm=True): if perm: dm = data[0] firing = data[1] else: dm = data['DM'][0] firing = data['Data'][0] C_1 = [] C_2 = [] C_3 = [] cpd_1 = [] cpd_2 = [] cpd_3 = [] average = vg.rew_prev_behaviour(data, n=n, perm=perm) for s, sess in enumerate(dm): DM = dm[s] firing_rates = firing[s] # firing_rates = scipy.stats.zscore(firing_rates,0) #firing_rates = firing_rates - np.mean(firing_rates,0) n_trials, n_neurons, n_timepoints = firing_rates.shape choices = DM[:, 1] reward = DM[:, 2] task = DM[:, 5] a_pokes = DM[:, 6] b_pokes = DM[:, 7] taskid = vg.task_ind(task, a_pokes, b_pokes) task_1 = np.where(taskid == 1)[0] task_2 = np.where(taskid == 2)[0] task_3 = np.where(taskid == 3)[0] reward_current = reward choices_current = choices - 0.5 rewards_1 = reward_current[task_1] choices_1 = choices_current[task_1] previous_rewards_1 = scipy.linalg.toeplitz(rewards_1, np.zeros( (1, n)))[n - 1:-1] previous_choices_1 = scipy.linalg.toeplitz(0.5 - choices_1, np.zeros((1, n)))[n - 1:-1] interactions_1 = scipy.linalg.toeplitz( (((0.5 - choices_1) * (rewards_1 - 0.5)) * 2), np.zeros( (1, n)))[n - 1:-1] ones = np.ones(len(interactions_1)).reshape(len(interactions_1), 1) X_1 = np.hstack( [previous_rewards_1, previous_choices_1, interactions_1, ones]) #average_val_ex_ch = np.concatenate([average[n].reshape(1),average[n*2:]]) #X_exl_1 = np.concatenate([X_1[:,n].reshape(len(X_1),1),X_1[:,n*2:]],1) #value = np.matmul(X[:,n*2:], average[n*2:]) value_1 = np.matmul(X_1, average) #value_1 =np.matmul(X_exl_1, average_val_ex_ch) rewards_1 = rewards_1[n:] choices_1 = choices_1[n:] value_1_choice_1 = value_1 * choices_1 ones_1 = np.ones(len(choices_1)) trials_1 = len(choices_1) prev_ch_reward_1 = choices_1 * rewards_1 firing_rates_1 = firing_rates[task_1][n:] predictors_all = OrderedDict([ ('Choice', choices_1), ('Reward', rewards_1), ('Value', value_1), ('Value Сhoice', value_1_choice_1), ('Prev Rew Ch', prev_ch_reward_1), # ('Prev Rew', prev_reward_1), # ('Prev Ch', prev_choice_1), ('ones', ones_1) ]) X_1 = np.vstack(predictors_all.values()).T[:trials_1, :].astype(float) n_predictors = X_1.shape[1] y_1 = firing_rates_1.reshape( [len(firing_rates_1), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] # tstats,x = regression_code_session(y_1, X_1) #tstats = reg_f.regression_code(y_1, X_1) ols = LinearRegression() ols.fit(X_1, y_1) C_1.append(ols.coef_.reshape(n_neurons, n_timepoints, n_predictors)) # Predictor loadings #C_1.append(tstats.reshape(n_predictors,n_neurons,n_timepoints)) # Predictor loadings cpd_1.append( re._CPD(X_1, y_1).reshape(n_neurons, n_timepoints, n_predictors)) rewards_2 = reward_current[task_2] choices_2 = choices_current[task_2] previous_rewards_2 = scipy.linalg.toeplitz(rewards_2, np.zeros( (1, n)))[n - 1:-1] previous_choices_2 = scipy.linalg.toeplitz(0.5 - choices_2, np.zeros((1, n)))[n - 1:-1] interactions_2 = scipy.linalg.toeplitz( (((0.5 - choices_2) * (rewards_2 - 0.5)) * 2), np.zeros( (1, n)))[n - 1:-1] ones = np.ones(len(interactions_2)).reshape(len(interactions_2), 1) X_2 = np.hstack( [previous_rewards_2, previous_choices_2, interactions_2, ones]) # average_val_ex_ch = np.concatenate([average[n].reshape(1),average[n*2:]]) # X_exl_2 = np.concatenate([X_2[:,n].reshape(len(X_2),1),X_2[:,n*2:]],1) # value = np.matmul(X[:,n*2:], average[n*2:]) value_2 = np.matmul(X_2, average) #value_2 =np.matmul(X_exl_2, average_val_ex_ch) rewards_2 = rewards_2[n:] choices_2 = choices_2[n:] value_2_choice_2 = choices_2 * value_2 ones_2 = np.ones(len(choices_2)) trials_2 = len(choices_2) firing_rates_2 = firing_rates[task_2][n:] prev_ch_reward_2 = choices_2 * rewards_2 predictors_all = OrderedDict([ ('Choice', choices_2), ('Reward', rewards_2), ('Value', value_2), ('Value Сhoice', value_2_choice_2), ('Prev Rew Ch', prev_ch_reward_2), # # ('Prev Rew', prev_reward_2), # ('Prev Ch', prev_choice_2), ('ones', ones_2) ]) X_2 = np.vstack(predictors_all.values()).T[:trials_2, :].astype(float) n_predictors = X_2.shape[1] y_2 = firing_rates_2.reshape( [len(firing_rates_2), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] # tstats,x = regression_code_session(y_2, X_2) ols = LinearRegression() ols.fit(X_2, y_2) C_2.append(ols.coef_.reshape(n_neurons, n_timepoints, n_predictors)) # Predictor loadings cpd_2.append( re._CPD(X_2, y_2).reshape(n_neurons, n_timepoints, n_predictors)) rewards_3 = reward_current[task_3] choices_3 = choices_current[task_3] previous_rewards_3 = scipy.linalg.toeplitz(rewards_3, np.zeros( (1, n)))[n - 1:-1] previous_choices_3 = scipy.linalg.toeplitz(0.5 - choices_3, np.zeros((1, n)))[n - 1:-1] interactions_3 = scipy.linalg.toeplitz( (((0.5 - choices_3) * (rewards_3 - 0.5)) * 2), np.zeros( (1, n)))[n - 1:-1] ones = np.ones(len(interactions_3)).reshape(len(interactions_3), 1) X_3 = np.hstack( [previous_rewards_3, previous_choices_3, interactions_3, ones]) # average_val_ex_ch = np.concatenate([average[n].reshape(1),average[n*2:]]) # X_exl_3 = np.concatenate([X_3[:,n].reshape(len(X_3),1),X_3[:,n*2:]],1) # # value = np.matmul(X[:,n*2:], average[n*2:]) value_3 = np.matmul(X_3, average) # value_3 =np.matmul(X_exl_3, average_val_ex_ch) rewards_3 = rewards_3[n:] choices_3 = choices_3[n:] value_3_choice_3 = choices_3 * value_3 prev_ch_reward_3 = choices_3 * rewards_3 ones_3 = np.ones(len(choices_3)) trials_3 = len(choices_3) firing_rates_3 = firing_rates[task_3][n:] predictors_all = OrderedDict([ ('Ch', choices_3), ('Rew', rewards_3), ('Value', value_3), ('Value Сhoice', value_3_choice_3), # ('Prev Rew Ch', prev_ch_reward_3), # ('Prev Rew', prev_reward_3), # ('Prev Ch', prev_choice_3), ('ones', ones_3) ]) X_3 = np.vstack(predictors_all.values()).T[:trials_3, :].astype(float) n_predictors = X_3.shape[1] y_3 = firing_rates_3.reshape( [len(firing_rates_3), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] #tstats,x = regression_code_session(y_3, X_3) ols = LinearRegression() ols.fit(X_3, y_3) C_3.append(ols.coef_.reshape(n_neurons, n_timepoints, n_predictors)) # Predictor loadings # C_3.append(tstats.reshape(n_predictors,n_neurons,n_timepoints)) # Predictor loadings cpd_3.append( re._CPD(X_3, y_3).reshape(n_neurons, n_timepoints, n_predictors)) C_1 = np.concatenate(C_1, 0) C_2 = np.concatenate(C_2, 0) C_3 = np.concatenate(C_3, 0) C_2_inf = [~np.isinf(C_2[0]).any(axis=1)] C_2_nan = [~np.isnan(C_2[0]).any(axis=1)] C_3_inf = [~np.isinf(C_3[0]).any(axis=1)] C_3_nan = [~np.isnan(C_3[0]).any(axis=1)] C_1_inf = [~np.isinf(C_1[0]).any(axis=1)] C_1_nan = [~np.isnan(C_1[0]).any(axis=1)] nans = np.asarray(C_1_inf) & np.asarray(C_1_nan) & np.asarray( C_3_inf) & np.asarray(C_3_nan) & np.asarray(C_2_inf) & np.asarray( C_2_nan) C_1 = np.transpose(C_1[:, nans[0], :], [2, 0, 1]) C_2 = np.transpose(C_2[:, nans[0], :], [2, 0, 1]) C_3 = np.transpose(C_3[:, nans[0], :], [2, 0, 1]) return C_1, C_2, C_3
def regression_on_Q_values(experiment,experiment_sim_Q1_value_a,experiment_sim_Q1_value_b, experiment_sim_Q4_values): C_1 = [] cpd = [] C_sq = [] # Finding correlation coefficients for task 1 for s,session in enumerate(experiment): aligned_spikes= session.aligned_rates[:] if aligned_spikes.shape[1] > 0: # sessions with neurons? n_trials, n_neurons, n_timepoints = aligned_spikes.shape Q_1_a = np.asarray(experiment_sim_Q1_value_a[s]) Q_1_b = np.asarray(experiment_sim_Q1_value_b[s]) Q_4 = np.asarray(experiment_sim_Q4_values[s]) Q_1_a = Q_1_a[:-1] Q_1_b = Q_1_b[:-1] Q_4 = Q_4[:-1] # Getting out task indicies forced_trials = session.trial_data['forced_trial'] outcomes = session.trial_data['outcomes'] choices = session.trial_data['choices'] non_forced_array = np.where(forced_trials == 0)[0] Q_1_a = Q_1_a[non_forced_array] Q_1_b = Q_1_b[non_forced_array] Q_4 = Q_4[non_forced_array] choices = choices[non_forced_array] aligned_spikes = aligned_spikes[:len(choices),:,:] outcomes = outcomes[non_forced_array] # Getting out task indicies ones = np.ones(len(choices)) predictors = OrderedDict([('Q1_a', Q_1_a), ('Q1_b', Q_1_b), ('Q_4', Q_4), ('choice', choices), ('reward', outcomes), ('ones', ones)]) X = np.vstack(predictors.values()).T[:len(choices),:].astype(float) n_predictors = X.shape[1] y = aligned_spikes.reshape([len(aligned_spikes),-1]) # Activity matrix [n_trials, n_neurons*n_timepoints] ols = LinearRegression(copy_X = True,fit_intercept= True) ols.fit(X,y) C_1.append(ols.coef_.reshape(n_neurons,n_timepoints, n_predictors)) # Predictor loadings C_sq.append((ols.coef_.reshape(n_neurons,n_timepoints, n_predictors)**2)) cpd.append(re._CPD(X,y).reshape(n_neurons,n_timepoints, n_predictors)) cpd = np.nanmean(np.concatenate(cpd,0), axis = 0) # Population CPD is mean over neurons. C_sq = np.nanmean(np.concatenate(C_sq,0), axis = 0) # Population CPD is mean over neurons. return cpd, predictors,C_sq, C_1
def regression_latent_state(experiment, experiment_sim_Q4_values): C_1 = [] C_coef = [] cpd_1 = [] # Finding correlation coefficients for task 1 for s,session in enumerate(experiment): aligned_spikes= session.aligned_rates[:] if aligned_spikes.shape[1] > 0: # sessions with neurons? n_trials, n_neurons, n_timepoints = aligned_spikes.shape #aligned_spikes = np.mean(aligned_spikes, axis = 2) # Getting out task indicies task = session.trial_data['task'] forced_trials = session.trial_data['forced_trial'] non_forced_array = np.where(forced_trials == 0)[0] task_non_forced = task[non_forced_array] task_1 = np.where(task_non_forced == 1)[0] task_2 = np.where(task_non_forced == 2)[0] predictor_A_Task_1, predictor_A_Task_2, predictor_A_Task_3,\ predictor_B_Task_1, predictor_B_Task_2, predictor_B_Task_3, reward,\ predictor_a_good_task_1,predictor_a_good_task_2, predictor_a_good_task_3 = re.predictors_pokes(session) # Getting out task indicies Q4 = experiment_sim_Q4_values[s] forced_trials = session.trial_data['forced_trial'] outcomes = session.trial_data['outcomes'] choices = session.trial_data['choices'] non_forced_array = np.where(forced_trials == 0)[0] choices = choices[non_forced_array] Q4 = Q4[non_forced_array] aligned_spikes = aligned_spikes[:len(choices),:] outcomes = outcomes[non_forced_array] # Getting out task indicies ones = np.ones(len(choices)) choices = choices[:len(task_1)] outcomes = outcomes[:len(task_1)] latent_state = np.ones(len(task_1)) latent_state[predictor_a_good_task_1] = -1 ones = ones[:len(task_1)] aligned_spikes = aligned_spikes[:len(task_1)] Q4 = Q4[:len(task_1)] choice_Q4 = choices*Q4 predictors = OrderedDict([#('latent_state',latent_state), ('choice', choices), ('reward', outcomes), ('Q4', Q4), ('choice_Q4',choice_Q4), ('ones', ones)]) X = np.vstack(predictors.values()).T[:len(choices),:].astype(float) n_predictors = X.shape[1] y = aligned_spikes.reshape([len(aligned_spikes),-1]) # Activity matrix [n_trials, n_neurons*n_timepoints] tstats = reg_f.regression_code(y, X) ols = LinearRegression(copy_X = True,fit_intercept= True) ols.fit(X,y) C_coef.append(ols.coef_.reshape(n_neurons, n_predictors,n_timepoints)) # Predictor loadings C_1.append(tstats.reshape(n_predictors,n_neurons,n_timepoints)) # Predictor loadings cpd_1.append(re._CPD(X,y).reshape(n_neurons,n_timepoints, n_predictors)) C_1 = np.concatenate(C_1, axis = 1) # C_coef = np.concatenate(C_coef, axis = 0) # cpd_1 = np.nanmean(np.concatenate(cpd_1,0), axis = 0) C_2 = [] C_coef_2 = [] cpd_2 = [] # Finding correlation coefficients for task 1 for s,session in enumerate(experiment): aligned_spikes= session.aligned_rates[:] if aligned_spikes.shape[1] > 0: # sessions with neurons? n_trials, n_neurons, n_timepoints = aligned_spikes.shape #aligned_spikes = np.mean(aligned_spikes, axis = 2) Q4 = experiment_sim_Q4_values[s] # Getting out task indicies task = session.trial_data['task'] forced_trials = session.trial_data['forced_trial'] non_forced_array = np.where(forced_trials == 0)[0] task_non_forced = task[non_forced_array] task_1 = np.where(task_non_forced == 1)[0] task_2 = np.where(task_non_forced == 2)[0] predictor_A_Task_1, predictor_A_Task_2, predictor_A_Task_3,\ predictor_B_Task_1, predictor_B_Task_2, predictor_B_Task_3, reward,\ predictor_a_good_task_1,predictor_a_good_task_2, predictor_a_good_task_3 = re.predictors_pokes(session) # Getting out task indicies forced_trials = session.trial_data['forced_trial'] outcomes = session.trial_data['outcomes'] choices = session.trial_data['choices'] non_forced_array = np.where(forced_trials == 0)[0] Q4 = Q4[non_forced_array] choices = choices[non_forced_array] aligned_spikes = aligned_spikes[:len(choices),:] outcomes = outcomes[non_forced_array] # Getting out task indicies ones = np.ones(len(choices)) choices = choices[len(task_1):len(task_1)+len(task_2)] latent_state = np.ones(len(choices)) latent_state[predictor_a_good_task_2] = -1 outcomes = outcomes[len(task_1):len(task_1)+len(task_2)] ones = ones[len(task_1):len(task_1)+len(task_2)] aligned_spikes = aligned_spikes[len(task_1):len(task_1)+len(task_2)] Q4 = Q4[len(task_1):len(task_1)+len(task_2)] choice_Q4 = choices*Q4 predictors = OrderedDict([#('latent_state',latent_state), ('choice', choices), ('reward', outcomes), ('Q4',Q4), ('choice_Q4',choice_Q4), ('ones', ones)]) X = np.vstack(predictors.values()).T[:len(choices),:].astype(float) n_predictors = X.shape[1] y = aligned_spikes.reshape([len(aligned_spikes),-1]) # Activity matrix [n_trials, n_neurons*n_timepoints] tstats = reg_f.regression_code(y, X) C_2.append(tstats.reshape(n_predictors,n_neurons,n_timepoints)) # Predictor loadings ols = LinearRegression(copy_X = True,fit_intercept= True) ols.fit(X,y) C_coef_2.append(ols.coef_.reshape(n_neurons, n_predictors,n_timepoints)) # Predictor loadings cpd_2.append(re._CPD(X,y).reshape(n_neurons,n_timepoints, n_predictors)) C_2 = np.concatenate(C_2, axis = 1) # Population CPD is mean over neurons. C_coef_2 = np.concatenate(C_coef_2, axis = 0) # Population CPD is mean over neurons. cpd_2 = np.nanmean(np.concatenate(cpd_2,0), axis = 0) C_3 = [] C_coef_3 = [] cpd_3 = [] # Finding correlation coefficients for task 1 for s,session in enumerate(experiment): aligned_spikes= session.aligned_rates[:] if aligned_spikes.shape[1] > 0: # sessions with neurons? n_trials, n_neurons, n_timepoints = aligned_spikes.shape #aligned_spikes = np.mean(aligned_spikes, axis = 2) # Getting out task indicies task = session.trial_data['task'] forced_trials = session.trial_data['forced_trial'] non_forced_array = np.where(forced_trials == 0)[0] task_non_forced = task[non_forced_array] task_1 = np.where(task_non_forced == 1)[0] task_2 = np.where(task_non_forced == 2)[0] Q4 = experiment_sim_Q4_values[s] predictor_A_Task_1, predictor_A_Task_2, predictor_A_Task_3,\ predictor_B_Task_1, predictor_B_Task_2, predictor_B_Task_3, reward,\ predictor_a_good_task_1,predictor_a_good_task_2, predictor_a_good_task_3 = re.predictors_pokes(session) # Getting out task indicies forced_trials = session.trial_data['forced_trial'] outcomes = session.trial_data['outcomes'] choices = session.trial_data['choices'] non_forced_array = np.where(forced_trials == 0)[0] Q4 = Q4[non_forced_array] choices = choices[non_forced_array] aligned_spikes = aligned_spikes[:len(choices),:] outcomes = outcomes[non_forced_array] # Getting out task indicies ones = np.ones(len(choices)) choices = choices[len(task_1)+len(task_2):] latent_state = np.ones(len(choices)) latent_state[predictor_a_good_task_3] = -1 outcomes = outcomes[len(task_1)+len(task_2):] ones = ones[len(task_1)+len(task_2):] Q4 = Q4[len(task_1)+len(task_2):] choice_Q4 = choices*Q4 aligned_spikes = aligned_spikes[len(task_1)+len(task_2):] predictors = OrderedDict([#('latent_state', latent_state), ('choice', choices), ('reward', outcomes), ('Q4', Q4), ('choice_Q4',choice_Q4), ('ones', ones)]) X = np.vstack(predictors.values()).T[:len(choices),:].astype(float) n_predictors = X.shape[1] y = aligned_spikes.reshape([len(aligned_spikes),-1]) # Activity matrix [n_trials, n_neurons*n_timepoints] tstats = reg_f.regression_code(y, X) C_3.append(tstats.reshape(n_predictors,n_neurons,n_timepoints)) # Predictor loadings ols = LinearRegression(copy_X = True,fit_intercept= True) ols.fit(X,y) C_coef_3.append(ols.coef_.reshape(n_neurons,n_timepoints, n_predictors)) # Predictor loadings cpd_3.append(re._CPD(X,y).reshape(n_neurons,n_timepoints, n_predictors)) C_3 = np.concatenate(C_3, axis = 1) # Population CPD is mean over neurons. C_coef_3 = np.concatenate(C_coef_3, axis = 0) # Population CPD is mean over neurons. cpd_3 = np.nanmean(np.concatenate(cpd_3,0), axis = 0) return C_1, C_2, C_3, C_coef,C_coef_2,C_coef_3,cpd_1,cpd_2,cpd_3,predictors
def time_in_block_corr(PFC, area = 'PFC', n = 11, plot_a = False, plot_b = False): all_subjects = [PFC['DM'][0][:9], PFC['DM'][0][9:25],PFC['DM'][0][25:39],PFC['DM'][0][39:]] all_firing = [PFC['Data'][0][:9], PFC['Data'][0][9:25],PFC['Data'][0][25:39],PFC['Data'][0][39:]] # all_subjects = [HP['DM'][0][:16], HP['DM'][0][16:24],HP['DM'][0][24:],PFC['DM'][0][:9], PFC['DM'][0][9:25],PFC['DM'][0][25:39],PFC['DM'][0][39:]] # all_firing = [HP['Data'][0][:16], HP['Data'][0][16:24],HP['Data'][0][24:],PFC['Data'][0][:9], PFC['Data'][0][9:25],PFC['Data'][0][25:39],PFC['Data'][0][39:]] # all_subjects = [HP['DM'][0][:16], HP['DM'][0][16:24],HP['DM'][0][24:]] # all_firing = [HP['Data'][0][:16], HP['Data'][0][16:24],HP['Data'][0][24:]] C_1_all = []; C_2_all = []; C_3_all = [] cpd_1 = []; cpd_2 = []; cpd_3 = [] average = vg.rew_prev_behaviour(PFC, n = n, perm = False) # average = vg.rew_prev_behaviour(HP, n = n, perm = False) for d,dd in enumerate(all_subjects): C_1 = []; C_2 = []; C_3 = [] dm = all_subjects[d] firing = all_firing[d] for s, sess in enumerate(dm): # if d <3: # average=average_2 # else: # average=average_1 DM = dm[s] firing_rates = firing[s] n_trials, n_neurons, n_timepoints = firing_rates.shape choices = DM[:,1] reward = DM[:,2] task = DM[:,5] a_pokes = DM[:,6] b_pokes = DM[:,7] taskid = vg.task_ind(task, a_pokes, b_pokes) task_1 = np.where(taskid == 1)[0] task_2 = np.where(taskid == 2)[0] task_3 = np.where(taskid == 3)[0] reward_current = reward choices_current = choices-0.5 rewards_1 = reward_current[task_1] choices_1 = choices_current[task_1] previous_rewards_1 = scipy.linalg.toeplitz(rewards_1, np.zeros((1,n)))[n-1:-1] previous_choices_1 = scipy.linalg.toeplitz(0.5-choices_1, np.zeros((1,n)))[n-1:-1] interactions_1 = scipy.linalg.toeplitz((((0.5-choices_1)*(rewards_1-0.5))*2),np.zeros((1,n)))[n-1:-1] ones = np.ones(len(interactions_1)).reshape(len(interactions_1),1) X_1 = np.hstack([previous_rewards_1,previous_choices_1,interactions_1,ones]) #average_val_ex_ch = np.concatenate([average[n].reshape(1),average[n*2:]]) #X_exl_1 = np.concatenate([X_1[:,n].reshape(len(X_1),1),X_1[:,n*2:]],1) #value = np.matmul(X[:,n*2:], average[n*2:]) value_1 =np.matmul(X_1, average) #value_1 =np.matmul(X_exl_1, average_val_ex_ch) rewards_1 = rewards_1[n:] choices_1 = choices_1[n:] ones_1 = np.ones(len(choices_1)) trials_1 = len(choices_1) value_1_choice_1 = choices_1*value_1 firing_rates_1 = firing_rates[task_1][n:] a_1 = np.where(choices_1 == 0.5)[0] b_1 = np.where(choices_1 == -0.5)[0] if plot_a == True: rewards_1 = rewards_1[a_1] choices_1 = choices_1[a_1] value_1 = value_1[a_1] ones_1 = ones_1[a_1] firing_rates_1 = firing_rates_1[a_1] # rewards_1 = scipy.stats.zscore(rewards_1) # value_1 = scipy.stats.zscore(value_1) elif plot_b == True: rewards_1 = rewards_1[b_1] choices_1 = choices_1[b_1] value_1 = value_1[b_1] ones_1 = ones_1[b_1] firing_rates_1 = firing_rates_1[b_1] # rewards_1 = scipy.stats.zscore(rewards_1) # value_1 = scipy.stats.zscore(value_1) predictors_all = OrderedDict([ ('Choice', choices_1), ('Reward', rewards_1), ('Value',value_1), ('Value Сhoice',value_1_choice_1), # ('Prev Rew Ch', prev_ch_reward_1), # ('Prev Rew', prev_reward_1), # ('Prev Ch', prev_choice_1), ('ones', ones_1) ]) X_1 = np.vstack(predictors_all.values()).T[:trials_1,:].astype(float) n_predictors = X_1.shape[1] y_1 = firing_rates_1.reshape([len(firing_rates_1),-1]) # Activity matrix [n_trials, n_neurons*n_timepoints] # tstats,x = regression_code_session(y_1, X_1) #tstats = reg_f.regression_code(y_1, X_1) ols = LinearRegression() ols.fit(X_1,y_1) C_1.append(ols.coef_.reshape(n_neurons, n_timepoints, n_predictors)) # Predictor loadings #C_1.append(tstats.reshape(n_predictors,n_neurons,n_timepoints)) # Predictor loadings cpd_1.append(re._CPD(X_1,y_1).reshape(n_neurons, n_timepoints, n_predictors)) rewards_2 = reward_current[task_2] choices_2 = choices_current[task_2] previous_rewards_2 = scipy.linalg.toeplitz(rewards_2, np.zeros((1,n)))[n-1:-1] previous_choices_2 = scipy.linalg.toeplitz(0.5-choices_2, np.zeros((1,n)))[n-1:-1] interactions_2 = scipy.linalg.toeplitz((((0.5-choices_2)*(rewards_2-0.5))*2),np.zeros((1,n)))[n-1:-1] ones = np.ones(len(interactions_2)).reshape(len(interactions_2),1) X_2 = np.hstack([previous_rewards_2,previous_choices_2,interactions_2,ones]) # average_val_ex_ch = np.concatenate([average[n].reshape(1),average[n*2:]]) # X_exl_2 = np.concatenate([X_2[:,n].reshape(len(X_2),1),X_2[:,n*2:]],1) # value = np.matmul(X[:,n*2:], average[n*2:]) value_2 =np.matmul(X_2, average) #value_2 =np.matmul(X_exl_2, average_val_ex_ch) rewards_2 = rewards_2[n:] choices_2 = choices_2[n:] ones_2 = np.ones(len(choices_2)) trials_2 = len(choices_2) firing_rates_2 = firing_rates[task_2][n:] value_2_choice_2 = choices_2*value_2 a_2 = np.where(choices_2 == 0.5)[0] b_2 = np.where(choices_2 == -0.5)[0] if plot_a == True: rewards_2 = rewards_2[a_2] choices_2 = choices_2[a_2] value_2 = value_2[a_2] ones_2 = ones_2[a_2] firing_rates_2 = firing_rates_2[a_2] # rewards_2 = scipy.stats.zscore(rewards_2) # value_2 = scipy.stats.zscore(value_2) elif plot_b == True: rewards_2 = rewards_2[b_2] choices_2 = choices_2[b_2] value_2 = value_2[b_2] ones_2 = ones_2[b_2] firing_rates_2 = firing_rates_2[b_2] # rewards_2 = scipy.stats.zscore(rewards_2) # value_2 = scipy.stats.zscore(value_2) predictors_all = OrderedDict([ ('Choice', choices_2), ('Reward', rewards_2), ('Value',value_2), ('Value Сhoice',value_2_choice_2), # ('Prev Rew Ch', prev_ch_reward_2), # # ('Prev Rew', prev_reward_2), # ('Prev Ch', prev_choice_2), ('ones', ones_2) ]) X_2 = np.vstack(predictors_all.values()).T[:trials_2,:].astype(float) n_predictors = X_2.shape[1] y_2 = firing_rates_2.reshape([len(firing_rates_2),-1]) # Activity matrix [n_trials, n_neurons*n_timepoints] # tstats,x = regression_code_session(y_2, X_2) ols = LinearRegression() ols.fit(X_2,y_2) C_2.append(ols.coef_.reshape(n_neurons, n_timepoints, n_predictors)) # Predictor loadings cpd_2.append(re._CPD(X_2,y_2).reshape(n_neurons, n_timepoints, n_predictors)) rewards_3 = reward_current[task_3] choices_3 = choices_current[task_3] previous_rewards_3 = scipy.linalg.toeplitz(rewards_3, np.zeros((1,n)))[n-1:-1] previous_choices_3 = scipy.linalg.toeplitz(0.5-choices_3, np.zeros((1,n)))[n-1:-1] interactions_3 = scipy.linalg.toeplitz((((0.5-choices_3)*(rewards_3-0.5))*2),np.zeros((1,n)))[n-1:-1] ones = np.ones(len(interactions_3)).reshape(len(interactions_3),1) X_3 = np.hstack([previous_rewards_3,previous_choices_3,interactions_3,ones]) # average_val_ex_ch = np.concatenate([average[n].reshape(1),average[n*2:]]) # X_exl_3 = np.concatenate([X_3[:,n].reshape(len(X_3),1),X_3[:,n*2:]],1) # # value = np.matmul(X[:,n*2:], average[n*2:]) value_3 =np.matmul(X_3, average) # value_3 =np.matmul(X_exl_3, average_val_ex_ch) rewards_3 = rewards_3[n:] choices_3 = choices_3[n:] ones_3 = np.ones(len(choices_3)) trials_3 = len(choices_3) firing_rates_3 = firing_rates[task_3][n:] value_3_choice_3 = choices_3*value_3 a_3 = np.where(choices_3 == 0.5)[0] b_3 = np.where(choices_3 == -0.5)[0] if plot_a == True: rewards_3 = rewards_3[a_3] choices_3 = choices_3[a_3] value_3 = value_3[a_3] ones_3 = ones_3[a_3] firing_rates_3 = firing_rates_3[a_3] # rewards_3 = scipy.stats.zscore(rewards_3) # value_3 = scipy.stats.zscore(value_3) elif plot_b == True: rewards_3 = rewards_3[b_3] choices_3 = choices_3[b_3] value_3 = value_3[b_3] ones_3 = ones_3[b_3] firing_rates_3 = firing_rates_3[b_3] # rewards_3 = scipy.stats.zscore(rewards_3) # value_3 = scipy.stats.zscore(value_3) predictors_all = OrderedDict([ ('Ch', choices_3), ('Rew', rewards_3), ('Value',value_3), ('Value Сhoice',value_3_choice_3), # # ('Prev Rew Ch', prev_ch_reward_3), # ('Prev Rew', prev_reward_3), # ('Prev Ch', prev_choice_3), ('ones', ones_3) ]) X_3 = np.vstack(predictors_all.values()).T[:trials_3,:].astype(float) rank = np.linalg.matrix_rank(X_1) print(rank) n_predictors = X_3.shape[1] print(n_predictors) y_3 = firing_rates_3.reshape([len(firing_rates_3),-1]) # Activity matrix [n_trials, n_neurons*n_timepoints] #tstats,x = regression_code_session(y_3, X_3) ols = LinearRegression() ols.fit(X_3,y_3) C_3.append(ols.coef_.reshape(n_neurons, n_timepoints, n_predictors)) # Predictor loadings # C_3.append(tstats.reshape(n_predictors,n_neurons,n_timepoints)) # Predictor loadings cpd_3.append(re._CPD(X_3,y_3).reshape(n_neurons, n_timepoints, n_predictors)) C_1_all.append(np.concatenate(C_1,0)); C_2_all.append(np.concatenate(C_2,0)); C_3_all.append(np.concatenate(C_3,0)) return C_1_all,C_2_all,C_3_all
def regression_RPE(data, perm=True): C = [] cpd = [] dm = data['DM'] firing = data['Data'] if perm: C_perm = [[] for i in range(perm) ] # To store permuted predictor loadings for each session. cpd_perm = [[] for i in range(perm) ] # To store permuted cpd for each session. for s, sess in enumerate(dm): DM = dm[s] firing_rates = firing[s] n_trials, n_neurons, n_timepoints = firing_rates.shape choices = DM[:, 1] reward = DM[:, 2] # state = DM[:,0] rpe = DM[:, 14] q1 = DM[:, 9] q4 = DM[:, 10] rand = np.random.normal(np.mean(q4), np.std(q4), len(q4)) ones = np.ones(len(rpe)) trials = len(ones) predictors_all = OrderedDict([ ('Reward', reward), ('Choice', choices), #('State', state), ('RPE', rpe), #('Q4', q4), #('Q1', q1), #('Noise', rand), ('ones', ones) ]) X = np.vstack( predictors_all.values()).T[:len(choices), :].astype(float) n_predictors = X.shape[1] y = firing_rates.reshape( [len(firing_rates), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] tstats = reg_f.regression_code(y, X) C.append(tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings cpd.append( re._CPD(X, y).reshape(n_neurons, n_timepoints, n_predictors)) if perm: for i in range(perm): X_perm = np.roll(X, np.random.randint(trials), axis=0) tstats = reg_f.regression_code(y, X_perm) C_perm[i].append( tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings cpd_perm[i].append( re._CPD(X_perm, y).reshape(n_neurons, n_timepoints, n_predictors)) if perm: # Evaluate P values. cpd_perm = np.stack( [np.nanmean(np.concatenate(cpd_i, 0), 0) for cpd_i in cpd_perm], 0) p = np.percentile(cpd_perm, 95, axis=0) cpd = np.nanmean(np.concatenate(cpd, 0), axis=0) C = np.concatenate(C, 1) return cpd_perm, p, cpd, C, predictors_all
def regression_past_choice(data, perm=True): C = [] cpd = [] dm = data['DM'][0] firing = data['Data'][0] if perm: C_perm = [[] for i in range(perm) ] # To store permuted predictor loadings for each session. cpd_perm = [[] for i in range(perm) ] # To store permuted cpd for each session. for s, sess in tqdm(enumerate(dm)): DM = dm[s] firing_rates = firing[s] n_trials, n_neurons, n_timepoints = firing_rates.shape choices = DM[:, 1] reward = DM[:, 2] block = DM[:, 4] block_df = np.diff(block) task = DM[:, 5] task_id = np.where(np.diff(task))[0] ones = np.ones(len(block)) trials = len(ones) stay = [] for c, ch in enumerate(choices): if c > 0: if choices[c - 1] == choices[c]: stay.append(1) else: stay.append(0) else: stay.append(0) a_side = 0 a_side_l = [] for r, rew in enumerate(reward): if r in task_id: a_side = 0 elif reward[r] == 1 and choices[r] == 1: a_side += 1 a_side_l.append(a_side) b_side = 0 b_side_l = [] for r, rew in enumerate(reward): if r in task_id: b_side = 0 elif reward[r] == 1 and choices[r] == 0: b_side += 1 b_side_l.append(b_side) stay_ch = np.asarray(stay) * choices predictors_all = OrderedDict([('Reward', reward), ('Choice', choices), ('Stay', stay), ('Stay x Choice', stay_ch), ('Reward Cum A', a_side_l), ('Reward Cum B', b_side_l), ('ones', ones)]) X = np.vstack( predictors_all.values()).T[:len(choices), :].astype(float) n_predictors = X.shape[1] y = firing_rates.reshape( [len(firing_rates), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] tstats = reg_f.regression_code(y, X) C.append(tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings cpd.append( re._CPD(X, y).reshape(n_neurons, n_timepoints, n_predictors)) if perm: for i in range(perm): X_perm = np.roll(X, np.random.randint(trials), axis=0) tstats = reg_f.regression_code(y, X_perm) C_perm[i].append( tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings cpd_perm[i].append( re._CPD(X_perm, y).reshape(n_neurons, n_timepoints, n_predictors)) if perm: # Evaluate P values. cpd_perm = np.stack( [np.nanmean(np.concatenate(cpd_i, 0), 0) for cpd_i in cpd_perm], 0) p = np.percentile(cpd_perm, 95, axis=0) cpd = np.nanmean(np.concatenate(cpd, 0), axis=0) C = np.concatenate(C, 1) return cpd_perm, p, cpd, C, predictors_all
def regression_bayes(experiment, bayes_prior, bayes_posterior): C = [] cpd = [] C_sq = [] # Finding correlation coefficients for task 1 for s, session in enumerate(experiment): aligned_spikes = session.aligned_rates[:] if aligned_spikes.shape[1] > 0: # sessions with neurons? n_trials, n_neurons, n_timepoints = aligned_spikes.shape prior = np.asarray(bayes_prior[s][:, 0]) posterior = np.asarray(bayes_posterior[s][:, 0]) # Getting out task indicies forced_trials = session.trial_data['forced_trial'] outcomes = session.trial_data['outcomes'] choices = session.trial_data['choices'] non_forced_array = np.where(forced_trials == 0)[0] choices = choices[non_forced_array] aligned_spikes = aligned_spikes[1:len(choices), :, :] outcomes = outcomes[non_forced_array] outcomes = outcomes[1:] choices = choices[1:] # Getting out task indicies ones = np.ones(len(choices)) predictors = OrderedDict([('Prior', prior), ('Posterior', posterior), ('choice', choices), ('reward', outcomes), ('ones', ones)]) X = np.vstack( predictors.values()).T[:len(choices), :].astype(float) n_predictors = X.shape[1] y = aligned_spikes.reshape( [len(aligned_spikes), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] ols = LinearRegression(copy_X=True, fit_intercept=False) ols.fit(X, y) C.append(ols.coef_.reshape(n_neurons, n_timepoints, n_predictors)) # Predictor loadings sq = ols.coef_.reshape(n_neurons, n_timepoints, n_predictors) sq = sq**2 C_sq.append(sq) cpd.append( re._CPD(X, y).reshape(n_neurons, n_timepoints, n_predictors)) cpd = np.nanmean(np.concatenate(cpd, 0), axis=0) # Population CPD is mean over neurons. C_sq_all = np.concatenate(C, 0) C = np.nanmean(np.concatenate(C, 0), axis=0) C_sq = np.nanmean(np.concatenate(C_sq, 0), axis=0) # Population CPD is mean over neurons. return cpd, predictors, C_sq, C_sq_all
def regression_Q_values_choices(experiment): C_1_choice = [] cpd_1_choice = [] C_2_choice = [] cpd_2_choice= [] C_3_choice = [] cpd_3_choice = [] # Finding correlation coefficients for task 1 for s,session in enumerate(experiment): aligned_spikes= session.aligned_rates[:] if aligned_spikes.shape[1] > 0: # sessions with neurons? predictor_A_Task_1, predictor_A_Task_2, predictor_A_Task_3,\ predictor_B_Task_1, predictor_B_Task_2, predictor_B_Task_3, reward,\ predictor_a_good_task_1,predictor_a_good_task_2, predictor_a_good_task_3,\ reward_previous,previous_trial_task_1,previous_trial_task_2,previous_trial_task_3,\ same_outcome_task_1, same_outcome_task_2, same_outcome_task_3,different_outcome_task_1,\ different_outcome_task_2, different_outcome_task_3 = re.predictors_include_previous_trial(session) n_trials, n_neurons, n_timepoints = aligned_spikes.shape # Task indicies task = session.trial_data['task'] forced_trials = session.trial_data['forced_trial'] non_forced_array = np.where(forced_trials == 0)[0] task_non_forced = task[non_forced_array] task_1 = np.where(task_non_forced == 1)[0] task_2 = np.where(task_non_forced == 2)[0] # (1) Better correlated with the *previous* choice, or the *current choice* predictor_A_Task_1 = predictor_A_Task_1[1:len(task_1)] previous_trial_task_1 = previous_trial_task_1[1:len(task_1)] aligned_spikes_task_1 = aligned_spikes[1:len(task_1)] ones = np.ones(len(predictor_A_Task_1)) # Task 1 predictors = OrderedDict([('Current Choice', predictor_A_Task_1), ('Previous Choice', previous_trial_task_1), ('ones', ones)]) X = np.vstack(predictors.values()).T[:len(predictor_A_Task_1),:].astype(float) n_predictors = X.shape[1] y = aligned_spikes_task_1.reshape([len(aligned_spikes_task_1),-1]) # Activity matrix [n_trials, n_neurons*n_timepoints] ols = LinearRegression(copy_X = True,fit_intercept= True) ols.fit(X,y) C_1_choice.append(ols.coef_.reshape(n_neurons,n_timepoints, n_predictors)) # Predictor loadings cpd_1_choice.append(re._CPD(X,y).reshape(n_neurons,n_timepoints, n_predictors)) # Task 2 # (1) Better correlated with the *previous* choice, or the *current choice* predictor_A_Task_2 = predictor_A_Task_2[len(task_1)+1:len(task_1)+len(task_2)] previous_trial_task_2 = previous_trial_task_2[len(task_1)+1:len(task_1)+len(task_2)] aligned_spikes_task_2 = aligned_spikes[len(task_1)+1:len(task_1)+len(task_2)] ones = np.ones(len(predictor_A_Task_2)) predictors = OrderedDict([('Current Choice', predictor_A_Task_2), ('Previous CHoice', previous_trial_task_2), ('ones', ones)]) X = np.vstack(predictors.values()).T[:len(predictor_A_Task_2),:].astype(float) n_predictors = X.shape[1] y = aligned_spikes_task_2.reshape([len(aligned_spikes_task_2),-1]) # Activity matrix [n_trials, n_neurons*n_timepoints] ols = LinearRegression(copy_X = True,fit_intercept= True) ols.fit(X,y) C_2_choice.append(ols.coef_.reshape(n_neurons,n_timepoints, n_predictors)) # Predictor loadings cpd_2_choice.append(re._CPD(X,y).reshape(n_neurons,n_timepoints, n_predictors)) # Task 3 # (1) Better correlated with the *previous* choice, or the *current choice* predictor_A_Task_3 = predictor_A_Task_3[len(task_1)+len(task_2)+1:] previous_trial_task_3 = previous_trial_task_3[len(task_1)+len(task_2)+1:] aligned_spikes_task_3 = aligned_spikes[len(task_1)+len(task_2)+1:] aligned_spikes_task_3 = aligned_spikes_task_3[:len(predictor_A_Task_3)] ones = np.ones(len(predictor_A_Task_3)) predictors = OrderedDict([('Current Choice', predictor_A_Task_3), ('Previous Choice', previous_trial_task_3), ('ones', ones)]) X = np.vstack(predictors.values()).T[:len(predictor_A_Task_3),:].astype(float) n_predictors = X.shape[1] y = aligned_spikes_task_3.reshape([len(aligned_spikes_task_3),-1]) # Activity matrix [n_trials, n_neurons*n_timepoints] ols = LinearRegression(copy_X = True,fit_intercept= True) ols.fit(X,y) C_3_choice.append(ols.coef_.reshape(n_neurons,n_timepoints, n_predictors)) # Predictor loadings cpd_3_choice.append(re._CPD(X,y).reshape(n_neurons,n_timepoints, n_predictors)) cpd_1_choice = np.nanmean(np.concatenate(cpd_1_choice,0), axis = 0) # Population CPD is mean over neurons. cpd_2_choice = np.nanmean(np.concatenate(cpd_2_choice,0), axis = 0) # Population CPD is mean over neurons. cpd_3_choice = np.nanmean(np.concatenate(cpd_3_choice,0), axis = 0) # Population CPD is mean over neurons. return C_1_choice, C_2_choice, C_3_choice, cpd_1_choice, cpd_2_choice, cpd_3_choice, predictors
def between_tasks(Data, DM, PFC=True): cpd_true = [] C_true = [] cpd_aligned = [] C_aligned = [] C_sq_true = [] C_sq_aligned = [] if PFC == True: ind_1 = np.arange(0, 26) ind_2 = np.arange(1, 27) ind_a = np.hstack((ind_1, ind_2)) ind_b = np.hstack((ind_2, ind_1)) else: ind_1 = np.arange(0, 15) ind_2 = np.arange(1, 16) ind_a = np.hstack((ind_1, ind_2)) ind_b = np.hstack((ind_2, ind_1)) all_sessions_firing, all_session_dm = select_trials(Data, DM, 10) for a, b in zip(ind_a, ind_b): aligned_a, aligned_b, original_a, original_b, task_1_aligned = procrustes( a, b, all_sessions_firing, all_session_dm) target = np.transpose(task_1_aligned, [1, 0, 2]) source = np.transpose(original_a, [1, 0, 2])[40:80, :, :] # Session 1 Task 2 dm_test = all_session_dm[a] trials, n_neurons, n_timepoints = source.shape reward_test = dm_test[:, 2][40:80] state_test = dm_test[:, 0][40:80] choices_test = dm_test[:, 1][40:80] ones_test = np.ones(len(choices_test)) reward_choice = choices_test * reward_test # Aligned Task 2 from Task 1 predictors_train = OrderedDict([('State', state_test), ('Reward', reward_test), ('Choice', choices_test), ('Reward Choice Int', reward_choice), ('ones', ones_test)]) X = np.vstack(predictors_train.values()).T[:trials, :].astype(float) n_predictors = X.shape[1] y = source.reshape( [len(source), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] tstats = reg_f.regression_code(y, X) C_true.append(tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings C_sq_true.append( tstats.reshape(n_predictors, n_neurons, n_timepoints)**2) cpd_true.append( re._CPD(X, y).reshape(n_neurons, n_timepoints, n_predictors)) # Aligned Using Neurons n_predictors = X.shape[1] y = target.reshape( [len(target), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] tstats = reg_f.regression_code(y, X) C_aligned.append(tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings C_sq_aligned.append( tstats.reshape(n_predictors, n_neurons, n_timepoints)**2) cpd_aligned.append( re._CPD(X, y).reshape(n_neurons, n_timepoints, n_predictors)) cpd_true = np.nanmean(np.concatenate(cpd_true, 0), axis=0) C_sq_true = np.concatenate(C_sq_true, 1) cpd_aligned = np.nanmean(np.concatenate(cpd_aligned, 0), axis=0) C_sq_aligned = np.concatenate(C_sq_aligned, 1) c = ['violet', 'black', 'green', 'blue', 'turquoise', 'grey', 'yellow', 'pink',\ 'purple', 'darkblue', 'darkred', 'darkgreen','darkyellow','lightgreen'] p = [*predictors_train] plt.figure() for i in np.arange(cpd_true.shape[1] - 1): plt.plot(cpd_true[:, i], label=p[i] + 'Real', color=c[i]) plt.plot(cpd_aligned[:, i], label=p[i] + 'Aligned', color=c[i], linestyle='--') plt.legend() plt.ylabel('CPD') plt.xlabel('Time in Trial') plt.xticks([25, 35, 42], ['I', 'C', 'R']) return cpd_aligned, cpd_true
def regression(Data, DM, PFC=True): cpd_true = [] C_true = [] cpd_misaligned = [] C_misaligned = [] cpd_aligned = [] C_aligned = [] C_sq_true = [] C_sq_misaligned = [] C_sq_aligned = [] if PFC == True: ind_1 = np.arange(0, 26) ind_2 = np.arange(1, 27) ind_a = np.hstack((ind_1, ind_2)) ind_b = np.hstack((ind_2, ind_1)) else: ind_1 = np.arange(0, 15) ind_2 = np.arange(1, 16) ind_a = np.hstack((ind_1, ind_2)) ind_b = np.hstack((ind_2, ind_1)) misaligned_list = [] aligned_list = [] for a, b in zip(ind_a, ind_b): all_sessions, all_session_dm, aligned_by_trial, original_a, original_b = in_progress( a, b, Data, DM, misaligned_list, aligned_list) # plt.figure() # for i in np.arange(aligned_by_trial.shape[0]): # plt.plot(np.mean(aligned_by_trial,1)[i,:]) # plt.figure() # for i in np.arange(original_b.shape[0]): # plt.plot(np.mean(original_b,1)[i,:]) #session_a = all_sessions[ind_a] dm_test = all_session_dm[a] session_training = np.transpose(original_a, [1, 0, 2]) session_misaligned = np.transpose(original_b, [1, 0, 2]) session_aligned = np.transpose(aligned_by_trial, [1, 0, 2]) trials, n_neurons, n_timepoints = session_training.shape reward_test = dm_test[:, 2] state_test = dm_test[:, 0] choices_test = dm_test[:, 1] ones_test = np.ones(len(choices_test)) trials_since_block = np.arange(0, 10) trials_since_block = np.tile(trials_since_block, 12) reward_choice = choices_test * reward_test trial_sq = (np.asarray(trials_since_block) - 0.5)**2 choice_trials_sq = choices_test * trial_sq interaction_trials_choice = trials_since_block * choices_test # Original Using Neurons predictors_train = OrderedDict([ ('State', state_test), ('Reward', reward_test), ('Choice', choices_test), #('Reward Choice Int', reward_choice), #('Trials in Block', trials_since_block), #('Squared Time in Block', trial_sq), #('Trials x Choice', interaction_trials_choice), #('Trials x Choice Sq',choice_trials_sq), ('ones', ones_test) ]) X = np.vstack(predictors_train.values()).T[:trials, :].astype(float) n_predictors = X.shape[1] y = session_training.reshape( [len(session_training), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] tstats = reg_f.regression_code(y, X) C_true.append(tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings C_sq_true.append( tstats.reshape(n_predictors, n_neurons, n_timepoints)**2) cpd_true.append( re._CPD(X, y).reshape(n_neurons, n_timepoints, n_predictors)) trials, n_neurons, n_timepoints = session_misaligned.shape # Misaligned Using Neurons y = session_misaligned.reshape( [len(session_misaligned), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] tstats = reg_f.regression_code(y, X) C_misaligned.append( tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings C_sq_misaligned.append( tstats.reshape(n_predictors, n_neurons, n_timepoints)**2) cpd_misaligned.append( re._CPD(X, y).reshape(n_neurons, n_timepoints, n_predictors)) # Aligned Using Neurons n_predictors = X.shape[1] y = session_aligned.reshape( [len(session_aligned), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] tstats = reg_f.regression_code(y, X) C_aligned.append(tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings C_sq_aligned.append( tstats.reshape(n_predictors, n_neurons, n_timepoints)**2) cpd_aligned.append( re._CPD(X, y).reshape(n_neurons, n_timepoints, n_predictors)) cpd_true = np.nanmean(np.concatenate(cpd_true, 0), axis=0) C_true = np.concatenate(C_true, 1) cpd_misaligned = np.nanmean(np.concatenate(cpd_misaligned, 0), axis=0) C_misaligned = np.concatenate(C_misaligned, 1) cpd_aligned = np.nanmean(np.concatenate(cpd_aligned, 0), axis=0) C_aligned = np.concatenate(C_aligned, 1) C_sq_true = np.concatenate(C_sq_true, 1) C_sq_misaligned = np.concatenate(C_sq_misaligned, 1) C_sq_aligned = np.concatenate(C_sq_aligned, 1) C_sq_true[np.isfinite(C_sq_true) == False] = np.NaN C_sq_true = np.nanmean(C_sq_true, 1)[:-1, :] C_sq_misaligned = np.nanmean(C_sq_misaligned, 1)[:-1, :] C_sq_aligned = np.nanmean(C_sq_aligned, 1)[:-1, :] c = ['violet', 'black', 'green', 'blue', 'turquoise', 'grey', 'yellow', 'pink',\ 'purple', 'darkblue', 'darkred', 'darkgreen','darkyellow','lightgreen'] p = [*predictors_train] plt.figure() for i in np.arange(C_sq_true.shape[0]): plt.plot(C_sq_true[i, :], label=p[i] + 'Real', color=c[i]) plt.plot(C_sq_misaligned[i, :], label=p[i] + 'Misaligned', color=c[i], linestyle='--') plt.plot(C_sq_aligned[i, :], label=p[i] + 'Aligned', color=c[i], linestyle=':') plt.legend() plt.ylabel('Coef Sq') plt.xlabel('Time in Trial') plt.xticks([25, 35, 42], ['I', 'C', 'R']) cpd_true = cpd_true[:, :-1] cpd_misaligned = cpd_misaligned[:, :-1] cpd_aligned = cpd_aligned[:, :-1] plt.figure() for i in np.arange(cpd_true.shape[1]): plt.plot(cpd_true[:, i], label=p[i] + 'Real', color=c[i]) plt.plot(cpd_misaligned[:, i], label=p[i] + 'Misaligned', color=c[i], linestyle='--') plt.plot(cpd_aligned[:, i], label=p[i] + 'Aligned', color=c[i], linestyle=':') plt.legend() plt.ylabel('CPD') plt.xlabel('Time in Trial') plt.xticks([25, 35, 42], ['I', 'C', 'R']) return misaligned_list, aligned_list
def regression_prev_choice(data, perm=True): C = [] cpd = [] dm = data['DM'][0] firing = data['Data'][0] if perm: C_perm = [[] for i in range(perm) ] # To store permuted predictor loadings for each session. cpd_perm = [[] for i in range(perm) ] # To store permuted cpd for each session. for s, sess in tqdm(enumerate(dm)): DM = dm[s] firing_rates = firing[s][1:, :, :] n_trials, n_neurons, n_timepoints = firing_rates.shape choices = DM[:, 1] reward = DM[:, 2] task = DM[:, 5] task_id = np.where(np.diff(task))[0] state = DM[:, 0] stay = choices[0:-1] == choices[1:] stay = stay * 1 stay = np.insert(stay, 0, 0) lastreward = reward[0:-1] lastreward = np.insert(lastreward, 0, 0) rl = np.zeros(len(stay)) rl[0] = 1 rl_right = np.zeros(len(stay)) rl_right[0] = choices[0] == state[0] choice_rr_start = -100 rl_wrong = np.zeros(len(stay)) rl_wrong[0] = choices[0] != state[0] choice_rw_start = -100 for tr in range(len(stay)): if tr > 0: if stay[tr] == 1: rl[tr] = rl[tr - 1] + 1 else: rl[tr] = 1 if ((choices[tr] == choice_rr_start) & (choices[tr] == state[tr])): rl_right[tr] = rl_right[tr - 1] + 1 elif (choices[tr] == state[tr]): rl_right[tr] = 1 choice_rr_start = choices[tr] else: rl_right[tr] = 0 choice_rr_start = -100 #If he made the wrong choice it can't be part of a correct run. if ((choices[tr] == choice_rw_start) & (choices[tr] != state[tr])): rl_wrong[tr] = rl_wrong[tr - 1] + 1 elif choices[tr] != state[tr]: rl_wrong[tr] = 1 choice_rw_start = choices[tr] else: rl_wrong[tr] = 0 choice_rw_start = -100 #If he made the right choice it can't be part of a wrong run. trials = len(reward) rl_wrong = rl_wrong[1:] rl_right = rl_right[1:] rl = rl[1:] prev_choice = DM[:-1, 1] choices = choices[1:] reward = reward[1:] task = task[1:] state = state[1:] ones = np.ones(len(reward)) int_repeat = choices * rl int_repeat_corr = state * rl_right int_repeat_incorr = state * rl_wrong error_count = [] err_count = 0 for r, rew in enumerate(reward): if rew == 0: if reward[r] == reward[r - 1]: err_count += 1 else: err_count = 0 error_count.append(err_count) predictors_all = OrderedDict([ ('Reward', reward), ('Choice', choices), ('State', state), ('Previous Choice 1', prev_choice), ('Repeat', rl), #('Error Count',error_count), #('Repeat Incorrect', rl_wrong), #('Repeat Correct', rl_right), # ('Repeat Int', int_repeat), #('Repeat Corr Int', int_repeat_corr), #('Repeat Incorr Int', int_repeat_incorr), ('ones', ones) ]) X = np.vstack( predictors_all.values()).T[:len(choices), :].astype(float) n_predictors = X.shape[1] y = firing_rates.reshape( [len(firing_rates), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] tstats = reg_f.regression_code(y, X) C.append(tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings cpd.append( re._CPD(X, y).reshape(n_neurons, n_timepoints, n_predictors)) if perm: for i in range(perm): X_perm = np.roll(X, np.random.randint(trials), axis=0) tstats = reg_f.regression_code(y, X_perm) C_perm[i].append( tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings cpd_perm[i].append( re._CPD(X_perm, y).reshape(n_neurons, n_timepoints, n_predictors)) if perm: # Evaluate P values. cpd_perm = np.stack( [np.nanmean(np.concatenate(cpd_i, 0), 0) for cpd_i in cpd_perm], 0) p = np.percentile(cpd_perm, 95, axis=0) cpd = np.nanmean(np.concatenate(cpd, 0), axis=0) C = np.concatenate(C, 1) return cpd_perm, p, cpd, C, predictors_all
def sequence_rewards_errors_regression_generalisation_rew( data, area='HP_', c_to_plot=1, c_to_proj=2, c_to_proj_3=3, ind_rew=1, plot_a=False, plot_b=False): dm = data['DM'][0] firing = data['Data'][0] C_1 = [] C_2 = [] C_3 = [] cpd_1 = [] cpd_2 = [] cpd_3 = [] c_to_plot = c_to_plot c_to_proj = c_to_proj c_to_proj_3 = c_to_proj_3 ind_rew = ind_rew for s, sess in enumerate(dm): runs_list = [] runs_list.append(0) DM = dm[s] firing_rates = firing[s] # firing_rates = firing_rates[:,:,:63] n_trials, n_neurons, n_timepoints = firing_rates.shape state = DM[:, 0] choices = DM[:, 1] - 0.5 reward = DM[:, 2] - 0.5 task = DM[:, 5] a_pokes = DM[:, 6] b_pokes = DM[:, 7] taskid = task_ind(task, a_pokes, b_pokes) trial_to_start = 7 taskid = taskid[trial_to_start:] task_1 = np.where(taskid == 1)[0] task_2 = np.where(taskid == 2)[0] task_3 = np.where(taskid == 3)[0] # reward_2_ago = reward[1:-2] # reward_3_ago = reward[:-3] reward_2_ago = np.mean( [reward[trial_to_start - 2:-2], reward[trial_to_start - 3:-3]], 0) reward_3_ago = np.mean( [reward[trial_to_start - 4:-4], reward[trial_to_start - 5:-5]], 0) reward_4_ago = np.mean([reward[trial_to_start - 6:-6], reward[:-7]], 0) reward_prev = reward[trial_to_start - 1:-1] reward_current = reward[trial_to_start:] firing_rates = firing_rates[trial_to_start:] choices_2_ago = np.mean( [choices[trial_to_start - 2:-2], choices[trial_to_start - 3:-3]], 0) choices_3_ago = np.mean( [choices[trial_to_start - 4:-4], choices[trial_to_start - 5:-5]], 0) choices_4_ago = np.mean([choices[trial_to_start - 6:-6], choices[:-7]], 0) choices_prev = choices[trial_to_start - 1:-1] choices_current = choices[trial_to_start:] state = state[trial_to_start:] cum_reward_orth = np.vstack( [reward_current, np.ones(len(reward_current))]).T xt = np.linalg.pinv(cum_reward_orth) identity = np.identity(len(reward_current)) id_x = (identity - np.matmul(cum_reward_orth, xt)) reward_o_1_ago = np.matmul(id_x, np.asarray(reward_prev)) reward_o_2_ago = np.matmul(id_x, np.asarray(reward_2_ago)) reward_o_3_ago = np.matmul(id_x, np.asarray(reward_3_ago)) reward_o_4_ago = np.matmul(id_x, np.asarray(reward_4_ago)) cum_ch_orth = np.vstack( [choices_current, np.ones(len(choices_current))]).T xt = np.linalg.pinv(cum_ch_orth) identity = np.identity(len(choices_current)) id_x = (identity - np.matmul(cum_ch_orth, xt)) choice_o_1_ago = np.matmul(id_x, np.asarray(choices_prev)) choice_o_2_ago = np.matmul(id_x, np.asarray(choices_2_ago)) choice_o_3_ago = np.matmul(id_x, np.asarray(choices_3_ago)) choice_o_4_ago = np.matmul(id_x, np.asarray(choices_4_ago)) ones = np.ones(len(reward_current)) reward_1 = reward_current[task_1] choices_1 = choices_current[task_1] _1_reward_1 = reward_o_1_ago[task_1] _2_reward_1 = reward_o_2_ago[task_1] _3_reward_1 = reward_o_3_ago[task_1] _4_reward_1 = reward_o_4_ago[task_1] _1_choices_1 = choice_o_1_ago[task_1] _2_choices_1 = choice_o_2_ago[task_1] _3_choices_1 = choice_o_3_ago[task_1] _4_choices_1 = choice_o_4_ago[task_1] _1_choices_1_for_int = choices_prev[task_1] _2_choices_1_for_int = choices_2_ago[task_1] _3_choices_1_for_int = choices_3_ago[task_1] _4_choices_1_for_int = choices_4_ago[task_1] _1_reward_1_ch = (_1_reward_1 * _1_choices_1_for_int) _2_reward_1_ch = (_2_reward_1 * _2_choices_1_for_int) _3_reward_1_ch = (_3_reward_1 * _3_choices_1_for_int) _4_reward_1_ch = (_4_reward_1 * _4_choices_1_for_int) ones_1 = ones[task_1] firing_rates_1 = firing_rates[task_1] a_1 = np.where(choices_1 == 0.5)[0] b_1 = np.where(choices_1 == -0.5)[0] if plot_a == True: reward_1 = reward_1[a_1] firing_rates_1 = firing_rates_1[a_1] _1_reward_1 = _1_reward_1[a_1] _2_reward_1 = _2_reward_1[a_1] _3_reward_1 = _3_reward_1[a_1] _4_reward_1 = _4_reward_1[a_1] _1_choices_1 = _1_choices_1[a_1] _2_choices_1 = _2_choices_1[a_1] _3_choices_1 = _3_choices_1[a_1] _4_choices_1 = _4_choices_1[a_1] _1_reward_1_ch = _1_reward_1_ch[a_1] _2_reward_1_ch = _2_reward_1_ch[a_1] _3_reward_1_ch = _3_reward_1_ch[a_1] _4_reward_1_ch = _4_reward_1_ch[a_1] ones_1 = ones_1[a_1] elif plot_b == True: reward_1 = reward_1[b_1] firing_rates_1 = firing_rates_1[b_1] _1_reward_1 = _1_reward_1[b_1] _2_reward_1 = _2_reward_1[b_1] _3_reward_1 = _3_reward_1[b_1] _4_reward_1 = _4_reward_1[b_1] _1_choices_1 = _1_choices_1[b_1] _2_choices_1 = _2_choices_1[b_1] _3_choices_1 = _3_choices_1[b_1] _4_choices_1 = _4_choices_1[b_1] _1_reward_1_ch = _1_reward_1_ch[b_1] _2_reward_1_ch = _2_reward_1_ch[b_1] _3_reward_1_ch = _3_reward_1_ch[b_1] _4_reward_1_ch = _4_reward_1_ch[b_1] ones_1 = ones_1[b_1] predictors_all = OrderedDict([('Reward', reward_1), ('Choice', choices_1), ('1 ago Outcome', _1_reward_1), ('2 ago Outcome', _2_reward_1), ('3 ago Outcome', _3_reward_1), ('4 ago Outcome', _4_reward_1), ('1 ago Choice', _1_choices_1), ('2 ago Choice', _2_choices_1), ('3 ago Choice', _3_choices_1), ('4 ago Choice', _4_choices_1), ('Prev Rew by Ch ', _1_reward_1_ch), ('2 Rew ago by Ch ', _2_reward_1_ch), ('3 Rew ago by Ch ', _3_reward_1_ch), ('4 Rew ago by Ch ', _4_reward_1_ch), ('ones', ones_1)]) X_1 = np.vstack( predictors_all.values()).T[:len(choices_1), :].astype(float) rank = np.linalg.matrix_rank(X_1) n_predictors = X_1.shape[1] y_1 = firing_rates_1.reshape( [len(firing_rates_1), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] #tstats = reg_f.regression_code(y_1, X_1) tstats, cope = regression_code_session(y_1, X_1) C_1.append(tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings cpd_1.append( re._CPD(X_1, y_1).reshape(n_neurons, n_timepoints, n_predictors)) reward_2 = reward_current[task_2] choices_2 = choices_current[task_2] _1_reward_2 = reward_o_1_ago[task_2] _2_reward_2 = reward_o_2_ago[task_2] _3_reward_2 = reward_o_3_ago[task_2] _4_reward_2 = reward_o_4_ago[task_2] _1_choices_2 = choice_o_1_ago[task_2] _2_choices_2 = choice_o_2_ago[task_2] _3_choices_2 = choice_o_3_ago[task_2] _4_choices_2 = choice_o_4_ago[task_2] _1_choices_2_for_int = choices_prev[task_2] _2_choices_2_for_int = choices_2_ago[task_2] _3_choices_2_for_int = choices_3_ago[task_2] _4_choices_2_for_int = choices_4_ago[task_2] _1_reward_2_ch = (_1_reward_2 * _1_choices_2_for_int) _2_reward_2_ch = (_2_reward_2 * _2_choices_2_for_int) _3_reward_2_ch = (_3_reward_2 * _3_choices_2_for_int) _4_reward_2_ch = (_4_reward_2 * _4_choices_2_for_int) ones_2 = ones[task_2] firing_rates_2 = firing_rates[task_2] a_2 = np.where(choices_2 == 0.5)[0] b_2 = np.where(choices_2 == -0.5)[0] if plot_a == True: reward_2 = reward_2[a_2] firing_rates_2 = firing_rates_2[a_2] _1_reward_2 = _1_reward_2[a_2] _2_reward_2 = _2_reward_2[a_2] _3_reward_2 = _3_reward_2[a_2] _4_reward_2 = _4_reward_2[a_2] _1_choices_2 = _1_choices_2[a_2] _2_choices_2 = _2_choices_2[a_2] _3_choices_2 = _3_choices_2[a_2] _4_choices_2 = _4_choices_2[a_2] _1_reward_2_ch = _1_reward_2_ch[a_2] _2_reward_2_ch = _2_reward_2_ch[a_2] _3_reward_2_ch = _3_reward_2_ch[a_2] _4_reward_2_ch = _4_reward_2_ch[a_2] ones_2 = ones_2[a_2] elif plot_b == True: reward_2 = reward_2[b_2] firing_rates_2 = firing_rates_2[b_2] _1_reward_2 = _1_reward_2[b_2] _2_reward_2 = _2_reward_2[b_2] _3_reward_2 = _3_reward_2[b_2] _4_reward_2 = _4_reward_2[b_2] _1_choices_2 = _1_choices_2[b_2] _2_choices_2 = _2_choices_2[b_2] _3_choices_2 = _3_choices_2[b_2] _4_choices_2 = _4_choices_2[b_2] _1_reward_2_ch = _1_reward_2_ch[b_2] _2_reward_2_ch = _2_reward_2_ch[b_2] _3_reward_2_ch = _3_reward_2_ch[b_2] _4_reward_2_ch = _4_reward_2_ch[b_2] ones_2 = ones_2[b_2] predictors_all = OrderedDict([('Reward', reward_2), ('Choice', choices_2), ('1 ago Outcome', _1_reward_2), ('2 ago Outcome', _2_reward_2), ('3 ago Outcome', _3_reward_2), ('4 ago Outcome', _4_reward_2), ('1 ago Choice', _1_choices_2), ('2 ago Choice', _2_choices_2), ('3 ago Choice', _3_choices_2), ('4 ago Choice', _4_choices_2), (' Prev Rew by Ch ', _1_reward_2_ch), (' 2 Rew ago by Ch ', _2_reward_2_ch), (' 3 Rew ago by Ch ', _3_reward_2_ch), (' 4 Rew ago by Ch ', _4_reward_2_ch), ('ones', ones_2)]) X_2 = np.vstack( predictors_all.values()).T[:len(choices_2), :].astype(float) y_2 = firing_rates_2.reshape( [len(firing_rates_2), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] #tstats = reg_f.regression_code(y_2, X_2) tstats, cope = regression_code_session(y_2, X_2) C_2.append(tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings cpd_2.append( re._CPD(X_2, y_2).reshape(n_neurons, n_timepoints, n_predictors)) reward_3 = reward_current[task_3] choices_3 = choices_current[task_3] _1_reward_3 = reward_o_1_ago[task_3] _2_reward_3 = reward_o_2_ago[task_3] _3_reward_3 = reward_o_3_ago[task_3] _4_reward_3 = reward_o_4_ago[task_3] _1_choices_3 = choice_o_1_ago[task_3] _2_choices_3 = choice_o_2_ago[task_3] _3_choices_3 = choice_o_3_ago[task_3] _4_choices_3 = choice_o_4_ago[task_3] _1_choices_3_for_int = choices_prev[task_3] _2_choices_3_for_int = choices_2_ago[task_3] _3_choices_3_for_int = choices_3_ago[task_3] _4_choices_3_for_int = choices_4_ago[task_3] _1_reward_3_ch = (_1_reward_3 * _1_choices_3_for_int) _2_reward_3_ch = (_2_reward_3 * _2_choices_3_for_int) _3_reward_3_ch = (_3_reward_3 * _3_choices_3_for_int) _4_reward_3_ch = (_4_reward_3 * _4_choices_3_for_int) ones_3 = ones[task_3] firing_rates_3 = firing_rates[task_3] a_3 = np.where(choices_3 == 0.5)[0] b_3 = np.where(choices_3 == -0.5)[0] if plot_a == True: reward_3 = reward_3[a_3] firing_rates_3 = firing_rates_3[a_3] _1_reward_3 = _1_reward_3[a_3] _2_reward_3 = _2_reward_3[a_3] _3_reward_3 = _3_reward_3[a_3] _4_reward_3 = _4_reward_3[a_3] _1_choices_3 = _1_choices_3[a_3] _2_choices_3 = _2_choices_3[a_3] _3_choices_3 = _3_choices_3[a_3] _4_choices_3 = _4_choices_3[a_3] _1_reward_3_ch = _1_reward_3_ch[a_3] _2_reward_3_ch = _2_reward_3_ch[a_3] _3_reward_3_ch = _3_reward_3_ch[a_3] _4_reward_3_ch = _4_reward_3_ch[a_3] ones_3 = ones_3[a_3] elif plot_b == True: reward_3 = reward_3[b_3] firing_rates_3 = firing_rates_3[b_3] _1_reward_3 = _1_reward_3[b_3] _2_reward_3 = _2_reward_3[b_3] _3_reward_3 = _3_reward_3[b_3] _4_reward_3 = _4_reward_3[b_3] _1_choices_3 = _1_choices_3[b_3] _2_choices_3 = _2_choices_3[b_3] _3_choices_3 = _3_choices_3[b_3] _4_choices_3 = _4_choices_3[b_3] _1_reward_3_ch = _1_reward_3_ch[b_3] _2_reward_3_ch = _2_reward_3_ch[b_3] _3_reward_3_ch = _3_reward_3_ch[b_3] _4_reward_3_ch = _4_reward_3_ch[b_3] ones_3 = ones_3[b_3] predictors_all = OrderedDict([('Reward', reward_3), ('Choice', choices_3), ('1 ago Outcome', _1_reward_3), ('2 ago Outcome', _2_reward_3), ('3 ago Outcome', _3_reward_3), ('4 ago Outcome', _4_reward_3), ('1 ago Choice', _1_choices_3), ('2 ago Choice', _2_choices_3), ('3 ago Choice', _3_choices_3), ('4 ago Choice', _4_choices_3), (' Prev Rew by Ch', _1_reward_3_ch), (' 2 Rew ago by Ch', _2_reward_3_ch), (' 3 Rew ago by Ch', _3_reward_3_ch), (' 4 Rew ago by Ch', _4_reward_3_ch), ('ones', ones_3)]) X_3 = np.vstack( predictors_all.values()).T[:len(choices_3), :].astype(float) y_3 = firing_rates_3.reshape( [len(firing_rates_3), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] #tstats = reg_f.regression_code(y_3, X_3) tstats, cope = regression_code_session(y_3, X_3) C_3.append(tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings cpd_3.append( re._CPD(X_3, y_3).reshape(n_neurons, n_timepoints, n_predictors)) C_1 = np.concatenate(C_1, 1) C_2 = np.concatenate(C_2, 1) C_3 = np.concatenate(C_3, 1) cpd_1 = np.nanmean(np.concatenate(cpd_1, 0), axis=0) cpd_2 = np.nanmean(np.concatenate(cpd_2, 0), axis=0) cpd_3 = np.nanmean(np.concatenate(cpd_3, 0), axis=0) cpd = np.mean([cpd_1, cpd_2, cpd_3], 0) C_2_inf = [~np.isinf(C_2[0]).any(axis=1)] C_2_nan = [~np.isnan(C_2[0]).any(axis=1)] C_3_inf = [~np.isinf(C_3[0]).any(axis=1)] C_3_nan = [~np.isnan(C_3[0]).any(axis=1)] C_1_inf = [~np.isinf(C_1[0]).any(axis=1)] C_1_nan = [~np.isnan(C_1[0]).any(axis=1)] nans = np.asarray(C_1_inf) & np.asarray(C_1_nan) & np.asarray( C_3_inf) & np.asarray(C_3_nan) & np.asarray(C_2_inf) & np.asarray( C_2_nan) C_1 = C_1[:, nans[0], :] C_2 = C_2[:, nans[0], :] C_3 = C_3[:, nans[0], :] c = wes.Darjeeling2_5.mpl_colors + wes.Mendl_4.mpl_colors + wes.GrandBudapest1_4.mpl_colors + wes.Moonrise1_5.mpl_colors j = 0 plt.figure() pred = list(predictors_all.keys()) pred = pred[:-1] for ii, i in enumerate(cpd.T[:-1]): plt.plot(i, color=c[j], label=pred[j]) j += 1 plt.legend() sns.despine() plt.title(area + 't-values') cell_id_cum_reward = np.where(np.mean(abs(C_1[1, :, :20]), 1) > 1.5)[0] cell_id_cum_error = np.where(np.mean(abs(C_1[2, :, :20]), 1) > 1.5)[0] cell_id_prev_ch = np.where(np.mean(abs(C_1[3, :, :20]), 1) > 1.5)[0] C_1_rew = C_1[ind_rew] C_2_rew = C_2[ind_rew] C_3_rew = C_3[ind_rew] C_1_rew_count = C_1[c_to_plot] C_2_rew_count = C_2[c_to_plot] C_3_rew_count = C_3[c_to_plot] reward_times_to_choose = np.asarray([20, 24, 35, 41]) #reward_times_to_choose = np.arange(0,63,10) # reward_times_to_choose = np.arange(0,80,10) ones = np.ones(len(C_1_rew)) C_1_rew_proj = np.ones( (C_1_rew.shape[0], reward_times_to_choose.shape[0] + 1)) C_2_rew_proj = np.ones( (C_1_rew.shape[0], reward_times_to_choose.shape[0] + 1)) C_3_rew_proj = np.ones( (C_1_rew.shape[0], reward_times_to_choose.shape[0] + 1)) j = 0 for i in reward_times_to_choose: if i == reward_times_to_choose[0]: C_1_rew_proj[:, j] = np.mean(C_1_rew[:, i - 20:i], 1) C_2_rew_proj[:, j] = np.mean(C_2_rew[:, i - 20:i], 1) C_3_rew_proj[:, j] = np.mean(C_3_rew[:, i - 20:i], 1) elif i == reward_times_to_choose[1] or i == reward_times_to_choose[2]: C_1_rew_proj[:, j] = np.mean(C_1_rew[:, i - 5:i + 5], 1) C_2_rew_proj[:, j] = np.mean(C_2_rew[:, i - 5:i + 5], 1) C_3_rew_proj[:, j] = np.mean(C_3_rew[:, i - 5:i + 5], 1) elif i == reward_times_to_choose[3]: C_1_rew_proj[:, j] = np.mean(C_1_rew[:, i:i + 5], 1) C_2_rew_proj[:, j] = np.mean(C_2_rew[:, i:i + 5], 1) C_3_rew_proj[:, j] = np.mean(C_3_rew[:, i:i + 5], 1) j += 1 C_1_rew_count_proj = np.ones( (C_1_rew.shape[0], reward_times_to_choose.shape[0] + 1)) C_2_rew_count_proj = np.ones( (C_1_rew.shape[0], reward_times_to_choose.shape[0] + 1)) C_3_rew_count_proj = np.ones( (C_1_rew.shape[0], reward_times_to_choose.shape[0] + 1)) j = 0 for i in reward_times_to_choose: if i == reward_times_to_choose[0]: C_1_rew_count_proj[:, j] = np.mean(C_1_rew_count[:, i - 20:i], 1) C_2_rew_count_proj[:, j] = np.mean(C_2_rew_count[:, i - 20:i], 1) C_3_rew_count_proj[:, j] = np.mean(C_3_rew_count[:, i - 20:i], 1) elif i == reward_times_to_choose[1] or i == reward_times_to_choose[2]: C_1_rew_count_proj[:, j] = np.mean(C_1_rew_count[:, i - 5:i + 5], 1) C_2_rew_count_proj[:, j] = np.mean(C_2_rew_count[:, i - 5:i + 5], 1) C_3_rew_count_proj[:, j] = np.mean(C_3_rew_count[:, i - 5:i + 5], 1) elif i == reward_times_to_choose[3]: C_1_rew_count_proj[:, j] = np.mean(C_1_rew_count[:, i:i + 5], 1) C_2_rew_count_proj[:, j] = np.mean(C_2_rew_count[:, i:i + 5], 1) C_3_rew_count_proj[:, j] = np.mean(C_3_rew_count[:, i:i + 5], 1) j += 1 cpd_1_2_rew, cpd_1_2_rew_var = regression_code_session( C_2_rew_count, C_1_rew_proj) cpd_1_3_rew, cpd_1_3_rew_var = regression_code_session( C_3_rew_count, C_1_rew_proj) cpd_2_3_rew, cpd_2_3_rew_var = regression_code_session( C_3_rew_count, C_2_rew_proj) rew_to_count_cpd = (cpd_1_2_rew + cpd_1_3_rew + cpd_2_3_rew) / np.sqrt( (cpd_1_2_rew_var + cpd_1_3_rew_var + cpd_2_3_rew_var)) # cpd_1_2_rew = re._CPD(C_1_rew_proj,C_2_rew_count) # cpd_1_3_rew = re._CPD(C_1_rew_proj,C_3_rew_count) # cpd_2_3_rew = re._CPD(C_2_rew_proj,C_3_rew_count) # rew_to_count_cpd = np.mean([cpd_1_2_rew, cpd_1_3_rew, cpd_2_3_rew],0) cpd_1_rew, cpd_1_rew_var = regression_code_session(C_1_rew_count, C_1_rew_proj) cpd_2_rew, cpd_2_rew_var = regression_code_session(C_2_rew_count, C_2_rew_proj) cpd_3_rew, cpd_3_rew_var = regression_code_session(C_3_rew_count, C_3_rew_proj) cpd_1_2_rew_count, cpd_1_2_rew_count_var = regression_code_session( C_2_rew_count, C_1_rew_count_proj) cpd_1_3_rew_count, cpd_1_3_rew_count_var = regression_code_session( C_3_rew_count, C_1_rew_count_proj) cpd_2_3_rew_count, cpd_2_3_rew_count_var = regression_code_session( C_3_rew_count, C_2_rew_count_proj) within_cpd = (cpd_1_rew + cpd_2_rew + cpd_3_rew) / np.sqrt( (cpd_1_rew_var + cpd_2_rew_var + cpd_3_rew_var)) count_to_count_cpd = (cpd_1_2_rew_count + cpd_1_3_rew_count + cpd_2_3_rew_count) / np.sqrt( (cpd_1_2_rew_count_var + cpd_1_3_rew_count_var + cpd_2_3_rew_count_var)) df = 2 count_to_count_p = 1 - stats.t.cdf(abs(count_to_count_cpd), df=df) # cpd_1_rew = re._CPD(C_1_rew_proj, C_1_rew_count) # cpd_2_rew = re._CPD(C_2_rew_proj, C_2_rew_count) # cpd_3_rew= re._CPD(C_3_rew_proj,C_3_rew_count) # cpd_1_2_rew_count = re._CPD(C_1_rew_count_proj, C_2_rew_count); # cpd_1_3_rew_count = re._CPD(C_1_rew_count_proj, C_3_rew_count); # cpd_2_3_rew_count = re._CPD(C_2_rew_count_proj, C_3_rew_count) # within_cpd =np.mean([cpd_1_rew, cpd_2_rew, cpd_3_rew],0) # count_to_count_cpd = np.mean([cpd_1_2_rew_count + cpd_1_3_rew_count + cpd_2_3_rew_count],0) cpd_1_rew_bias, cpd_1_rew_bias_var = regression_code_session( C_1_rew, C_1_rew_proj) cpd_2_rew_bias, cpd_2_rew_bias_var = regression_code_session( C_2_rew, C_2_rew_proj) cpd_3_rew_bias, cpd_3_rew_bias_var = regression_code_session( C_3_rew, C_3_rew_proj) bias_cpd = (cpd_1_rew_bias + cpd_2_rew_bias + cpd_3_rew_bias) / np.sqrt( (cpd_1_rew_bias_var + cpd_2_rew_bias_var + cpd_3_rew_bias_var)) # cpd_1_rew_bias = re._CPD(C_1_rew_proj, C_1_rew) # cpd_2_rew_bias = re._CPD(C_2_rew_proj, C_2_rew) # cpd_3_rew_bias = re._CPD(C_3_rew_proj, C_3_rew) # bias_cpd = np.mean([cpd_1_rew_bias, cpd_2_rew_bias, cpd_3_rew_bias], 0) c = wes.Darjeeling2_5.mpl_colors + wes.Mendl_4.mpl_colors + wes.GrandBudapest1_4.mpl_colors + wes.Moonrise1_5.mpl_colors + wes.Moonrise6_5.mpl_colors plt.figure(figsize=(20, 3)) plt.subplot(2, 4, 1) j = 0 for i in bias_cpd[:-1]: plt.plot(i, color=c[j], label=str(j)) j += 1 plt.legend() sns.despine() plt.title('Vectors within Task Rewards to Rewards Biased') plt.ylabel(' T-stats') # plt.ylabel('cpd') plt.subplot(2, 4, 2) j = 0 for i in within_cpd[:-1]: plt.plot(i, color=c[j], label=str(j)) j += 1 plt.legend() sns.despine() plt.title(' Vectors within Task Rewards to Reward Counts ') plt.ylabel(' T-stats') # plt.ylabel('cpd') plt.subplot(2, 4, 3) j = 0 for i in count_to_count_cpd[:-1]: plt.plot(i, color=c[j], label=str(j)) j += 1 plt.legend() plt.title( str(list(predictors_all.keys())[c_to_plot]) + ' ' + 'between tasks') sns.despine() plt.ylabel(' T-stats') # plt.ylabel('cpd') plt.subplot(2, 4, 4) j = 0 for i in rew_to_count_cpd[:-1]: plt.plot(i, color=c[j], label=str(j)) j += 1 plt.legend() plt.title('Vectors from Rewards to Reward Counts Tasks ') sns.despine() # plt.ylabel('cpd') plt.ylabel(' T-stats') cpd_1_2_rew_rev, cpd_1_2_rew_rev_var = regression_code_session( C_2_rew, C_1_rew_count_proj) cpd_1_3_rew_rev, cpd_1_3_rew_rev_var = regression_code_session( C_3_rew, C_1_rew_count_proj) cpd_2_3_rew_rev, cpd_2_3_rew_rev_var = regression_code_session( C_3_rew, C_2_rew_count_proj) count_to_rew_cpd = ( cpd_1_2_rew_rev + cpd_1_3_rew_rev + cpd_2_3_rew_rev) / np.sqrt( (cpd_1_2_rew_rev_var + cpd_1_3_rew_rev_var + cpd_2_3_rew_rev_var)) # cpd_1_2_rew_rev = re._CPD(C_1_rew_count_proj, C_2_rew) # cpd_1_3_rew_rev = re._CPD(C_1_rew_count_proj, C_3_rew) # cpd_2_3_rew_rev = re._CPD(C_2_rew_count_proj, C_3_rew) # count_to_rew_cpd = np.mean([cpd_1_2_rew_rev, cpd_1_3_rew_rev, cpd_2_3_rew_rev],0) cpd_1_rew, cpd_1_rew_var = regression_code_session(C_1_rew, C_1_rew_count_proj) cpd_2_rew, cpd_2_rew_var = regression_code_session(C_2_rew, C_2_rew_count_proj) cpd_3_rew, cpd_3_rew_var = regression_code_session(C_3_rew, C_3_rew_count_proj) cpd_1_2_rew_within, cpd_1_2_rew_within_var = regression_code_session( C_2_rew, C_1_rew_proj) cpd_1_3_rew_within, cpd_1_3_rew_within_var = regression_code_session( C_3_rew, C_1_rew_proj) cpd_2_3_rew_within, cpd_2_3_rew_within_var = regression_code_session( C_3_rew, C_2_rew_proj) within_cpd_rev = (cpd_1_rew + cpd_2_rew + cpd_3_rew) / np.sqrt( (cpd_1_rew_var + cpd_2_rew_var + cpd_3_rew_var)) rew_to_count_rew = (cpd_1_2_rew_within + cpd_1_3_rew_within + cpd_2_3_rew_within) / np.sqrt( (cpd_1_2_rew_within_var + cpd_1_3_rew_within_var + cpd_2_3_rew_within_var)) # cpd_1_rew = re._CPD(C_1_rew_count_proj,C_1_rew) # cpd_2_rew= re._CPD(C_2_rew_count_proj, C_2_rew) # cpd_3_rew = re._CPD(C_3_rew_count_proj, C_3_rew) # cpd_1_2_rew_within = re._CPD(C_1_rew_proj, C_2_rew) # cpd_1_3_rew_within = re._CPD(C_1_rew_proj, C_3_rew) # cpd_2_3_rew_within = re._CPD(C_2_rew_proj, C_3_rew) # within_cpd_rev = np.mean([cpd_1_rew, cpd_2_rew , cpd_3_rew],0) # rew_to_count_rew = np.mean([cpd_1_2_rew_within,cpd_1_3_rew_within, cpd_2_3_rew_within],0) cpd_1_rew_bias, cpd_1_rew_bias_var = regression_code_session( C_1_rew_count, C_1_rew_count_proj) cpd_2_rew_bias, cpd_2_rew_bias_var = regression_code_session( C_2_rew_count, C_2_rew_count_proj) cpd_3_rew_bias, cpd_3_rew_bias_var = regression_code_session( C_3_rew_count, C_3_rew_count_proj) bias_cpd_rev = ( cpd_1_rew_bias + cpd_2_rew_bias + cpd_3_rew_bias) / np.sqrt( (cpd_1_rew_bias_var + cpd_2_rew_bias_var + cpd_3_rew_bias_var)) # cpd_1_rew_bias = re._CPD(C_1_rew_count_proj, C_1_rew_count) # cpd_2_rew_bias = re._CPD(C_2_rew_count_proj, C_2_rew_count) # cpd_3_rew_bias = re._CPD(C_3_rew_count_proj, C_3_rew_count) # bias_cpd_rev = np.mean([cpd_1_rew_bias,cpd_2_rew_bias,cpd_3_rew_bias],0) c = wes.Darjeeling2_5.mpl_colors + wes.Mendl_4.mpl_colors + wes.GrandBudapest1_4.mpl_colors + wes.Moonrise1_5.mpl_colors + wes.Moonrise6_5.mpl_colors plt.subplot(2, 4, 5) j = 0 for i in bias_cpd_rev[:-1]: plt.plot(i, color=c[j], label=str(j)) j += 1 plt.legend() sns.despine() plt.title('Vectors within Task Reward Counts to Counts Biased Rev') plt.ylabel(' T-stats') #plt.ylabel('cpd') plt.subplot(2, 4, 6) j = 0 for i in within_cpd_rev[:-1]: plt.plot(i, color=c[j], label=str(j)) j += 1 plt.legend() sns.despine() plt.title(' Vectors within Task Rewards Counts to Reward ') plt.ylabel(' T-stats') #plt.ylabel('cpd') plt.subplot(2, 4, 7) j = 0 for i in rew_to_count_rew[:-1]: plt.plot(i, color=c[j], label=str(j)) j += 1 plt.legend() plt.title('Vectors between Tasks ') sns.despine() plt.ylabel(' T-stats') #plt.ylabel('cpd') plt.subplot(2, 4, 8) j = 0 for i in count_to_rew_cpd[:-1]: plt.plot(i, color=c[j], label=str(j)) j += 1 plt.legend() plt.title('Vectors from Rewards Counts to Reward Tasks ') sns.despine() plt.ylabel(' T-stats') #plt.ylabel('cpd') plt.tight_layout() C_1_rew_2 = C_1[c_to_proj] C_2_rew_2 = C_2[c_to_proj] C_3_rew_2 = C_3[c_to_proj] C_1_rew_3 = C_1[c_to_proj_3] C_2_rew_3 = C_2[c_to_proj_3] C_3_rew_3 = C_3[c_to_proj_3] cpd_1_prev_1_2, cpd_1_prev_1_2_var = regression_code_session( C_1_rew_2, C_1_rew_count_proj) cpd_2_prev_1_2, cpd_2_prev_1_2_var = regression_code_session( C_2_rew_2, C_2_rew_count_proj) cpd_3_prev_1_2, cpd_3_prev_1_2_var = regression_code_session( C_3_rew_2, C_3_rew_count_proj) prev_rew_1_2 = ( cpd_1_prev_1_2 + cpd_2_prev_1_2 + cpd_3_prev_1_2) / np.sqrt( (cpd_1_prev_1_2_var + cpd_2_prev_1_2_var + cpd_3_prev_1_2_var)) cpd_1_prev_1_3, cpd_1_prev_1_3_var = regression_code_session( C_1_rew_3, C_1_rew_count_proj) cpd_2_prev_1_3, cpd_2_prev_1_3_var = regression_code_session( C_2_rew_3, C_2_rew_count_proj) cpd_3_prev_1_3, cpd_3_prev_1_3_var = regression_code_session( C_3_rew_3, C_3_rew_count_proj) prev_rew_1_3 = ( cpd_1_prev_1_3 + cpd_2_prev_1_3 + cpd_3_prev_1_3) / np.sqrt( (cpd_1_prev_1_3_var + cpd_2_prev_1_3_var + cpd_3_prev_1_3_var)) # plt.figure(figsize = (15,2)) # plt.subplot(1,3,1) # j = 0 # for i in count_to_count_cpd[:-1]: # plt.plot(i, color = c[j], label = str(j)) # j+=1 # plt.legend() # plt.title(str(list(predictors_all.keys())[c_to_plot]) + ' ' + 'between tasks') # sns.despine() # plt.ylabel(' T-stats') # # plt.ylabel('cpd') # plt.subplot(1,3,2) # j = 0 # for i in prev_rew_1_3[:-1]: # plt.plot(i, color = c[j], label = str(j)) # j+=1 # plt.legend() # plt.title('from' + ' '+ str(list(predictors_all.keys())[c_to_plot]) + ' '+ 'to' + ' ' +str(list(predictors_all.keys())[c_to_proj_3])) # sns.despine() # plt.ylabel(' T-stats') # #plt.ylabel('cpd') # plt.tight_layout() # plt.subplot(1,3,3) # j = 0 # for i in prev_rew_1_2[:-1]: # plt.plot(i, color = c[j], label = str(j)) # j+=1 # plt.legend() # plt.title('from' + ' '+ str(list(predictors_all.keys())[c_to_plot]) + ' '+ 'to' + ' ' +str(list(predictors_all.keys())[c_to_proj])) # sns.despine() # plt.ylabel(' T-stats') # #plt.ylabel('cpd') # plt.tight_layout() return cell_id_cum_reward, cell_id_cum_error, cell_id_prev_ch
def sequence_rewards_errors_regression_generalisation(data, perm=True, area='HP_', interactions=True, a=True): dm = data['DM'][0] firing = data['Data'][0] C_1 = [] cpd_1 = [] C_2 = [] cpd_2 = [] C_3 = [] cpd_3 = [] if perm: C_1_perm = [[] for i in range(perm)] C_2_perm = [[] for i in range(perm)] C_3_perm = [[] for i in range(perm)] cpd_perm_all = [[] for i in range(perm)] for s, sess in enumerate(dm): runs_list = [] runs_list.append(0) DM = dm[s] firing_rates = firing[s] n_trials, n_neurons, n_timepoints = firing_rates.shape choices = DM[:, 1] # choices[np.where(choices ==0)[0]] = -1 reward = DM[:, 2] task = DM[:, 5] task_1 = np.where(task == 1)[0] task_2 = np.where(task == 2)[0] task_3 = np.where(task == 3)[0] state = DM[:, 0] correct = np.where(state == choices)[0] incorrect = np.where(state != choices)[0] cum_error = [] runs_list_corr = [] runs_list_incorr = [] err = 0 for r in reward: if r == 0: err += 1 else: err = 0 cum_error.append(err) cum_reward = [] for r in reward: if r == 1: err += 1 else: err = 0 cum_reward.append(err) run = 0 for c, ch in enumerate(choices): if c > 0: if choices[c] == choices[c - 1]: run += 1 elif choices[c] != choices[c - 1]: run = 0 runs_list.append(run) corr_run = 0 run_ind_c = [] for c, ch in enumerate(choices): if c > 0 and c in correct: if choices[c] == choices[c - 1]: if corr_run == 0: run_ind_c.append(c) corr_run += 1 elif choices[c] != choices[c - 1]: corr_run = 0 else: corr_run = 0 runs_list_corr.append(corr_run) incorr_run = 0 run_ind_inc = [] for c, ch in enumerate(choices): if c > 0 and c in incorrect: if choices[c] == choices[c - 1]: if incorr_run == 0: run_ind_inc.append(c) incorr_run += 1 elif choices[c] != choices[c - 1]: incorr_run = 0 else: incorr_run = 0 runs_list_incorr.append(incorr_run) choices_a = np.where(choices == 1)[0] choices_b = np.where(choices == 0)[0] a_cum_rew = np.copy(np.asarray(np.asarray(cum_reward))) b_cum_rew = np.copy(np.asarray(np.asarray(cum_reward))) a_cum_rew[choices_b] = 0 b_cum_rew[choices_a] = 0 a_cum_error = np.copy(np.asarray(np.asarray(cum_error))) b_cum_error = np.copy(np.asarray(np.asarray(cum_error))) a_cum_error[choices_b] = 0 b_cum_error[choices_a] = 0 ones = np.ones(len(reward)) reward_1 = reward[task_1] choices_1 = choices[task_1] cum_error_1 = np.asarray(cum_error)[task_1] cum_reward_1 = np.asarray(cum_reward)[task_1] cum_error_1_a = np.asarray(a_cum_error)[task_1] cum_error_1_b = np.asarray(b_cum_error)[task_1] cum_reward_1_a = np.asarray(a_cum_rew)[task_1] cum_reward_1_b = np.asarray(b_cum_rew)[task_1] ones_1 = ones[task_1] cum_error_1_ch = cum_error_1 * choices_1 cum_rew_1_ch = cum_reward_1 * choices_1 firing_rates_1 = firing_rates[task_1] int_rew_ch_1 = reward_1 * choices_1 if interactions == True: predictors_all = OrderedDict([ ('Reward', reward_1), ('Choice', choices_1), ('Errors', cum_error_1), ('Rewards', cum_reward_1), ('Choice x Cum Error', cum_error_1_ch), ('Choice x Cum Reward', cum_rew_1_ch), ('Choice x Reward', int_rew_ch_1), ('ones', ones_1) ]) else: predictors_all = OrderedDict([('Reward', reward_1), ('Choice', choices_1), ('Errors A', cum_error_1_a), ('Errors B', cum_error_1_b), ('Rewards A', cum_reward_1_a), ('Rewards B', cum_reward_1_b), ('Choice x Reward', int_rew_ch_1), ('ones', ones_1)]) X_1 = np.vstack( predictors_all.values()).T[:len(choices_1), :].astype(float) rank = np.linalg.matrix_rank(X_1) # print(rank) # print(X_1.shape[1]) n_predictors = X_1.shape[1] y_1 = firing_rates_1.reshape( [len(firing_rates_1), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] tstats = reg_f.regression_code(y_1, X_1) C_1.append(tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings cpd_1.append( re._CPD(X_1, y_1).reshape(n_neurons, n_timepoints, n_predictors)) reward_2 = reward[task_2] choices_2 = choices[task_2] cum_error_2 = np.asarray(cum_error)[task_2] cum_reward_2 = np.asarray(cum_reward)[task_2] ones_2 = ones[task_2] cum_error_2_ch = cum_error_2 * choices_2 cum_rew_2_ch = cum_reward_2 * choices_2 int_rew_ch_2 = reward_2 * choices_2 cum_error_2_a = np.asarray(a_cum_error)[task_2] cum_error_2_b = np.asarray(b_cum_error)[task_2] cum_reward_2_a = np.asarray(a_cum_rew)[task_2] cum_reward_2_b = np.asarray(b_cum_rew)[task_2] firing_rates_2 = firing_rates[task_2] if interactions == True: predictors_all = OrderedDict([ ('Reward', reward_2), ('Choice', choices_2), ('Errors', cum_error_2), ('Rewards', cum_reward_2), ('Choice x Cum Error', cum_error_2_ch), ('Choice x Cum Reward', cum_rew_2_ch), ('Choice x Reward', int_rew_ch_2), ('ones', ones_2) ]) else: predictors_all = OrderedDict([('Reward', reward_2), ('Choice', choices_2), ('Errors A', cum_error_2_a), ('Errors B', cum_error_2_b), ('Rewards A', cum_reward_2_a), ('Rewards B', cum_reward_2_b), ('Choice x Reward', int_rew_ch_2), ('ones', ones_2)]) X_2 = np.vstack( predictors_all.values()).T[:len(choices_2), :].astype(float) y_2 = firing_rates_2.reshape( [len(firing_rates_2), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] tstats = reg_f.regression_code(y_2, X_2) C_2.append(tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings cpd_2.append( re._CPD(X_2, y_2).reshape(n_neurons, n_timepoints, n_predictors)) reward_3 = reward[task_3] choices_3 = choices[task_3] cum_error_3 = np.asarray(cum_error)[task_3] cum_reward_3 = np.asarray(cum_reward)[task_3] ones_3 = ones[task_3] cum_error_3_ch = cum_error_3 * choices_3 cum_rew_3_ch = cum_reward_3 * choices_3 int_rew_ch_3 = reward_3 * choices_3 cum_error_3_a = np.asarray(a_cum_error)[task_3] cum_error_3_b = np.asarray(b_cum_error)[task_3] cum_reward_3_a = np.asarray(a_cum_rew)[task_3] cum_reward_3_b = np.asarray(b_cum_rew)[task_3] firing_rates_3 = firing_rates[task_3] if interactions == True: predictors_all = OrderedDict([ ('Reward', reward_3), ('Choice', choices_3), ('Errors', cum_error_3), ('Rewards', cum_reward_3), ('Choice x Cum Error', cum_error_3_ch), ('Choice x Cum Reward', cum_rew_3_ch), ('Choice x Reward', int_rew_ch_3), ('ones', ones_3) ]) else: predictors_all = OrderedDict([('Reward', reward_3), ('Choice', choices_3), ('Errors A', cum_error_3_a), ('Errors B', cum_error_3_b), ('Rewards A', cum_reward_3_a), ('Rewards B', cum_reward_3_b), ('Choice x Reward', int_rew_ch_3), ('ones', ones_3)]) X_3 = np.vstack( predictors_all.values()).T[:len(choices_3), :].astype(float) y_3 = firing_rates_3.reshape( [len(firing_rates_3), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] tstats = reg_f.regression_code(y_3, X_3) C_3.append(tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings cpd_3.append( re._CPD(X_3, y_3).reshape(n_neurons, n_timepoints, n_predictors)) if perm: for i in range(perm): X_perm_1 = np.roll(X_1, np.random.randint(len(X_1)), axis=0) tstats = reg_f.regression_code(y_1, X_perm_1) C_1_perm[i].append( tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings cpd_perm_1 = re._CPD(X_perm_1, y_1).reshape(n_neurons, n_timepoints, n_predictors) X_perm_2 = np.roll(X_2, np.random.randint(len(X_2)), axis=0) tstats = reg_f.regression_code(y_2, X_perm_2) C_2_perm[i].append( tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings cpd_perm_2 = re._CPD(X_perm_2, y_2).reshape(n_neurons, n_timepoints, n_predictors) X_perm_3 = np.roll(X_3, np.random.randint(len(X_3)), axis=0) tstats = reg_f.regression_code(y_3, X_perm_3) C_3_perm[i].append( tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings cpd_perm_3 = re._CPD(X_perm_3, y_3).reshape(n_neurons, n_timepoints, n_predictors) cpd_perm_all[i].append( np.nanmean([cpd_perm_1, cpd_perm_2, cpd_perm_3], 0)) cpd_perm_all = np.stack( [np.mean(np.concatenate(cpd_i, 0), 0) for cpd_i in cpd_perm_all], 0) cpd_1 = np.nanmean(np.concatenate(cpd_1, 0), axis=0) C_1 = np.concatenate(C_1, 1) cpd_2 = np.nanmean(np.concatenate(cpd_2, 0), axis=0) C_2 = np.concatenate(C_2, 1) cpd_3 = np.nanmean(np.concatenate(cpd_3, 0), axis=0) C_3 = np.concatenate(C_3, 1) cpds_true = np.mean([cpd_1, cpd_2, cpd_3], 0) pal_c = sns.cubehelix_palette(8, start=2, rot=0, dark=0, light=.95) c = wes.Darjeeling2_5.mpl_colors + wes.Mendl_4.mpl_colors + wes.GrandBudapest1_4.mpl_colors + wes.Moonrise1_5.mpl_colors cpd_perm_all = np.max(np.percentile(cpd_perm_all, 95, axis=0), 0) j = 0 plt.figure() for i in cpds_true.T[:-1]: plt.plot(i, color=c[j], label=list(predictors_all.keys())[j]) plt.hlines(cpd_perm_all[j], xmin=0, xmax=63, color=c[j], linestyle=':') j += 1 plt.legend() sns.despine() plt.title(area + 'CPDs') if interactions == True: X_nan, firing_rates_1_inf_rew,firing_rates_2_inf_rew,firing_rates_3_inf_rew,firing_rates_1_inf_error,firing_rates_2_inf_error,\ firing_rates_3_inf_error,firing_rates_1_inf_rew_int,firing_rates_2_inf_rew_int,firing_rates_3_inf_rew_int,firing_rates_1_inf_error_int,\ firing_rates_2_inf_error_int,firing_rates_3_inf_error_int = find_coefficients(C_1,C_2,C_3,interactions = interactions, a = a) X_1_rew = X_nan[:, :5] X_1_rew_int = X_nan[:, 5:10] X_1_error = X_nan[:, 10:15] X_1_error_int = X_nan[:, 15:20] X_2_rew = X_nan[:, 20:25] X_2_rew_int = X_nan[:, 25:30] X_2_error = X_nan[:, 30:35] X_2_error_int = X_nan[:, 35:40] X_3_rew = X_nan[:, 40:45] X_3_rew_int = X_nan[:, 45:50] X_3_error = X_nan[:, 50:55] X_3_error_int = X_nan[:, 55:60] # plt.figure() # for i in range(4): # plt.subplot(2,2,i+1) # sns.regplot(X_1_rew[:,i],X_2_rew[:,i], color = 'red',label = 'Reward') # #sns.regplot(X_1_rew[:,i],X_3_rew[:,i], color = 'black') # #sns.regplot(X_3_rew[:,i],X_2_rew[:,i], color = 'grey') # corr = np.mean([np.corrcoef(X_1_rew[:,i],X_2_rew[:,i])[0,1],np.corrcoef(X_1_rew[:,i],X_3_rew[:,i])[0,1],np.corrcoef(X_2_rew[:,i],X_3_rew[:,i])[0,1]]) # plt.annotate(np.round(corr,2),(1,1.5)) # plt.legend() # sns.despine() # plt.figure() # for i in range(4): # plt.subplot(2,2,i+1) # sns.regplot(X_1_rew_int[:,i],X_2_rew_int[:,i], color = 'grey', label = 'Reward Interaction') # corr = np.mean([np.corrcoef(X_1_rew_int[:,i],X_2_rew_int[:,i])[0,1],np.corrcoef(X_1_rew_int[:,i],X_3_rew_int[:,i])[0,1],np.corrcoef(X_2_rew_int[:,i],X_3_rew_int[:,i])[0,1]]) # plt.annotate(np.round(corr,2),(1,1.5)) # plt.legend() # sns.despine() # plt.figure() # for i in range(4): # plt.subplot(2,2,i+1) # sns.regplot(X_1_error[:,i],X_2_error[:,i], color = 'purple', label = 'Error') # corr = np.mean([np.corrcoef(X_1_error[:,i],X_2_error[:,i])[0,1],np.corrcoef(X_1_error[:,i],X_3_error[:,i])[0,1],np.corrcoef(X_2_error[:,i],X_3_error[:,i])[0,1]]) # plt.annotate(np.round(corr,2),(1,1.5)) # plt.figure() # for i in range(4): # plt.subplot(2,2,i+1) # sns.regplot(X_1_error_int[:,i],X_2_error_int[:,i], color = 'purple', label = 'Error') # corr = np.mean([np.corrcoef(X_1_error_int[:,i],X_2_error_int[:,i])[0,1],np.corrcoef(X_1_error_int[:,i],X_3_error_int[:,i])[0,1],np.corrcoef(X_2_error_int[:,i],X_3_error_int[:,i])[0,1]]) # plt.annotate(np.round(corr,2),(1,1.5)) # plt.legend() # sns.despine() cpd_1_2_rew = re._CPD(X_1_rew, firing_rates_2_inf_rew) cpd_1_3_rew = re._CPD(X_1_rew, firing_rates_3_inf_rew) cpd_2_1_rew = re._CPD(X_2_rew, firing_rates_1_inf_rew) cpd_2_3_rew = re._CPD(X_2_rew, firing_rates_3_inf_rew) cpd_3_1_rew = re._CPD(X_3_rew, firing_rates_1_inf_rew) cpd_3_2_rew = re._CPD(X_3_rew, firing_rates_2_inf_rew) cpd_1_2_error = re._CPD(X_1_error, firing_rates_2_inf_error) cpd_1_3_error = re._CPD(X_1_error, firing_rates_3_inf_error) cpd_2_1_error = re._CPD(X_2_error, firing_rates_1_inf_error) cpd_2_3_error = re._CPD(X_2_error, firing_rates_3_inf_error) cpd_3_1_error = re._CPD(X_3_error, firing_rates_1_inf_error) cpd_3_2_error = re._CPD(X_3_error, firing_rates_2_inf_error) cpd_1_2_rew_int = re._CPD(X_1_rew_int, firing_rates_2_inf_rew_int) cpd_1_3_rew_int = re._CPD(X_1_rew_int, firing_rates_3_inf_rew_int) cpd_2_1_rew_int = re._CPD(X_2_rew_int, firing_rates_1_inf_rew_int) cpd_2_3_rew_int = re._CPD(X_2_rew_int, firing_rates_3_inf_rew_int) cpd_3_1_rew_int = re._CPD(X_3_rew_int, firing_rates_1_inf_rew_int) cpd_3_2_rew_int = re._CPD(X_3_rew_int, firing_rates_2_inf_rew_int) cpd_1_2_error_int = re._CPD(X_1_error_int, firing_rates_2_inf_error_int) cpd_1_3_error_int = re._CPD(X_1_error_int, firing_rates_3_inf_error_int) cpd_2_1_error_int = re._CPD(X_2_error_int, firing_rates_1_inf_error_int) cpd_2_3_error_int = re._CPD(X_2_error_int, firing_rates_3_inf_error_int) cpd_3_1_error_int = re._CPD(X_3_error_int, firing_rates_1_inf_error_int) cpd_3_2_error_int = re._CPD(X_3_error_int, firing_rates_2_inf_error_int) cpd_rew_int = np.nanmean([ cpd_1_2_rew_int, cpd_1_3_rew_int, cpd_2_1_rew_int, cpd_2_3_rew_int, cpd_3_1_rew_int, cpd_3_2_rew_int ], 0) cpd_error_int = np.nanmean([ cpd_1_2_error_int, cpd_1_3_error_int, cpd_2_1_error_int, cpd_2_3_error_int, cpd_3_1_error_int, cpd_3_2_error_int ], 0) else: X_nan, firing_rates_1_inf_rew,firing_rates_2_inf_rew,firing_rates_3_inf_rew,firing_rates_1_inf_error,firing_rates_2_inf_error,\ firing_rates_3_inf_error = find_coefficients(C_1,C_2,C_3,interactions = interactions, a = a) X_1_rew = X_nan[:, :5] X_1_error = X_nan[:, 5:10] X_2_rew = X_nan[:, 10:15] X_2_error = X_nan[:, 15:20] X_3_rew = X_nan[:, 20:25] X_3_error = X_nan[:, 25:30] # plt.figure() # for i in range(4): # plt.subplot(2,2,i+1) # sns.regplot(X_1_rew[:,i],X_2_rew[:,i], color = 'red',label = 'Reward') # #sns.regplot(X_1_rew[:,i],X_3_rew[:,i], color = 'black') # #sns.regplot(X_3_rew[:,i],X_2_rew[:,i], color = 'grey') # corr = np.mean([np.corrcoef(X_1_rew[:,i],X_2_rew[:,i])[0,1],np.corrcoef(X_1_rew[:,i],X_3_rew[:,i])[0,1],np.corrcoef(X_2_rew[:,i],X_3_rew[:,i])[0,1]]) # plt.annotate(np.round(corr,2),(1,1.5)) # plt.legend() # plt.figure() # for i in range(4): # plt.subplot(2,2,i+1) # sns.regplot(X_1_error[:,i],X_2_error[:,i], color = 'purple', label = 'Error') # corr = np.mean([np.corrcoef(X_1_error[:,i],X_2_error[:,i])[0,1],np.corrcoef(X_1_error[:,i],X_3_error[:,i])[0,1],np.corrcoef(X_2_error[:,i],X_3_error[:,i])[0,1]]) # plt.annotate(np.round(corr,2),(1,1.5)) cpd_1_2_rew = re._CPD(X_1_rew, firing_rates_2_inf_rew) cpd_1_3_rew = re._CPD(X_1_rew, firing_rates_3_inf_rew) cpd_2_1_rew = re._CPD(X_2_rew, firing_rates_1_inf_rew) cpd_2_3_rew = re._CPD(X_2_rew, firing_rates_3_inf_rew) cpd_3_1_rew = re._CPD(X_3_rew, firing_rates_1_inf_rew) cpd_3_2_rew = re._CPD(X_3_rew, firing_rates_2_inf_rew) cpd_1_2_error = re._CPD(X_1_error, firing_rates_2_inf_error) cpd_1_3_error = re._CPD(X_1_error, firing_rates_3_inf_error) cpd_2_1_error = re._CPD(X_2_error, firing_rates_1_inf_error) cpd_2_3_error = re._CPD(X_2_error, firing_rates_3_inf_error) cpd_3_1_error = re._CPD(X_3_error, firing_rates_1_inf_error) cpd_3_2_error = re._CPD(X_3_error, firing_rates_2_inf_error) cpd_rew = np.nanmean([ cpd_1_2_rew, cpd_1_3_rew, cpd_2_1_rew, cpd_2_3_rew, cpd_3_1_rew, cpd_3_2_rew ], 0) cpd_error = np.nanmean([ cpd_1_2_error, cpd_1_3_error, cpd_2_1_error, cpd_2_3_error, cpd_3_1_error, cpd_3_2_error ], 0) pal = sns.cubehelix_palette(8) pal_c = sns.cubehelix_palette(8, start=2, rot=0, dark=0, light=.95) if interactions == True: sub = 2 else: sub = 1 plt.figure() plt.subplot(2, sub, 1) plt.plot(cpd_rew[:, 0], color=pal[0], label='Pre Init Period') plt.plot(cpd_rew[:, 1], color=pal[2], label='Init Period') plt.plot(cpd_rew[:, 2], color=pal[4], label='Choice Period') plt.plot(cpd_rew[:, 3], color=pal[6], label='Reward Period') plt.title(area + 'Between Tasks Reward Runs') plt.legend() sns.despine() # plt.ylim(0,0.18) plt.subplot(2, sub, 2) plt.plot(cpd_error[:, 0], color=pal_c[0], label='Pre Init Period') plt.plot(cpd_error[:, 1], color=pal_c[2], label='Init Period') plt.plot(cpd_error[:, 2], color=pal_c[4], label='Choice Period') plt.plot(cpd_error[:, 3], color=pal_c[6], label='Reward Period') plt.title(area + 'Between Tasks Error Runs') # plt.ylim(0,0.06) if interactions == True: plt.subplot(2, sub, 3) plt.plot(cpd_rew_int[:, 0], color=pal[0], label='Pre Init Period') plt.plot(cpd_rew_int[:, 1], color=pal[2], label='Init Period') plt.plot(cpd_rew_int[:, 2], color=pal[4], label='Choice Period') plt.plot(cpd_rew_int[:, 3], color=pal[6], label='Reward Period') plt.title(area + 'Between Tasks Reward Runs Interactions with Choice') plt.legend() sns.despine() # plt.ylim(0,0.18) plt.subplot(2, sub, 4) plt.plot(cpd_error_int[:, 0], color=pal_c[0], label='Pre Init Period') plt.plot(cpd_error_int[:, 1], color=pal_c[2], label='Init Period') plt.plot(cpd_error_int[:, 2], color=pal_c[4], label='Choice Period') plt.plot(cpd_error_int[:, 3], color=pal_c[6], label='Reward Period') plt.title(area + 'Between Tasks Error Runs Interactions with Choice') # plt.ylim(0,0.06) plt.legend() sns.despine() cpd_rew_perm = [] cpd_error_perm = [] cpd_rew_int_perm = [] cpd_error_int_perm = [] for i, ii, in enumerate(C_3_perm): C_1 = np.concatenate(C_1_perm[i], 1) C_2 = np.concatenate(C_3_perm[i], 1) C_3 = np.concatenate(C_2_perm[i], 1) if interactions == True: X_nan, firing_rates_1_inf_rew,firing_rates_2_inf_rew,firing_rates_3_inf_rew,firing_rates_1_inf_error,firing_rates_2_inf_error,\ firing_rates_3_inf_error,firing_rates_1_inf_rew_int,firing_rates_2_inf_rew_int,firing_rates_3_inf_rew_int,firing_rates_1_inf_error_int,\ firing_rates_2_inf_error_int,firing_rates_3_inf_error_int = find_coefficients(C_1,C_2,C_3,interactions = interactions, a = a) X_1_rew = X_nan[:, :5] X_1_rew_int = X_nan[:, 5:10] X_1_error = X_nan[:, 10:15] X_1_error_int = X_nan[:, 15:20] X_2_rew = X_nan[:, 20:25] X_2_rew_int = X_nan[:, 25:30] X_2_error = X_nan[:, 30:35] X_2_error_int = X_nan[:, 35:40] X_3_rew = X_nan[:, 40:45] X_3_rew_int = X_nan[:, 45:50] X_3_error = X_nan[:, 50:55] X_3_error_int = X_nan[:, 55:60] cpd_1_2_rew = re._CPD(X_1_rew, firing_rates_2_inf_rew) cpd_1_3_rew = re._CPD(X_1_rew, firing_rates_3_inf_rew) cpd_2_1_rew = re._CPD(X_2_rew, firing_rates_1_inf_rew) cpd_2_3_rew = re._CPD(X_2_rew, firing_rates_3_inf_rew) cpd_3_1_rew = re._CPD(X_3_rew, firing_rates_1_inf_rew) cpd_3_2_rew = re._CPD(X_3_rew, firing_rates_2_inf_rew) cpd_1_2_error = re._CPD(X_1_error, firing_rates_2_inf_error) cpd_1_3_error = re._CPD(X_1_error, firing_rates_3_inf_error) cpd_2_1_error = re._CPD(X_2_error, firing_rates_1_inf_error) cpd_2_3_error = re._CPD(X_2_error, firing_rates_3_inf_error) cpd_3_1_error = re._CPD(X_3_error, firing_rates_1_inf_error) cpd_3_2_error = re._CPD(X_3_error, firing_rates_2_inf_error) cpd_1_2_rew_int = re._CPD(X_1_rew_int, firing_rates_2_inf_rew_int) cpd_1_3_rew_int = re._CPD(X_1_rew_int, firing_rates_3_inf_rew_int) cpd_2_1_rew_int = re._CPD(X_2_rew_int, firing_rates_1_inf_rew_int) cpd_2_3_rew_int = re._CPD(X_2_rew_int, firing_rates_3_inf_rew_int) cpd_3_1_rew_int = re._CPD(X_3_rew_int, firing_rates_1_inf_rew_int) cpd_3_2_rew_int = re._CPD(X_3_rew_int, firing_rates_2_inf_rew_int) cpd_1_2_error_int = re._CPD(X_1_error_int, firing_rates_2_inf_error_int) cpd_1_3_error_int = re._CPD(X_1_error_int, firing_rates_3_inf_error_int) cpd_2_1_error_int = re._CPD(X_2_error_int, firing_rates_1_inf_error_int) cpd_2_3_error_int = re._CPD(X_2_error_int, firing_rates_3_inf_error_int) cpd_3_1_error_int = re._CPD(X_3_error_int, firing_rates_1_inf_error_int) cpd_3_2_error_int = re._CPD(X_3_error_int, firing_rates_2_inf_error_int) cpd_rew_int_perm.append( np.nanmean([ cpd_1_2_rew_int, cpd_1_3_rew_int, cpd_2_1_rew_int, cpd_2_3_rew_int, cpd_3_1_rew_int, cpd_3_2_rew_int ], 0)) cpd_error_int_perm.append( np.nanmean([ cpd_1_2_error_int, cpd_1_3_error_int, cpd_2_1_error_int, cpd_2_3_error_int, cpd_3_1_error_int, cpd_3_2_error_int ], 0)) else: X_nan, firing_rates_1_inf_rew,firing_rates_2_inf_rew,firing_rates_3_inf_rew,firing_rates_1_inf_error,firing_rates_2_inf_error,\ firing_rates_3_inf_error = find_coefficients(C_1,C_2,C_3,interactions = interactions, a = a) X_1_rew = X_nan[:, :5] X_1_error = X_nan[:, 5:10] X_2_rew = X_nan[:, 10:15] X_2_error = X_nan[:, 15:20] X_3_rew = X_nan[:, 20:25] X_3_error = X_nan[:, 25:30] cpd_1_2_rew = re._CPD(X_1_rew, firing_rates_2_inf_rew) cpd_1_3_rew = re._CPD(X_1_rew, firing_rates_3_inf_rew) cpd_2_1_rew = re._CPD(X_2_rew, firing_rates_1_inf_rew) cpd_2_3_rew = re._CPD(X_2_rew, firing_rates_3_inf_rew) cpd_3_1_rew = re._CPD(X_3_rew, firing_rates_1_inf_rew) cpd_3_2_rew = re._CPD(X_3_rew, firing_rates_2_inf_rew) cpd_1_2_error = re._CPD(X_1_error, firing_rates_2_inf_error) cpd_1_3_error = re._CPD(X_1_error, firing_rates_3_inf_error) cpd_2_1_error = re._CPD(X_2_error, firing_rates_1_inf_error) cpd_2_3_error = re._CPD(X_2_error, firing_rates_3_inf_error) cpd_3_1_error = re._CPD(X_3_error, firing_rates_1_inf_error) cpd_3_2_error = re._CPD(X_3_error, firing_rates_2_inf_error) cpd_rew_perm.append( np.nanmean([ cpd_1_2_rew, cpd_1_3_rew, cpd_2_1_rew, cpd_2_3_rew, cpd_3_1_rew, cpd_3_2_rew ], 0)) cpd_error_perm.append( np.nanmean([ cpd_1_2_error, cpd_1_3_error, cpd_2_1_error, cpd_2_3_error, cpd_3_1_error, cpd_3_2_error ], 0)) cpd_rew_perm = np.max(np.percentile(cpd_rew_perm, 95, axis=0), 0) cpd_error_perm = np.max(np.percentile(cpd_error_perm, 95, axis=0), 0) plt.subplot(2, sub, 1) plt.hlines(cpd_rew_perm[0], xmin=0, xmax=63, color=pal[0], label='Pre Init Period', linestyle=':') plt.hlines(cpd_rew_perm[1], xmin=0, xmax=63, color=pal[2], label='Init Period', linestyle=':') plt.hlines(cpd_rew_perm[2], xmin=0, xmax=63, color=pal[4], label='Choice Period', linestyle=':') plt.hlines(cpd_rew_perm[3], xmin=0, xmax=63, color=pal[6], label='Reward Period', linestyle=':') plt.legend() sns.despine() plt.subplot(2, sub, 2) plt.hlines(cpd_error_perm[0], xmin=0, xmax=63, color=pal_c[0], label='Pre Init Period', linestyle=':') plt.hlines(cpd_error_perm[1], xmin=0, xmax=63, color=pal_c[2], label='Init Period', linestyle=':') plt.hlines(cpd_error_perm[2], xmin=0, xmax=63, color=pal_c[4], label='Choice Period', linestyle=':') plt.hlines(cpd_error_perm[3], xmin=0, xmax=63, color=pal_c[6], label='Reward Period', linestyle=':') plt.legend() sns.despine() if interactions == True: cpd_rew_int_perm = np.max(np.percentile(cpd_rew_int_perm, 95, axis=0), 0) cpd_error_int_perm = np.max( np.percentile(cpd_error_int_perm, 95, axis=0), 0) plt.subplot(2, sub, 3) plt.hlines(cpd_rew_int_perm[0], xmin=0, xmax=63, color=pal[0], label='Pre Init Period', linestyle=':') plt.hlines(cpd_rew_int_perm[1], xmin=0, xmax=63, color=pal[2], label='Init Period', linestyle=':') plt.hlines(cpd_rew_int_perm[2], xmin=0, xmax=63, color=pal[4], label='Choice Period', linestyle=':') plt.hlines(cpd_rew_int_perm[3], xmin=0, xmax=63, color=pal[6], label='Reward Period', linestyle=':') plt.legend() sns.despine() plt.subplot(2, sub, 4) plt.hlines(cpd_error_int_perm[0], xmin=0, xmax=63, color=pal_c[0], label='Pre Init Period', linestyle=':') plt.hlines(cpd_error_int_perm[1], xmin=0, xmax=63, color=pal_c[2], label='Init Period', linestyle=':') plt.hlines(cpd_error_int_perm[2], xmin=0, xmax=63, color=pal_c[4], label='Choice Period', linestyle=':') plt.hlines(cpd_error_int_perm[3], xmin=0, xmax=63, color=pal_c[6], label='Reward Period', linestyle=':') plt.legend() sns.despine()
def time_in_block(data, area='PFC'): dm = data['DM'][0] firing = data['Data'][0] C_1 = [] C_2 = [] C_3 = [] cpd_1 = [] cpd_2 = [] cpd_3 = [] # cpd_perm_p_1 = []; cpd_perm_p_2 = []; cpd_perm_p_3 = [] for s, sess in enumerate(dm): DM = dm[s] firing_rates = firing[s][1:] # firing_rates = firing_rates[:,:,:63] n_trials, n_neurons, n_timepoints = firing_rates.shape choices = DM[:, 1] - 0.5 reward = DM[:, 2] - 0.5 task = DM[:, 5][1:] a_pokes = DM[:, 6][1:] b_pokes = DM[:, 7][1:] reward_prev = reward[:-1] reward = reward[1:] choices_prev = choices[:-1] choices = choices[1:] taskid = task_ind(task, a_pokes, b_pokes) task_1 = np.where(taskid == 1)[0] task_2 = np.where(taskid == 2)[0] task_3 = np.where(taskid == 3)[0] reward_PE = np.zeros(len(task)) for r, rr in enumerate(reward): if reward[r] != reward[r - 1]: reward_PE[r] = 0.5 elif reward[r] == reward[r - 1]: reward_PE[r] = -0.5 choice_PE = np.zeros(len(task)) for r, rr in enumerate(choices): if choices[r] != choices[r - 1]: choice_PE[r] = 0.5 elif choices[r] == choices[r - 1]: choice_PE[r] = -0.5 reward_PE_1 = reward_PE[task_1] choice_PE_1 = choice_PE[task_1] rewards_1 = reward[task_1] choices_1 = choices[task_1] rewards_1 = reward[task_1] ones_1 = np.ones(len(choices_1)) trials_1 = len(choices_1) prev_reward_1 = reward_prev[task_1] prev_choice_1 = choices_prev[task_1] #prev_choice_1 = choices_1*choice_PE_1 choice_PE_1_reward_current = choice_PE_1 * rewards_1 choice_PE_1_reward_prev = choice_PE_1 * prev_reward_1 rew_ch_1 = choices_1 * rewards_1 prev_choice_1_lr = prev_choice_1 * prev_reward_1 firing_rates_1 = firing_rates[task_1] predictors_all = OrderedDict([ ('Choice', choices_1), ('Reward', rewards_1), ('Reward Repeat/Switch', reward_PE_1), ('Choice Repeat/Switch', choice_PE_1), ('Repeat/Switch Current Reward', choice_PE_1_reward_current), ('Repeat/Switch Prev Reward', choice_PE_1_reward_prev), ('Choice x Reward ', rew_ch_1), ('Prev Ch x Last Reward', prev_choice_1_lr), ('Prev Rew', prev_reward_1), ('Prev Ch', prev_choice_1), ('ones', ones_1) ]) X_1 = np.vstack(predictors_all.values()).T[:trials_1, :].astype(float) n_predictors = X_1.shape[1] y_1 = firing_rates_1.reshape( [len(firing_rates_1), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] tstats = reg_f.regression_code(y_1, X_1) C_1.append(tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings cpd_1.append( re._CPD(X_1, y_1).reshape(n_neurons, n_timepoints, n_predictors)) choices_2 = choices[task_2] rewards_2 = reward[task_2] ones_2 = np.ones(len(choices_2)) reward_PE_2 = reward_PE[task_2] choice_PE_2 = choice_PE[task_2] prev_reward_2 = reward_prev[task_2] prev_choice_2 = choices_prev[task_2] #prev_choice_2 = choices_2*choice_PE_2 choice_PE_2_reward_current = choice_PE_2 * rewards_2 choice_PE_2_reward_prev = choice_PE_2 * prev_reward_2 trials_2 = len(choices_2) rew_ch_2 = choices_2 * rewards_2 prev_choice_2_lr = prev_choice_2 * prev_reward_2 ones_2 = np.ones(len(choices_2)) firing_rates_2 = firing_rates[task_2] predictors_all = OrderedDict([ ('Choice', choices_2), ('Reward', rewards_2), ('Reward Repeat/Switch', reward_PE_2), ('Choice Repeat/Switch', choice_PE_2), ('Repeat/Switch Current Reward', choice_PE_2_reward_current), ('Repeat/Switch Prev Reward', choice_PE_2_reward_prev), ('Choice x Reward ', rew_ch_2), (' Prev Ch x Last Reward', prev_choice_2_lr), ('Prev Rew', prev_reward_2), ('Prev Ch', prev_choice_2), ('ones', ones_2) ]) X_2 = np.vstack(predictors_all.values()).T[:trials_2, :].astype(float) n_predictors = X_2.shape[1] y_2 = firing_rates_2.reshape( [len(firing_rates_2), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] tstats = reg_f.regression_code(y_2, X_2) C_2.append(tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings cpd_2.append( re._CPD(X_2, y_2).reshape(n_neurons, n_timepoints, n_predictors)) choices_3 = choices[task_3] rewards_3 = reward[task_3] ones_3 = np.ones(len(choices_3)) trials_3 = len(choices_3) ones_3 = np.ones(len(choices_3)) prev_reward_3 = reward_prev[task_3] choice_PE_3 = choice_PE[task_3] reward_PE_3 = reward_PE[task_3] choice_PE_3_reward_current = choice_PE_3 * rewards_3 choice_PE_3_reward_prev = choice_PE_3 * prev_reward_3 prev_choice_3 = choices_prev[task_3] #prev_choice_3 = choices_3*choice_PE_3 rew_ch_3 = choices_3 * rewards_3 prev_choice_3_lr = prev_choice_3 * prev_reward_3 firing_rates_3 = firing_rates[task_3] predictors_all = OrderedDict([ ('Ch', choices_3), ('Rew', rewards_3), ('Rew Stay', reward_PE_3), ('Ch Stay', choice_PE_3), ('Stay Cur Rew', choice_PE_3_reward_current), ('Stay Prev Rew', choice_PE_3_reward_prev), ('Ch x Rew ', rew_ch_3), (' Prev Ch x Prev Rew', prev_choice_3_lr), ('Prev Rew', prev_reward_3), ('Prev Ch', prev_choice_3), ('ones', ones_3) ]) X_3 = np.vstack(predictors_all.values()).T[:trials_3, :].astype(float) rank = np.linalg.matrix_rank(X_3) print(rank) n_predictors = X_3.shape[1] print(n_predictors) y_3 = firing_rates_3.reshape( [len(firing_rates_3), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] tstats = reg_f.regression_code(y_3, X_3) C_3.append(tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings cpd_3.append( re._CPD(X_3, y_3).reshape(n_neurons, n_timepoints, n_predictors)) C_1 = np.concatenate(C_1, 1) C_2 = np.concatenate(C_2, 1) C_3 = np.concatenate(C_3, 1) cpd_1 = np.nanmean(np.concatenate(cpd_1, 0), axis=0) cpd_2 = np.nanmean(np.concatenate(cpd_2, 0), axis=0) cpd_3 = np.nanmean(np.concatenate(cpd_3, 0), axis=0) cpd = np.mean([cpd_1, cpd_2, cpd_3], 0) c = wes.Darjeeling2_5.mpl_colors + wes.Mendl_4.mpl_colors + wes.GrandBudapest1_4.mpl_colors + wes.Moonrise1_5.mpl_colors j = 0 plt.figure() pred = list(predictors_all.keys()) pred = pred[2:-1] for ii, i in enumerate(cpd.T[2:-1]): plt.plot(i, color=c[j], label=pred[j]) j += 1 plt.legend() sns.despine() C_2_inf = [~np.isinf(C_2[0]).any(axis=1)] C_2_nan = [~np.isnan(C_2[0]).any(axis=1)] C_3_inf = [~np.isinf(C_3[0]).any(axis=1)] C_3_nan = [~np.isnan(C_3[0]).any(axis=1)] C_1_inf = [~np.isinf(C_1[0]).any(axis=1)] C_1_nan = [~np.isnan(C_1[0]).any(axis=1)] nans = np.asarray(C_1_inf) & np.asarray(C_1_nan) & np.asarray( C_3_inf) & np.asarray(C_3_nan) & np.asarray(C_2_inf) & np.asarray( C_2_nan) C_1 = C_1[:, nans[0], :] C_2 = C_2[:, nans[0], :] C_3 = C_3[:, nans[0], :] preds = np.arange(len(list(predictors_all.keys()))) coef_1 = np.tile(preds, 11) coef_2 = np.concatenate((preds, np.roll(preds,1), np.roll(preds,2),np.roll(preds,3), np.roll(preds,4),np.roll(preds,5),\ np.roll(preds,6), np.roll(preds,7), np.roll(preds,8),np.roll(preds,9), np.roll(preds,10))) m = 0 l = 0 plt.figure(figsize=(10, 10)) for c_1, c_2 in zip(coef_1, coef_2): title = list(predictors_all.keys())[c_1] + ' ' + 'on' + ' ' + list( predictors_all.keys())[c_2] m += 1 l += 1 if m == 10: plt.savefig('/Users/veronikasamborska/Desktop/runs/within' + area + str(l) + '.png') plt.figure(figsize=(10, 10)) m -= 9 C_1_rew = C_1[c_1] C_2_rew = C_2[c_1] C_3_rew = C_3[c_1] C_1_rew_count = C_1[c_2] C_2_rew_count = C_2[c_2] C_3_rew_count = C_3[c_2] reward_times_to_choose = np.asarray([20, 24, 35, 41]) C_1_rew_proj = np.ones( (C_1_rew.shape[0], reward_times_to_choose.shape[0] + 1)) C_2_rew_proj = np.ones( (C_1_rew.shape[0], reward_times_to_choose.shape[0] + 1)) C_3_rew_proj = np.ones( (C_1_rew.shape[0], reward_times_to_choose.shape[0] + 1)) j = 0 for i in reward_times_to_choose: if i == reward_times_to_choose[0]: C_1_rew_proj[:, j] = np.mean(C_1_rew[:, i - 20:i], 1) C_2_rew_proj[:, j] = np.mean(C_2_rew[:, i - 20:i], 1) C_3_rew_proj[:, j] = np.mean(C_3_rew[:, i - 20:i], 1) elif i == reward_times_to_choose[1] or i == reward_times_to_choose[ 2]: C_1_rew_proj[:, j] = np.mean(C_1_rew[:, i - 5:i + 5], 1) C_2_rew_proj[:, j] = np.mean(C_2_rew[:, i - 5:i + 5], 1) C_3_rew_proj[:, j] = np.mean(C_3_rew[:, i - 5:i + 5], 1) elif i == reward_times_to_choose[3]: C_1_rew_proj[:, j] = np.mean(C_1_rew[:, i:i + 5], 1) C_2_rew_proj[:, j] = np.mean(C_2_rew[:, i:i + 5], 1) C_3_rew_proj[:, j] = np.mean(C_3_rew[:, i:i + 5], 1) j += 1 C_1_rew_count_proj = np.ones( (C_1_rew.shape[0], reward_times_to_choose.shape[0] + 1)) C_2_rew_count_proj = np.ones( (C_1_rew.shape[0], reward_times_to_choose.shape[0] + 1)) C_3_rew_count_proj = np.ones( (C_1_rew.shape[0], reward_times_to_choose.shape[0] + 1)) j = 0 for i in reward_times_to_choose: if i == reward_times_to_choose[0]: C_1_rew_count_proj[:, j] = np.mean(C_1_rew_count[:, i - 20:i], 1) C_2_rew_count_proj[:, j] = np.mean(C_2_rew_count[:, i - 20:i], 1) C_3_rew_count_proj[:, j] = np.mean(C_3_rew_count[:, i - 20:i], 1) elif i == reward_times_to_choose[1] or i == reward_times_to_choose[ 2]: C_1_rew_count_proj[:, j] = np.mean(C_1_rew_count[:, i - 5:i + 5], 1) C_2_rew_count_proj[:, j] = np.mean(C_2_rew_count[:, i - 5:i + 5], 1) C_3_rew_count_proj[:, j] = np.mean(C_3_rew_count[:, i - 5:i + 5], 1) elif i == reward_times_to_choose[3]: C_1_rew_count_proj[:, j] = np.mean(C_1_rew_count[:, i:i + 5], 1) C_2_rew_count_proj[:, j] = np.mean(C_2_rew_count[:, i:i + 5], 1) C_3_rew_count_proj[:, j] = np.mean(C_3_rew_count[:, i:i + 5], 1) j += 1 cpd_1_2_rew, cpd_1_2_rew_var = regression_code_session( C_1_rew_count, C_1_rew_proj) cpd_1_3_rew, cpd_1_3_rew_var = regression_code_session( C_2_rew_count, C_2_rew_proj) cpd_2_3_rew, cpd_2_3_rew_var = regression_code_session( C_3_rew_count, C_3_rew_proj) rew_to_count_cpd = (cpd_1_2_rew + cpd_1_3_rew + cpd_2_3_rew) / np.sqrt( (cpd_1_2_rew_var + cpd_1_3_rew_var + cpd_2_3_rew_var)) j = 0 plt.subplot(5, 2, m) for i in rew_to_count_cpd[:-1]: plt.plot(i, color=c[j], label=str(j)) j += 1 # plt.legend() plt.title(area + ' ' + str(title)) sns.despine() plt.tight_layout()
def regression_general(data): C = [] cpd = [] C_1 = [] C_2 = [] C_3 = [] cpd_1_2 = [] cpd_2_3 = [] dm = data['DM'] #dm = dm[:-1] firing = data['Data'] #firing = firing[:-1] for s, sess in enumerate(dm): DM = dm[s] firing_rates = firing[s] n_trials, n_neurons, n_timepoints = firing_rates.shape if n_neurons > 10: session_trials_since_block = [] state = DM[:, 0] choices = DM[:, 1] reward = DM[:, 2] b_pokes = DM[:, 7] a_pokes = DM[:, 6] task = DM[:, 5] block = DM[:, 4] block_df = np.diff(block) taskid = rc.task_ind(task, a_pokes, b_pokes) correct_choice = np.where(choices == state)[0] correct = np.zeros(len(choices)) correct[correct_choice] = 1 a_since_block = [] trials_since_block = [] t = 0 #Bug in the state? for st, s in enumerate(block): if state[st - 1] != state[st]: t = 0 else: t += 1 trials_since_block.append(t) session_trials_since_block.append(trials_since_block) t = 0 for st, (s, c) in enumerate(zip(block, choices)): if state[st - 1] != state[st]: t = 0 a_since_block.append(t) elif c == 1: t += 1 a_since_block.append(t) else: a_since_block.append(0) negative_reward_count = [] rew = 0 block_df = np.append(block_df, 0) for r, b in zip(reward, block_df): if r == 0: rew += 1 negative_reward_count.append(rew) elif r == 1: rew -= 1 negative_reward_count.append(rew) if b != 0: rew = 0 positive_reward_count = [] rew = 0 block_df = np.append(block_df, 0) for r, b in zip(reward, block_df): if r == 1: rew += 1 positive_reward_count.append(rew) elif r == 0: rew += 0 positive_reward_count.append(rew) if b != 0: rew = 0 positive_reward_count = np.asarray(positive_reward_count) negative_reward_count = np.asarray(negative_reward_count) choices_int = np.ones(len(reward)) choices_int[np.where(choices == 0)] = -1 reward_choice_int = choices_int * reward interaction_trial_latent = trials_since_block * state interaction_a_latent = a_since_block * state int_a_reward = a_since_block * reward interaction_trial_choice = trials_since_block * choices_int reward_trial_in_block = trials_since_block * positive_reward_count negative_reward_count_st = negative_reward_count * correct positive_reward_count_st = positive_reward_count * correct negative_reward_count_ch = negative_reward_count * choices positive_reward_count_ch = positive_reward_count * choices ones = np.ones(len(choices)) predictors_all = OrderedDict([ ('Reward', reward), ('Choice', choices), #('Correct', correct), #('A in Block', a_since_block), #('A in Block x Reward', int_a_reward), ('State', state), ('Trial in Block', trials_since_block), #('Interaction State x Trial in Block', interaction_trial_latent), #('Interaction State x A count', interaction_a_latent), ('Choice x Trials in Block', interaction_trial_choice), ('Reward x Choice', reward_choice_int), # ('No Reward Count in a Block', negative_reward_count), # ('No Reward x Correct', negative_reward_count_st), # ('Reward Count in a Block', positive_reward_count), # ('Reward Count x Correct', positive_reward_count_st), # ('No reward Count x Choice',negative_reward_count_ch), # ('Reward Count x Choice',positive_reward_count_ch), # ('Reward x Trial in Block',reward_trial_in_block), ('ones', ones) ]) X = np.vstack( predictors_all.values()).T[:len(choices), :].astype(float) n_predictors = X.shape[1] y = firing_rates.reshape( [len(firing_rates), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] tstats = reg_f.regression_code(y, X) C.append(tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings cpd.append( re._CPD(X, y).reshape(n_neurons, n_timepoints, n_predictors)) task_1 = np.where(taskid == 1)[0] task_2 = np.where(taskid == 2)[0] task_3 = np.where(taskid == 3)[0] # Task 1 reward_t1 = reward[task_1] choices_t1 = choices[task_1] correct_t1 = correct[task_1] a_since_block_t1 = np.asarray(a_since_block)[task_1] int_a_reward_t1 = int_a_reward[task_1] state_t1 = state[task_1] trials_since_block_t1 = np.asarray(trials_since_block)[task_1] interaction_trial_latent_t1 = interaction_trial_latent[task_1] interaction_a_latent_t1 = interaction_a_latent[task_1] interaction_trial_choice_t1 = interaction_trial_choice[task_1] reward_choice_int_t1 = reward_choice_int[task_1] negative_reward_count_t1 = negative_reward_count[task_1] negative_reward_count_st_t1 = negative_reward_count_st[task_1] positive_reward_count_t1 = positive_reward_count[task_1] positive_reward_count_st_t1 = positive_reward_count_st[task_1] negative_reward_count_ch_t1 = negative_reward_count_ch[task_1] positive_reward_count_ch_t1 = positive_reward_count_ch[task_1] reward_trial_in_block_t1 = reward_trial_in_block[task_1] firing_rates_t1 = firing_rates[task_1] ones = np.ones(len(choices_t1)) predictors = OrderedDict([ ('Reward', reward_t1), ('Choice', choices_t1), ('Correct', correct_t1), ('A in Block', a_since_block_t1), ('A in Block x Reward', int_a_reward_t1), ('State', state_t1), ('Trial in Block', trials_since_block_t1), ('Interaction State x Trial in Block', interaction_trial_latent_t1), ('Interaction State x A count', interaction_a_latent_t1), ('Choice x Trials in Block', interaction_trial_choice_t1), ('Reward x Choice', reward_choice_int_t1), ('No Reward Count in a Block', negative_reward_count_t1), ('No Reward x Correct', negative_reward_count_st_t1), ('Reward Count in a Block', positive_reward_count_t1), ('Reward Count x Correct', positive_reward_count_st_t1), ('No reward Count x Choice', negative_reward_count_ch_t1), ('Reward Count x Choice', positive_reward_count_ch_t1), ('Reward x Trial in Block', reward_trial_in_block_t1), ('ones', ones) ]) X_1 = np.vstack( predictors.values()).T[:len(choices_t1), :].astype(float) n_predictors = X_1.shape[1] y_1 = firing_rates_t1.reshape( [len(firing_rates_t1), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] tstats = reg_f.regression_code(y_1, X_1) C_1.append(tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings # Task 2 reward_t2 = reward[task_2] choices_t2 = choices[task_2] correct_t2 = correct[task_2] a_since_block_t2 = np.asarray(a_since_block)[task_2] int_a_reward_t2 = int_a_reward[task_2] state_t2 = state[task_2] trials_since_block_t2 = np.asarray(trials_since_block)[task_2] interaction_trial_latent_t2 = interaction_trial_latent[task_2] interaction_a_latent_t2 = interaction_a_latent[task_2] interaction_trial_choice_t2 = interaction_trial_choice[task_2] reward_choice_int_t2 = reward_choice_int[task_2] negative_reward_count_t2 = negative_reward_count[task_2] negative_reward_count_st_t2 = negative_reward_count_st[task_2] positive_reward_count_t2 = positive_reward_count[task_2] positive_reward_count_st_t2 = positive_reward_count_st[task_2] negative_reward_count_ch_t2 = negative_reward_count_ch[task_2] positive_reward_count_ch_t2 = positive_reward_count_ch[task_2] reward_trial_in_block_t2 = reward_trial_in_block[task_2] firing_rates_t2 = firing_rates[task_2] ones = np.ones(len(choices_t2)) predictors = OrderedDict([ ('Reward', reward_t2), ('Choice', choices_t2), ('Correct', correct_t2), ('A in Block', a_since_block_t2), ('A in Block x Reward', int_a_reward_t2), ('State', state_t2), ('Trial in Block', trials_since_block_t2), ('Interaction State x Trial in Block', interaction_trial_latent_t2), ('Interaction State x A count', interaction_a_latent_t2), ('Choice x Trials in Block', interaction_trial_choice_t2), ('Reward x Choice', reward_choice_int_t2), ('No Reward Count in a Block', negative_reward_count_t2), ('No Reward x Correct', negative_reward_count_st_t2), ('Reward Count in a Block', positive_reward_count_t2), ('Reward Count x Correct', positive_reward_count_st_t2), ('No reward Count x Choice', negative_reward_count_ch_t2), ('Reward Count x Choice', positive_reward_count_ch_t2), ('Reward x Trial in Block', reward_trial_in_block_t2), ('ones', ones) ]) X_2 = np.vstack( predictors.values()).T[:len(choices_t2), :].astype(float) n_predictors = X_2.shape[1] y_2 = firing_rates_t2.reshape( [len(firing_rates_t2), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] tstats = reg_f.regression_code(y_2, X_2) C_2.append(tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings # Task 3 reward_t3 = reward[task_3] choices_t3 = choices[task_3] correct_t3 = correct[task_3] a_since_block_t3 = np.asarray(a_since_block)[task_3] int_a_reward_t3 = int_a_reward[task_3] state_t3 = state[task_3] trials_since_block_t3 = np.asarray(trials_since_block)[task_3] interaction_trial_latent_t3 = interaction_trial_latent[task_3] interaction_a_latent_t3 = interaction_a_latent[task_3] interaction_trial_choice_t3 = interaction_trial_choice[task_3] reward_choice_int_t3 = reward_choice_int[task_3] negative_reward_count_t3 = negative_reward_count[task_3] negative_reward_count_st_t3 = negative_reward_count_st[task_3] positive_reward_count_t3 = positive_reward_count[task_3] positive_reward_count_st_t3 = positive_reward_count_st[task_3] negative_reward_count_ch_t3 = negative_reward_count_ch[task_3] positive_reward_count_ch_t3 = positive_reward_count_ch[task_3] reward_trial_in_block_t3 = reward_trial_in_block[task_3] firing_rates_t3 = firing_rates[task_3] ones = np.ones(len(choices_t3)) predictors = OrderedDict([ ('Reward', reward_t3), ('Choice', choices_t3), ('Correct', correct_t3), ('A in Block', a_since_block_t3), ('A in Block x Reward', int_a_reward_t3), ('State', state_t3), ('Trial in Block', trials_since_block_t3), ('Interaction State x Trial in Block', interaction_trial_latent_t3), ('Interaction State x A count', interaction_a_latent_t3), ('Choice x Trials in Block', interaction_trial_choice_t3), ('Reward x Choice', reward_choice_int_t3), ('No Reward Count in a Block', negative_reward_count_t3), ('No Reward x Correct', negative_reward_count_st_t3), ('Reward Count in a Block', positive_reward_count_t3), ('Reward Count x Correct', positive_reward_count_st_t3), ('No reward Count x Choice', negative_reward_count_ch_t3), ('Reward Count x Choice', positive_reward_count_ch_t3), ('Reward x Trial in Block', reward_trial_in_block_t3), ('ones', ones) ]) X_3 = np.vstack( predictors.values()).T[:len(choices_t3), :].astype(float) n_predictors = X_3.shape[1] y_3 = firing_rates_t3.reshape( [len(firing_rates_t3), -1]) # Activity matrix [n_trials, n_neurons*n_timepoints] tstats = reg_f.regression_code(y_3, X_3) C_3.append(tstats.reshape(n_predictors, n_neurons, n_timepoints)) # Predictor loadings cpd_1_2.append( _CPD_cross_task(X_1, X_2, y_1, y_2).reshape(n_neurons, n_timepoints, n_predictors)) cpd_2_3.append( _CPD_cross_task(X_2, X_3, y_2, y_3).reshape(n_neurons, n_timepoints, n_predictors)) print(n_neurons) cpd = np.nanmean(np.concatenate(cpd, 0), axis=0) C = np.concatenate(C, 1) C_1 = np.concatenate(C_1, 1) C_2 = np.concatenate(C_2, 1) C_3 = np.concatenate(C_3, 1) cpd_1_2 = np.nanmean(np.concatenate(cpd_1_2, 0), axis=0) cpd_2_3 = np.nanmean(np.concatenate(cpd_2_3, 0), axis=0) return C, cpd, C_1, C_2, C_3, cpd_1_2, cpd_2_3, predictors_all, session_trials_since_block