def plot_waveforms_opto(spike_data, prm): if 'random_snippets_opto' in spike_data: print( 'I will plot the waveform shapes for each cluster for opto_tagging data.' ) save_path = prm.get_output_path() + '/Figures/opto_tagging' if os.path.exists(save_path) is False: os.makedirs(save_path) for cluster in range(len(spike_data)): cluster = spike_data.cluster_id.values[cluster] - 1 max_channel = spike_data.primary_channel[cluster] highest_value = np.max( spike_data.random_snippets_opto[cluster][max_channel - 1, :, :] * -1) lowest_value = np.min( spike_data.random_snippets_opto[cluster][max_channel - 1, :, :] * -1) fig = plt.figure(figsize=(5, 5)) grid = plt.GridSpec(2, 2, wspace=0.5, hspace=0.5) for channel in range(4): plot_spikes_for_channel(grid, highest_value, lowest_value, spike_data, cluster, channel, 'random_snippets_opto') plt.savefig(save_path + '/' + spike_data.session_id[cluster] + '_' + str(cluster + 1) + '_waveforms_opto.png', dpi=300, bbox_inches='tight', pad_inches=0) # plt.savefig(save_path + '/' + spike_data.session_id[cluster] + '_' + str(cluster + 1) + '_waveforms_opto.pdf', bbox_inches='tight', pad_inches=0) plt.close()
def plot_phased_tg(t2, f3, tg, stark=False): from nudie.utils.plotting import shiftedColorMap if stark: return res = np.real(tg).T nlevels = 50 vmax, vmin = np.max(res), np.min(res) ticker = mpl.mpl.ticker.MaxNLocator(nlevels) levels = ticker.tick_values(vmin, vmax) #levels = levels[np.abs(levels) > levels_threshold] xsection = res[800, :] midpoint = 1 - vmax / (vmax + abs(vmin)) cmap = shiftedColorMap(mpl.cm.RdBu_r, midpoint=midpoint) fig = mpl.figure() gs = mpl.GridSpec(2, 2, height_ratios=[2, 1], width_ratios=[5, 0.1]) ax1 = fig.add_subplot(gs[0, 0]) ax2 = fig.add_subplot(gs[1, 0]) ax3 = fig.add_subplot(gs[:, 1]) ax1.contour(-t2, f3, res, 10, colors='k') cf = ax1.contourf(-t2, f3, res, levels=levels, cmap=cmap) ax1.set_ylabel('detection frequency') ax1.set_xlabel('t2 time') mpl.colorbar(cf, cax=ax3, use_gridspec=True) ax2.plot(-t2, xsection) ax2.grid() gs.tight_layout(fig) mpl.show()
def make_combined_autocorr_plot(time_10, corr_10, time_250, corr_250, spike_data, save_path, cluster): grid = plt.GridSpec(2, 1, hspace=0.5) autocorr_plot = plt.subplot(grid[0, 0]) plt.suptitle("Autocorrelograms", fontsize=24) plt.xlabel('Time lag (ms)', fontsize=14) plt.ylabel('Probability', fontsize=14) plt.xlim(-10, 10) plt.xticks(fontsize=14) plt.yticks(fontsize=14) plt.xticks([-10, 0, 10], [-10, 0, 10]) plt.bar(time_10, corr_10, align='center', width=1, color='black') autocorr_plot2 = plt.subplot(grid[1, 0]) plt.xlim(-250, 250) plt.xticks(fontsize=14) plt.yticks(fontsize=14) plt.xlabel('Time lag (ms)', fontsize=14) plt.ylabel('Probability', fontsize=14) plt.xticks([-250, 0, 250], [-250, 0, 250]) plt.bar(time_250, corr_250, align='center', width=1, color='black') plt.savefig(save_path + '/' + spike_data.session_id[cluster] + '_' + str(cluster + 1) + '_autocorrelograms.png', dpi=300, bbox_inches='tight', pad_inches=0) plt.close()
def _prepareChart(self) -> None: # Do not use LaTeX if NO_LATEX variable is set. no_latex = bool(os.getenv('NO_LATEX', False)) params = dict(font='serif', style='white') if not no_latex: params['rc'] = {'text.usetex': True} sns.set(**params) # Set up the subplot grid f = plt.figure(figsize=(6, 4)) gs = plt.GridSpec(10, 10, hspace=0) ax_heatmap = f.add_subplot(gs[4:, :]) ax_plot = f.add_subplot(gs[:4, :], sharex=ax_heatmap) plt.setp(ax_heatmap.yaxis.get_majorticklines(), visible=False) plt.setp(ax_heatmap.get_yticklabels(), visible=False) plt.setp(ax_plot.get_xticklabels(), visible=False) plt.setp(ax_plot.xaxis.get_majorticklines(), visible=False) plt.setp(ax_plot.xaxis.get_minorticklines(), visible=False) # Make the grid look nice sns.utils.despine(f) sns.utils.despine(ax=ax_plot, left=True) f.tight_layout() plt.sca(ax_heatmap) sns.heatmap(self.data, linewidth=0.01, xticklabels=10, cbar_kws=dict(orientation='horizontal', shrink=.75, aspect=25, pad=.2)) ax_heatmap.set(ylabel='Lane') plt.sca(ax_plot) colors = sns.color_palette(['#000']) sns.set_palette(colors) if not no_latex: ylabel = 'Density ($\\frac{vehicles}{step}$)' else: ylabel = 'Density (vehicles/step)' ax_plot.set(xlabel=None, ylabel=ylabel) sns.lineplot(data=self.data.sum(axis=0) / self.data.shape[0])
def plot_waveforms(spike_data, prm): print('I will plot the waveform shapes for each cluster.') save_path = prm.get_output_path() + '/Figures/firing_properties' if os.path.exists(save_path) is False: os.makedirs(save_path) for cluster in range(len(spike_data)): cluster = spike_data.cluster_id.values[cluster] - 1 fig = plt.figure(figsize=(5, 5)) plt.suptitle("Spike waveforms", fontsize=24) grid = plt.GridSpec(2, 2, wspace=1, hspace=0.5) for channel in range(4): plot_spikes_for_channel_centered(grid, spike_data, cluster, channel, 'random_snippets') plt.savefig(save_path + '/' + spike_data.session_id[cluster] + '_' + str(cluster + 1) + '_waveforms.png', dpi=300, bbox_inches='tight', pad_inches=0) # plt.savefig(save_path + '/' + spike_data.session_id[cluster] + '_' + str(cluster + 1) + '_waveforms.pdf', bbox_inches='tight', pad_inches=0) plt.close()
sys.path.append("/usr/local/bin/") import matplotlib matplotlib.rcParams['axes.linewidth'] = 0.5 from astropy.io import fits galaxy = "PTF11qnr" data = pyfits.getdata("../MUSE/AMUSING_dataproducts/%s.SSP.cube.fits.gz" % galaxy) tessela = data[1] V = np.log10(data[0]) tessela[tessela == 0] = np.nan fig = plt.figure(figsize=(4, 2)) grid = plt.GridSpec(1, 2, top=0.999, right=0.995, left=0.1, bottom=0.2) ax = fig.add_subplot(grid[0, 0]) ax1 = fig.add_subplot(grid[0, 1]) ax.imshow(V, origin="l", vmin=-3.5, vmax=-0.8, cmap="binary", aspect="auto") ax1.imshow(tessela, origin="l", cmap="gist_earth", aspect="auto") ax.set_xlabel("pixels", fontsize=8) #,labelpad = 0) ax.set_ylabel("pixels", fontsize=8) #,labelpad = 0) plt.setp(ax.get_yticklabels(), rotation='vertical', fontsize=8) plt.setp(ax.get_xticklabels(), fontsize=8) ax1.set_xlabel("pixels", fontsize=8) #,labelpad = 0) plt.setp(ax1.get_yticklabels(), rotation='vertical', fontsize=8) plt.setp(ax1.get_xticklabels(), fontsize=8)
axis=1)[:A.shape[0] / 4, :] bina = 1 binb = 1 a_num = A.shape[0] b_num = A.shape[1] a_vv = np.copy(A.reshape(a_num // bina, bina, b_num // binb, binb)) A = np.mean(np.mean(a_vv, axis=3), axis=1) cj = np.append(cj[:, 7 * cj.shape[1] / 8:cj.shape[1]], cj[:, :cj.shape[1] / 8], axis=1)[:cj.shape[0] / 4, :] #cg = np.log10(np.power(np.abs(cj[:cj.shape[0]/2,:]),2)) #vmin = A.mean()-2.*A.std() #vmax = A.mean()+A.std() #print cg.shape,A.shape gs = plt.GridSpec(2, 4, wspace=0.4, hspace=0.4) fig = plt.figure(figsize=(6, 6)) fig.add_subplot(gs[:2, :2]) plt.figure(1) #plt.subplot(121) x = np.linspace(-25.4, +25.4, A.shape[1], endpoint=True) y = np.linspace(0, 128, A.shape[0], endpoint=True) x_ds, y_ds = np.meshgrid(x, y) A = np.where(A > 0, A, 0.0001) A = np.log10(np.power(A, 2)) print y_ds.shape, x_ds.shape, A.shape plt.pcolormesh(x_ds, y_ds, A, cmap=cm.Greys, vmin=-1, vmax=3) #ax=plt.imshow(np.log10(np.power(A,2)), aspect='auto', cmap=cm.Greys, interpolation='nearest', vmin=-1, origin='lower') plt.colorbar() plt.ylim(0, 128) plt.xlim(-25.4, 25.4)
p_guess_quad_zenith = [1.5, -1] poptquad_zenith, pcovquad_zenith = opt.curve_fit( quad_curvefit_zenith, dec, ratio, p0=p_guess_quad_zenith, sigma=ratio_err, maxfev=10000) redchisq_decfits[3] = redchisq( ratio, quad_curvefit_zenith(dec, *poptquad_zenith), ratio_err, 2)[0] a_fit[3], c_fit[3] = poptquad_zenith[0], poptquad_zenith[1] plt.rcParams[ 'figure.figsize'] = 20, 5 # Setting figure size. Have to close window for it to have effect. gs = plt.GridSpec(1, 6) ax = plt.subplot(gs[0]) ax1 = plt.subplot(gs[1]) ax2 = plt.subplot(gs[2]) ax3 = plt.subplot(gs[3]) ax4 = plt.subplot(gs[4]) ax5 = plt.subplot(gs[5]) # ax.scatter(dec, ratio, marker='+',color = 'k',c=SNR, cmap=plt.cm.Greys)#, c=SNR, cmap=plt.cm.Greys) # ax1.scatter(dec, ratio, marker='+',color ='k',c=SNR, cmap=plt.cm.Greys)#, c=SNR, cmap=plt.cm.Greys) # ax2.scatter(dec, ratio, marker='+',color ='k',c=SNR, cmap=plt.cm.Greys)#, c=SNR, cmap=plt.cm.Greys) # ax3.scatter(dec, ratio, marker='+',color ='k',c=SNR, cmap=plt.cm.Greys) # ax4.scatter(dec, ratio, marker='+',color ='k',c=SNR, cmap=plt.cm.Greys) # ax5.scatter(dec, ratio, marker='+',color ='k',c=SNR, cmap=plt.cm.Greys) ax.scatter(dec, ratio, marker='o', color='k', c=SNR, cmap=plt.cm.Greys) #, c=SNR, cmap=plt.cm.Greys) ax1.scatter(dec,
def multiplot_violin_paper(df, fname, settings): """Plot data properties as violin plots. Far from optimized code: seaborn does not make this easy so added a lot of formatting using raw matplotlib commands Args: df (DataFrame): prediction dataframe fname (filename): settings (ExperimentSettings): custom class to hold hyperparameters Returns: figure (png) """ # Set up the axes with gridspec plt.clf() fig = plt.figure() grid = plt.GridSpec(2, 4, hspace=0.2, wspace=0.2) ax_00 = fig.add_subplot(grid[0, 0]) ax_01 = fig.add_subplot(grid[0, 1], sharey=ax_00) ax_02 = fig.add_subplot(grid[0, 2], sharey=ax_00) ax_03 = fig.add_subplot(grid[0, 3], sharey=ax_00) ax_1 = fig.add_subplot(grid[1, :]) axes = [ax_00, ax_01, ax_02, ax_03] # Ia vs non Ia sns.set_palette(sns.color_palette(BI_COLORS)) g = sns.violinplot( x="target", y="SIM_PEAKMAG_g", hue="salt", data=df, split=True, ax=axes[0], inner="quartile", ) g.set_xlabel("") g.legend_.remove() g.yaxis.set_tick_params(labelsize=14) g.set_title("g", fontsize=14) g.set_ylabel("magnitude", fontsize=14) g.set_ylim(20, 28) g.spines["right"].set_visible(False) g.spines["top"].set_visible(False) g.set_xticklabels(["Ia", "nonIa"], fontsize=14) g = sns.violinplot( x="target", y="SIM_PEAKMAG_i", hue="salt", data=df, split=True, ax=axes[1], inner="quartile", ) g.set_xlabel("") g.set_ylabel("") g.legend_.remove() g.yaxis.set_ticks_position("none") g.set_title("i", fontsize=14) g.set_ylim(20, 28) g.spines["right"].set_visible(False) g.spines["top"].set_visible(False) g.spines["left"].set_visible(False) g.set_xticklabels(["Ia", "nonIa"], fontsize=14) plt.setp(axes[1].get_yticklabels(), visible=False) g = sns.violinplot( x="target", y="SIM_PEAKMAG_r", hue="salt", data=df, split=True, ax=axes[2], inner="quartile", ) g.legend_.remove() g.yaxis.set_ticks_position("none") g.set_xlabel("") g.set_ylabel("") g.set_title("r", fontsize=18) g.xaxis.set_tick_params(labelsize=14) g.set_ylim(20, 28) g.spines["right"].set_visible(False) g.spines["top"].set_visible(False) g.spines["left"].set_visible(False) g.set_xticklabels(["Ia", "nonIa"], fontsize=14) plt.setp(axes[2].get_yticklabels(), visible=False) g = sns.violinplot( x="target", y="SIM_PEAKMAG_z", hue="salt", data=df, split=True, ax=axes[3], inner="quartile", ) g.legend_.remove() g.yaxis.set_ticks_position("none") g.set_title("z", fontsize=14) g.set_xlabel("") g.set_ylabel("") g.set_ylim(20, 28) g.spines["right"].set_visible(False) g.spines["top"].set_visible(False) g.spines["left"].set_visible(False) g.set_xticklabels(["Ia", "nonIa"], fontsize=14) plt.setp(axes[3].get_yticklabels(), visible=False) # redshift g = sns.violinplot( x="SNTYPE", y="SIM_REDSHIFT_CMB", hue="salt", data=df, split=True, ax=ax_1, inner="quartile", ) g.set_ylabel("simulated redshift", fontsize=14) g.set_xlabel("") g.set_ylim(0, 1.0) g.set_xticklabels([a for a in settings.sntypes.values()], fontsize=14) g.xaxis.set_tick_params(labelsize=14) g.yaxis.set_tick_params(labelsize=14) g.legend_.remove() g.spines["right"].set_visible(False) g.spines["top"].set_visible(False) g.spines["bottom"].set_visible(False) plt.savefig(f"{settings.figures_dir}/multiviolin_{fname}.png") plt.close() del fig
dec18_ind = np.where(dec >= 18.) ratio_dec18 = ratio[dec18_ind] ratio_err_dec18 = ratio_err[dec18_ind] dec18_less_ind = np.where(dec < 18.) ratio_less_dec18 = ratio[dec18_less_ind] ratio_err_less_dec18 = ratio_err[dec18_less_ind] SNR = ratio_err # poptzero_ratio_dec18, pcovzero_ratio_dec18 = opt.curve_fit(zero_curvefit, dec[dec18_ind], ratio_dec18, p0 = p_guess_zero, sigma = ratio_err_dec18, maxfev = 10000) # poptzero_ratio_less_dec18, pcovzero_ratio_less_dec18 = opt.curve_fit(zero_curvefit, dec[dec18_less_ind], ratio_less_dec18, p0 = p_guess_zero, sigma = ratio_err_less_dec18, maxfev = 10000) plt.rcParams[ 'figure.figsize'] = 12, 5 # Setting figure size. Have to close window for it to have effect. gs = plt.GridSpec(1, 2, wspace=0, width_ratios=[3, 1]) ax = plt.subplot(gs[0]) ax1 = plt.subplot(gs[1]) ax.scatter(dec, ratio, marker='o', c=SNR, cmap=plt.cm.Greys_r, norm=matplotlib.colors.LogNorm()) #, c=SNR, cmap=plt.cm.Greys) dec_long = np.arange( min(dec) + 0.07 * min(dec), max(dec) + 0.10 * max(dec), 0.1) dec_long = np.array(dec_long) if options.do_ratio_errors: ax.plot(dec_long, np.ones(len(dec_long)) * zero_curvefit(dec_long, a_mcmc_plot),
def heatmap(x, y, tfs=12, bkg_color='#F1F1F1', separate_first=0, **kwargs): """ Calculate a heatmap Based on: https://towardsdatascience.com/better-heatmaps-and-correlation-matrix-plots-in-python-41445d0f2bec """ if 'color' in kwargs: color = kwargs['color'] else: color = [1] * len(x) if 'palette' in kwargs: palette = kwargs['palette'] n_colors = len(palette) else: n_colors = 256 # Use 256 colors for the diverging color palette palette = sns.diverging_palette( 359, 122, s=90, n=500) #sns.color_palette("BrBG", n_colors) if 'color_range' in kwargs: color_min, color_max = kwargs['color_range'] else: color_min, color_max = min(color), max( color ) # Range of values that will be mapped to the palette, i.e. min and max possible correlation def value_to_color(val): if color_min == color_max: return palette[-1] else: val_position = float((val - color_min)) / ( color_max - color_min ) # position of value in the input range, relative to the length of the input range val_position = min(max(val_position, 0), 1) # bound the position betwen 0 and 1 ind = int(val_position * (n_colors - 1)) # target index in the color palette return palette[ind] if 'size' in kwargs: size = kwargs['size'] else: size = [1] * len(x) if 'size_range' in kwargs: size_min, size_max = kwargs['size_range'][0], kwargs['size_range'][1] else: size_min, size_max = min(size), max(size) size_scale = kwargs.get('size_scale', 500) def value_to_size(val): if size_min == size_max: return 1 * size_scale else: val_position = (val - size_min) * 0.99 / ( size_max - size_min ) + 0.01 # position of value in the input range, relative to the length of the input range val_position = min(max(val_position, 0), 1) # bound the position betwen 0 and 1 return val_position * size_scale if 'x_order' in kwargs: x_names = [t for t in kwargs['x_order']] else: x_names = [t for t in sorted(set([v for v in x]))] x_to_num = {p[1]: p[0] for p in enumerate(x_names)} if 'y_order' in kwargs: y_names = [t for t in kwargs['y_order']] else: y_names = [t for t in sorted(set([v for v in y]))] y_to_num = {p[1]: p[0] for p in enumerate(y_names)} plot_grid = plt.GridSpec(1, 30, hspace=0.2, wspace=0.1) # Setup a 1x10 grid ax = plt.subplot(plot_grid[:, :-1] ) # Use the left 14/15ths of the grid for the main plot marker = kwargs.get('marker', 's') kwargs_pass_on = { k: v for k, v in kwargs.items() if k not in [ 'color', 'palette', 'color_range', 'size', 'size_range', 'size_scale', 'marker', 'x_order', 'y_order' ] } ax.scatter(x=[x_to_num[v] for v in x], y=[y_to_num[v] for v in y], marker=marker, s=[value_to_size(v) for v in size], c=[value_to_color(v) for v in color], **kwargs_pass_on) ax.set_xticks([v for k, v in x_to_num.items()]) ax.set_xticklabels([k for k in x_to_num], rotation=45, horizontalalignment='right', fontsize=tfs) ax.set_yticks([v for k, v in y_to_num.items()]) ax.set_yticklabels([k for k in y_to_num], fontsize=tfs) ax.grid(False, 'major') ax.grid(True, 'minor') ax.set_xticks([t + 0.5 for t in ax.get_xticks()], minor=True) ax.set_yticks([t + 0.5 for t in ax.get_yticks()], minor=True) ax.set_xlim([-0.5, max([v for v in x_to_num.values()]) + 0.5]) ax.set_ylim([-0.5, max([v for v in y_to_num.values()]) + 0.5]) ax.set_facecolor(bkg_color) if separate_first: l = np.sqrt(len(x)) plt.axvline(separate_first - .5, color='gray') plt.axhline(l - .5 - separate_first, color='gray') # Add color legend on the right side of the plot if color_min < color_max: ax = plt.subplot(plot_grid[:, -1]) # Use the rightmost column of the plot #ax.axis('off') plt.box(on=None) col_x = [0] * len(palette) # Fixed x coordinate for the bars bar_y = np.linspace( color_min, color_max, n_colors) # y coordinates for each of the n_colors bars bar_height = bar_y[1] - bar_y[0] print(bar_height) ax.barh( y=bar_y, width=[15] * len(palette), # Make bars 5 units wide left=col_x, # Make bars start at 0 height=bar_height, color=palette, linewidth=0) ax.set_ylim(-2, 2) ax.set_xlim( 0, 5 ) # Bars are going from 0 to 5, so lets crop the plot somewhere in the middle ax.grid(False) # Hide grid ax.set_facecolor('white') # Make background white ax.set_xticks([]) # Remove horizontal ticks ax.set_yticks( np.linspace(min(bar_y), max(bar_y), 3)) # Show vertical ticks for min, middle and max ax.yaxis.tick_right() # Show vertical ticks on the right plt.sca(plt.subplot(plot_grid[:, :-1]))
def make_combined_field_analysis_figures(prm, spatial_firing): print('I will make the combined images for field analysis results now.') save_path = prm.get_output_path() + '/Figures/field_analysis' if os.path.exists(save_path) is False: os.makedirs(save_path) plt.close('all') figures_path = prm.get_output_path() + '/Figures/' for cluster in range(len(spatial_firing)): cluster = spatial_firing.cluster_id.values[cluster] - 1 spike_scatter_path = figures_path + 'firing_scatters/' + spatial_firing.session_id[cluster] + '_' + str(cluster + 1) + '_spikes_on_trajectory.png' rate_map_path = figures_path + 'rate_maps/' + spatial_firing.session_id[cluster] + '_rate_map_' + str(cluster + 1) + '.png' head_direction_polar_path = figures_path + 'head_direction_plots_polar/' + spatial_firing.session_id[cluster] + '_hd_polar_' + str(cluster + 1) + '.png' head_direction_map_path = figures_path + 'head_direction_plots_2d/' + spatial_firing.session_id[cluster] + '_hd_map_' + str(cluster + 1) + '.png' firing_fields_rate_map_path = figures_path + 'firing_field_plots/' + spatial_firing.session_id[cluster] + '_firing_fields_rate_map' + str(cluster + 1) + '.png' firing_fields_coloured_spikes_path = figures_path + 'firing_fields_coloured_spikes/' + spatial_firing.session_id[cluster] + '_firing_fields_coloured_spikes' + str(cluster + 1) + '.png' firing_field_path = figures_path + 'firing_field_plots/' + spatial_firing.session_id[cluster] + '_cluster_' + str(cluster + 1) + '_firing_field_' firing_field_path_first = prm.get_output_path() + '/first_half/Figures/firing_field_plots/' + spatial_firing.session_id[cluster] + '_cluster_' + str(cluster + 1) + '_firing_field_' firing_field_path_second = prm.get_output_path() + '/second_half/Figures/firing_field_plots/' + spatial_firing.session_id[cluster] + '_cluster_' + str(cluster + 1) + '_firing_field_' number_of_firing_fields = 0 if 'firing_fields' in spatial_firing: number_of_firing_fields = len(spatial_firing.firing_fields[cluster]) if number_of_firing_fields == 0: continue number_of_rows = 4 number_of_columns = 5 if number_of_firing_fields > 5: number_of_columns = number_of_firing_fields grid = plt.GridSpec(number_of_rows, number_of_columns, wspace=0.2, hspace=0.2) rounded_r = [ '%.4f' % elem for elem in spatial_firing.field_corr_r[cluster]] rounded_p = [ '%.4f' % elem for elem in spatial_firing.field_corr_p[cluster]] plt.suptitle("r: " + str(rounded_r) + '\np: ' + str(rounded_p)) if os.path.exists(spike_scatter_path): spike_scatter = mpimg.imread(spike_scatter_path) spike_scatter_plot = plt.subplot(grid[0, 0]) spike_scatter_plot.axis('off') spike_scatter_plot.imshow(spike_scatter) if os.path.exists(head_direction_polar_path): polar_hd = mpimg.imread(head_direction_polar_path) polar_hd_plot = plt.subplot(grid[0, 1]) polar_hd_plot.axis('off') polar_hd_plot.imshow(polar_hd) if os.path.exists(head_direction_map_path): hd_map = mpimg.imread(head_direction_map_path) hd_map_plot = plt.subplot(grid[0, 2]) hd_map_plot.axis('off') hd_map_plot.imshow(hd_map) if os.path.exists(firing_fields_rate_map_path): firing_fields = mpimg.imread(firing_fields_rate_map_path) firing_fields_plot = plt.subplot(grid[0, 3]) firing_fields_plot.axis('off') firing_fields_plot.imshow(firing_fields) if os.path.exists(firing_fields_coloured_spikes_path): firing_fields = mpimg.imread(firing_fields_coloured_spikes_path) firing_fields_plot = plt.subplot(grid[0, 4]) firing_fields_plot.axis('off') firing_fields_plot.imshow(firing_fields) for field in range(number_of_firing_fields): path = firing_field_path + str(field + 1) + '.png' firing_field_polar = mpimg.imread(path) row = 1 col = field firing_fields_polar_plot = plt.subplot(grid[row, col]) firing_fields_polar_plot.axis('off') firing_fields_polar_plot.imshow(firing_field_polar) for field in range(number_of_firing_fields): path = firing_field_path_first + str(field + 1) + '.png' firing_field_polar = mpimg.imread(path) row = 2 col = field firing_fields_polar_plot = plt.subplot(grid[row, col]) firing_fields_polar_plot.axis('off') firing_fields_polar_plot.imshow(firing_field_polar) for field in range(number_of_firing_fields): path = firing_field_path_second + str(field + 1) + '.png' firing_field_polar = mpimg.imread(path) row = 3 col = field firing_fields_polar_plot = plt.subplot(grid[row, col]) firing_fields_polar_plot.axis('off') firing_fields_polar_plot.imshow(firing_field_polar) plt.savefig(save_path + '/' + spatial_firing.session_id[cluster] + '_' + str(cluster + 1) + '.png', dpi=1000) # plt.savefig(save_path + '/' + spatial_firing.session_id[cluster] + '_' + str(cluster + 1) + '.pdf', dpi=1000) plt.close()
def make_combined_figure(prm, spatial_firing): print('I will make the combined images now.') save_path = prm.get_output_path() + '/Figures/combined' if os.path.exists(save_path) is False: os.makedirs(save_path) plt.close('all') figures_path = prm.get_output_path() + '/Figures/' for cluster in range(len(spatial_firing)): cluster = spatial_firing.cluster_id.values[cluster] - 1 coverage_path = figures_path + 'session/heatmap.png' spike_scatter_path = figures_path + 'firing_scatters/' + spatial_firing.session_id[cluster] + '_' + str(cluster + 1) + '_spikes_on_trajectory.png' rate_map_path = figures_path + 'rate_maps/' + spatial_firing.session_id[cluster] + '_rate_map_' + str(cluster + 1) + '.png' head_direction_polar_path = figures_path + 'head_direction_plots_polar/' + spatial_firing.session_id[cluster] + '_hd_polar_' + str(cluster + 1) + '.png' head_direction_map_path = figures_path + 'head_direction_plots_2d/' + spatial_firing.session_id[cluster] + '_hd_map_' + str(cluster + 1) + '.png' firing_fields_rate_map_path = figures_path + 'firing_field_plots/' + spatial_firing.session_id[cluster] + '_firing_fields_rate_map' + str(cluster + 1) + '.png' spike_histogram_path = figures_path + 'firing_properties/' + spatial_firing.session_id[cluster] + '_' + str(cluster + 1) + '_spike_histogram.png' speed_histogram_path = figures_path + 'firing_properties/' + spatial_firing.session_id[cluster] + '_' + str(cluster + 1) + '_speed_histogram.png' firing_field_path = figures_path + 'firing_field_plots/' + spatial_firing.session_id[cluster] + '_cluster_' + str(cluster + 1) + '_firing_field_' autocorrelograms = figures_path + 'firing_properties/' + spatial_firing.session_id[cluster] + '_' + str(cluster + 1) + '_autocorrelograms.png' waveforms_path = figures_path + 'firing_properties/' + spatial_firing.session_id[cluster] + '_' + str(cluster + 1) + '_waveforms.png' rate_map_autocorrelogram_path = figures_path + 'rate_map_autocorrelogram/' + spatial_firing.session_id[cluster] + '_rate_map_autocorrelogram_' + str(cluster + 1) + '.png' speed_vs_firing_rate_path = figures_path + 'firing_properties/' + spatial_firing.session_id[cluster] + '_' + str(cluster + 1) + '_speed_vs_firing_rate.png' number_of_firing_fields = 0 if 'firing_fields' in spatial_firing: number_of_firing_fields = len(spatial_firing.firing_fields[cluster]) number_of_rows = math.ceil((number_of_firing_fields + 1)/6) + 2 grid = plt.GridSpec(number_of_rows, 5, wspace=0.025, hspace=0.05) if os.path.exists(waveforms_path): waveforms = mpimg.imread(waveforms_path) waveforms_plot = plt.subplot(grid[0, 0]) waveforms_plot.axis('off') waveforms_plot.imshow(waveforms) if os.path.exists(spike_histogram_path): spike_hist = mpimg.imread(spike_histogram_path) spike_hist_plot = plt.subplot(grid[0, 2]) spike_hist_plot.axis('off') spike_hist_plot.imshow(spike_hist) if os.path.exists(autocorrelograms): autocorrelogram_10 = mpimg.imread(autocorrelograms) autocorrelogram_10_plot = plt.subplot(grid[0, 1]) autocorrelogram_10_plot.axis('off') autocorrelogram_10_plot.imshow(autocorrelogram_10) if os.path.exists(speed_vs_firing_rate_path): speed_vs_rate = mpimg.imread(speed_vs_firing_rate_path) speed_vs_rate_plot = plt.subplot(grid[0, 3]) speed_vs_rate_plot.axis('off') speed_vs_rate_plot.imshow(speed_vs_rate) if os.path.exists(coverage_path): coverage = mpimg.imread(coverage_path) coverage_plot = plt.subplot(grid[0, 4]) coverage_plot.axis('off') coverage_plot.imshow(coverage) if os.path.exists(spike_scatter_path): spike_scatter = mpimg.imread(spike_scatter_path) spike_scatter_plot = plt.subplot(grid[1, 0]) spike_scatter_plot.axis('off') spike_scatter_plot.imshow(spike_scatter) if os.path.exists(rate_map_path): rate_map = mpimg.imread(rate_map_path) rate_map_plot = plt.subplot(grid[1, 1]) rate_map_plot.axis('off') rate_map_plot.imshow(rate_map) if os.path.exists(rate_map_autocorrelogram_path): rate_map_autocorr = mpimg.imread(rate_map_autocorrelogram_path) rate_map_autocorr_plot = plt.subplot(grid[1, 2]) rate_map_autocorr_plot.axis('off') rate_map_autocorr_plot.imshow(rate_map_autocorr) if os.path.exists(head_direction_polar_path): polar_hd = mpimg.imread(head_direction_polar_path) polar_hd_plot = plt.subplot(grid[1, 3]) polar_hd_plot.axis('off') polar_hd_plot.imshow(polar_hd) if os.path.exists(head_direction_map_path): hd_map = mpimg.imread(head_direction_map_path) hd_map_plot = plt.subplot(grid[1, 4]) hd_map_plot.axis('off') hd_map_plot.imshow(hd_map) if os.path.exists(firing_fields_rate_map_path): firing_fields = mpimg.imread(firing_fields_rate_map_path) firing_fields_plot = plt.subplot(grid[2, 0]) firing_fields_plot.axis('off') firing_fields_plot.imshow(firing_fields) for field in range(number_of_firing_fields): path = firing_field_path + str(field + 1) + '.png' firing_field_polar = mpimg.imread(path) row = math.floor((field+1)/5) + 2 col = (field+1) % 5 firing_fields_polar_plot = plt.subplot(grid[row, col]) firing_fields_polar_plot.axis('off') firing_fields_polar_plot.imshow(firing_field_polar) plt.savefig(save_path + '/' + spatial_firing.session_id[cluster] + '_' + str(cluster + 1) + '.png', dpi=1000) # plt.savefig(save_path + '/' + spatial_firing.session_id[cluster] + '_' + str(cluster + 1) + '.pdf') plt.close()
def dynamic_heatmap(df, columns, fontsize=20, annot=False, palette=None, figsize=(15, 10), squaresize=500): """Plots a heatmap that changes size values depending on correlation Adapted from: https://towardsdatascience.com/better-heatmaps-and-correlation-matrix-plots-in-python-41445d0f2bec""" plt.figure(figsize=figsize) corr = df[columns].corr() sns.set(style="dark") grid_bg_color = sns.axes_style()['axes.facecolor'] # Generate a mask for the upper triangle mask = np.zeros_like(corr, dtype=np.bool) mask[np.triu_indices_from(mask)] = True corr = pd.melt(corr.reset_index(), id_vars='index') # Unpivot the dataframe, so we can get pair of arrays for x and y corr.columns = ['x', 'y', 'value'] x = corr['x'] y = corr['y'] size = corr['value'].abs() # Set up the matplotlib figure f, ax = plt.subplots(figsize=figsize) ax.set_xticklabels( ax.get_xticklabels(), rotation=45, horizontalalignment='right'); # Mapping from column names to integer coordinates x_labels = [v for v in sorted(x.unique())] y_labels = [v for v in sorted(y.unique())] x_to_num = {p[1]: p[0] for p in enumerate(x_labels)} y_to_num = {p[1]: p[0] for p in enumerate(y_labels)} size_scale = squaresize if palette: n_colors = len(palette) else: n_colors = 256 # Use 256 colors for the diverging color palette palette = sns.diverging_palette(20, 220, n=n_colors) # Create the palette color_min, color_max = [-1, 1] # Range of values that will be mapped to the palette, i.e. min and max possible correlation color = corr["value"] def value_to_color(val): val_position = float((val - color_min)) / ( color_max - color_min) # position of value in the input range, relative to the length of the input range ind = int(val_position * (n_colors - 1)) # target index in the color palette return palette[ind] plot_grid = plt.GridSpec(1, 15, hspace=0.2, wspace=0.1) # Setup a 1x15 grid ax = plt.subplot(plot_grid[:, :-1]) # Use the leftmost 14 columns of the grid for the main plot ax.scatter( x=x.map(x_to_num), # Use mapping for x y=y.map(y_to_num), # Use mapping for y s=size * size_scale, # Vector of square sizes, proportional to size parameter c=color.apply(value_to_color), # Vector of square colors, mapped to color palette marker='s' # Use square as scatterplot marker ) # Show column labels on the axes ax.set_xticks([x_to_num[v] for v in x_labels]) ax.set_xticklabels(x_labels, rotation=45, horizontalalignment='right') ax.set_yticks([y_to_num[v] for v in y_labels]) ax.set_yticklabels(y_labels) # ax.set_fontsize(font_scale) for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] + ax.get_xticklabels() + ax.get_yticklabels()): item.set_fontsize(fontsize) numbers = corr['value'].round(decimals=2) if annot: for i, txt in enumerate(numbers): annot_font_size = int(fontsize * size[i] * annot) ax.annotate(txt, (x.map(x_to_num)[i], y.map(x_to_num)[i]), horizontalalignment="center", verticalalignment="center", color=grid_bg_color, fontweight="black", fontsize=annot_font_size) ax.grid(False, 'major') ax.grid(True, 'minor') ax.set_xticks([t + 0.5 for t in ax.get_xticks()], minor=True) ax.set_yticks([t + 0.5 for t in ax.get_yticks()], minor=True) ax.set_xlim([-0.5, max([v for v in x_to_num.values()]) + 0.5]) ax.set_ylim([-0.5, max([v for v in y_to_num.values()]) + 0.5]) # Add color legend on the right side of the plot ax = plt.subplot(plot_grid[:, -1]) # Use the rightmost column of the plot col_x = [0] * len(palette) # Fixed x coordinate for the bars bar_y = np.linspace(color_min, color_max, n_colors) # y coordinates for each of the n_colors bars bar_height = bar_y[1] - bar_y[0] ax.barh( y=bar_y, width=[5] * len(palette), # Make bars 5 units wide left=col_x, # Make bars start at 0 height=bar_height, color=palette, linewidth=0 ) ax.set_xlim(1, 2) # Bars are going from 0 to 5, so lets crop the plot somewhere in the middle ax.grid(False) # Hide grid ax.set_xticks([]) # Remove horizontal ticks ax.set_yticks(np.linspace(min(bar_y), max(bar_y), 3)) # Show vertical ticks for min, middle and max ax.yaxis.tick_right() # Show vertical ticks on the right plt.show()
scenes_spec = [] for _ in range(N): scene_obs = {} for obj in objects: scene_obs[obj] = obj scenes_spec += [scene_obs] world.create_scenes(scenes_spec) def gridnum(i, ncols): return i // ncols, i % ncols plt.ion() fig = plt.figure(figsize=(10, 5)) spec = plt.GridSpec(ncols=N // 2, nrows=2, figure=fig) ax = [fig.add_subplot(spec[gridnum(i, ncols=N // 2)]) for i in range(N)] plt.tight_layout() for b in range(50): transforms = [] for _ in range(N): model_matrices = [] for _ in objects: xy = torch.rand(2) * 128 - 64 model_matrices += [Translate(x=xy[0], y=xy[1], z=0)] transforms += [model_matrices] distance = 30 elevation = 0.0
xtickslabels = np.arange(-m / 2, m / 2 + 1, 2) yticks = np.arange(-n / 2 + 0.5, n / 2 + 1, 2) ytickslabels = np.arange(-n / 2, n / 2 + 1, 2) else: n = e.shape[0] m = e.shape[1] xticks = np.arange(-m / 2 + 0.5, m / 2 + 1, 2) xtickslabels = np.arange(-m / 2 + 1, m / 2 + 1, 2) yticks = np.arange(-n / 2 + 0.5, n / 2 + 1, 2) ytickslabels = np.arange(-n / 2 + 1, n / 2 + 1, 2) extent = [-n / 2, n / 2, -m / 2, m / 2] np.save('e_field_fourier_nonoise_tfd.npy', e) # defining the grid of the plot gs = plt.GridSpec(4, 6, wspace=0.4, hspace=0.4) fig = plt.figure(figsize=(18, 12)) fig.add_subplot(gs[:2, :2]) plt.imshow(e.real, aspect='equal', extent=extent, interpolation='nearest', origin='lower', cmap='viridis') plt.title(r'Simulated $\tilde{E}(\tau,f_D)$') ax = plt.gca() ax.set_xticks(xticks) ax.set_xticklabels(xtickslabels) ax.set_yticks(yticks) ax.set_yticklabels(ytickslabels)
sns.set_style("darkgrid") sns.set_context("paper") fs = 14 # fontsize si = 141 lw = 2 # linewidth sp1 = 6 sp2 = 25 color1 = 'k' color2 = 'red' color3 = 'k' #%% start figure fig = plt.figure(figsize=(19, 9)) grid = plt.GridSpec(2, 24, wspace=0., hspace=0.2) #% subplot (a) ax = plt.subplot( grid[0, :12], projection=projection) #plt.subplot(2,2,1, projection=projection) plt.title('(a) $R_{0.1}$, eddying', fontsize=fs) g = ax.gridlines(crs=ccrs.PlateCarree(), draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--') g.xlocator = mticker.FixedLocator([-180, -90, -0, 90, 180]) g.xlabels_top = False g.ylabels_right = False
idxlon = np.logical_and(Lons >= maxminlon, Lons <= minmaxlon) assert (idxlon == True).all() avgd = np.flip(avgd[idxlat], 0) # land = np.full(avgd.shape, np.nan); land[avgd==0] = 1; avgd[avgd == 0] = np.nan avd50gm[j] = mean_latitudeweigthed(avgd, Lats) / 100. avgd50, surf50, Lons, Lats = calc_fields( name= '/Volumes/HardDisk/POP/output/highres/timeseries/timeseries_per_location_ddeg1_sp25_dd10_tempresmonmean.nc' ) avgd50mean = mean_latitudeweigthed(avgd50, Lats) / 100. #%% start figure fig = plt.figure(figsize=(19, 15)) grid = plt.GridSpec(3, 24, wspace=0., hspace=0.4) #% Subplot (a) highres ax0 = plt.subplot( grid[0, :12], projection=projection) #plt.subplot(2,2,1, projection=projection) plt.title('(a)$R_{0.1}$', fontsize=fs) g = ax0.gridlines(crs=ccrs.PlateCarree(), draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--') g.xlabels_top = False g.ylabels_right = False g.xlabels_bottom = False g.xlabel_style = {'fontsize': fs}
def jointplot(X, Y, xlabel=None, ylabel=None, binsim=40, binsh=20, contour=True): """ Plots the joint distribution of posteriors for X1 and X2, including the 1D histograms showing the median and standard deviations. The work that went in creating this nice method is shown, step by step, in the ipython notebook "error contours.ipynb". Sources of inspiration: - http://python4mpia.github.io/intro/quick-tour.html - http://stackoverflow.com/questions/12301071/multidimensional-confidence-intervals Usage: >>> jointplot(M.rtr.trace(),M.mdot.trace(),xlabel='$\log \ r_{\\rm tr}$', ylabel='$\log \ \dot{m}$') gives the following plot. .. figure:: ../figures/jointplot.png :scale: 100 % :alt: Two-dimensional kernel density distribution. Two-dimensional kernel density distribution, along with one-dimensional histograms of each distribution. """ import scipy.stats # Generates 2D histogram for image histt, xt, yt = numpy.histogram2d(X, Y, bins=[binsim, binsim], normed=False) histt = numpy.transpose( histt) # Beware: numpy switches axes, so switch back. # assigns correct proportions to subplots fig = pylab.figure() gs = pylab.GridSpec(2, 2, width_ratios=[3, 1], height_ratios=[1, 3], wspace=0.001, hspace=0.001) con = pylab.subplot(gs[2]) histx = pylab.subplot(gs[0], sharex=con) histy = pylab.subplot(gs[3], sharey=con) # Image con.imshow(histt, extent=[xt[0], xt[-1], yt[0], yt[-1]], origin='lower', cmap=pylab.cm.gray_r, aspect='auto') # Overplot with error contours 1,2 sigma if contour == True: pdf = scipy.stats.gaussian_kde([X, Y]) x, y = pylab.meshgrid(xt, yt) z = numpy.array(pdf.evaluate([x.flatten(), y.flatten()])).reshape(x.shape) # the [61,15] values were obtained by trial and error until the joint confidence # contours matched the confidence intervals from the individual X,Y s = scipy.stats.scoreatpercentile(pdf(pdf.resample(1000)), [61, 15]) cs = con.contour(x, y, z, levels=s, extent=[x[0], x[-1], y[0], y[-1]], linestyles=['-', '-', '-'], colors=['black', 'blue']) # use dictionary in order to assign your own labels to the contours. #fmtdict = {s[0]:r'$1\sigma$',s[1]:r'$2\sigma$'} #con.clabel(cs, fmt=fmtdict, inline=True, fontsize=20) if xlabel != None: con.set_xlabel(xlabel) if ylabel != None: con.set_ylabel(ylabel) # X-axis histogram histx.hist(X, binsh, histtype='stepfilled', facecolor='lightblue') pylab.setp(histx.get_xticklabels(), visible=False) # no X label pylab.setp(histx.get_yticklabels(), visible=False) # no Y label # Vertical lines with median and 1sigma confidence yax = histx.set_ylim() histx.plot([numpy.median(X), numpy.median(X)], [yax[0], yax[1]], 'k-', linewidth=2) # median xsd = scipy.stats.scoreatpercentile(X, [15.87, 84.13]) histx.plot([xsd[0], xsd[0]], [yax[0], yax[1]], 'k--') # -1sd histx.plot([xsd[-1], xsd[-1]], [yax[0], yax[1]], 'k--') # +1sd # Y-axis histogram histy.hist(Y, binsh, histtype='stepfilled', orientation='horizontal', facecolor='lightyellow') pylab.setp(histy.get_yticklabels(), visible=False) # no Y label pylab.setp(histy.get_xticklabels(), visible=False) # no X label # Vertical lines with median and 1sigma confidence xax = histy.set_xlim() histy.plot([xax[0], xax[1]], [numpy.median(Y), numpy.median(Y)], 'k-', linewidth=2) # median ysd = scipy.stats.scoreatpercentile(Y, [15.87, 84.13]) histy.plot([xax[0], xax[1]], [ysd[0], ysd[0]], 'k--') # -1sd histy.plot([xax[0], xax[1]], [ysd[-1], ysd[-1]], 'k--') # +1sd
def gsea_plot(rank_metric, enrich_term, hit_ind, nes, pval, fdr, RES, phenoPos=None, phenoNeg=None, figsize =(6.5,6), **kwarg): """This is the main function for reproducing the gsea plot. :param rank_metric: rankings, rank_metric['rank'].values. :param enrich_term: gene_set name :param hit_ind: hit indexs of rank_metric['gene_name'] presented in gene set S. :param nes: Normalized enrichment scores. :param pval: nominal p-value. :param fdr: false discoveray rate. :param RES: ranking enrichment scores of all genes in rank_metric['gene_name']. :param phenoPos: phenotype lable, positive correlated. :param phenoNeg: phenotype lable, negative correlated. :param figsize: matplotlib figsize. :return: fig object of gsea plot. """ #plt.style.use('classic') # center color map at midpoint = 0 norm = _MidpointNormalize(midpoint=0) #dataFrame of ranked matrix scores x = rank_metric.index.values #figsize = (6,6) phenoP_label = phenoPos + ' (Positively Correlated)' phenoN_label = phenoNeg + ' (Negatively Correlated)' zero_score_ind = np.abs(rank_metric['rank']).argmin() z_score_label = 'Zero score at ' + str(zero_score_ind) nes_label = 'NES: '+ "{:.3f}".format(float(nes)) pval_label = 'Pval: '+ "{:.3f}".format(float(pval)) fdr_label = 'FDR: '+ "{:.3f}".format(float(fdr)) #im_matrix = rank_metric.ix[:,1:].T im_matrix = rank_metric.iloc[:,1:].T #in most case, we will have mangy plots, so do not display plots #It's also convinient to run this script on command line. plt.ioff() #GSEA Plots gs = plt.GridSpec(16,1) fig = plt.figure(figsize=figsize) #Ranked Metric Scores Plot ax1 = fig.add_subplot(gs[11:]) ax1.fill_between(x, y1= rank_metric['rank'], y2=0, color='#C9D3DB') ax1.set_ylabel("Ranked list metric",fontsize=14) ax1.text(.05, .9, phenoP_label, color='red', horizontalalignment='left', verticalalignment='top', transform=ax1.transAxes) ax1.text(.95, .05, phenoN_label, color='Blue', horizontalalignment='right', verticalalignment='bottom', transform=ax1.transAxes) # the x coords of this transformation are data, and the y coord are axes trans1 = transforms.blended_transform_factory(ax1.transData, ax1.transAxes) ax1.vlines(zero_score_ind, 0, 1, linewidth=.5, transform=trans1, linestyles='--', color='grey') ax1.text(zero_score_ind, 0.5, z_score_label, horizontalalignment='center', verticalalignment='center', transform=trans1) ax1.set_xlabel("Rank in Ordered Dataset", fontsize=14) ax1.spines['top'].set_visible(False) ax1.tick_params(axis='both', which='both', top='off', right='off', left='off') ax1.locator_params(axis='y', nbins=5) ax1.yaxis.set_major_formatter(plt.FuncFormatter(lambda tick_loc,tick_num : '{:.1f}'.format(tick_loc) )) # use round method to control float number #ax1.yaxis.set_major_formatter(plt.FuncFormatter(lambda tick_loc,tick_num : round(tick_loc, 1) )) #gene hits ax2 = fig.add_subplot(gs[8:10], sharex=ax1) # the x coords of this transformation are data, and the y coord are axes trans2 = transforms.blended_transform_factory(ax2.transData, ax2.transAxes) ax2.vlines(hit_ind, 0, 1,linewidth=.5,transform=trans2) ax2.spines['bottom'].set_visible(False) ax2.tick_params(axis='both', which='both', bottom='off', top='off', labelbottom='off', right='off', left='off',labelleft='off') #colormap ax3 = fig.add_subplot(gs[10],sharex=ax1) ax3.imshow(im_matrix, aspect='auto', norm=norm, cmap=plt.cm.seismic, interpolation='none') # cm.coolwarm ax3.spines['bottom'].set_visible(False) ax3.tick_params(axis='both', which='both', bottom='off', top='off', labelbottom='off', right='off', left='off',labelleft='off') # Enrichment score plot ax4 = fig.add_subplot(gs[:8],sharex=ax1) ax4.plot(x,RES,linewidth=4,color ='#88C544') ax4.text(.1, .1, fdr_label, transform=ax4.transAxes) ax4.text(.1, .2, pval_label, transform=ax4.transAxes) ax4.text(.1, .3, nes_label, transform=ax4.transAxes) # the y coords of this transformation are data, and the x coord are axes trans4 = transforms.blended_transform_factory(ax4.transAxes, ax4.transData) ax4.hlines(0, 0, 1, linewidth=.5, transform=trans4, color='grey') ax4.set_ylabel("Enrichment score (ES)", fontsize=14) ax4.set_xlim(min(x), max(x)) ax4.tick_params(axis='both', which='both', bottom='off', top='off', labelbottom='off', right='off') ax4.locator_params(axis='y', nbins=5) # FuncFormatter need two argment, I don't know why. this lambda function used to format yaxis tick labels. ax4.yaxis.set_major_formatter(plt.FuncFormatter(lambda tick_loc,tick_num : '{:.1f}'.format(tick_loc)) ) #fig adjustment fig.suptitle(enrich_term, fontsize=16) fig.subplots_adjust(hspace=0) #fig.tight_layout() plt.close(fig) return fig