def plot_percentpfs_ofdroppedcells(self, tasks_to_plot, bins=10): fs, ax = plt.subplots(1, figsize=(6, 3), dpi=100, sharey='all', sharex='all') for n in np.unique(self.pfparam_combined.animalname): # Plot COM of place cells along track df = self.pfparam_combined[self.pfparam_combined.animalname == n] numpyfile = [i for i in self.npyfiles if n in i][0] droppedcells = np.load( os.path.join(self.CombinedDataFolder, numpyfile), allow_pickle=True)['dropped_cells'].item()[tasks_to_plot[1]] if n == 'CFC4': normfactor = 678 else: normfactor = np.load(os.path.join(self.CombinedDataFolder, numpyfile), allow_pickle=True)['numcells'] df_plot = df[df['Task'] == tasks_to_plot[0]] com = df_plot[df_plot['CellNumber'].isin( droppedcells)]['WeightedCOM'] * self.trackbins hist_com, bins_com, center, width = CommonFunctions.make_histogram( com, bins, len(df_plot), self.tracklength) ax.bar(center, hist_com, align='center', width=width, color=sns.color_palette('dark', 1), alpha=0.5) ax.set_title('Fields in %s but not in %s' % (tasks_to_plot[0], tasks_to_plot[1])) pf.set_axes_style(ax, numticks=4)
def plot_compiled_errorcorrelation(axis, SaveFolder, TaskDict, trackbins, to_plot='R2', classifier_type='Bayes'): l = Compile() files = [f for f in os.listdir(SaveFolder) if classifier_type in f] compilemeanerr = {k: [] for k in TaskDict.keys()} compilelaptime = {k: [] for k in TaskDict.keys()} for f in files: print(f) animalname = f[:f.find('_')] animal_tasks = DataDetails.ExpAnimalDetails(animalname)['task_dict'] data = np.load(os.path.join(SaveFolder, f), allow_pickle=True) for n, t in enumerate(animal_tasks): m, laptime = l.plotlaptime_withbayeserror(axis=axis[n], task=t, lapframes=data['lapframes'].item()[t], y_actual=data['fit'].item()[t]['ytest'], y_predicted=data['fit'].item()[t]['yang_pred'], numlaps=data['numlaps'].item()[t], laptime=data['laptime'].item()[t], trackbins=trackbins, to_plot=to_plot) pf.set_axes_style(axis[n], numticks=4) compilemeanerr[t].extend(m) compilelaptime[t].extend(laptime) # # get and plot best fit line # for n, t in enumerate(TaskDict): # regression_line = l.best_fit_slope_and_intercept(np.asarray(compilemeanerr[t]), np.asarray(compilelaptime[t])) # corrcoef = np.corrcoef(np.asarray(compilemeanerr[t]), np.asarray(compilelaptime[t]))[0, 1] # axis[n].plot(compilemeanerr[t], regression_line, color='k', linewidth=2) # axis[n].set_title('%s r = %0.2f' % (t, corrcoef)) return compilelaptime, compilemeanerr
def plot_bayesR2(self, r2data, ax, traininglaps=20): count = 0 for n, i in enumerate(self.taskstoplot): x = np.arange(count, count + np.size(self.numlicksperlap[i])) print(i) if i == 'Task2': print(self.lickstoplap) ax.plot(x[:self.lickstoplap], r2data[x[:self.lickstoplap]], '.-', color=self.task2_colors[0], linewidth=0.5, markersize=1, zorder=2) ax.plot(x[self.lickstoplap:], r2data[x[self.lickstoplap:]], '.-', color=self.task2_colors[1], linewidth=0.5, markersize=1, zorder=2) elif i in ['Task1', 'Task1a']: ax.plot(x[traininglaps:], r2data[x[traininglaps:]], '.-', color=self.colors[n], linewidth=0.5, markersize=1, zorder=2) else: ax.plot(x, r2data[x], '.-', color=self.colors[n], linewidth=0.5, markersize=1, zorder=2) for l in np.arange(np.size(self.numlicksperlap[i])): if i in ['Task1', 'Task1a'] and l < traininglaps: continue if self.numlicksperlap[i][l] > 0: ax.axvline(count + l, color='grey', linewidth=0.2, zorder=1) count += np.size(self.numlicksperlap[i]) ax.set_xlabel('Lap #') ax.set_ylabel('R-squared') ax.set_ylim((-0.1, 1)) pf.set_axes_style(ax)
def plot_barplot_correlation(ax, c_cntrl, c_exp): df1 = pd.DataFrame.from_dict(c_exp) df1 = df1.dropna() df1 = df1.melt(var_name='Task', value_name='Correlation') df2 = pd.DataFrame.from_dict(c_cntrl) df2 = df2.dropna() df2 = df2.melt(var_name='Task', value_name='Correlation') df = pd.concat((df1, df2)) sns.boxplot(x='Task', y='Correlation', data=df[~df['Task'].isin(['Task1', 'Task1a'])], ax=ax, order=['Task1b', 'Task2b', 'Task3', 'Task4'], showfliers=False, width=0.5) for t in ['Task2b', 'Task3', 'Task4']: t1, p = scipy.stats.ttest_ind( df[df.Task == t]['Correlation'], df[df.Task == 'Task1b']['Correlation']) print('Task1 with %s : %0.3f' % (t, p)) pf.set_axes_style(ax)
def plot_rastermap(self, ax, ylim=0): if ylim == 0: ylim = self.numcells ax[0].imshow(self.Sm, vmin=0, vmax=0.5, cmap='jet', aspect='auto', extent=[ 0, self.Sm.shape[1] / self.framespersec, 0, self.Sm.shape[0] ]) ax[0].set_ylim((0, ylim)) count = 0 for n, i in enumerate(self.taskstoplot): x = np.linspace( count, count + np.size(self.good_running_data[i]) / self.framespersec, np.size(self.good_running_data[i])) ax[0].axvline(x[-1], color='k') ax[1].plot(x, self.good_running_data[i], color=self.colors[n]) count += np.size(self.good_running_data[i]) / self.framespersec ax[1].plot(x, self.lick_data[i] * 0.7, '|', color='grey', linewidth=0.5, markersize=10) ax[1].set_yticklabels([]) for a in ax: pf.set_axes_style(a, numticks=2)
def compiled_rastermap(self, fighandle, ax, taskstoplot, compiled_fdata, compiled_Smdata, compiled_runningdata, compiled_lickdata): im = ax[0].imshow(compiled_Smdata, vmin=0, vmax=0.3, cmap='plasma', aspect='auto', interpolation='hanning', extent=[0, compiled_Smdata.shape[1] / self.framespersec, 0, compiled_Smdata.shape[0]]) CommonFunctions.plot_colorbar(fighandle, ax[0], im, title=f'\u0394F/F', ticks=[0, 0.3]) ax[0].set_xlim((0, compiled_Smdata.shape[1] / self.framespersec)) count = 0 count_dff = 0 for n, i in enumerate(taskstoplot): x = np.linspace(count, count + np.size(compiled_runningdata[i]) / self.framespersec, np.size(compiled_runningdata[i])) ax[0].axvline(x[-1], color='k', linewidth=0.5) if i == 'Task2': ax[2].plot(x[:self.lickstopframe], compiled_runningdata[i][:self.lickstopframe], color=self.task2_colors[0], linewidth=0.5) ax[2].plot(x[self.lickstopframe:], compiled_runningdata[i][self.lickstopframe:], color=self.task2_colors[1], linewidth=0.5) else: ax[2].plot(x, compiled_runningdata[i], color=self.colors[n], linewidth=0.5) ax[2].plot(x, compiled_lickdata[i] * 0.75, '|', color='grey', markeredgewidth=0.05, markersize=5, alpha=0.5) ax[1].plot(x, savgol_filter( np.nanmean(compiled_fdata[:, count_dff:count_dff + np.size(compiled_runningdata[i])], 0), 31, 2), color=self.colors[n], linewidth=0.5) count += np.size(compiled_runningdata[i]) / self.framespersec count_dff += np.size(compiled_runningdata[i]) ax[2].set_yticklabels([]) ax[1].set_ylim((0, 0.15)) pf.set_axes_style(ax[0], numticks=4) pf.set_axes_style(ax[1], numticks=1)
def get_bayes_data(self, axis, accuracy_measure='R2'): decoderfit = self.BayesData['fit'].item() count = 0 for n, t in enumerate(self.taskstoplot): y_actual = decoderfit[t]['ytest'] y_predicted = decoderfit[t]['yang_pred'] R2 = self.calulate_lapwiseerror(y_actual, y_predicted, self.good_lapframes[t], accuracy_measure) if t == 'Task1': R2 = R2[-5:] numlaps = np.size(R2) print(numlaps) x = np.arange(count, count + numlaps) axis.plot(x, R2, '.-', color=self.colors[n], linewidth=2, markeredgecolor='black', zorder=2) for nl in np.arange(numlaps): if self.numlicksperlap[t][nl] > 0: axis.axvline(nl + count, color='k', alpha=0.5, linewidth=1, markersize=10, zorder=1) count += numlaps if accuracy_measure == 'R2': axis.set_ylabel('Goodness of fit') else: axis.set_ylabel('Decoder Error (cm)') pf.set_axes_style(axis, numticks=3)
def plot_lapwiseaccuracy_concatenated(axis, animalinfo, taskdict, decoderfit, data, to_plot='R2'): l = LapWiseAnalysis() count = 0 c = sns.color_palette('dark') for n, t in enumerate(taskdict): R2, accuracy = l.calulate_lapwiseerror(y_actual=decoderfit[t]['ytest'], y_predicted=decoderfit[t]['ypred'], trackbins=animalinfo['trackbins'], numlaps=data.numlaps[t], lapframes=data.good_lapframes[t]) if to_plot == 'R2': axis.set_ylabel('Goodness of fit') if t == 'Task1': data_plot = R2[-5:] else: data_plot = R2 else: axis.set_ylabel('Decoding Accuracy') if t == 'Task1': data_plot = accuracy[-5:] else: data_plot = accuracy numlaps = np.size(data_plot) x = np.arange(count, count + numlaps) axis.plot(x, data_plot, color=c[n], linewidth=2) licks = data.numlicksperlap[t] for nl in np.arange(numlaps): if licks[nl] > 0: axis.axvline(nl + count, color='grey', linewidth=1, markersize=10) count += numlaps pf.set_axes_style(axis)
def plot_stability_precision_of_reward_cells(self, reward_data): for index, row in reward_data.iterrows(): animalname = row['AnimalName'] cellnumber = row['CellNumber'] thiscell_data = self.rewardparam_combined[ (self.rewardparam_combined['animalname'] == animalname) & (self.rewardparam_combined['CellNumber'] == cellnumber)] if index == 0: combinedf = thiscell_data else: combinedf = pd.concat((combinedf, thiscell_data)) columns_to_plot = ['Precision', 'Stability'] fs, ax = plt.subplots(1, len(columns_to_plot), figsize=(7, 3)) for n, c in enumerate(columns_to_plot): sns.boxplot(x='Task', y=c, data=combinedf, ax=ax[n], order=self.TaskDict.keys(), palette='Blues', showfliers=False) # sns.stripplot(x='Task', y=c, data=combinedf, ax=ax[n], color='k', size=2) pf.set_axes_style(ax[n]) fs.tight_layout() return combinedf
def compile_mean_bderror(self, ax): mean_error = {k: [] for k in ['R2', 'Task', 'animalname', 'BD error (cm)', 'BD accuracy']} for a in self.animals: animalinfo = DataDetails.ExpAnimalDetails(a) if self.datatype == 'endzonerem': bayesmodel = np.load( os.path.join(animalinfo['saveresults'], 'modeloneachtask_withendzonerem.npy'), allow_pickle=True).item() else: bayesmodel = np.load(os.path.join(animalinfo['saveresults'], 'modeloneachtask.npy'), allow_pickle=True).item() for t in animalinfo['task_dict'].keys(): kfold = np.max(bayesmodel[t]['K-foldDataframe']['CVIndex']) mean_error['R2'].extend(bayesmodel[t]['K-foldDataframe']['R2_angle']) mean_error['BD accuracy'].extend(bayesmodel[t]['K-foldDataframe']['ModelAccuracy']) for k in np.arange(kfold): mean_error['BD error (cm)'].append( np.mean(bayesmodel[t]['K-foldDataframe']['Y_ang_diff'][k] * self.trackbins)) mean_error['Task'].append(t) mean_error['animalname'].append(a) mean_error_df = pd.DataFrame.from_dict(mean_error) for n, i in enumerate(['R2', 'BD accuracy', 'BD error (cm)']): sns.boxplot(x='Task', y=i, data=mean_error_df, palette='Blues', ax=ax[n], showfliers=False) for t in self.taskdict.keys(): if t != 'Task1': d, p = Stats.significance_test(mean_error_df[mean_error_df.Task == t][i], mean_error_df[mean_error_df.Task == 'Task1'][i], type_of_test='KStest') print(f'%s: %s: KStest: p-value %0.4f' % (i, t, p)) ax[n].set_xlabel('') pf.set_axes_style(ax[n], numticks=4)
def compile_confusion_matrix(self, fs, ax): cm_all = {k: np.zeros((int(self.tracklength / self.trackbins), int(self.tracklength / self.trackbins))) for k in self.taskdict.keys()} for a in self.animals: animalinfo = DataDetails.ExpAnimalDetails(a) if self.datatype == 'endzonerem': bayesmodel = np.load( os.path.join(animalinfo['saveresults'], 'modeloneachtask_withendzonerem.npy'), allow_pickle=True).item() else: bayesmodel = np.load(os.path.join(animalinfo['saveresults'], 'modeloneachtask.npy'), allow_pickle=True).item() for t in animalinfo['task_dict']: cm = bayesmodel[t]['cm'] cm_all[t] += cm for n, t in enumerate(self.taskdict.keys()): cm_all[t] = cm_all[t].astype('float') / cm_all[t].sum(axis=1)[:, np.newaxis] img = ax[n].imshow(cm_all[t], cmap="Blues", vmin=0, vmax=0.4, interpolation='nearest') ax[n].plot(ax[n].get_xlim()[::-1], ax[n].get_ylim(), ls="--", c=".3", lw=1) pf.set_axes_style(ax[n], numticks=3, both=True) if n == len(self.taskdict) - 1: CommonFunctions.create_colorbar(fighandle=fs, axis=ax[n], imghandle=img, title='Probability', ticks=[0, 0.4]) ax[0].set_ylabel('Actual') ax[0].set_xlabel('Predicted')
def velocity_inspace_byattention(self, axis): plot_title = [ 'With Lick', 'Attention withoutlick', 'Without attention' ] for n, laptype in enumerate([ 'lapswithlicks', 'attentivelaps_withoutlicks', 'notattentivelaps_withoutlicks' ]): vinspace = np.asarray([]) for a in self.animalname: required_laps = np.load(os.path.join(self.FolderName, a, 'SaveAnalysed', 'attentionlaps.npz'), allow_pickle=True) laps = required_laps[laptype] if n == 1: speed_ratio = np.asarray(self.speed_ratio[a]['Task2']) weird = np.where(speed_ratio > 1.06)[0] laps = np.intersect1d(weird, laps) vinspace = np.vstack( (vinspace, self.velocity_slope[a]['Task2'][laps, :])) if vinspace.size else \ self.velocity_slope[a]['Task2'][laps, :] axis[n].plot(vinspace.T, color='lightgrey') axis[n].plot(np.mean(vinspace, 0), color='k') axis[n].set_title(plot_title[n]) axis[n].set_xticks([0, 18, 36]) axis[n].set_xticklabels([0, 100, 200]) axis[n].set_xlabel('Track Length (cm)') pf.set_axes_style(axis[n]) axis[0].set_ylabel('Normalized velocity')
def plot_decoderaccuracy_with_tracklength(axis, modeldataframe, tracklength, trackbins, taskcolors, angleflag=False): # Plot accuracy with maze position # Only plot for reward vs no reward condition numbins = int(tracklength / trackbins) for t in ['Task1a', 'Task1b']: Y_diff_by_track_mean = np.zeros((kfold_splits, numbins)) for k in np.arange(kfold_splits): if angleflag: y_diff = np.asarray(modeldataframe[t]['K-foldDataframe']['Y_ang_diff'][k]) * trackbins else: y_diff = np.asarray(modeldataframe[t]['K-foldDataframe']['Y_diff'][k]) * trackbins y_test = np.asarray(modeldataframe[t]['K-foldDataframe']['y_test'][k]) for i in np.arange(numbins): Y_indices = np.where(y_test == i)[0] Y_diff_by_track_mean[k, i] = np.mean(y_diff[Y_indices]) meandiff = np.nanmean(Y_diff_by_track_mean, 0) semdiff = scipy.stats.sem(Y_diff_by_track_mean, 0, nan_policy='omit') error1, error2 = meandiff - semdiff, meandiff + semdiff axis.plot(np.arange(numbins), meandiff, color=taskcolors[t]) axis.fill_between(np.arange(numbins), error1, error2, alpha=0.5, color=taskcolors[t]) axis.set_xlabel('Track Length (cm)') axis.set_ylabel('Difference in\ndecoder accuracy (cm)') CommonFunctions.convertaxis_to_tracklength(axis, tracklength, trackbins, convert_axis='x') axis.set_xlim((0, tracklength / trackbins)) pf.set_axes_style(axis, numticks=5)
def plot_bayeserror_with_slidingwindow(axis, colors, bayeserror, numlicks): zerolick = np.where(numlicks == 0) nonzerolick = np.where(numlicks > 0) print(np.shape(zerolick), np.shape(nonzerolick)) label = ['With Licks', 'Without Licks'] ax1 = axis[0].twinx() for n, l in enumerate([nonzerolick, zerolick]): weights = np.ones_like(bayeserror[l]) / float(len(bayeserror[l])) sns.distplot(bayeserror[l], bins=np.arange(-1, 1, 50), hist=False, ax=ax1, color=colors[n], label=label[n]) axis[0].hist(bayeserror[l], bins=np.linspace(-0.5, 1, 20), color=colors[n], alpha=0.5, weights=weights) axis[1].hist(bayeserror[l], bins=np.linspace(-0.5, 1, 1000), color=colors[n], normed=True, cumulative=True, histtype='step') axis[1].set_ylim((0, 1)) axis[0].set_ylabel('Normalized laps') for a in axis: pf.set_axes_style(a, numticks=4) a.set_xlabel('R-squared') t, p = scipy.stats.ks_2samp(bayeserror[nonzerolick], bayeserror[zerolick]) axis[0].set_title(f'P-value : %f' % p)
def plot_placecells_with_track_pertask(self, pc_activity, sorted_pcs, figsize=(10, 4)): taskaxis = {'Task1': 0, 'Task2': 1, 'Task3': 2, 'Task4': 3, 'Task5': 4} fs, ax1 = plt.subplots(1, len(self.TaskDict), figsize=figsize, dpi=100, sharex='all', sharey='all') for taskname in self.TaskDict.keys(): task_data = pc_activity[taskname][sorted_pcs[taskname], :] normalise_data = (task_data - np.min(task_data.flatten())) / ( np.max(task_data.flatten()) - np.min(task_data.flatten())) ax1[taskaxis[taskname]].imshow(normalise_data, aspect='auto', cmap='jet', interpolation='nearest', vmin=0, vmax=0.5) ax1[taskaxis[taskname]].set_title(self.new_taskDict[taskname]) ax1[taskaxis[taskname]].set_xticks([0, 20, 39]) ax1[taskaxis[taskname]].set_xticklabels([0, 100, 200]) ax1[taskaxis[taskname]].set_xlim((0, 39)) pf.set_axes_style(ax1[taskaxis[taskname]], numticks=4) ax1[0].set_xlabel('Track Length (cm)') ax1[0].set_ylabel('Cell') ax1[0].locator_params(nbins=4) fs.tight_layout() plt.show()
def plot_confusion_matrix_ofkfold(fighandle, axis, cv_dataframe, tracklength, trackbins): cm_all = np.zeros((int(tracklength / trackbins), int(tracklength / trackbins))) # Bins by binss for i in np.arange(kfold_splits): y_actual = cv_dataframe['y_test'][i] y_predicted = cv_dataframe['y_predict_angle'][i] cm = confusion_matrix(y_actual, y_predicted) print(np.shape(cm)) if np.size(cm, 0) != int(tracklength / trackbins): cm_temp = np.zeros((int(tracklength / trackbins), int(tracklength / trackbins))) cm_temp[:np.size(cm, 0), :np.size(cm, 1)] = cm print('Correcting', np.shape(cm_temp)) cm_all += cm_temp else: cm_all += cm cm_all = cm_all.astype('float') / cm_all.sum(axis=1)[:, np.newaxis] img = axis.imshow(cm_all, cmap="Blues", vmin=0, vmax=0.5, interpolation='bilinear') CommonFunctions.create_colorbar(fighandle=fighandle, axis=axis, imghandle=img, title='Probability') # convert axis ro track length # CommonFunctions.convertaxis_to_tracklength(axis, tracklength, trackbins, convert_axis='both') axis.plot(axis.get_xlim()[::-1], axis.get_ylim(), ls="--", c=".3", lw=1) axis.set_ylabel('Actual') axis.set_xlabel('Predicted') pf.set_axes_style(axis, numticks=4) return cm_all
def plot_decoderaccuracy_with_numcells(axis, modeldataframe, taskdict, taskcolors, angleflag=False): for t in taskdict.keys(): numcells_df = modeldataframe[t]['Numcells_Dataframe'] if angleflag: sns.pointplot(x='SampleSize', y='R2_angle', data=numcells_df, color=taskcolors[t], ax=axis) else: sns.pointplot(x='SampleSize', y='R2', data=numcells_df, color=taskcolors[t], ax=axis) # axis.set_ylim((-1.6, 1)) axis.legend( handles=axis.lines[::len(numcells_df['SampleSize'].unique()) + 1], labels=taskdict.keys(), loc='center left', bbox_to_anchor=(1, 0.5)) axis.set_xlabel('Percentage of active cells used') axis.set_ylabel('Decoding accuracy') # axis.set_aspect(aspect=1.6) plt.close(2) pf.set_axes_style(axis, numticks=4)
def plot_lick_withtime(axis, numlicks, axislabel, axislim=(0, 1), color='k', errorbar=0, dashed=1): # num = (numlicks - np.min(numlicks, 1)[:, np.newaxis]) # denom = (np.max(numlicks, 1) - np.min(numlicks, 1))[:, np.newaxis] numlicks = numlicks / np.nanmax(numlicks, 1)[:, np.newaxis] mean_licks = np.nanmean(numlicks, 0) sem_licks = scipy.stats.sem(numlicks, 0, nan_policy='omit') if dashed: axis.plot(mean_licks, 'o-', color=color, markerfacecolor='none') else: axis.plot(mean_licks, 'o', color=color, markerfacecolor='none') if errorbar == 1: axis.errorbar(np.arange(np.size(mean_licks)), mean_licks, yerr=sem_licks, ls='none', color='lightgrey') elif errorbar == 0: axis.fill_between(np.arange(np.size(mean_licks)), mean_licks - sem_licks, mean_licks + sem_licks, color='lightgrey') axis.set_ylabel(axislabel) axis.set_xlabel('Laps in time') axis.set_ylim(axislim) pf.set_axes_style(axis, numticks=4)
def plot_rewardcoms_on_allcoms(self, combined_data, ax, taskA, taskB, color, reward_flag=0): if reward_flag: y = (combined_data[f'WeightedCOM_%s' % taskA] / self.framerate) - self.nsecondsroundrew x = (combined_data[f'WeightedCOM_%s' % taskB] / self.framerate) - self.nsecondsroundrew ax.plot([-self.nsecondsroundrew, self.nsecondsroundrew * 2], [-self.nsecondsroundrew, self.nsecondsroundrew * 2], linewidth=2, color=".3") else: y, x = combined_data[f'WeightedCOM_%s' % taskA] * self.trackbins, combined_data[ f'WeightedCOM_%s' % taskB] * self.trackbins ax.plot([0, self.tracklength], [0, self.tracklength], linewidth=2, color=".3") ax.scatter(y, x, color=color) ax.set_xlabel(taskB) ax.set_ylabel(taskA) ax.set_title('Selected Reward Cells') pf.set_axes_style(ax, numticks=3)
def plot_compiledconfusionmatrix(axis, SaveFolder, TaskDict, classifier_type='Bayes'): files = [f for f in os.listdir(SaveFolder) if classifier_type in f] all_ytest = {k: [] for k in TaskDict.keys()} all_ypred = {k: [] for k in TaskDict.keys()} for f in files: animal_tasks = DataDetails.ExpAnimalDetails(f[:f.find('_')])['task_dict'] data = np.load(os.path.join(SaveFolder, f), allow_pickle=True) print(f) for n, t in enumerate(animal_tasks): if t == 'Task1a': all_ytest[t].extend(data['fit'].item()[t]['ytest'][-500:]) all_ypred[t].extend(data['fit'].item()[t]['yang_pred'][-500:]) else: all_ytest[t].extend(data['fit'].item()[t]['ytest']) all_ypred[t].extend(data['fit'].item()[t]['yang_pred']) for n, t in enumerate(['Task1', 'Task1a']): y_actual = all_ytest[t] y_predicted = all_ypred[t] cm = confusion_matrix(y_actual, y_predicted) cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis] img = axis[n].imshow(cm, cmap="Blues", vmin=0, vmax=0.4, interpolation='nearest') axis[n].plot(axis[n].get_xlim()[::-1], axis[n].get_ylim(), ls="--", c=".3", lw=1) pf.set_axes_style(axis[n], numticks=3, both=True) axis[n].set_title(t) axis[0].set_ylabel('Actual') axis[0].set_xlabel('Predicted')
def plot_bayeserror_with_slidingwindow(self, taskstoplot, bayeserror, numlicks): # Plot just No Reward data fs, ax = plt.subplots(2, figsize=(6, 8)) colors = sns.color_palette('deep') # # Get mean of licks # norm_lick = numlicks['Task2'] / np.nanmax(numlicks['Task2'], 1)[:, np.newaxis] # mean_lick = np.mean(norm_lick, 0) # sem_lick = scipy.stats.sem(norm_lick, 0) # Flatten error and licks and clean up bayeserror_flat = {k: [] for k in taskstoplot} numlicks_flat = {k: [] for k in taskstoplot} norm_lick = {k: [] for k in taskstoplot} # Remove those with NAN for t in taskstoplot: bayeserror_flat[t] = bayeserror[t].flatten() numlicks_flat[t] = numlicks[t].flatten() notnan_index = np.where(~np.isnan(bayeserror_flat[t]))[0] print(np.shape(bayeserror_flat[t]), np.shape(numlicks_flat[t])) bayeserror_flat[t] = bayeserror_flat[t][notnan_index] numlicks_flat[t] = numlicks_flat[t][notnan_index] temp_lick = numlicks[t] / np.nanmax(numlicks[t], 1)[:, np.newaxis] norm_lick[t] = temp_lick.flatten()[notnan_index] zerolick = np.where(numlicks_flat['Task2'] == 0) nonzerolick = np.where(numlicks_flat['Task2'] > 0) # Percentage of laps with greater correlation print('Zero licks with high correlation %d%%' % ( (np.size(np.where(bayeserror_flat['Task2'][zerolick] > 0.8)) / np.size(zerolick)) * 100)) print('High licks with high correlation %d%%' % ( (np.size(np.where(bayeserror_flat['Task2'][nonzerolick] > 0.8)) / np.size(nonzerolick)) * 100)) # ax[0].scatter(bayeserror_flat['Task2'][nonzerolick], norm_lick['Task2'][nonzerolick], marker='+', s=100, # alpha=0.5, color=colors[0]) # ax[0].plot(bayeserror['Task2'].flatten()[zerolick], norm_lick['Task2'][zerolick], '|', # markersize=12, alpha=0.5, color=colors[1], linewidth=0.5) # ax[0].set_ylabel('Normalized licks') # ax[0].set_xlabel('R-squared') # print(bayeserror['Task2'].flatten()[zerolick]) # ax[1].hist(bayeserror_flat['Task2'][nonzerolick], cumulative=True, histtype='step', normed=True, bins=10, alpha=0.5) # ax[1].hist(bayeserror_flat['Task2'][zerolick], cumulative=True, histtype='step', normed=True, bins=10, alpha=0.5) y = [0.3, 0] label = ['With Licks', 'Without Licks'] for n, l in enumerate([nonzerolick, zerolick]): sns.distplot(bayeserror_flat['Task2'][l], bins=np.arange(-1, 1, 50), hist=False, ax=ax[1], kde_kws={'cut': 0}, color=colors[n], label=label[n]) ax[1].hist(bayeserror_flat['Task2'][l], bins=np.linspace(-0.5, 1, 20), color=colors[n], alpha=0.5, normed=True) # ax[1].plot(bayeserror_flat['Task2'][l], [y[n]] * len(bayeserror_flat['Task2'][l]), '|', markersize=12, # alpha=0.5, linewidth=0.5, color=colors[n]) ax[0].hist(bayeserror_flat['Task2'][l], bins=np.linspace(-0.5, 1, 100), color=colors[n], alpha=0.5, normed=True, cumulative=True, histtype='step') ax[1].legend() ax[1].set_xlabel('R-squared') ax[1].set_ylabel('Normalised histrogram') for a in ax: pf.set_axes_style(a, numticks=4)
def plot_com_scatter_heatmap(fig, axis, combined_dataset, taskA, taskB, tracklength, bins=10, vmax=0): # Scatter plots y = combined_dataset[0, :] x = combined_dataset[1, :] axis[0].scatter(y, x, color='k', s=3) axis[0].plot([0, tracklength], [0, tracklength], linewidth=2, color=".3") axis[0].set_xlabel(taskB) axis[0].set_ylabel(taskA) axis[0].set_title('Center of Mass') # Heatmap of scatter plot heatmap, xedges, yedges = np.histogram2d(y, x, bins=bins) heatmap = (heatmap / np.size(y)) * 100 extent = [xedges[0], xedges[-1], yedges[0], yedges[-1]] if vmax == 0: img = axis[1].imshow(heatmap.T, cmap='gray_r', extent=extent, interpolation='bilinear', origin='lower', vmin=0, vmax=np.max(heatmap)) else: img = axis[1].imshow(heatmap.T, cmap='gray_r', extent=extent, interpolation='bilinear', origin='lower', vmin=0, vmax=vmax) axis[1].plot([0 + bins, tracklength - bins], [0 + bins, tracklength - bins], linewidth=2, color=".3") axins = PlotPCs.add_colorbar_as_inset(axes=axis[1]) if vmax == 0: cb = fig.colorbar(img, cax=axins, pad=0.2, ticks=[0, np.int(np.max(heatmap))]) else: cb = fig.colorbar(img, cax=axins, pad=0.2, ticks=[0, vmax]) cb.set_label('% Field Density', rotation=270, labelpad=12) for a in axis: pf.set_axes_style(a, numticks=4) a.set_ylim((0, tracklength)) a.set_xlim((0, tracklength))
def plot_bayeserror_bytimebins(self, ax, bin_df, plottitle): sns.boxplot(x='Bin', y='Value', data=bin_df, order=[f'Bin%d' % i for i in np.arange(4)], palette='Reds', ax=ax) sns.stripplot(x='Bin', y='Value', data=bin_df, order=[f'Bin%d' % i for i in np.arange(4)], palette='Reds', ax=ax) ax.set_title(plottitle) ax.set_xticklabels(ax.get_xticklabels(), rotation=45) ax.set_xlabel('') pf.set_axes_style(ax, numticks=4)
def plot_com_scatter_heatmap(self, combined_dataset, taskA, taskB, bins=10, vmax=0, datatype='array'): # Scatter plots fs, ax = plt.subplots(1, 2, figsize=(8, 4)) if datatype == 'array': y = combined_dataset[0, :] x = combined_dataset[1, :] ax[0].scatter(y, x, color='k', s=3) ax[0].plot([0, self.tracklength], [0, self.tracklength], linewidth=1, color=".3") ax[0].set_xlabel(taskB) ax[0].set_ylabel(taskA) ax[0].set_title('Center of Mass') # Heatmap of scatter plot heatmap, xedges, yedges = np.histogram2d(y, x, bins=bins) heatmap = (heatmap / np.size(y)) * 100 extent = [xedges[0], xedges[-1], yedges[0], yedges[-1]] if vmax == 0: img = ax[1].imshow(heatmap.T, cmap='gray_r', extent=extent, interpolation='bilinear', origin='lower', vmin=0, vmax=np.max(heatmap)) else: img = ax[1].imshow(heatmap.T, cmap='gray_r', extent=extent, interpolation='bilinear', origin='lower', vmin=0, vmax=vmax) ax[1].plot([0 + bins, self.tracklength - bins], [0 + bins, self.tracklength - bins], linewidth=2, color=".3") axins = CommonFunctions.add_colorbar_as_inset(axes=ax[1]) if vmax == 0: cb = fs.colorbar(img, cax=axins, pad=0.2, ticks=[0, np.int(np.max(heatmap))]) else: cb = fs.colorbar(img, cax=axins, pad=0.2, ticks=[0, vmax]) cb.set_label('% Field Density', rotation=270, labelpad=12) for a in ax: pf.set_axes_style(a, numticks=5)
def plot_numcells(axis, numcells_df, taskstoplot): numcells_df = numcells_df[taskstoplot] df = numcells_df.melt(var_name='Task', value_name='numcells') sns.boxplot(x='Task', y='numcells', data=df, ax=axis, width=0.5) for n, row in numcells_df.iterrows(): axis.plot(row, 'o-', color='k', markerfacecolor='none') axis.set_ylabel('Percentage of place cells') GetPValues().get_shuffle_pvalue(numcells_df, taskstocompare=taskstoplot) pf.set_axes_style(axis, numticks=4)
def plot_pfparams(self, tasks_to_plot): # Plot a combined historgram and a boxplot of means columns_to_plot = [ 'Precision', 'Width', 'FiringRatio', 'Firingintensity', 'Stability' ] df_plot = self.pfparam_combined[self.pfparam_combined['Task'].isin( tasks_to_plot)] fs, ax = plt.subplots(len(columns_to_plot), 3, figsize=(7, 8), gridspec_kw={'width_ratios': [2, 2, 1]}) for n1, c in enumerate(columns_to_plot): # Plot boxplot sns.boxplot(x='Task', y=c, data=df_plot, ax=ax[n1, 2], order=tasks_to_plot, showfliers=False) ax[n1, 2].set_xlabel('') # For significance test x, y = df_plot[df_plot['Task'] == tasks_to_plot[0]][c], df_plot[ df_plot['Task'] == tasks_to_plot[1]][c] d, p = CommonFunctions.significance_test(x, y, type_of_test='KStest') print(f'%s: KStest : p-value %0.4f' % (c, p)) d, p = CommonFunctions.significance_test(x, y, type_of_test='Wilcoxon') print(f'%s: Wilcoxon : p-value %0.4f' % (c, p)) for n2, t in enumerate(tasks_to_plot): # Plot histogram d = df_plot[df_plot['Task'] == t][c] d = d[~np.isnan(d)] sns.distplot(d, ax=ax[n1, 0], kde=False) ax[n1, 1].hist(d, bins=1000, normed=True, cumulative=True, label='CDF', histtype='step', linewidth=1, alpha=0.8) # Does the sample come from a null distribution s, p = CommonFunctions.normalitytest(d) print( '%s in Task %s against normal distribution p-value %0.4f' % (c, t, p)) for a in ax.flatten(): pf.set_axes_style(a, numticks=3) fs.tight_layout() fs.savefig('Place Cell params.pdf', bbox_inches='tight')
def plot_compilederror_withlick(axis, SaveFolder, TaskDict, trackbins, separate_lickflag=0, licktype='all', to_plot='R2', classifier_type='Bayes'): l = Compile() files = [f for f in os.listdir(SaveFolder) if classifier_type in f] compilelickdata = {k: [] for k in TaskDict.keys()} compileerror = {k: [] for k in TaskDict.keys()} lickstoplap = [] animalname = [] for f in files: # print(f) animalname.append(f[:f.find('_')]) animal_tasks = DataDetails.ExpAnimalDetails( f[:f.find('_')])['task_dict'] print(len(animal_tasks)) data = np.load(os.path.join(SaveFolder, f), allow_pickle=True) if data['lickstoplap'].item()['Task2'] > 2: print(f) for n, t in enumerate(animal_tasks): lap_r2, lap_accuracy = l.calulate_lapwiseerror( y_actual=data['fit'].item()[t]['ytest'], y_predicted=data['fit'].item()[t]['yang_pred'], trackbins=trackbins, numlaps=data['numlaps'].item()[t], lapframes=data['lapframes'].item()[t]) if licktype == 'all': licks = data['alllicks'].item() lickstop = data['lickstoplap'].item()['Task2'] else: licks = data['licks_befclick'].item() lickstop = data['lickstoplap_befclick'].item()['Task2'] if to_plot == 'R2': data_compile = lap_r2 else: data_compile = lap_accuracy l.plot_bayeserror_with_lickrate( data_compile, licks[t], data['lickstoplap'].item()['Task2'], t, axis[n], separate_lickflag) pf.set_axes_style(axis[n], numticks=4) compilelickdata[t].append(licks[t]) compileerror[t].append(np.asarray(data_compile)) lickstoplap.append(lickstop) return compileerror, compilelickdata, np.asarray(lickstoplap), animalname
def plot_scatter(self, axis, animallist, thresh=1.0, notflag=0): speed_ratio = [] bayes = [] for a in self.animalname: if len(animallist) > 0: if notflag: if a not in animallist: bayes.extend(self.bayescompiled[a]['Task2']) speed_ratio.extend( self.speed_ratio[a]['Task2'] / np.mean(self.speed_ratio[a]['Task1'])) else: if a in animallist: bayes.extend(self.bayescompiled[a]['Task2']) speed_ratio.extend( self.speed_ratio[a]['Task2'] / np.mean(self.speed_ratio[a]['Task1'])) else: bayes.extend(self.bayescompiled[a]['Task2']) speed_ratio.extend(self.speed_ratio[a]['Task2'] / np.mean(self.speed_ratio[a]['Task1'])) print(np.shape(bayes)) # if notflag: # bayes, speed_ratio = np.asarray(bayes), np.asarray(speed_ratio) # bayes = bayes[speed_ratio > thresh] # speed_ratio = speed_ratio[speed_ratio > thresh] axis.plot(bayes, speed_ratio, 'o', color='grey', markerfacecolor='none') # regression_line = CommonFunctions.best_fit_slope_and_intercept(np.asarray(bayes), # np.asarray(speed_ratio)) corrcoef = np.corrcoef(np.nan_to_num(bayes), np.nan_to_num(speed_ratio))[0, 1] pearsonsr = scipy.stats.pearsonr(np.nan_to_num(bayes), np.nan_to_num(speed_ratio)) y_pred_linearreg, rsquared = CommonFunctions.linear_regression( np.asarray(bayes), np.asarray(speed_ratio)) axis.plot(bayes, y_pred_linearreg, color='k', linewidth=1) # speed_dark = self.get_dark_attentiondata() # axis.axhline(np.mean(speed_dark), color='r') # axis.axhline(np.mean(speed_dark) - scipy.stats.sem(speed_dark), linestyle='--', color='r') # axis.axhline(np.mean(speed_dark) + scipy.stats.sem(speed_dark), linestyle='--', color='r') pf.set_axes_style(axis) axis.set_title('r2=%0.3f, r=%0.3f, p=%0.3f' % (rsquared, corrcoef, pearsonsr[1])) axis.set_xlabel('Decoder R2') axis.set_ylabel('Attention')
def plot_histogram_speed_ratio(self, axis, taskstoplot, bins=20): # Plot taskdata speed_ratio_exp = [] axis1 = axis.twinx() for n, t in enumerate(taskstoplot): for a in self.speed_ratio.keys(): speed_ratio_exp.extend(self.speed_ratio[a][t]) weights = np.ones_like(speed_ratio_exp) / float( len(speed_ratio_exp)) sns.distplot(speed_ratio_exp, bins=np.linspace(0, 2, bins), color=self.colors[n], hist=False, kde=True, ax=axis1) axis.hist(speed_ratio_exp, bins=np.linspace(0, 2, bins), color=self.colors[n], linewidth=2, weights=weights, label=t, alpha=0.5) # plot dark data speed_ratio_dark = [] for a in self.speed_ratio_dark.keys(): speed_ratio_dark.extend(self.speed_ratio_dark[a]) weights = np.ones_like(speed_ratio_dark) / float(len(speed_ratio_dark)) sns.distplot(speed_ratio_dark, bins=np.linspace(0, 2, bins), kde=True, ax=axis1, hist=False, color='grey') axis.hist(speed_ratio_dark, bins=np.linspace(0, 2, bins), color='grey', linewidth=2, weights=weights, label='Dark', alpha=0.5) axis.legend(loc='center left', bbox_to_anchor=(1, 0.5)) axis.set_xlim((0, 2)) axis.set_xticks((0, 1.00, 2.00)) axis.set_xticklabels((0, 1.00, 2.00)) axis.axvline(1, linestyle='--', color='k') axis1.set_yticklabels('') axis.set_xlabel('Ratio of speed in middle by speed at end') pf.set_axes_style(axis, numticks=3) pf.set_axes_style(axis1) axis.set_ylabel('Lap bins')
def plotcrossvalidationresult(axis, cv_dataframe, trackbins, numsplits): # Difference meandiff = np.mean(cv_dataframe['Y_diff'].tolist(), 1) * trackbins sem = scipy.stats.sem(cv_dataframe['Y_diff'].tolist(), 1) * trackbins error1, error2 = meandiff - sem, meandiff + sem axis.plot(np.arange(numsplits), meandiff) axis.fill_between(np.arange(numsplits), error1, error2, alpha=0.5) axis.set_xlabel('CrossValidation #') axis.set_ylabel('Difference (cm)') axis.set_title(f'Difference in predicted position %.2f +/- %2f' % (np.mean(cv_dataframe['Y_diff'].tolist()) * trackbins, np.std(cv_dataframe['Y_diff'].tolist()) * trackbins)) axis.set_ylim((0, np.max(error2))) pf.set_axes_style(axis, numticks=4)