def make_posemap(img, pose, video_num, img_size, f_num, gauss_size): posemap = pose_map(pose, img_size, gauss_size) posemap = np.uint8(255 * posemap) posemap = cv2.applyColorMap(posemap, cv2.COLORMAP_JET) posemap = cv2.cvtColor(posemap, cv2.COLOR_BGR2RGB) posemap = posemap / 255 s_img = posemap * 1.0 + img fig = plt.figure(figsize=(16, 10)) gs = GridSpec(4, 5, left=0.13, right=0.9) gs.update(wspace=-0.01) gs_1 = GridSpecFromSubplotSpec(nrows=4, ncols=3, subplot_spec=gs[0:4, 0:3]) fig.add_subplot(gs_1[:, :]) delete_line() plt.imshow(s_img) gs_2 = GridSpecFromSubplotSpec(nrows=2, ncols=2, subplot_spec=gs[0:2, 3:5]) fig.add_subplot(gs_2[:, :]) delete_line() plt.imshow(img) gs_3 = GridSpecFromSubplotSpec(nrows=2, ncols=2, subplot_spec=gs[2:4, 3:5]) fig.add_subplot(gs_3[:, :]) delete_line() plt.imshow(posemap, cmap='jet') plt.clim(0, 1) plt.colorbar() SAVE_PATH = "../../../demo/images/posemap" if not os.path.exists(os.path.join(SAVE_PATH, "posemap_" + video_num)): os.makedirs(os.path.join(SAVE_PATH, "posemap_" + video_num)) plt.savefig( os.path.join(SAVE_PATH, "posemap_" + video_num, str(f_num).zfill(5) + ".png")) plt.close()
def plot_all_measures(data, meta, kind='mouse', title=''): """ meta should have: 'n_iters', 'n_pc', 'f_range', 'subsetsizes', 'pc_range' kind: 'mouse' (includes sum & nonsum PSD data), 'mouse_old', or 'sim' (ising or shuffle) plot layout: [ ES ] [ subset size vs ES exponent ] [ correlation ] [ PSD ] [ subset size vs PSD exponent ] """ subsetsizes = meta['subsetsizes'] n_pc = meta['n_pc'] n = len(subsetsizes) dsuffix = '1' if kind == 'mouse' else '' ## Plot style fig=plt.figure(figsize=(19,8)) subset_fractions = np.linspace(0,1,n) cmap = plt.cm.cool(subset_fractions) plt.rcParams["axes.prop_cycle"] = plt.cycler("color", cmap) gs = GridSpec(2,3, width_ratios=[1,1,4], wspace=.8) # gs1 = GridSpecFromSubplotSpec(2, 2, subplot_spec=gs[:,:2], hspace=0.5, wspace=0.3) gs2 = GridSpecFromSubplotSpec(2, 3, subplot_spec=gs[:,2]) ## Spectra for (ip, spec), labs in zip(enumerate(['eigs', 'pows']), [['log ES', 'PC dimension', 'Variance'], ['log PSD', 'Frequency (Hz)', 'Power']]): ax = fig.add_subplot(gs1[ip,0]) for i, n_i in enumerate(subsetsizes): if isinstance(n_pc, int) and n_pc < n_i: n_pc_curr = n_pc elif isinstance(n_pc, float): n_pc_curr = int(n_pc*n_i) xvals = np.arange(1,n_pc_curr+1)/n_pc_curr if spec == 'eigs'\ else np.arange(0,61/120, 1/120) # Eigenspectrum ax.plot(xvals, data[spec][i]) #KEEP THIS LINE: proportion of PCs logaxes() pltlabel(*labs) ## Exponent distributions for (ip, exp), labs in zip(enumerate(['pca_m', 'ft_m'+dsuffix]), [['ES exponent \n at each subset size', '', 'Exponent'], ['PSD exponent \n at each subset size', '', 'Exponent']]): ax = fig.add_subplot(gs1[ip,1]) exp_plot(data, exp, ax=ax) pltlabel(*labs) ## colorbar for first two cols cax = fig.add_axes([0.45, 0.3, 0.01, 0.35]) hexes = [mpl.colors.rgb2hex(c) for c in cmap] # VERY hacky way of getting hex values of cmap cool solo_colorbar([hexes[0], hexes[-1]], subset_fractions, 'fraction sampled', orientation='vertical', cax=cax) ## Interspec Correlation ax = fig.add_subplot(gs2[:]) corr_plot(data['pearson_corr'+dsuffix], 'Pearson', p_vals=data['pearson_p'+dsuffix], ax=ax) plt.suptitle(title) plt.tight_layout()
def kriging_plot(dataset, xy, v, param, selected_model, save_name=None, front_color="rb", title=None, show=True): fig = plt.figure(figsize=(9, 8)) gs_master = GridSpec(nrows=1, ncols=2, width_ratios=[8, 1]) gs_1 = GridSpecFromSubplotSpec(nrows=1, ncols=1, subplot_spec=gs_master[0, 0]) ax = fig.add_subplot(gs_1[:, :]) gs_2 = GridSpecFromSubplotSpec(nrows=1, ncols=1, subplot_spec=gs_master[0, 1]) ax_c = fig.add_subplot(gs_2[:, :]) for i in dataset["back"].keys(): poly = plt.Polygon(dataset["back"][i], fill=False) ax.add_patch(poly) if front_color == "rb": color_dict, color_bar, min_y, max_y, dy = rb(dataset["data"], dataset["double"]) else: print("???") sys.exit() for i in dataset["front"].keys(): poly = plt.Polygon(dataset["front"][i], fc=color_dict[i]) ax.add_patch(poly) x_back = [x for i in dataset["back"].keys() for x, _ in dataset["back"][i]] y_back = [y for i in dataset["back"].keys() for _, y in dataset["back"][i]] xmin = min(x_back) xmax = max(x_back) ymin = min(y_back) ymax = max(y_back) ax.set_xlim([xmin, xmax]) ax.set_ylim([ymin, ymax]) if title: ax.set_title(title) for i, c in zip(np.linspace(min_y, max_y, 256), color_bar): poly = plt.Polygon(((0, i), (1, i), (1, i + dy), (0, i + dy)), fc=c) ax_c.add_patch(poly) ax_c.set_xlim([0, 1]) ax_c.tick_params(labelbottom=False) ax_c.set_ylim([min_y, max_y]) if save_name: plt.savefig(save_name) if show: plt.show() return
def heatmap(dataset, save_name=None, front_color="rb", back_color="k", title=None, show=True, school=False): fig = plt.figure(figsize=(9,8)) gs_master = GridSpec(nrows=1, ncols=2, width_ratios=[8, 1]) gs_1 = GridSpecFromSubplotSpec(nrows=1, ncols=1, subplot_spec=gs_master[0, 0]) ax = fig.add_subplot(gs_1[:, :]) gs_2 = GridSpecFromSubplotSpec(nrows=1, ncols=1, subplot_spec=gs_master[0, 1]) ax_c = fig.add_subplot(gs_2[:, :]) for i in dataset["back"].keys(): poly = plt.Polygon(dataset["back"][i], fc=back_color) ax.add_patch(poly) if front_color == "rb": color_dict, color_bar, min_y, max_y, dy = rb(dataset["data"], dataset["double"]) else: print("???") sys.exit() for i in dataset["front"].keys(): poly = plt.Polygon(dataset["front"][i], fc=color_dict[i]) ax.add_patch(poly) x_back = [x for i in dataset["back"].keys() for x,_ in dataset["back"][i]] y_back = [y for i in dataset["back"].keys() for _,y in dataset["back"][i]] xmin = min(x_back) xmax = max(x_back) ymin = min(y_back) ymax = max(y_back) ax.set_xlim([xmin,xmax]) ax.set_ylim([ymin,ymax]) if title: ax.set_title(title) for i,c in zip(np.linspace(min_y, max_y, 256), color_bar): poly = plt.Polygon(((0,i),(1,i),(1,i+dy),(0,i+dy)), fc=c) ax_c.add_patch(poly) ax_c.set_xlim([0,1]) ax_c.tick_params(labelbottom=False) ax_c.set_ylim([min_y, max_y]) if school: sf2 = load_toyama_second_pos().values() x = [] y = [] for i in sf2: x.append(i[0]) y.append(i[1]) ax.plot(x, y, marker="o", linestyle="None") if save_name: plt.savefig(save_name) if show: plt.show()
def density_projection(dens_x): from ofdft_ml.statslib.pca import PrincipalComponentAnalysis from matplotlib.gridspec import GridSpec, GridSpecFromSubplotSpec pca = PrincipalComponentAnalysis(8) dens_t = pca.fit_transform(dens_x) tr_mat = pca.tr_mat_ # plots ## density data distribution dens_fig = plt.figure(0, figsize=(10, 5)) dens_gs = GridSpec(1, 2) ### scatter plot gs_0 = GridSpecFromSubplotSpec(1, 1, dens_gs[0]) ax_0 = dens_fig.add_subplot(gs_0[0]) ax_0.scatter(dens_t[:, 0], dens_t[:, 1]) ax_0.set_xlabel('principal #1') ax_0.set_ylabel('principal #2') ### histogram plot _, bins_p0 = np.histogram(dens_t[:, 0], bins=20, density=False) x_min, x_max = np.amin(dens_t[:, 0]), np.amax(dens_t[:, 0]) gs_1 = GridSpecFromSubplotSpec(4, 2, dens_gs[1], wspace=0.1) dens_axes = [dens_fig.add_subplot(gs_1[i, j]) for i in [0, 1, 2, 3] for j in [0, 1]] for i in range(8): n, bins_edge, patches = dens_axes[i].hist(dens_t[:, i], bins=bins_p0) y_max = np.amax(n) dens_axes[i].xaxis.set_major_locator(FixedLocator([x_min, x_max])) dens_axes[i].xaxis.set_major_formatter(NullFormatter()) dens_axes[i].yaxis.set_major_formatter(NullFormatter()) dens_axes[i].set_xlim([x_min-0.5, x_max+0.5]) dens_axes[i].set_ylim([0, y_max]) dens_axes[6].xaxis.set_major_formatter(FixedFormatter(['%.1f' %(x_min), '%.1f' %(x_max)])) dens_axes[7].xaxis.set_major_formatter(FixedFormatter(['%.1f' %(x_min), '%.1f' %(x_max)])) dens_fig.text(0.7, 0.04, 'range') dens_fig.text(0.51, 0.5, 'fraction', va='center', rotation='vertical') dens_fig.savefig('principal_components.png') ## transfer matrix plot X = np.linspace(0, 1, dens_x.shape[1]) mat_fig = plt.figure(1, figsize=(5, 5)) mat_gs = GridSpec(2, 2, wspace=0.2) mat_axes = [mat_fig.add_subplot(mat_gs[i, j]) for i in [0, 1] for j in [0, 1]] for i in range(4): mat_axes[i].plot(X, tr_mat[:, i], label='#%s' %(i)) vec_min, vec_max = np.amin(tr_mat[:, i]), np.amax(tr_mat[:, i]) mat_axes[i].legend() mat_axes[i].xaxis.set_major_locator(FixedLocator([0, 1])) mat_axes[i].yaxis.set_major_locator(FixedLocator([vec_min, vec_max])) mat_axes[i].xaxis.set_major_formatter(NullFormatter()) mat_axes[i].yaxis.set_major_formatter(FixedFormatter(['%.2f' %(vec_min), '%.2f' %(vec_max)])) mat_axes[2].xaxis.set_major_formatter(FixedFormatter(['0', '1'])) mat_axes[3].xaxis.set_major_formatter(FixedFormatter(['0', '1'])) mat_fig.savefig('transfer_matrix.png') return 0
def annotated_heatmap(ax, data, colors_x, colors_y, annotate=True, cmap='binary', show_ylabel=True, annotate_size=LEGEND_TEXT_SIZE): # This is the function to make annotated heatmaps ax.axis('off') _gs = GridSpecFromSubplotSpec(2, 2, subplot_spec=ax, wspace=0, hspace=0, height_ratios=[49, 1], width_ratios=[1, 49]) ax_m = ax.figure.add_subplot(_gs[0, 1]) ax_v = ax.figure.add_subplot(_gs[0, 0]) ax_h = ax.figure.add_subplot(_gs[1, 1]) normed = data / data.sum(axis=0) normed.fillna(0, inplace=True) sns.heatmap(normed, annot=data if annotate else False, fmt='d', ax=ax_m, square=False, cmap=cmap, cbar=False, xticklabels=1, yticklabels=1, annot_kws=dict(fontsize=annotate_size)) for k, color in enumerate(colors_x): ax_h.barh(0, 1, left=k, color=color, height=1) for k, color in enumerate(colors_y): ax_v.bar(0, 1, bottom=k, color=color, width=1) transfer_ticks(ax_m, ax_h, which='x', rotation=90) transfer_ticks(ax_m, ax_v, which='y') fix_spines(ax_h, [], keep_ticks=True) fix_spines(ax_v, [], keep_ticks=True) ax_h.set_xlabel('Reference') if show_ylabel: ax_v.set_ylabel('Prediction') return ax
def set_layout(self): fig = plt.figure() self.fig = fig plt.subplots_adjust( left=0.12, # pos. of subplots left border bottom=0.15, # pos. of subplots bottom border right=0.88, # pos. of subplots right border top=0.9, # pos. of subplots top border wspace=0.6, # horizontal space between supblots hspace=0.6, # vertical space between subplots ) gs00 = GridSpec(nrows=1, ncols=1) gsA = GridSpecFromSubplotSpec(2, 3, subplot_spec=gs00[0, 0], wspace=0.1, hspace=0.1) axA1 = fig.add_subplot(gsA[:, 0]) axA2 = fig.add_subplot(gsA[0, 1:]) axA3 = fig.add_subplot(gsA[1, 1:]) self.subfig_1 = [axA1] self.subfig_2 = [axA2, axA3]
def plot_slides(self, coronal: int, sagittal: int, ss: SubplotSpec = None, fig: Any = None, return_figure: Any = False) -> Any: if self.is_label and self.reference: return self.colored.plot_slides(coronal=coronal, sagittal=sagittal, contour=False, ss=ss, fig=fig, return_figure=return_figure) else: if fig is None: fig = plt.gcf() if ss is None: ss = plt.GridSpec(1, 1)[0] if return_figure: fig.clear() gs = GridSpecFromSubplotSpec(1, 2, subplot_spec=ss) ax = fig.add_subplot(gs[0]) ax.imshow(self[coronal, :, :], cmap="gray") ax.axvline(sagittal, c='y', lw=1) ax = fig.add_subplot(gs[1]) ax.imshow(self[:, :, sagittal].T, cmap="gray") ax.axvline(coronal, c='y', lw=1) if return_figure: return fig
def plot_image_grid(self, cell, metric_name, metric): imgs = metric['data'] imgs = np.clip(imgs, 0., 1.) n_images = len(imgs) inner_grid_width = int(np.sqrt(n_images)) inner_grid = GridSpecFromSubplotSpec(inner_grid_width, inner_grid_width, cell, wspace=0.1, hspace=0.1) is_first_one = True for i in range(n_images): inner_ax = plt.subplot(inner_grid[i]) if is_first_one: inner_ax.set_title(metric_name) is_first_one = False if imgs.ndim == 4: inner_ax.imshow(imgs[i, :, :, :], interpolation='none', vmin=0.0, vmax=1.0) else: inner_ax.imshow(imgs[i, :, :], cmap='gray', interpolation='none', vmin=0.0, vmax=1.0) inner_ax.axis('off')
def plot_lda_topics(documents, nrows, ncols, with_colorbar=True, topic_mixtures=None, cmap='Viridis', dpi=160): fig = plt.figure() gs = GridSpec(nrows, ncols) vmin, vmax = (0, documents.max()) for i in range(nrows): for j in range(ncols): index = i * ncols + j gsi = GridSpecFromSubplotSpec(6, 5, subplot_spec=gs[i, j]) _document_with_topic(fig, gsi, index, documents[index], topic_mixture=topic_mixtures[index], vmin=vmin, vmax=vmax) return fig
def plot(self, **pca_plotting_kwargs): if not self.has_been_fit: self.fit() gs_x = 18 gs_y = 12 ax = None if 'ax' not in pca_plotting_kwargs \ else pca_plotting_kwargs['ax'] if ax is None: fig, ax = plt.subplots(1, 1, figsize=(18, 8)) gs = GridSpec(gs_x, gs_y) else: gs = GridSpecFromSubplotSpec(gs_x, gs_y, ax.get_subplotspec()) ax_scores = plt.subplot(gs[5:10, :2]) ax_scores.set_xlabel("Feature Importance") ax_scores.set_ylabel("Density Estimate") if 'show_vectors' not in pca_plotting_kwargs: pca_plotting_kwargs['show_vectors'] = True ax_pca = plt.subplot(gs[:, 2:]) pca_plotting_kwargs['ax'] = ax_pca self.plot_scores(ax=ax_scores) pcaviz = self.do_pca(**pca_plotting_kwargs) plt.tight_layout() return pcaviz
def _draw_MR(self, p, dp=10, subplot_spec=None): """Draw the MR curve with dp % variation in the parameter p.""" u = constants p = p.split()[0] parameter_variation = (p, dp/100.0) if subplot_spec: gs = GridSpecFromSubplotSpec(1, 2, subplot_spec=subplot_spec) else: gs = GridSpec(1, 2) plt.figure(figsize=(10, 5)) plt.subplot(gs[0]) derivatives = self.derivatives._asdict() ip = self.param_names.index(parameter_variation[0]) dp_ = parameter_variation[1]*self.params[ip] dR = derivatives['R'][:, ip] * dp_ dM = derivatives['M'][:, ip] * dp_ plt.plot(self.R/u.km, self.M/u.M0) error_ellipse(self.R/u.km, self.M/u.M0, xerr=dR/u.km, yerr=dM/u.M0, alpha=0.2) plt.xlabel('R [km]') plt.ylabel('M [solar_mass]') plt.subplot(gs[1]) dLambda = self.dLambda[:, ip] * dp plt.plot(self.Lambda, self.M/u.M0) error_ellipse(self.Lambda, self.M/u.M0, xerr=dLambda, yerr=dM/u.M0, alpha=0.2) plt.xlabel('Lambda') plt.ylabel('M [solar_mass]')
def barplot(ax, data, colors, colors_bar, labels, xlabel): ax.axis('off') _gs = GridSpecFromSubplotSpec(1, 2, subplot_spec=ax, wspace=0, hspace=0, width_ratios=[1, 49]) ax_m = ax.figure.add_subplot(_gs[0, 1]) ax_v = ax.figure.add_subplot(_gs[0, 0]) L = len(labels) y = np.arange(L) ax_m.barh(y, data, color=colors, height=0.9, zorder=3) transfer_ticks(ax_m, ax_v, which='y') for k, color in enumerate(colors_bar): ax_v.bar(0, 1, bottom=k-0.5, color=color, width=1) ax_v.set_yticks(y) ax_v.set_yticklabels(labels) ax_m.set_xlabel(xlabel) ax_m.grid(True, which='major', zorder=0) ax_m.set_ylim(0-0.5, L-0.5) ax_v.set_ylim(*ax_m.get_ylim()) fix_spines(ax_m, ['left'], keep_ticks=True) fix_spines(ax_v, [], keep_ticks=True) ax_m.invert_yaxis() ax_v.invert_yaxis() return ax
def marginal_heatmap(ax, data_m, data_x, data_y, colors_x, colors_y, colors_x_bar, colors_y_bar, marg_xlabel='Samples per class', marg_ylabel='Pos Pred Value', cmap='binary', annotate=True, annotate_size=LEGEND_TEXT_SIZE): # This is the function for figure 1 ax.axis('off') _gs = GridSpecFromSubplotSpec(4, 4, subplot_spec=ax, wspace=0.01, hspace=0.01, height_ratios=[25, 1, 49, 1], width_ratios=[1, 49, 1, 25]) ax_m = ax.figure.add_subplot(_gs[2, 1]) ax_h1 = ax.figure.add_subplot(_gs[3, 1]) ax_h2 = ax.figure.add_subplot(_gs[1, 1], sharex=ax_m) ax_x = ax.figure.add_subplot(_gs[0, 1], sharex=ax_m) ax_v1 = ax.figure.add_subplot(_gs[2, 0]) ax_v2 = ax.figure.add_subplot(_gs[2, 2], sharey=ax_m) ax_y = ax.figure.add_subplot(_gs[2, 3], sharey=ax_m) normed = data_m / data_m.sum(axis=0) normed.fillna(0, inplace=True) sns.heatmap(normed, annot=data_m if annotate else False, fmt='d', ax=ax_m, square=False, cmap=cmap, cbar=False, xticklabels=1, yticklabels=1, annot_kws=dict(fontsize=annotate_size)) ax_x.bar(np.arange(data_x.shape[0]) + 0.5, data_x, width=0.9, color=colors_x) ax_y.barh(np.arange(data_y.shape[0]) + 0.5, data_y, height=0.9, color=colors_y) for k, color in enumerate(colors_x_bar): ax_h1.barh(0, 1, left=k, color=color, height=1) ax_h2.barh(0, 1, left=k, color=color, height=1) for k, color in enumerate(colors_y_bar): ax_v1.bar(0, 1, bottom=k, color=color, width=1) ax_v2.bar(0, 1, bottom=k, color=color, width=1) for (i, ci), (j, cj) in product(enumerate(colors_x_bar), enumerate(colors_y_bar)): if ci != cj: continue patch = mpatches.Rectangle([i, j], 1, 1, color=ci, alpha=0.2, lw=0) ax_m.add_artist(patch) transfer_ticks(ax_m, ax_h1, which='x', rotation=90) transfer_ticks(ax_m, ax_v1, which='y') fix_spines(ax_h1, [], keep_ticks=True) fix_spines(ax_v1, [], keep_ticks=True) fix_spines(ax_h2, [], keep_ticks=False) fix_spines(ax_v2, [], keep_ticks=False) fix_spines(ax_x, ['left'], keep_ticks=False) fix_spines(ax_y, ['bottom'], keep_ticks=False) ax_h1.set_xlabel('Reference') ax_v1.set_ylabel('Prediction') ax_x.set_ylabel(marg_xlabel) ax_y.set_xlabel(marg_ylabel) return ax
def make_hand_image(img, l_img, r_img, pose, video_num, f_num, cutout_size): fig = plt.figure(figsize=(16, 10)) gs = GridSpec(4, 5, left=0.06, right=1.2) gs.update(wspace=0.2) gs_1 = GridSpecFromSubplotSpec(nrows=4, ncols=3, subplot_spec=gs[0:4, 0:3]) fig.add_subplot(gs_1[:, :]) ax = plt.axes() r = patches.Rectangle( xy=(int((pose[0]) * 224 / 1080) - 87 - int(cutout_size * 224 / 540), int((pose[1]) * 224 / 1080) - int(cutout_size * 224 / 540)), width=int(cutout_size * 2 * 224 / 540), height=int(cutout_size * 2 * 224 / 540), ec='#AD13E5', linewidth='4.0', fill=False) l = patches.Rectangle( xy=(int((pose[2]) * 224 / 1080) - 87 - int(cutout_size * 224 / 540), int((pose[3]) * 224 / 1080) - int(cutout_size * 224 / 540)), width=int(cutout_size * 2 * 224 / 540), height=int(cutout_size * 2 * 224 / 540), ec='#AD13E5', linewidth='4.0', fill=False) ax.add_patch(r) ax.add_patch(l) delete_line() plt.imshow(img) gs_2 = GridSpecFromSubplotSpec(nrows=2, ncols=2, subplot_spec=gs[1:3, 0:1]) fig.add_subplot(gs_2[:, :]) delete_line() plt.imshow(l_img) gs_3 = GridSpecFromSubplotSpec(nrows=2, ncols=2, subplot_spec=gs[1:3, 3:4]) fig.add_subplot(gs_3[:, :]) delete_line() plt.imshow(r_img) # Make the directory if it doesn't exist. SAVE_PATH = "../../../demo/images/hand" if not os.path.exists(os.path.join(SAVE_PATH, "hand_" + video_num)): os.makedirs(os.path.join(SAVE_PATH, "hand_" + video_num)) plt.savefig( os.path.join(SAVE_PATH, "hand_" + video_num, str(f_num).zfill(5) + ".png")) plt.close()
def plot(self, subspec): gs = GridSpecFromSubplotSpec(1, self.nchildren, width_ratios=self.ratios, subplot_spec=subspec, **self.spacing) for col in range(self.nchildren): child = self.children.get(col) if child is not None: child.plot(gs[0, col])
def plot(self, subspec): gs = GridSpecFromSubplotSpec(self.nchildren, 1, height_ratios=self.ratios, subplot_spec=subspec, **self.spacing) for row in range(self.nchildren): child = self.children.get(row) if child is not None: child.plot(gs[row, 0])
def ini_inner_grids(self): d_inner_grids = dict() for host in self.hosts: out_coor = self.d_outer_coor[host] d_inner_grids[host] = GridSpecFromSubplotSpec( 2, 1, subplot_spec=self.outer_grid[out_coor], wspace=self.inner_wspace, hspace=self.inner_hspace) return d_inner_grids
def __init__(self, data, X=None, Y=None): self.data = data self.X = np.arange(self.data.shape[1]) if X is None else X self.Y = np.arange(self.data.shape[0]) if Y is None else Y vmin = np.min(self.data) vmax = np.max(self.data) # Create and displays the figure object. self.fig = plt.figure(figsize=(8,8), frameon=True, tight_layout=True) # Create grid for layout grid = GridSpec(4,4) self.ax_main = self.fig.add_subplot(grid[0:3,0:3]) #self.ax_main.autoscale(enable=True, tight=True) self.ax_main.autoscale(enable=False) self.ax_main.set_xlim(np.min(self.X), np.max(self.X)) self.ax_main.set_ylim(np.min(self.Y), np.max(self.Y)) # Use 'auto' to adjust the aspect ratio to fill the figure window, 'equal' to fix it. self.ax_main.set_aspect('auto', adjustable='box-forced') self.ax_h = self.fig.add_subplot(grid[3,0:3], sharex=self.ax_main) self.ax_h.set_axis_bgcolor('0.8') self.ax_h.autoscale(False) self.ax_h.set_ylim(vmin, vmax) self.ax_v = self.fig.add_subplot(grid[0:3,3], sharey=self.ax_main) self.ax_v.set_axis_bgcolor('0.8') self.ax_v.autoscale(False) self.ax_v.set_xlim(vmax, vmin) self.prev_pt = None self.ax_cb = None self.cursor = MultiCursor(self.fig.canvas, (self.ax_main, self.ax_h, self.ax_v), horizOn=True, vertOn=True, color='white', ls='--', lw=1) self.fig.canvas.mpl_connect('button_press_event', self._plot_clicked) # Setup control buttons btn_grid = GridSpecFromSubplotSpec(4, 1, subplot_spec=grid[3,3]) self.btn_colorbar = Button(self.fig.add_subplot(btn_grid[2,0]), 'Colorbar') self.btn_colorbar.on_clicked(self._plot_colorbar) self.btn_reset = Button(self.fig.add_subplot(btn_grid[3,0]), 'Reset') self.btn_reset.on_clicked(self._plot_reset) # Setup color range sliders self.slider_vmin = Slider(self.fig.add_subplot(btn_grid[0,0]), "vmin", vmin, vmax, valinit=vmin) self.slider_vmin.on_changed(self._plot_rangechanged) self.slider_vmax = Slider(self.fig.add_subplot(btn_grid[1,0]), "vmax", vmin, vmax, valinit=vmax, slidermin=self.slider_vmin) self.slider_vmax.on_changed(self._plot_rangechanged) self.slider_vmin.slidermax = self.slider_vmax self.fig.canvas.draw()
def make_attention_map(img,heatmap,video_num,f_num,save_name): #attention map heatmap = heatmap.numpy() heatmap = np.average(heatmap,axis=0) heatmap = util.normalize_heatmap(heatmap) # 元の画像と同じサイズになるようにヒートマップのサイズを変更 heatmap = cv2.resize(heatmap, (img.shape[1], img.shape[0])) heatmap = np.uint8(255 * heatmap) heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET) heatmap = cv2.cvtColor(heatmap, cv2.COLOR_BGR2RGB) heatmap=heatmap/255 # heatmap * image s_img = heatmap * 0.7 + img #plt fig=plt.figure(figsize=(16,10)) gs = GridSpec(4,5,left=0.13,right=0.9) gs.update(wspace=-0.01) gs_1 = GridSpecFromSubplotSpec(nrows=4, ncols=3, subplot_spec=gs[0:4, 0:3]) fig.add_subplot(gs_1[:, :]) util.delete_line() plt.imshow(s_img) gs_2 = GridSpecFromSubplotSpec(nrows=2, ncols=2, subplot_spec=gs[0:2, 3:5]) fig.add_subplot(gs_2[:,:]) util.delete_line() plt.imshow(img) gs_3 = GridSpecFromSubplotSpec(nrows=2, ncols=2, subplot_spec=gs[2:4, 3:5]) fig.add_subplot(gs_3[:,:]) util.delete_line() plt.imshow(heatmap,cmap='jet') plt.clim(0,1) plt.colorbar() # Make the directory if it doesn't exist. SAVE_PATH = "../../../demo/images/attention" if not os.path.exists(os.path.join(SAVE_PATH,save_name+"_"+video_num)): os.makedirs(os.path.join(SAVE_PATH,save_name+"_"+video_num)) plt.savefig(os.path.join(SAVE_PATH,save_name+"_"+video_num,str(f_num).zfill(5)+".png")) plt.close()
def visualize_seir_computation(results: pd.DataFrame, compartments: List[Any], show_individual_compartments=False): """Visualizes the SEIR computation""" if show_individual_compartments: w, h = plt.figaspect(2) fig = plt.figure(figsize=(w, h)) gs = GridSpec(1, 2, fig, width_ratios=[5, 1]) gsp = GridSpecFromSubplotSpec(4, 1, gs[0], hspace=0) ax = fig.add_subplot(gsp[0]) _plot_compartment_subplot(ax, 'susceptible', results) ax = fig.add_subplot(gsp[1], sharex=ax) _plot_compartment_subplot(ax, 'exposed', results) ax = fig.add_subplot(gsp[2], sharex=ax) _plot_compartment_subplot(ax, 'infected (active)', results) ax = fig.add_subplot(gsp[3], sharex=ax) lines = _plot_compartment_subplot(ax, 'deaths', results) ax.yaxis.set_major_formatter(EngFormatter()) ax = fig.add_subplot(gs[1]) ax.legend(lines, compartments) ax.set_xticks(()) ax.set_yticks(()) ax.set_axis_off() fig.tight_layout() fig = plt.figure() ax = fig.add_subplot(111) ax.plot(results['time'], results['exposed'], label='exposed') ax.plot(results['time'], results['infected (active)'], label='infected (active)') ax.plot(results['time'], results['hospitalized (active)'], label='hospitalized (active)') ax.plot(results['time'], results['in ICU'], label='in ICU') ax.plot(results['time'], results['deaths'], label='deaths', color='k') ax.legend() ax.set_xlabel('time (days)') ax.set_ylabel('# of people') ax.yaxis.set_major_formatter(EngFormatter()) fig.tight_layout() plt.show()
def subtype_combined_barplot(ax, data, colors, colors_bar, labels, bar_labels, xlabel, bar_text=True, show_ylabels=True): ax.axis('off') _gs = GridSpecFromSubplotSpec(1, 2, subplot_spec=ax, wspace=0, hspace=0, width_ratios=[1, 49]) ax_m = ax.figure.add_subplot(_gs[0, 1]) ax_v = ax.figure.add_subplot(_gs[0, 0]) L = len(bar_labels) y = np.arange(L) ax_m.barh(y, data, color=colors, height=0.9, zorder=3) transfer_ticks(ax_m, ax_v, which='y') for k, color in enumerate(colors_bar): ax_v.bar(0, 1, bottom=k-0.5, color=color, width=1) if bar_text: bars = ax_m.patches for k, (color, bar, label) in enumerate(zip(colors, bars, bar_labels)): bar_width = bar.get_width() lum = sns.utils.relative_luminance(color) text_color = ".15" if (lum > .308) or (bar_width < 0.05) else "w" t = ax_m.text(0.02, k, label, color=text_color, va='center', size=TICK_TEXT_SIZE, clip_on=True, wrap=True) if bar_width > 0.1: t.set_clip_path(bar) label_counts = pd.value_counts(labels).sort_index() ax_v.set_yticks(label_counts.cumsum() - 2) ax_v.set_yticklabels(label_counts.index) ax_m.set_xlabel(xlabel) if data.max() < 1.01: ax_m.set_xlim(0, 1.01) ax_m.set_xticks(np.arange(0, 1.1, 0.2)) ax_m.grid(True, which='major', zorder=0) ax_m.set_ylim(0-0.5, L-0.5) ax_v.set_ylim(*ax_m.get_ylim()) fix_spines(ax_m, ['left'], keep_ticks=True) fix_spines(ax_v, ['left'], keep_ticks=True) ax_m.invert_yaxis() ax_v.invert_yaxis() if not show_ylabels: ax_v.set_yticklabels([]) return ax
def set_layout(self): fig = plt.figure() self.fig = fig plt.subplots_adjust(left=0.13, bottom=0.08, right=0.88, top=0.93, wspace=.5, hspace=2.4) gs00 = GridSpec(nrows=11, ncols=1) gsA = GridSpecFromSubplotSpec(3, 3, subplot_spec=gs00[0:5, 0], wspace=0.07, hspace=0.07) axA1 = fig.add_subplot(gsA[1:, 0]) axA2 = fig.add_subplot(gsA[1:, 1:]) axB1 = fig.add_subplot(gsA[0, 0]) axB2 = fig.add_subplot(gsA[0, 1:]) self.subfig_1 = [axA1, axA2, axB1, axB2] gsC = GridSpecFromSubplotSpec(5, 1, subplot_spec=gs00[5:8, 0], wspace=0.1, hspace=1.) axC = fig.add_subplot(gsC[0:4, 0]) self.subfig_2 = axC gsD = GridSpecFromSubplotSpec(5, 1, subplot_spec=gs00[8:, 0], wspace=0.1, hspace=1.) axD = fig.add_subplot(gsD[0:4, 0]) self.subfig_3 = axD
def plot_slides(self, coronal: int, sagittal: int, contour: bool = False, ss: SubplotSpec = None, fig: Any = None, return_figure: bool = False) -> Any: if fig is None: fig = plt.gcf() if ss is None: ss = plt.GridSpec(1, 1)[0] if return_figure: fig.clear() gs = GridSpecFromSubplotSpec(1, 2, subplot_spec=ss) ax = fig.add_subplot(gs[0]) coronal_section = self[coronal, :, :] ax.imshow(coronal_section) ax.axvline(sagittal, c='y', lw=1) if contour: coronal_section = self.vol_data[coronal, :, :] for one_hot in one_hot_encoding(coronal_section): ith_contours = find_contours(one_hot, 0.5) for n_ith_contour in ith_contours: ax.plot(n_ith_contour[:, 1], n_ith_contour[:, 0], lw=0.8, color="w", zorder=1000) ax = fig.add_subplot(gs[1]) sagittal_section = self[:, :, sagittal] ax.imshow(np.transpose(sagittal_section, (1, 0, 2))) ax.axvline(coronal, c='y', lw=1) if contour: sagittal_section = self.vol_data[:, :, sagittal] for one_hot in one_hot_encoding(sagittal_section): ith_contours = find_contours(one_hot, 0.5) for n_ith_contour in ith_contours: ax.plot(n_ith_contour[:, 0], n_ith_contour[:, 1], lw=0.8, color="w", zorder=1000) if return_figure: return fig
def __call__(self, ax=None, title='', show_point_labels=False, show_vectors=True, show_vector_labels=True, markersize=10, legend=True): gs_x = 14 gs_y = 12 if ax is None: self.reduced_fig, ax = plt.subplots(1, 1, figsize=(25, 12)) gs = GridSpec(gs_x, gs_y) else: gs = GridSpecFromSubplotSpec(gs_x, gs_y, ax.get_subplotspec()) self.reduced_fig = plt.gcf() ax_components = plt.subplot(gs[:, :5]) ax_loading1 = plt.subplot(gs[:, 6:8]) ax_loading2 = plt.subplot(gs[:, 10:14]) # kwargs.update({'ax': ax_components}) self.plot_samples(show_point_labels=show_point_labels, title=title, show_vectors=show_vectors, show_vector_labels=show_vector_labels, markersize=markersize, legend=legend, ax=ax_components) self.plot_loadings(pc=self.x_pc, ax=ax_loading1) self.plot_loadings(pc=self.y_pc, ax=ax_loading2) sns.despine() self.reduced_fig.tight_layout() if self.DataModel is not None and not self.featurewise: self.plot_violins() return self
def plot(self, ax=None, n_cols=2): if ax is None: fig = plt.figure() ax = fig.add_subplot() else: fig = ax.figure pd_results_ = self.pd_results_ n_features = len(pd_results_) feature_names_ = self.feature_names_ n_cols = min(n_cols, n_features) n_rows = int(np.ceil(n_features / float(n_cols))) gs = GridSpecFromSubplotSpec(n_cols, n_rows, subplot_spec=ax.get_subplotspec()) axes = {} ax.set_subplotspec(gs[0]) ax.update_params() ax.set_position(ax.figbox) axes[feature_names_[0]] = ax for i in range(1, n_features): feature_name = feature_names_[i] axes[feature_name] = fig.add_subplot(gs[i]) artists = {} for feature_name, (avg_preds, values) in zip(feature_names_, pd_results_): cur_ax = axes[feature_name] artist = cur_ax.plot(values[0], avg_preds[0].ravel())[0] artists[feature_name] = artist cur_ax.set_xlabel(feature_name) self.axes_ = axes self.artists_ = artists self.figure_ = ax.get_figure() return self
def showKernel(model, layer, index_filter=-1, index_channel=-1, figsize=(25, 25)): # Mendapatkan weight / kernel weights = model.get_layer(layer).get_weights()[0] # Konfigurasi plotting fig = plt.figure(figsize=figsize) grid = GridSpec(nrows=weights.shape[3], ncols=1, figure=fig) nested_grid = [] # Menampilkan weights per kernel range_kernel = range(index_filter, index_filter + 1) if index_filter > -1 else range(weights.shape[3]) for i in range_kernel: nrows = int(np.ceil(weights.shape[2] / 6)) ncols = 6 nested_grid.append( GridSpecFromSubplotSpec(nrows=nrows, ncols=ncols, subplot_spec=grid[i])) range_channel = range(index_channel, index_channel + 1) if index_channel > -1 else range( weights.shape[2]) for j in range_channel: row_pos = int(np.ceil((j + 1) / ncols)) col_pos = int(j + 1 - (6 * (row_pos - 1))) ax = plt.Subplot(fig, nested_grid[i][row_pos - 1, col_pos - 1]) ax.imshow(weights[:, :, j, i], cmap='gray') ax.title.set_text(f'Kernel {i+1}, channel {j+1}') fig.add_subplot(ax) plt.xticks([]) plt.yticks([]) plt.show()
def plot(self, *, ax=None, n_cols=3, line_kw=None, contour_kw=None): """Plot partial dependence plots. Parameters ---------- ax : Matplotlib axes or array-like of Matplotlib axes, default=None - If a single axis is passed in, it is treated as a bounding axes and a grid of partial dependence plots will be drawn within these bounds. The `n_cols` parameter controls the number of columns in the grid. - If an array-like of axes are passed in, the partial dependence plots will be drawn directly into these axes. - If `None`, a figure and a bounding axes is created and treated as the single axes case. n_cols : int, default=3 The maximum number of columns in the grid plot. Only active when `ax` is a single axes or `None`. line_kw : dict, default=None Dict with keywords passed to the `matplotlib.pyplot.plot` call. For one-way partial dependence plots. contour_kw : dict, default=None Dict with keywords passed to the `matplotlib.pyplot.contourf` call for two-way partial dependence plots. Returns ------- display : :class:`~sklearn.inspection.PartialDependenceDisplay` """ check_matplotlib_support("plot_partial_dependence") import matplotlib.pyplot as plt # noqa from matplotlib.gridspec import GridSpecFromSubplotSpec # noqa if line_kw is None: line_kw = {} if contour_kw is None: contour_kw = {} if ax is None: _, ax = plt.subplots() default_contour_kws = {"alpha": 0.75} contour_kw = {**default_contour_kws, **contour_kw} default_line_kws = { "color": "C0", "label": "average" if self.kind == "both" else None, } line_kw = {**default_line_kws, **line_kw} individual_line_kw = line_kw.copy() del individual_line_kw["label"] if self.kind == "individual" or self.kind == "both": individual_line_kw["alpha"] = 0.3 individual_line_kw["linewidth"] = 0.5 n_features = len(self.features) if self.kind in ("individual", "both"): n_ice_lines = self._get_sample_count(len(self.pd_results[0].individual[0])) if self.kind == "individual": n_lines = n_ice_lines else: n_lines = n_ice_lines + 1 else: n_ice_lines = 0 n_lines = 1 if isinstance(ax, plt.Axes): # If ax was set off, it has most likely been set to off # by a previous call to plot. if not ax.axison: raise ValueError( "The ax was already used in another plot " "function, please set ax=display.axes_ " "instead" ) ax.set_axis_off() self.bounding_ax_ = ax self.figure_ = ax.figure n_cols = min(n_cols, n_features) n_rows = int(np.ceil(n_features / float(n_cols))) self.axes_ = np.empty((n_rows, n_cols), dtype=object) if self.kind == "average": self.lines_ = np.empty((n_rows, n_cols), dtype=object) else: self.lines_ = np.empty((n_rows, n_cols, n_lines), dtype=object) self.contours_ = np.empty((n_rows, n_cols), dtype=object) axes_ravel = self.axes_.ravel() gs = GridSpecFromSubplotSpec( n_rows, n_cols, subplot_spec=ax.get_subplotspec() ) for i, spec in zip(range(n_features), gs): axes_ravel[i] = self.figure_.add_subplot(spec) else: # array-like ax = np.asarray(ax, dtype=object) if ax.size != n_features: raise ValueError( "Expected ax to have {} axes, got {}".format(n_features, ax.size) ) if ax.ndim == 2: n_cols = ax.shape[1] else: n_cols = None self.bounding_ax_ = None self.figure_ = ax.ravel()[0].figure self.axes_ = ax if self.kind == "average": self.lines_ = np.empty_like(ax, dtype=object) else: self.lines_ = np.empty(ax.shape + (n_lines,), dtype=object) self.contours_ = np.empty_like(ax, dtype=object) # create contour levels for two-way plots if 2 in self.pdp_lim: Z_level = np.linspace(*self.pdp_lim[2], num=8) self.deciles_vlines_ = np.empty_like(self.axes_, dtype=object) self.deciles_hlines_ = np.empty_like(self.axes_, dtype=object) for pd_plot_idx, (axi, feature_idx, pd_result) in enumerate( zip(self.axes_.ravel(), self.features, self.pd_results) ): avg_preds = None preds = None feature_values = pd_result["values"] if self.kind == "individual": preds = pd_result.individual elif self.kind == "average": avg_preds = pd_result.average else: # kind='both' avg_preds = pd_result.average preds = pd_result.individual if len(feature_values) == 1: self._plot_one_way_partial_dependence( preds, avg_preds, feature_values[0], feature_idx, n_ice_lines, axi, n_cols, pd_plot_idx, n_lines, individual_line_kw, line_kw, ) else: self._plot_two_way_partial_dependence( avg_preds, feature_values, feature_idx, axi, pd_plot_idx, Z_level, contour_kw, ) return self
def main(): import os import time import json import matplotlib.pyplot as plt import numpy as np from keras.losses import binary_crossentropy from keras.optimizers import Adam from matplotlib.gridspec import GridSpec, GridSpecFromSubplotSpec train_x = np.load('./data/cat_face.npy') # -1 から 1 に変換 train_x = (train_x.astype('float32')-127.5)/127.5 train_size = train_x.shape[0] generator = build_generator() print('Generator model:') print(generator.summary()) discriminator = build_discriminator() print('Discriminator model:') print(discriminator.summary()) gan = build_gan(generator, discriminator) gan.compile( loss=binary_crossentropy, optimizer=Adam(lr=2e-4, beta_1=.5), metrics=['accuracy'] ) train_discriminator = build_train_discriminator(discriminator) train_discriminator.compile( loss=binary_crossentropy, optimizer=Adam(lr=2e-4, beta_1=.5), metrics=['accuracy'] ) batch_size = 128 epochs = 200 steps_per_epoch = train_size//batch_size # steps_per_epoch = 500 print( f'Train size: {train_size}, ' f'Batch size: {batch_size}, ' f'Epochs: {epochs}, ' f'Total Steps: {steps_per_epoch*epochs}' ) p_r = np.ones((batch_size, 1), dtype=np.float32) p_f = np.zeros((batch_size, 1), dtype=np.float32) np.random.seed(0) test_noise = np.random.uniform(-1, 1, size=(30, 100)).astype(np.float32) test_indices = np.random.randint(0, train_size, size=6) plot_real_images = train_x[test_indices] np.random.seed(None) d_loss, d_acc = [], [] g_loss, g_acc = [], [] cnt = 0 for epoch in range(epochs): print(f'Epoch {epoch+1}/{epochs}') start = time.time() # データをシャッフル np.random.shuffle(train_x) d_loss_epoch, d_acc_epoch = [], [] g_loss_epoch, g_acc_epoch = [], [] for step in range(steps_per_epoch): # バッチサイズの分だけ画像を選択 real_images = train_x[step*batch_size:(step+1)*batch_size] # バッチサイズの分だけランダムにノイズを生成 noise = np.random.uniform(-1, 1, size=(batch_size, 100)) noise = noise.astype(np.float32) # generatorにより画像を生成 fake_images = generator.predict(noise) # Discriminatorのtrain d_history = train_discriminator.train_on_batch( [real_images, fake_images], [p_r, p_f] ) tmp_d_loss = float(d_history[0]/2) tmp_d_acc = float((d_history[3]+d_history[4])/2) d_loss.append(tmp_d_loss) d_acc.append(tmp_d_acc) d_loss_epoch.append(tmp_d_loss) d_acc_epoch.append(tmp_d_acc) # バッチサイズの分だけランダムにノイズを生成 noise = np.random.uniform(-1, 1, size=(batch_size, 100)) noise = noise.astype(np.float32) # Generatorのtrain g_history = gan.train_on_batch(noise, p_r) tmp_d_loss = float(g_history[0]) tmp_d_acc = float(g_history[1]) g_loss.append(tmp_d_loss) g_acc.append(tmp_d_acc) g_loss_epoch.append(tmp_d_loss) g_acc_epoch.append(tmp_d_acc) cnt += 1 d_loss_std = np.std(d_loss_epoch) g_loss_std = np.std(g_loss_epoch) d_loss_mean = np.mean(d_loss_epoch) g_loss_mean = np.mean(g_loss_epoch) d_acc_std = np.std(d_acc_epoch) g_acc_std = np.std(g_acc_epoch) d_acc_mean = np.mean(d_acc_epoch) g_acc_mean = np.mean(g_acc_epoch) print( f'd_loss: {d_loss_mean:.4f}, ' f'd_loss_std: {d_loss_std:.4f}, ' f'd_acc: {d_acc_mean:.2f}, ' f'd_acc_std: {d_acc_std:.2f}, ' ) print( f'g_loss: {g_loss_mean:.4f}, ' f'g_loss_std: {g_loss_std:.4f}, ' f'g_acc: {g_acc_mean:.2f}, ' f'g_acc_std: {g_acc_std:.2f}, ' ) print( f'time: {int(time.time() - start)} s' ) generated_images = generator.predict(test_noise) plt.figure(figsize=(6, 6)) grid0 = GridSpec(1, 2, width_ratios=(5, 1)) grid00 = GridSpecFromSubplotSpec(6, 5, subplot_spec=grid0[0]) for i in range(generated_images.shape[0]): plt.subplot(grid00[i]) img = generated_images[i, :, :, :]*127.5 + 127.5 img = img.astype(np.uint8) plt.imshow(img) plt.axis('off') grid01 = GridSpecFromSubplotSpec(6, 1, subplot_spec=grid0[1]) for i in range(plot_real_images.shape[0]): plt.subplot(grid01[i]) img = plot_real_images[i, :, :, :]*127.5 + 127.5 img = img.astype(np.uint8) plt.imshow(img) plt.axis('off') plt.subplots_adjust(left=0, right=1, bottom=0, top=1, hspace=0, wspace=0) path = f'figure/dcgan_cat_face/image_{epoch+1:03d}.png' if not os.path.exists(os.path.dirname(path)): os.makedirs(os.path.dirname(path)) plt.savefig(path) plt.close() path = f'var/log/dcgan_cat_face_history.json' if not os.path.exists(os.path.dirname(path)): os.makedirs(os.path.dirname(path)) history = [d_loss, g_loss] with open(path, 'w+', encoding='UTF-8') as f: json.dump(history, f) path = f'model/dcgan_cat_face/model_{epoch+1:03d}.h5' if not os.path.exists(os.path.dirname(path)): os.makedirs(os.path.dirname(path)) generator.save(path)
xyz_guided.reshape(-1, 3).tolist()) for s in [idx, rmse_rec, rmse_pred, rmse_guided]: result_str += str(s) + ',' result_str = result_str[:-1] + '\n' # layout fig = plt.figure(figsize=(10, 5)) plt.rcParams["font.size"] = 18 gs_master = GridSpec(nrows=2, ncols=2, height_ratios=[1, 1], width_ratios=[3, 0.1]) gs_1 = GridSpecFromSubplotSpec(nrows=1, ncols=4, subplot_spec=gs_master[0, 0], wspace=0.05, hspace=0) gs_2 = GridSpecFromSubplotSpec(nrows=1, ncols=4, subplot_spec=gs_master[1, 0], wspace=0.05, hspace=0) gs_3 = GridSpecFromSubplotSpec(nrows=2, ncols=1, subplot_spec=gs_master[0:1, 1]) ax_enh0 = fig.add_subplot(gs_1[0, 0]) ax_enh1 = fig.add_subplot(gs_1[0, 1]) ax_enh2 = fig.add_subplot(gs_1[0, 2]) ax_enh3 = fig.add_subplot(gs_1[0, 3])