def updateAssessmentGraphs(): states = [] imageRadius = IMAGE_SIZE / 2 for xImg in range(IMAGE_SIZE): for yImg in range(IMAGE_SIZE): x = xImg - imageRadius y = yImg - imageRadius v = np.clip(math.sqrt(x * x + y * y) * 16 / imageRadius, 0, 16) v = v - 8 theta = None if x < 0: theta = math.atan(y / x) + math.pi elif x == 0 and y > 0: theta = math.pi elif x == 0 and y < 0: theta = -math.pi elif x == 0 and y == 0: theta = 0 elif x > 0 and y < 0: theta = math.atan(y / x) + math.pi + math.pi else: theta = math.atan(y / x) states.append([math.cos(theta), math.sin(theta), v]) (action_mean_val) = sess.run([action_mean], feed_dict={state_ph: states}) actionsChosenImg = np.reshape(action_mean_val, [IMAGE_SIZE, IMAGE_SIZE]) policyGraph.cla() policyColorBar.cla() ax = policyGraph.imshow(actionsChosenImg) colorbar(ax, cax=policyColorBar) policyFigure.canvas.draw()
def plot_inset_nn_all(ax, pw, xlim=(12e6, 16e6), ylim=(4e6, 6e6)): pw = pw.sel(x=slice(*xlim), y=slice(*ylim)) x, y, z = pw.x / 1e6, pw.y / 1e6, pw.values c = "w" styles = { 'axes.edgecolor': c, 'axes.labelcolor': c, 'xtick.color': c, 'ytick.color': c } with plt.rc_context(styles): axins = zoomed_inset_axes(ax, 2, loc='center left') # zoom = 6 im = axins.pcolormesh(x, y, z, rasterized=True) # colorbar cax = inset_axes( axins, width="100%", # width = 10% of parent_bbox width height="20%", # height : 50% loc="lower center", # bbox_to_anchor=(1.05, 0., 1, 1), bbox_to_anchor=(0.0, -.30, 1., 1), bbox_transform=axins.transAxes, borderpad=0, ) colorbar(im, cax=cax, orientation='horizontal') axins.set_xticklabels('') axins.set_yticklabels('') mark_inset(ax, axins, loc1=1, loc2=4, fc="none", ec=c)
def plot_heatmap3d(df_heatmap): """Plot 3D heatmap.""" # 3D Plotting fig = plt.figure(figsize=(25, 18)) ax = plt.axes(projection="3d") fig.set_facecolor("white") ax.set_facecolor("white") # axes ax.w_xaxis.pane.fill = False ax.w_yaxis.pane.fill = False ax.w_zaxis.pane.fill = False ax.w_zaxis.grid(visible=False) # labels ax.yaxis.labelpad = 30 ax.xaxis.labelpad = 50 ax.zaxis.labelpad = 30 ax.tick_params(axis="z", pad=15) ax.tick_params(axis="x", pad=20) # data df_pivot = df_heatmap.pivot_table(values="val", index="beta", columns="delta") # coordinates x = np.arange(0.944, 0.962, 0.002) y = np.arange(0.75, 1.05, 0.01) x, y = np.meshgrid(x, y) z = df_pivot.iloc[:, 11:].values ax.set_zticks([]) # colormap colormap = get_custom_cmap() surf = ax.plot_surface(x, y, z, cmap=colormap) format_ = mpl.ticker.ScalarFormatter(useOffset=False, useMathText=True) format_.set_powerlimits((3, 3)) colorbar( surf, ax=ax, shrink=0.7, aspect=10, ticks=[10_000] + list(np.linspace(20_000, 140_000, 7)), format=format_, ) # labels' names ax.set_xlabel(r"$\delta$", fontsize=20, rotation=270) ax.set_ylabel(r"$\beta$", fontsize=20) ax.set_zlabel("Criterion", fontsize=20, rotation=360) ax.set_title("Heatmap criterion", weight="bold", fontsize=28, y=1.05) # disable automatic rotation ax.zaxis.set_rotate_label(False) ax.view_init(50, 10) return fig
def _plot_bicmaps(X_orig_std, best_co_config): # Train model with best config. orig_co_model = SpectralCoclustering(random_state=0, svd_method='arpack') orig_co_model.set_params(**best_co_config) orig_co_model.fit(X_orig_std) orig_co_row_sorted = X_orig_std[np.argsort(orig_co_model.row_labels_), :] orig_co_fit_data = orig_co_row_sorted[:, np.argsort(orig_co_model.column_labels_)] hmap = sns.heatmap( orig_co_fit_data, robust=True, cmap=plt.cm.viridis, fmt='f', vmin=np.min(orig_co_fit_data), vmax=np.max(orig_co_fit_data), cbar=False ) coords = bic_coords(orig_co_model, best_co_config['n_clusters']) for num in coords.index: plt.plot( (coords.loc[num, ['x1', 'x2', 'x2', 'x1', 'x1']]), (coords.loc[num, ['y1', 'y1', 'y2', 'y2', 'y1']]), c='darkred' ) plt.ylabel('Patients') plt.xlabel('Features') plt.yticks([], []) plt.xticks([], []) ax_divider = make_axes_locatable(hmap) cax = ax_divider.append_axes('right', size='3%', pad='2%') colorbar.colorbar( hmap.get_children()[0], cax=cax, orientation='vertical' ) #cax.xaxis.set_label_text('AUC', fontname='Sans') #cax.xaxis.set_label_position('top') cbar_ticks = np.linspace( np.nanmin(orig_co_fit_data), np.nanmax(orig_co_fit_data), 6 ) cax.yaxis.set_ticks(cbar_ticks) cax.yaxis.set_ticklabels([f'{num:.01f}' for num in cbar_ticks]) plt.savefig( '../biclustering/bic_map_original_images.pdf', bbox_inches='tight', transparent=True, dpi=CONFIG.DPI, )
def updateAssessmentGraphs(self): states = [] imageRadius = constants.IMAGE_SIZE / 2 for xImg in range(constants.IMAGE_SIZE): for yImg in range(constants.IMAGE_SIZE): x = xImg - imageRadius y = yImg - imageRadius v = np.clip(math.sqrt(x * x + y * y) * 16 / imageRadius, 0, 16) v = v - 8 theta = None if x < 0: theta = math.atan(y / x) + math.pi elif x == 0 and y > 0: theta = math.pi elif x == 0 and y < 0: theta = -math.pi elif x == 0 and y == 0: theta = 0 elif x > 0 and y < 0: theta = math.atan(y / x) + math.pi + math.pi else: theta = math.atan(y / x) states.append([math.cos(theta), math.sin(theta), v]) (actionsChosen, qAssessments) = self.sess.run( self.graphingOperations, feed_dict={ self.statePh: states, self.quantileThresholdsPh: np.random.uniform(low=0.0, high=1.0, size=(len(states), self.numQuantiles)) }) actionsChosenImg = np.reshape( actionsChosen, [constants.IMAGE_SIZE, constants.IMAGE_SIZE]) qAssessmentsImg = np.reshape( qAssessments, [constants.IMAGE_SIZE, constants.IMAGE_SIZE]) self.qAssessmentGraph.cla() self.qAssessmentColorBar.cla() ax = self.qAssessmentGraph.imshow(qAssessmentsImg) colorbar(ax, cax=self.qAssessmentColorBar) self.qAssessmentFigure.canvas.draw() self.policyGraph.cla() self.policyColorBar.cla() ax = self.policyGraph.imshow(actionsChosenImg) colorbar(ax, cax=self.policyColorBar) self.policyFigure.canvas.draw()
def gen_heatmap(results, path_to_fig=None, kind='test_score', show=False): results_mat, selector_lbls, estimator_lbls = gen_results_matrix(results, kind=kind) plt.title('AUC', x=1.035, y=1.03) hmap = sns.heatmap( results_mat.T * 100, yticklabels=format_selector_labels(selector_lbls), xticklabels=format_estimator_labels(estimator_lbls), vmin=np.nanmin(results_mat) * 100 - 3, vmax=np.nanmax(results_mat) * 100 + 3, cmap=plt.cm.viridis, robust=True, annot=True, fmt='.1f', square=1, linewidth=.5, cbar=False, annot_kws={'size': 18}, ) plt.xlabel('Classification Algorithm', va='top', ha='center') plt.ylabel('Feature Selection Algorithm', va='bottom', ha='center') hmap.set_yticklabels(hmap.get_yticklabels(), rotation=0) hmap.set_xticklabels(hmap.get_xticklabels(), rotation=0, va='top', ha='center') # labelpad=-40, y=1.05, rotation=0 ax_divider = make_axes_locatable(hmap) cax = ax_divider.append_axes('right', size='3%', pad='2%') colorbar.colorbar(hmap.get_children()[0], cax=cax, orientation='vertical') #cax.xaxis.set_label_text('AUC', fontname='Sans') #cax.xaxis.set_label_position('top') cbar_ticks = np.linspace( np.nanmin(results_mat) * 100 - 3, np.nanmax(results_mat) * 100 + 3, 6) cax.yaxis.set_ticks(cbar_ticks) cax.yaxis.set_ticklabels([f'{num:.01f}' for num in cbar_ticks]) if path_to_fig is not None: plt.savefig( path_to_fig, bbox_inches='tight', transparent=True, dpi=CONFIG.DPI, ) if show: plt.show()
def showcov(self, triang, val, vmin=-130, vmax=-50, cmap=plt.cm.jet, bbuild=False, btile=True): """ Show a coverage Parameters ---------- triang : triangulation val : values """ lonmin = np.min(triang.x) lonmax = np.max(triang.x) latmin = np.min(triang.y) latmax = np.max(triang.y) extent = (lonmin, lonmax, latmin, latmax) print(extent) mp = smopy.Map((extent[2] + 0.1, extent[0] + 0.1, extent[3] - 0.1, extent[1] - 0.1), z=12) if bbuild: f, ax, d = self.show(fig=f, ax=ax, contour=False, btile=False, bldg=True, height=False, coord='lonlat', extent=self.extent) #ax = plt.gca() if mp != []: triang.x, triang.y = mp.to_pixels(triang.y, triang.x) #ax = mp.show_mpl(figsize=(10,10)) ax = plt.gca() tc = ax.tripcolor( triang, val.flatten(), #shading='gouraud', #shading='flat', cmap=cmap, vmax=vmax, vmin=vmin, alpha=0.4, edgecolors='k', linewidth=0.0) #plt.axis('equal') ax = mp.show_mpl(ax=ax) divider = make_axes_locatable(ax) cax = divider.append_axes("right", size="5%", pad="5%") cb = colorbar(tc, cax=cax) cb.set_label_text('Loss(dB)', fontsize=18) return (cb)
def plot_Z(Z_mean, wi_mean, lami_est, w_thresh=.01, cm_greys=plt.cm.get_cmap('Greys', 5), fs_lab=10, add_colorbar=True, fs_cbar=10, fs_w=10, fs_celltypes=10, xlab="markers", ylab="cell subpopulations (abundance)", markernames=[], fs_markers=10, w_digits=1): J = Z_mean.shape[0] k_ord = wi_mean.argsort() z_cols = [] for k in k_ord.tolist(): if wi_mean[k] > w_thresh: z_cols.append(k) z_cols = np.array(z_cols) Z_hat = Z_mean[:, z_cols].T im = plt.imshow(Z_hat, aspect='auto', vmin=0, vmax=1, cmap=cm_greys) plt.xlabel(xlab, fontsize=fs_lab) plt.ylabel(ylab, fontsize=fs_lab) # W percentages w_perc = wi_mean[z_cols] w_perc = [str((wp * 100).round(w_digits)) + '%' for wp in w_perc] ax = plt.gca() # plt.xticks([]) labels = ['{} ({})'.format(zc + 1, wp) for (zc, wp) in zip(z_cols, w_perc)] plt.yticks(np.arange(len(z_cols)), labels, fontsize=fs_celltypes) add_gridlines_Z(Z_hat) plt.xticks(rotation=90, fontsize=fs_markers) if len(markernames) == 0: plt.xticks(np.arange(J), np.arange(J) + 1) else: plt.xticks(np.arange(J), markernames) # add wi_mean on right side # K = z_cols.shape[0] # ax2 = ax.twinx() # ax2.set_yticks(range(K)) # plt.yticks((K-1) / K * np.arange(K) + .5, w_perc[::-1], fontsize=fs_w) # ax2.tick_params(length=0) # colorbar if add_colorbar: ax_divider = make_axes_locatable(ax) cax = ax_divider.append_axes("top", size="7%", pad="2%") cax.xaxis.set_ticks_position("top") cbar = colorbar(im, cax=cax, orientation="horizontal") cbar.ax.tick_params(labelsize=fs_cbar)
def plotMixtureMatrix(ax, mixtureMatrix, labels): """ auxiliary function to plot the mixture matrix Keywords: --- ax: the axes object --- mixtureMatrix: the data for the mixture matrix --- labels: labels in the mixture matrix corresponding to classes """ # Add a finite number to the otherwise zero values # to get around the logarithmic nan values mixtureMatrix[np.where(mixtureMatrix == 0)] += 1 disc = np.max(mixtureMatrix) fonts = {'fontsize': 8} tickSize = 6 cmap = mpl.cm.get_cmap('inferno', disc) cmap.set_under((0., 0., 0.)) im = ax.imshow(mixtureMatrix, cmap=cmap, aspect=1., interpolation='nearest', norm=LogNorm()) cax = inset_axes( ax, width="5%", # width = 10% of parent_bbox width height="100%", # height : 50% loc=3, bbox_to_anchor=(1.05, 0., 1, 1), bbox_transform=ax.transAxes, borderpad=0, ) f = ticker.ScalarFormatter(useOffset=False, useMathText=True) g = lambda x, pos: "${}$".format(f._formatSciNotation('%1.10e' % x)) cbar = colorbar(im, cax=cax, ticks=[100, 900], extend='both', format=ticker.FuncFormatter(g)) cbar.ax.tick_params(labelsize=6) ax.set_ylabel('true label', **fonts) ax.set_xlabel('predicted label', **fonts) for location in ['top', 'bottom', 'left', 'right']: ax.spines[location].set_linewidth(5.) # Change the ticks to labels names ax.xaxis.set_major_locator(MaxNLocator(integer=True)) ax.yaxis.set_major_locator(MaxNLocator(integer=True)) ax.tick_params(length=0., pad=5) ax.set_xticks(np.arange(len(labels))) ax.set_xticklabels(labels, fontsize=tickSize) ax.set_yticks(np.arange(len(labels))) ax.set_yticklabels(labels, fontsize=tickSize) ax.tick_params(axis='both', which='minor')
def showcov(self, triang, val, vmin=-130, vmax=-50, cmap=plt.cm.jet, bbuild = False, btile=True): """ Show a coverage Parameters ---------- triang : triangulation val : values """ lonmin = np.min(triang.x) lonmax = np.max(triang.x) latmin = np.min(triang.y) latmax = np.max(triang.y) extent = (lonmin, lonmax, latmin, latmax) print(extent) mp = smopy.Map((extent[2]+0.1, extent[0]+0.1, extent[3]-0.1,extent[1]-0.1), z=10) if bbuild: f, ax, d = self.show(fig=f, ax=ax, contour=False, btile=False, bldg=True, height=False, coord='lonlat', extent=self.extent) #ax = plt.gca() triang_ = copy.deepcopy(triang) if mp!=[]: triang_.x,triang_.y = mp.to_pixels(triang_.y, triang_.x) #ax = mp.show_mpl(figsize=(10,10)) ax = plt.gca() tc = ax.tripcolor(triang_, val.flatten(), #shading='gouraud', #shading='flat', cmap=cmap, vmax=vmax, vmin=vmin, alpha = 0.4, edgecolors='k', linewidth=0.0) #plt.axis('equal') ax = mp.show_mpl(ax=ax) divider = make_axes_locatable(ax) cax = divider.append_axes("right",size="5%",pad="5%") cb = colorbar(tc, cax=cax) cb.set_label_text('Loss(dB)',fontsize=18) return(cb)
def __plot_colorbar(self, img, orientation='vertical'): if orientation == 'horizontal': ax_divider = make_axes_locatable(self.ax) if self.is_inverted: cax = ax_divider.append_axes("top", size=0.09, pad=0.2) else: cax = ax_divider.append_axes("bottom", size=0.09, pad=0.2) colorbar(img, cax=cax, orientation='horizontal') else: # vertical y_ax = self.y_ax if self.properties['norm'] == 'log': from matplotlib.ticker import LogFormatter formatter = LogFormatter(10, labelOnlyBase=False) aa = np.array([1, 2, 5]) c_min, c_max = self.matrix_val_range def abs_inc(num): if num != 0: sign = num / abs(num) return int(sign * abs(num + 1)) else: return 1 lower_ = int(np.log10(c_min)) upper_ = abs_inc(int(np.log10(c_max))) tick_values = np.concatenate( [aa * 10**x for x in range(lower_, upper_)]) c_bar = plt.colorbar(img, ax=y_ax, ticks=tick_values, format=formatter, fraction=0.98) else: c_bar = plt.colorbar(img, ax=y_ax, fraction=0.98) c_bar.solids.set_edgecolor("face") c_bar.ax.tick_params(labelsize='smaller') c_bar.ax.yaxis.set_ticks_position('left')
def visualize(r, obser, predit, var): """Draws original, encoded and decoded images""" fig, (ax1, ax2) = plt.subplots(1, 2) fig.set_size_inches(10, 10) fig.subplots_adjust(wspace=0.5) fig.suptitle("Week " + str(r + 1) + " Plots", fontsize=16) im1 = ax1.imshow(obser, vmin=-1, vmax=1) ax1_divider = make_axes_locatable(ax1) cax1 = ax1_divider.append_axes("right", size="7%", pad="2%") cb1 = colorbar(im1, cax=cax1) ax1.set_title("Observed" + var) im2 = ax2.imshow(predit, vmin=-1, vmax=1) ax2_divider = make_axes_locatable(ax2) cax2 = ax2_divider.append_axes("right", size="7%", pad="2%") cb2 = colorbar(im2, cax=cax2) ax2.set_title("Predicted" + var) fig.savefig(pp, format='pdf')
def showSubim(self): """Shows the subimage""" # We might select only one of the filters if self.subimFilter > 0: if self.tData['FILTER'][self.iData] <> self.subimFilter: return if not self.axInset: self.setupSubim() # hilight here. self.hilightCurrentScatter() # dynamic scaling vmin = -5.0e-3 vmax = 5.0e-3 if self.t[self.iData] - np.min(self.t) > 1.2: vmin = -1.0e-3 vmax = 1.0e-3 dum = self.axInset.imshow(self.subim, origin='lower', \ cmap='gray', interpolation='nearest', \ vmin=vmin, vmax=vmax) try: self.cax.remove() except: notAlreadyHere = True # add colorbar self.cax = inset_axes( self.axInset, width="5%", # width = 10% of parent_bbox width height="100%", # height : 50% loc=3, bbox_to_anchor=(1.05, 0., 1, 1), bbox_transform=self.axInset.transAxes, borderpad=0) colorbar(dum, cax=self.cax)
def heatmap_sequence(one_hot, ax=None, sort_idx=None, aspect='auto', figsize_tmpl=(8, 4), cbar=True, title=None): """Plot a heatmap of sequences """ if ax is None: figsize = (figsize_tmpl[0] * one_hot.shape[1] / 200, figsize_tmpl[1] * one_hot.shape[0] / 2000) fig, ax = plt.subplots(figsize=figsize) if sort_idx is None: sort_idx = np.arange(one_hot.shape[0]) cmap = colors.ListedColormap(["red", "orange", "blue", "green"][::-1]) qrates = np.array(list("TGCA")) bounds = np.linspace(-.5, 3.5, 5) norm = colors.BoundaryNorm(bounds, 4) fmt = mpl.ticker.FuncFormatter(lambda x, pos: qrates[::-1][norm(x)]) img = ax.imshow(one_hot.argmax(axis=-1)[sort_idx], aspect=aspect, cmap=cmap, norm=norm, alpha=0.8) if cbar: ax2_divider = make_axes_locatable(ax) cax2 = ax2_divider.append_axes("top", size="5%", pad=0.05) # cb2 = colorbar(im2, cax=cax2, orientation="horizontal") cb2 = colorbar(img, cax=cax2, cmap=cmap, norm=norm, boundaries=bounds, orientation="horizontal", ticks=[0, 1, 2, 3], format=fmt) cax2.xaxis.set_ticks_position("top") seq_len = one_hot.shape[1] ticks = np.arange(0, seq_len + 1, 25) ax.set_xticks(ticks) ax.set_xticklabels(ticks - seq_len // 2) ax.set_ylabel("Seqlet index") ax.set_xlabel("Position") if title is not None: ax.set_title(title) return fig
def show_xt(self, ax, cmp="jet", Vmin=-0.2, Vmax=0.2, fsz=12): ext = [self.time[0], self.time[-1], self.y0, self.y1] im = ax.imshow(self.amp, vmin=Vmin, vmax=Vmax, extent=ext, origin="lower", interpolation="bilinear", cmap=cmp) #ax.set_xlabel("time [$\mu$s]",fontsize=fsz) ax.set_ylabel("y [mm]", fontsize=fsz) ax_div = make_axes_locatable(ax) cax = ax_div.append_axes("right", size="5%", pad="2%") cbar = colorbar(im, cax=cax)
def plot_y(yi, wi_mean, lami_est, fs_lab=10, fs_cbar=10, lw=3, cm=blue2red.cm(6), vlim=(-3, 3), fs_xlab=10, fs_ylab=10, ylab="cells", markernames=[], interpolation=None, rotation=90, ha="center"): J = yi.shape[1] vmin, vmax = vlim if type(wi_mean) == int: K = wi_mean wi_mean = np.array([(lami_est == k + 1).mean() for k in range(K)]) lami_new, counts = relabel_lam(lami_est, wi_mean) counts_cumsum = np.cumsum(counts) yi_sorted = yi[np.argsort(lami_new), :] im = plt.imshow(yi_sorted, aspect='auto', vmin=vmin, vmax=vmax, cmap=cm, interpolation=interpolation) for c in counts_cumsum[:-1]: plt.axhline(c, color='yellow', linewidth=lw) plt.xticks(rotation=rotation, ha=ha) if len(markernames) == 0: plt.xticks(np.arange(J), np.arange(J) + 1, fontsize=fs_xlab) else: plt.xticks(np.arange(J), markernames, fontsize=fs_xlab) plt.yticks(fontsize=fs_ylab) plt.xlabel("markers", fontsize=fs_lab) plt.ylabel(ylab, fontsize=fs_lab) ax = plt.gca() ax_divider = make_axes_locatable(ax) cax = ax_divider.append_axes("top", size="7%", pad="2%") cax.xaxis.set_ticks_position("top") cbar = colorbar(im, cax=cax, orientation="horizontal") cbar.ax.tick_params(labelsize=fs_cbar)
def error_contourf(predictions, labels, ax, text_labels=None): '''Make a smoothed contour plot showing absolute errors along the slab.''' errors = num.sqrt(num.sum((predictions - labels)**2, axis=1)) med = num.median(errors) vmin = 0. vmax = med + 1.5 * num.std(errors) s = ax.scatter(predictions.T[0], predictions.T[2], s=8, c=errors, linewidth=0.1, edgecolors='grey', vmin=vmin, vmax=vmax, cmap='viridis_r') ax.set_xlabel('N-S') ax.set_ylabel('Z') cax = inset_axes( ax, width="2%", # width = 10% of parent_bbox width height="100%", # height : 50% loc='lower left', bbox_to_anchor=(1.25, 0.0, 1, 1), bbox_transform=ax.transAxes, borderpad=0, ) # cax.set_title('Err [km]') cbar = colorbar(s, cax=cax) cbar.ax.text(9.5, 0.5, r'$\triangle$DD [km]', rotation=90., horizontalalignment='center', verticalalignment='center', transform=cax.transAxes) cbar.ax.tick_params(labelsize=MAIN_FONT_SIZE - 2) if text_labels: assert len(text_labels) == len(predictions) for ip, p in enumerate(predictions): ax.text(p[0], p[2], text_labels[ip], fontsize=POINT_SIZE)
def error_contourf(predictions, labels, ax): '''Make a smoothed contour plot showing absolute errors along the slab.''' errors = num.sqrt(num.sum((predictions-labels)**2, axis=1)) med = num.median(errors) vmin = 0. vmax = med + 1.5 * num.std(errors) s = ax.scatter(predictions.T[0], predictions.T[2], s=6, c=errors, linewidth=0, vmin=vmin, vmax=vmax) ax.set_xlabel('N-S') ax.set_ylabel('Z') # colorbar cax = inset_axes(ax, width="2%", # width = 10% of parent_bbox width height="50%", # height : 50% loc='lower left', bbox_to_anchor=(0., 0.05, 1, 1), bbox_transform=ax.transAxes, borderpad=0, ) cbar = colorbar(s, cax=cax) cbar.ax.tick_params(labelsize=MAIN_FONT_SIZE-2)
def show(self, ax, fsz=16): ext = [self.time[0], self.time[-1], -self.ycod[0], -self.ycod[-1]] Vmax = np.sum(self.C[:]) / 150 #ax.imshow(self.C, extent=ext,aspect="auto",origin="lower",cmap="jet",interpolation="bilinear",vmin=0,vmax=Vmax) im = ax.imshow(self.C, extent=ext, aspect="auto", origin="lower", cmap="jet", interpolation="bilinear", vmin=0, vmax=Vmax) ax_div = make_axes_locatable(ax) cax = ax_div.append_axes("right", size="5%", pad="2.5%") cbar = colorbar(im, cax=cax, orientation="vertical") cbar.ax.tick_params(labelsize=fsz - 2) ax.set_xlim(ext[0:2]) ax.set_ylim(ext[2:4]) ax.set_ylabel("y [mm]", fontsize=fsz) ax.set_xlabel("time [$\mu$s]", fontsize=fsz) ax.tick_params(labelsize=fsz)
def visualize_duty_phi(self): fig, axs = plt.subplots(2, 1, figsize=(12, 12)) extent = [0, 1.0, self.phi_space[0], self.phi_space[-1]] img = axs[0].imshow(self.auto_correlation_matrix, origin='lower', aspect='auto', extent=extent, cmap='plasma') ax_div = make_axes_locatable(axs[0]) # add an axes above the main axes. cax2 = ax_div.append_axes("top", size="7%", pad="2%") cb2 = colorbar(img, cax=cax2, orientation="horizontal") # change tick position to top. Tick position defaults to bottom and overlaps # the image. cax2.xaxis.set_ticks_position("top") cax2.set_xlabel(r"$\mathcal{L}$") axs[0].scatter(self.duty_param, self.phi_param, color='red', marker='X') axs[0].set_xlabel(r'Duty Cycle') axs[0].set_ylabel(r"Meander Start $(\Phi)$") axs[1].plot(self.voltage_offset, self.delta_f) axs[1].plot(self.voltage_offset, \ self.square_function(self.voltage_offset, self.phi_param, self.duty_param, self.period, max(self.delta_f))) return fig, axs
def mean_bscan_FFT(self, ax, x1=0, x2=0): if x1 * x1 + x2 * x2 == 0: i1 = 0 i2 = self.Ny else: i1 = np.argmin(abs(self.xcod - x1)) i2 = np.argmin(abs(self.xcod - x2)) Bmp = np.mean(self.amp[:, i1:i2 + 1, :], 1) BMP = np.fft.fft(Bmp, axis=1) fmax = 1 / self.dt ext = [0, fmax, self.Xa[1], self.Xb[1]] BMP = np.fft.ifft(BMP, axis=0) Bmax = np.max(np.abs(BMP)) #im=ax.imshow(np.abs(BMP)/Bmax,cmap="jet",origin="lower",aspect="auto",interpolation="bilinear",extent=ext,vmin=0,vmax=0.5) BMP[0:int(self.Ny / 2), 0:int(self.Nt / 2)] = 0.0 BMP[int(self.Ny / 2):-1, int(self.Nt / 2):-1] = 0.0 Bt = np.fft.fft(BMP, axis=0) Bt = np.fft.ifft(Bt, axis=1) Btmax = np.max(np.real(Bt)) im = ax.imshow(np.real(Bt) / Btmax, cmap="jet", origin="lower", aspect="auto", interpolation="bilinear", extent=ext) #,vmin=-0.5,vmax=0.5) #ax.set_xlim([0,10]) ax_div = make_axes_locatable(ax) cax = ax_div.append_axes("right", size="5%", pad="2%") cb = colorbar(im, cax=cax) ax.set_ylabel("y [mm]") ax.set_xlabel("frequency [MHz]") ax.set_title("Frequency spectrum")
density=True, weights=wgt) binm = 0.5 * (bins[0:-1] + bins[1:]) cx0.plot(binm, hist, label=txtf) C = omg / K C = np.reshape(C, [Nx * Ny]) Cb = np.sum(C * wgt) / np.sum(wgt[:]) print("<c>=", np.mean(C[:]), Cb) axdiv = make_axes_locatable(ax[k]) bxdiv = make_axes_locatable(bx[k]) cxdiv = make_axes_locatable(cx[k]) cax = axdiv.append_axes("right", size="7%", pad="2%") cbx = bxdiv.append_axes("right", size="7%", pad="2%") ccx = cxdiv.append_axes("right", size="7%", pad="2%") cba = colorbar(ima, cax=cax) cbb = colorbar(imb, cax=cbx) cbc = colorbar(imc, cax=ccx) ax[k].set_xlabel("x [mm]", fontsize=fsz) bx[k].set_xlabel("x [mm]", fontsize=fsz) cx[k].set_xlabel("x [mm]", fontsize=fsz) #ax0.text(0,5,"(a)",fontsize=fsz+2,horizontalalignment="center") ax0.set_xlabel("wave number [/mm]", fontsize=fsz) ax0.set_ylabel("probability density", fontsize=fsz) #bx0.text(-170,0.012,"(b)",fontsize=fsz+2,horizontalalignment="left",verticalalignment="top") bx0.set_xlabel("angle [deg]", fontsize=fsz) bx0.set_ylabel("probability density", fontsize=fsz) bx0.set_xlim([-180, 180])
def plotTimeSpatial(argv): # plt.rcParams.update({'font.size': 14}) sns.set(style='whitegrid', rc={"grid.linewidth": 0.1}) sns.set_context("paper", font_scale=0.9) ncols = 2 nrows = ceil(len(argv['models']) / ncols) fig, axes = plt.subplots(nrows=nrows, ncols=ncols, figsize=(14, 12), dpi=100, sharex=False, sharey=True) axes = axes.flatten() for i, model in enumerate(argv['models']): # if i==1: fpath = '../data/month/%s.nc' % model dataset = Dataset(fpath, mode='r') LATS = dataset.variables['lat'][:] LONS = dataset.variables['long'][:] var = dataset.variables[argv['variableNames'][i]] ax = axes[i] ax.set_title(model + ': ' + argv['label'] + ' (' + var.units + ')', fontdict={'fontsize': 18}) # time lat lon data = np.ma.masked_equal(var[:], 0) data = data.reshape(-1, 12, LAT_NUM, LON_NUM).mean(axis=(0, 3)) data = data.T[::-1, :] headNan = np.zeros([(int(90 - LAT_END + GRID_LENGTH) * 2 + 1), 12]) footNan = np.zeros([(int(LAT_START + 60) * 2) + 1, 12]) fulldata = np.concatenate((headNan, data, footNan), axis=0) df = pd.DataFrame(fulldata) # print(headNan.shape, data.shape, footNan.shape, fulldata.shape) LATS = -(np.arange((90 + 60) * 2 + 1) - 180) / 2 LATS = LATS.astype(np.int32) df.index = LATS # lat df.columns = np.arange(12) + 1 # 1-12 month # print(df.index, df.columns) # print(data[5:,:2]) df = df.fillna(0) cmap = LinearSegmentedColormap.from_list('custom_cb', [(0, '#EEEEEE'), (0.125, '#615EFE'), (0.25, '#0080AC'), (0.375, '#01B251'), (0.5, '#73C605'), (0.675, '#DEF103'), (0.75, '#FF9703'), (0.875, '#FC0101'), (1, '#B30404')], N=125) hm = sns.heatmap(df, annot=False, yticklabels=30, linewidths=0, ax=ax, cbar=False, cmap=cmap, cbar_kws={"orientation": "horizontal"}) # hm.axes.set_title("Title",) # hm.set_xlabel("X Label",fontsize=30) # hm.set_ylabel("Y Label",fontsize=20) hm.tick_params(labelsize=15) ax_divider = make_axes_locatable(ax) cax = ax_divider.append_axes('right', size='5%', pad='2%') cax.tick_params(labelsize=18) colorbar(ax.get_children()[0], cax=cax, orientation='vertical') cax.xaxis.set_ticks_position('top') dataset.close() # fig.tight_layout(w_pad=5, h_pad=2) # fig.subplots_adjust(bottom=.1, hspace=0.2) # [left, bottom, width, height] # cbar_ax=fig.add_axes([.1, .05, .8, .015]) # cbar = fig.colorbar(cs, cax=cbar_ax, orientation='horizontal') # cbar.set_label('kgC m-2 y-1') # fig.subplots_adjust(left=.05, bottom=.05) fig.text(0.5, 0.04, 'Month', ha='center', fontsize=22) fig.text(0.04, 0.5, 'Latitude', va='center', rotation='vertical', fontsize=22) plt.savefig('../figure/%s-lat-time.jpg' % argv['label']) plt.close('all') print(argv['label'] + ' time-spatial map')
print("jmax=", jmax) Df = 0.125 inc = int(Df / bndl.df) im = ax.imshow(np.abs(FK), extent=ext, interpolation="none", aspect="auto", cmap="jet", origin="lower") indx = np.arange(jmin, jmax + 1, inc) ax.plot(bndl.freq[indx], -k_peak[indx], ".k", markersize="6") axdiv = make_axes_locatable(ax) cax = axdiv.append_axes("right", size="7%", pad="2%") cb = colorbar(im, cax=cax) fs = bndl.freq[jmin:jmax + 1] print(fs) print(k_peak) deg = 1 coef = np.polyfit(k_peak[jmin:jmax + 1], fs, deg) pk = np.poly1d(coef) pkd = np.poly1d(np.polyder(coef)) ax.plot(pk(k_peak[jmin:jmax + 1]), -k_peak[jmin:jmax + 1], "k--") print(coef) c = -bndl.freq[indx] / k_peak[indx] cg = -pkd(k_peak[indx]) ax.tick_params(labelsize=fsz)
existing axes, creates a divider for it and returns an instance of the AxesLocator class. The append_axes method of this AxesLocator can then be used to create a new axes on a given side ("top", "right", "bottom", or "left") of the original axes. This example uses Axes Divider to add colorbars next to axes. """ import matplotlib.pyplot as plt from mpl_toolkits.axes_grid1.axes_divider import make_axes_locatable from mpl_toolkits.axes_grid1.colorbar import colorbar fig, (ax1, ax2) = plt.subplots(1, 2) fig.subplots_adjust(wspace=0.5) im1 = ax1.imshow([[1, 2], [3, 4]]) ax1_divider = make_axes_locatable(ax1) # add an axes to the right of the main axes. cax1 = ax1_divider.append_axes("right", size="7%", pad="2%") cb1 = colorbar(im1, cax=cax1) im2 = ax2.imshow([[1, 2], [3, 4]]) ax2_divider = make_axes_locatable(ax2) # add an axes above the main axes. cax2 = ax2_divider.append_axes("top", size="7%", pad="2%") cb2 = colorbar(im2, cax=cax2, orientation="horizontal") # change tick position to top. Tick position defaults to bottom and overlaps # the image. cax2.xaxis.set_ticks_position("top") plt.show()
def get_demo_image(): from matplotlib.cbook import get_sample_data import numpy as np f = get_sample_data("axes_grid/bivariate_normal.npy", asfileobj=False) z = np.load(f) # z is a numpy array of 15x15 return z, (-3, 4, -4, 3) fig, ax = plt.subplots(figsize=[5, 4]) Z, extent = get_demo_image() ax.set(aspect=1, xlim=(-15, 15), ylim=(-20, 5)) axins = zoomed_inset_axes(ax, zoom=2, loc='upper left') im = axins.imshow(Z, extent=extent, interpolation="nearest", origin="lower") plt.xticks(visible=False) plt.yticks(visible=False) # colorbar cax = inset_axes( axins, width="5%", # width = 10% of parent_bbox width height="100%", # height : 50% loc='lower left', bbox_to_anchor=(1.05, 0., 1, 1), bbox_transform=axins.transAxes, borderpad=0, ) colorbar(im, cax=cax) plt.show()
aspect="equal", cmap="jet", origin="lower", extent=ext, interpolation="none") #,vmin=0.,vmax=180.,interpolation="none") [X, Y] = np.meshgrid(x, y) X = np.transpose(X) Y = np.transpose(Y) Kx = np.transpose(Kx) C = np.angle(Kx) / np.pi * 180. ax.quiver(X + 20, Y, np.real(Kx), np.imag(Kx), np.abs(C), cmap="jet") ax_div = make_axes_locatable(ax) cax = ax_div.append_axes("right", size="5%", pad="2.5%") cbar1 = colorbar(im, cax=cax, orientation="vertical") fig2 = plt.figure() bx = fig2.add_subplot(111) bx.tick_params(labelsize=fsz) bx.set_xlabel("x[mm]", fontsize=fsz) bx.set_ylabel("y[mm]", fontsize=fsz) jm = bx.quiver(X, Y, np.real(Kx), np.imag(Kx), np.abs(C), cmap="jet", scale_units="xy", scale=2.0,
fig, ax = plt.subplots(figsize=[5, 4]) Z, extent = get_demo_image() ax.set(aspect=1, xlim=(-15, 15), ylim=(-20, 5)) axins = zoomed_inset_axes(ax, 2, loc=2) # zoom = 6 im = axins.imshow(Z, extent=extent, interpolation="nearest", origin="lower") plt.xticks(visible=False) plt.yticks(visible=False) # colorbar cax = inset_axes(axins, width="5%", # width = 10% of parent_bbox width height="100%", # height : 50% loc=3, bbox_to_anchor=(1.05, 0., 1, 1), bbox_transform=axins.transAxes, borderpad=0, ) colorbar(im, cax=cax) plt.show()
ax.set(aspect=1, xlim=(-15, 15), ylim=(-20, 5)) axins = zoomed_inset_axes(ax, 2, loc=2) # zoom = 6 im = axins.imshow(Z, extent=extent, interpolation="nearest", origin="lower") plt.xticks(visible=False) plt.yticks(visible=False) # colorbar cax = inset_axes(axins, width="5%", # width = 10% of parent_bbox width height="100%", # height : 50% loc=3, bbox_to_anchor=(1.05, 0., 1, 1), bbox_transform=axins.transAxes, borderpad=0, ) colorbar(im, cax=cax) #, ticks=[1,2,3]) plt.draw() plt.show()
xlbl = 'X (um)' ylbl = 'Y (um)' fig, axarr = plt.subplots(plot_rows, plot_columns, figsize=(2 * plot_columns, 6 * plot_rows)) fig.tight_layout(pad=5.0) vmin = 345 vmax = 358 cmap = plt.get_cmap('jet') for ax in axarr.flat: try: # In case the number of your files is not a multiple of 4 dict_key = onlyfiles[axnum].split(".nid")[0] im[str(axnum)] = ax.pcolormesh(xaxis_dict[dict_key], yaxis_dict[dict_key], data_dict[dict_key], cmap=cmap) if force_limits: im[str(axnum)].set_clim(vmin=vmin, vmax=vmax) ax.set_title(dict_key[0:15]) # 15 characters from the filename ax.set(xlabel=xlbl, ylabel=ylbl) ax_divider = make_axes_locatable(ax) cax = ax_divider.append_axes("right", size="5%", pad="2%") colorbar(im[str(axnum)], cax=cax) axnum += 1 except: pass fig.subplots_adjust(wspace=0.6, hspace=0.8) plt.show()
""" ================= Demo New Colorbar ================= """ import matplotlib.pyplot as plt from mpl_toolkits.axes_grid1.colorbar import colorbar plt.rcParams["text.usetex"] = False fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(6, 3)) im1 = ax1.imshow([[1, 2], [3, 4]]) cb1 = fig.colorbar(im1, ax=ax1) cb1.ax.set_yticks([1, 3]) ax1.set_title("Original MPL's colorbar w/\nset_yticks([1,3])", size=10) im2 = ax2.imshow([[1, 2], [3, 4]]) cb2 = colorbar(im2, ax=ax2) cb2.ax.set_yticks([1, 3]) ax2.set_title("AxesGrid's colorbar w/\nset_yticks([1,3])", size=10) plt.show()
isum = 0 # init. counter for k in nums: fname = dir_name + "/scope_" + str(k) + ".csv" # data file name awv.load(fname) # load A-scan data if isum == 0: bwv = Bwv(nfile, awv.Nt) # initialize B-scan container bwv.set_time(awv.time[0], awv.time[-1]) # set time & frequency axes # Copy from awv --> bwv bwv.B[isum, :] += awv.amp[:] # time signal isum += 1 # increment counter fig1 = plt.figure() ax = fig1.add_subplot(111) ax_div = make_axes_locatable(ax) cax = ax_div.append_axes("right", size="7%", pad="2%") im = bwv.show(ax) cbar = colorbar(im, cax=cax) cbar.ax.tick_params(labelsize=12) #----------------------------------------- fsz = 14 ax.set_xlabel("time [$\mu$sec]", fontsize=fsz) ax.set_ylabel("data No.", fontsize=fsz) ax.set_xlim([5, 35]) ax.tick_params(labelsize=fsz) ax.set_title(name, fontsize=fsz) fig1.savefig("bscan_" + Mineral + ".png", bbox_inches="tight") plt.show()
def pltshow(plt, dpi=150): global imgx, imgy temppath = tempimage() plt.savefig(temppath, dpi=dpi) dx,dy = imagesize(temppath) w = min(W,dx) image(temppath,imgx,imgy,width=w) imgy = imgy + dy + 20 os.remove(temppath) size(W, HEIGHT+dy+40) else: def pltshow(mplpyplot): mplpyplot.show() # nodebox section end plt.rcParams["text.usetex"] = False fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(6, 3)) im1 = ax1.imshow([[1, 2], [3, 4]]) cb1 = fig.colorbar(im1, ax=ax1) cb1.ax.set_yticks([1, 3]) ax1.set_title("Original MPL's colorbar w/\nset_yticks([1,3])", size=10) im2 = ax2.imshow([[1, 2], [3, 4]]) cb2 = colorbar(im2, ax=ax2) cb2.ax.set_yticks([1, 3]) ax2.set_title("AxesGrid's colorbar w/\nset_yticks([1,3])", size=10) pltshow(plt)
fig = plt.figure(1, [5, 4]) ax = fig.add_subplot(111) Z, extent = get_demo_image() ax.set(aspect=1, xlim=(-15, 15), ylim=(-20, 5)) axins = zoomed_inset_axes(ax, 2, loc=2) # zoom = 6 im = axins.imshow(Z, extent=extent, interpolation="nearest", origin="lower") plt.xticks(visible=False) plt.yticks(visible=False) # colorbar cax = inset_axes( axins, width="5%", # width = 10% of parent_bbox width height="100%", # height : 50% loc=3, bbox_to_anchor=(1.05, 0., 1, 1), bbox_transform=axins.transAxes, borderpad=0, ) colorbar(im, cax=cax) #, ticks=[1,2,3]) plt.draw() plt.show()
def save_figures(data, source, model_version, filter, suffix=None, k=10): # Load data from json obj results = data['results'] df = pd.DataFrame(results) # Aggregate by head # Convert column to 3d ndarray (num_examples x num_layers x num_heads) indirect_by_head = np.stack(df['indirect_effect_head'].to_numpy()) direct_by_head = np.stack(df['direct_effect_head'].to_numpy()) # Average by head mean_indirect_by_head = indirect_by_head.mean(axis=0) mean_direct_by_head = direct_by_head.mean(axis=0) # Select top k heads by indirect effect topk_inds = topk_indices(mean_indirect_by_head, k) # Aggregate by layer # Convert column to 2d ndarray (num_examples x num_layers) indirect_by_layer = np.stack(df['indirect_effect_layer'].to_numpy()) direct_by_layer = np.stack(df['direct_effect_layer'].to_numpy()) mean_indirect_by_layer = indirect_by_layer.mean(axis=0) mean_direct_by_layer = direct_by_layer.mean(axis=0) n_layers = indirect_by_layer.shape[1] plt.rc('figure', titlesize=20) # Plot stacked bar chart palette = sns.color_palette() #('muted') plt.figure(num=1, figsize=(5, 2)) topk_direct = [] topk_indirect = [] labels = [] for ind in topk_inds: layer, head = np.unravel_index(ind, mean_indirect_by_head.shape) topk_indirect.append(mean_indirect_by_head[layer, head]) topk_direct.append(mean_direct_by_head[layer, head]) labels.append(f'{layer}-{head}') width = 0.6 inds = range(k) p1 = plt.bar(inds, topk_indirect, width, linewidth=0, color=palette[1]) p2 = plt.bar(inds, topk_direct, width, bottom=topk_indirect, linewidth=0, color=palette[0]) plt.ylabel('Effect', size=11) plt.title('Effects of top heads', fontsize=11) plt.xticks(inds, labels, size=10) plt.yticks(size=10) p3 = plt.axhline(data['mean_total_effect'], linestyle='--') plt.legend((p3, p2[0], p1[0]), ('Total', 'Direct', 'Indirect'), loc='upper right', fontsize=11, bbox_to_anchor=(.99, 0.90)) sns.despine() path = 'structural_attention/figures/stacked_bar_charts' if not os.path.exists(path): os.makedirs(path) plt.savefig(f'{path}/{source}_{model_version}_{filter}.pdf', format='pdf') plt.close() annot = False # Plot heatmap for direct and indirect effect for effect_type in ('indirect', 'direct'): if effect_type == 'indirect': mean_effect = mean_indirect_by_head else: mean_effect = mean_direct_by_head ax = sns.heatmap(mean_effect, rasterized=True, annot=annot, annot_kws={"size": 9}, fmt=".2f", square=True) ax.set(xlabel='Head', ylabel='Layer', title=f'Mean {effect_type.capitalize()} Effect') plt.figure(num=1, figsize=(7, 5)) path = f'structural_attention/figures/heat_maps_{effect_type}' if not os.path.exists(path): os.makedirs(path) plt.savefig(f'{path}/{source}_{model_version}_{filter}.pdf', format='pdf') plt.close() # Plot layer-level bar chart for indirect and direct effects for effect_type in ('indirect', 'direct'): if effect_type == 'indirect': mean_effect = mean_indirect_by_layer else: mean_effect = mean_direct_by_layer plt.figure(num=1, figsize=(5, 5)) ax = sns.barplot(x=mean_effect, y=list(range(n_layers)), orient="h", color="#4472C4") ax.set(ylabel='Layer', title=f'Mean {effect_type.capitalize()} Effect') path = f'structural_attention/figures/layer_{effect_type}' if not os.path.exists(path): os.makedirs(path) plt.savefig(f'{path}/{source}_{model_version}_{filter}.pdf', format='pdf') plt.close() # Plot combined heatmap and barchart for direct and indirect effects for do_sort in False, True: for effect_type in ('indirect', 'direct'): if effect_type == 'indirect': effect_head = mean_indirect_by_head effect_layer = mean_indirect_by_layer if do_sort: effect_head = -np.sort( -effect_head ) # Sort indirect effects within each layer in descending order else: if do_sort: continue effect_head = mean_direct_by_head effect_layer = mean_direct_by_layer fig = plt.figure(figsize=(3, 2.2)) if model_version == 'distilgpt2': ax1 = plt.subplot2grid((100, 85), (0, 0), colspan=62, rowspan=99) ax2 = plt.subplot2grid((100, 85), (32, 69), colspan=17, rowspan=35) elif model_version in ('gpt2', 'gpt2_random'): ax1 = plt.subplot2grid((100, 85), (0, 0), colspan=65, rowspan=99) ax2 = plt.subplot2grid((100, 85), (12, 70), colspan=15, rowspan=75) elif model_version == 'gpt2-medium': ax1 = plt.subplot2grid((100, 85), (0, 5), colspan=55, rowspan=99) ax2 = plt.subplot2grid((100, 85), (2, 64), colspan=17, rowspan=95) elif model_version == 'gpt2-large': ax1 = plt.subplot2grid((100, 85), (0, 5), colspan=55, rowspan=96) ax2 = plt.subplot2grid((100, 85), (0, 62), colspan=17, rowspan=97) elif model_version == 'gpt2-xl': ax1 = plt.subplot2grid((100, 85), (0, 5), colspan=55, rowspan=96) ax2 = plt.subplot2grid((100, 85), (0, 62), colspan=17, rowspan=97) heatmap = sns.heatmap(effect_head, center=0.0, ax=ax1, annot=annot, annot_kws={"size": 9}, fmt=".2f", square=True, cbar=False, linewidth=0.1, linecolor='#D0D0D0', cmap=LinearSegmentedColormap.from_list( 'rg', ["#F14100", "white", "#3D4FC4"], N=256)) plt.setp(heatmap.get_yticklabels(), fontsize=7) plt.setp(heatmap.get_xticklabels(), fontsize=7) heatmap.tick_params(axis='x', pad=1, length=2) heatmap.tick_params(axis='y', pad=1, length=2) heatmap.yaxis.labelpad = 2 heatmap.invert_yaxis() if model_version != 'gpt2-xl': for i, label in enumerate(heatmap.xaxis.get_ticklabels()): if i % 2 == 1: label.set_visible(False) for i, label in enumerate(heatmap.yaxis.get_ticklabels()): if i % 2 == 1: label.set_visible(False) if do_sort: heatmap.axes.get_xaxis().set_ticks([]) else: if model_version == 'gpt2-xl': every_nth = 2 for n, label in enumerate(ax1.xaxis.get_ticklabels()): if n % every_nth != 0: label.set_visible(False) for n, label in enumerate(ax1.yaxis.get_ticklabels()): if n % every_nth != 0: label.set_visible(False) # split axes of heatmap to put colorbar ax_divider = make_axes_locatable(ax1) if model_version in ('gpt2-large', 'gpt2-xl'): cax = ax_divider.append_axes('left', size='7%', pad='45%') else: cax = ax_divider.append_axes('left', size='7%', pad='33%') # # make colorbar for heatmap. # # Heatmap returns an axes obj but you need to get a mappable obj (get_children) cbar = colorbar(ax1.get_children()[0], cax=cax, orientation='vertical') cax.yaxis.set_ticks_position('left') cbar.solids.set_edgecolor("face") cbar.ax.tick_params(labelsize=7, length=4, pad=2) ax1.set_title(structure_to_title[source], size=6) ax1.set_xlabel('Head', size=6) ax1.set_ylabel('Layer', size=6) for _, spine in ax1.spines.items(): spine.set_visible(True) ax2.set_title(' Layer Effect', size=6) bp = sns.barplot(x=effect_layer, ax=ax2, y=list(range(n_layers)), color="#3D4FC4", orient="h") plt.setp(bp.get_xticklabels(), fontsize=7) bp.tick_params(axis='x', pad=1, length=3) ax2.invert_yaxis() ax2.set_yticklabels([]) ax2.spines['top'].set_visible(False) ax2.spines['right'].set_visible(False) ax2.spines['left'].set_visible(False) ax2.xaxis.set_ticks_position('bottom') ax2.axvline(0, linewidth=.85, color='black') path = f'structural_attention/figures/heat_maps_with_bar_{effect_type}{"_sorted" if do_sort else ""}' if not os.path.exists(path): os.makedirs(path) fname = f'{path}/{source}_{model_version}_{filter}.pdf' plt.savefig(fname, format='pdf', bbox_inches='tight') plt.close()
import matplotlib.pyplot as plt plt.rcParams["text.usetex"]=False fig = plt.figure(1, figsize=(6, 3)) ax1 = fig.add_subplot(121) im1 = ax1.imshow([[1,2],[3,4]]) cb1 = plt.colorbar(im1) cb1.ax.set_yticks([1, 3]) ax1.set_title("Original MPL's colorbar w/\nset_yticks([1,3])", size=10) from mpl_toolkits.axes_grid1.colorbar import colorbar ax2 = fig.add_subplot(122) im2 = ax2.imshow([[1,2],[3,4]]) cb2 = colorbar(im2) cb2.ax.set_yticks([1, 3]) ax2.set_title("AxesGrid's colorbar w/\nset_yticks([1,3])", size=10) plt.show()