def build_convfreqs(res, saveto=None, savefig=None): ''' Build plot with simulation descriptives ... Arguments --------- res saveto savefig Returns ------- out ts ''' g = res.groupby(level=['prop_mix']) f, axes = plt.subplots(g.ngroups, 1, figsize=(6, 10)) color = 'k' backcolor = '0.5' ''' if type(axes) != list: axes = [axes] ''' out = [] ts = [] for i, block in enumerate(zip(axes, g)): ax, pack = block id, s = pack g1 = s.index.get_level_values('group').unique()[0] plotblock = s.dropna().groupby(level=['tau', 'group'])\ .size().unstack()[g1] plotblock = pd.DataFrame({id: plotblock}) plotblock.plot(kind='line', ax=ax, color=color, grid=False, \ alpha=1.0) ax.legend().set_visible(False) ax.set_ylim((0, 550)) ax.set_xlabel('Tau', size=10, color=backcolor) ax.set_ylabel('Draws', size=10, color=backcolor) ax.tick_params(axis='both', which='major', labelsize=10, labelcolor=backcolor, color=backcolor) plt.setp(ax.spines.values(), color=backcolor) out.append(plotblock) ticks = s.dropna().groupby(level=['tau', 'group'])\ .mean()['ticks'].unstack()[g1] ticks.name = id axT = ax.twinx() ticks.plot(kind='line', style='--', ax=axT, color=color, grid=False, \ alpha=1.0) axT.set_xlim((0, 0.7)) axT.set_ylabel('Iterations', size=10, color=backcolor) axT.tick_params(axis='both', which='major', labelsize=10, labelcolor=backcolor, color=backcolor) ts.append(ticks) title = id + ' | ' + walk[id] plt.title(title) d = plt.Line2D((0, 0), (1, 1), linestyle='-', c=color) t = plt.Line2D((0, 0), (1, 1), linestyle='--', c=color) plt.legend([d, t], ["Draws", "Iterations"], loc=0, frameon=False) f.tight_layout() if savefig: plt.savefig(savefig) else: plt.show() out = pd.concat(out, axis=1).fillna(0) ts = pd.concat(ts, axis=1) if saveto: fo = open(saveto, 'w') fo.write('\n\\vspace{2cm}\n') t0 = out.ix[:, :3].to_latex() fo.write(t0) fo.write('\n\\vspace{2cm}\n') t1 = out.ix[:, 3:].to_latex() fo.write(t1) fo.close() return out, ts
print 'Sod shock NOT work' ####################################################### if (showPlot): fig, ax = plt.subplots(3, sharex=True) x = [] y = [] yp = [] yv = [] for i in range(len(detector)): x.append(float( detector[i][0])) #+0.5)#In this test case the origin is in -0.5 y.append(float(FSrho[i][0])) yp.append(float(FSP[i][0])) yv.append(float(FSV[i][0])) line = plt.Line2D(x, y, color='red', linewidth=2) line2 = plt.Line2D(Analytical_X, Analytical_Yrho, color='blue', linewidth=2) #line.text.set_color('red') #line.text.set_fontsize(16) ax[0].add_line(line) ax[0].add_line(line2) line3 = plt.Line2D(x, yp, color='red', linewidth=2) line4 = plt.Line2D(Analytical_X, Analytical_Yp, color='blue', linewidth=2) ax[1].add_line(line3) ax[1].add_line(line4) line5 = plt.Line2D(x, yv, color='red', linewidth=2)
def line2d(cls, nodesx, nodesy, color='', ls='-', lw=1): return plt.Line2D(nodesx, nodesy, color=color, ls=ls, lw=lw)
def plot_tire_eval(xy, radius, pts, vehicle=None, path=None): """Plot tire configuration and evaluation points. Args: xy [n x 2]: tire locations. radiums [n x 1]: tire radii. pts [n x 2]: evaluation point locations. vehicle [str]: vehicle name. path [str]: path for saving figure. None if plot only. """ xmin, ymin = xy.min(axis=0)[0], xy.min(axis=0)[1] xmax, ymax = xy.max(axis=0)[0], xy.max(axis=0)[1] xlen, ylen = xy.ptp(axis=0)[0], xy.ptp(axis=0)[1] xlim = [xmin - xlen, xmax + xlen] ylim = [ymin - ylen / 2, ymax + ylen / 2] fig = plt.figure() ax = fig.subplots() plt.xlim(xlim) plt.ylim(ylim) ax.set_axisbelow(True) ax.minorticks_on() plt.grid(which='major', linestyle='-', color='gray') plt.grid(which='minor', linestyle='--') ax.set_aspect(1) # plot tires for i in range(len(xy)): ax.add_artist(plt.Circle((xy[i, 0], xy[i, 1]), radius[i], color='b')) ax.add_artist( plt.Text(xy[i, 0], xy[i, 1], str(i), color='white', va='center', ha='center')) # plot eval points ax.scatter(pts[:, 0], pts[:, 1], marker='*', color='red', zorder=5) for i in range(len(pts)): ax.add_artist( plt.Text(pts[i, 0], pts[i, 1] - 2, str(i), color='black', va='top', ha='center')) # legend custom_legend = [ plt.Line2D([], [], marker='o', color='blue', linestyle='None'), plt.Line2D([], [], marker='*', color='red', linestyle='None') ] ax.legend(custom_legend, ['Tire Location', 'Evaluation Point'], loc='upper right', framealpha=1) if vehicle != None: plt.title("Configuration of {}".format(vehicle)) plt.xlabel("X Coordinate (in.)") plt.ylabel("Y Coordinate (in.)") if path != None: plt.savefig(path, dpi=300, bbox_inches='tight') plt.close(fig) else: plt.show()
x.append(int(row[0]))#num cluster y.append(int(row[1]))#iterazion z.append(float(row[2]))#ssim if int(row[1])==5:#con 5 iter x1.append(int(row[0]))#num cluster y1.append(int(row[1]))#iterazion z1.append(float(row[2]))#ssim if int(row[1])==25:#con 25 iter x2.append(int(row[0]))#num cluster y2.append(int(row[1]))#iterazion z2.append(float(row[2]))#ssim plt.plot(x, z, label= "stars", color= "blue",marker='o') plt.plot(x1, z1, label= "stars", color= "red",marker='+') plt.plot(x2, z2, label= "stars", color= "green",marker='*') iter50 = plt.Line2D([], [], color='blue', marker='o',markersize=5, label='40 iterazioni') iter5 = plt.Line2D([], [], color='red', marker='+',markersize=15, label='5 iterazioni') iter25 = plt.Line2D([], [], color='green', marker='*',markersize=15, label='25 iterazioni') plt.legend(handles=[iter5,iter25,iter50]) plt.title('Dati SSIM') plt.xlabel('Cluster') plt.ylabel('SSIM') plt.xticks(np.arange(0, 72, 8)) plt.yticks(np.arange(0.6, 1, 0.02)) plt.show()
linewidth=2) ax.set_title(testQNames[idx]) ax.set_xlabel(xaxes[idx]) ax.set_ylabel(yaxes[idx]) ax.axis([-1, 1, 0, yMaxs[idx]]) ax.set_yticks([0.0, 0.001, 0.002, 0.003], minor=False) ax.yaxis.set_major_formatter( mtick.FixedFormatter( [r"$0.0$", r"$1.0$", r"$2.0$", r"$\times\ 10^{-3}$"])) ax.set_xticks([-1.0, -0.5, 0.0, 0.5, 1.0], minor=False) ax.xaxis.set_major_formatter( mtick.FixedFormatter( [r"$\minus1.0$", r"$\minus0.5$", r"$0.0$", r"$0.5$", r"$1.0$"])) pyplot.suptitle(supTitle, fontsize="16") line1 = pyplot.Line2D((0, 1), (0, 0), color="blue", linewidth=2) line2 = pyplot.Line2D((0, 1), (0, 0), color="red", linewidth=2) lines, figStrs = [line1, line2], [r"$\rm{Generated}$", r"$\rm{Expected}$"] figure.legend(lines, figStrs, bbox_to_anchor=[0.5, 0.05], loc='center', ncol=2) pyplot.tight_layout() ##Space main title out to prevent overlapping and allow space for legend below: pyplot.subplots_adjust(top=0.85, bottom=0.17) assertions.show_graph() print "\nFinished testing get_quarks_theta." assertions.pause(__name__) ##Test get_quark_weights and get_quark_code:##
def make_biaxial(train_feat, valid_feat, test_feat, train_y, valid_y, test_y, figpath, xlabel=None, ylabel=None, add_legend=False): # make the biaxial figure sns.set_style('white') palette = np.array(sns.color_palette("Set2", 3)) plt.figure(figsize=(3, 3)) ax = plt.subplot(aspect='equal') # the training samples ax.scatter(train_feat[:, 0], train_feat[:, 1], s=30, alpha=.5, c=palette[train_y], marker='>', edgecolors='face') # the validation samples ax.scatter(valid_feat[:, 0], valid_feat[:, 1], s=30, alpha=.5, c=palette[valid_y], marker=(5, 1), edgecolors='face') # the test samples ax.scatter(test_feat[:, 0], test_feat[:, 1], s=30, alpha=.5, c=palette[test_y], marker='o', edgecolors='face') # http://stackoverflow.com/questions/13303928/how-to-make-custom-legend-in-matplotlib a1 = plt.Line2D((0, 1), (0, 0), color=palette[0]) a2 = plt.Line2D((0, 1), (0, 0), color=palette[1]) a3 = plt.Line2D((0, 1), (0, 0), color=palette[2]) a4 = plt.Line2D((0, 1), (0, 0), color='k', marker='>', linestyle='', markersize=8) a5 = plt.Line2D((0, 1), (0, 0), color='k', marker=(5, 1), linestyle='', markersize=8) a6 = plt.Line2D((0, 1), (0, 0), color='k', marker='o', linestyle='', markersize=8) #Create legend from custom artist/label lists if add_legend: first_legend = plt.legend([a1, a2, a3], ['healthy', 'CN', 'CBF'], fontsize=16, loc=1, fancybox=True) plt.gca().add_artist(first_legend) plt.legend([a4, a5, a6], ['train', 'valid', 'test'], fontsize=16, loc=4, fancybox=True) #plt.xlim(-2, 2) #plt.ylim(-2, 2) ax.set_aspect('equal', 'datalim') ax.margins(0.1) if xlabel is not None: plt.xlabel(xlabel, fontsize=12) if ylabel is not None: plt.ylabel(ylabel, fontsize=12) plt.tight_layout() sns.despine() plt.savefig(figpath, format='eps') plt.clf() plt.close()
def plot_metrics_for_all_the_algos(file_name, dest_dir_loca, lbl_plot_data_dict_ls, metrics_index, np_group_size, color_dict, marker_dict, xlable, ylable, title, x1=None, x2=None, xticks_ls=np.arange(40, 111, 10), y1=None, y2=None, ytick_ls=None, ytick_lbl_ls=None, loc=0): plt.clf() fig = plt.figure() ax = fig.add_subplot(111) i = 0 eb_l = [] l_s = [] if len(lbl_plot_data_dict_ls) == 1: linestyles = ['-'] else: linestyles = ['--', '-'] for lbl_plot_data_dict in lbl_plot_data_dict_ls: eb_l = [] l_s = [] sorted_order = sorted(lbl_plot_data_dict.keys()) for l in sorted_order: plot_data = lbl_plot_data_dict[l] # for l, plot_data in lbl_plot_data_dict.items(): metric = plot_data[metrics_index] l_s.append(l) # plt.plot(np_group_size, metric[:,0], color=color_dict[l], marker=marker.next(), label=l) err = ss.t._ppf((1 + 0.95) / 2, np.subtract(metric[:, 1], 1)) # print metric[:,1] eb = plt.errorbar(np_group_size, metric[:, 0], color=color_dict[l], fmt=marker_dict[l] + linestyles[i], yerr=err * metric[:, 2], label=l) eb[-1][0].set_linestyle(linestyles[i]) eb_l.append(eb) plt.xlabel(xlable) plt.ylabel(ylable) plt.title(title) if xticks_ls is not None: plt.xticks(xticks_ls) elif x1 is not None and x2 is not None: plt.xlim(x1, x2) else: '' if ytick_ls is not None and ytick_lbl_ls is not None: plt.yticks(ytick_ls, ytick_lbl_ls) elif ytick_ls is not None: plt.yticks(ytick_ls) elif y1 is not None and y2 is not None: plt.ylim(y1, y2) else: '' i += 1 if i == 2: sim = plt.Line2D((0, 1), (0, 0), color='k', linestyle='--') testbed = plt.Line2D((0, 1), (0, 0), color='k', linestyle='-') eb_l += [sim, testbed] l_s += ['Simulation', 'Testbed'] legends = ax.legend(eb_l, l_s, loc=loc, ncol=2, frameon=False) for t in legends.get_texts(): if color_dict.has_key(t.get_text()): t.set_color(color_dict[t.get_text()]) # print t.get_text() # fig.savefig(dest_dir_loca + file_name + ".svg", format='svg', dpi=1200) fig.savefig(dest_dir_loca + file_name + ".eps", format='eps', dpi=1200)
def warming_up_fine_tuning_history( warming_up_history, warming_up_lr, fine_tuning_history, fig1_size, fig2_size, epsilon=1e-07 # keras.backend.epsilon() ) -> Figure: """ """ try: warming_up_epochs = len(warming_up_history['loss']) except KeyError as kerr: raise KeyError('"warming_up_history.loss" column missing') ###################################################################### ## concatenate "warming-up" and "fine-tuning" histories ## ###################################################################### history_df = pd.concat((pd.concat( (pd.DataFrame(copy.deepcopy(warming_up_history)), pd.DataFrame({'lr': [warming_up_lr] * warming_up_epochs})), axis=1), pd.DataFrame(copy.deepcopy(fine_tuning_history))), axis=0).reset_index(drop=True) history_df.index -= warming_up_epochs column_names = [ 'val_loss', 'val_categorical_crossentropy', 'val_categorical_accuracy', 'val_precision', 'val_recall', 'val_precision_NEG', 'val_recall_NEG', 'val_precision_NEUT', 'val_recall_NEUT', 'val_precision_POS', 'val_recall_POS', 'loss', 'categorical_crossentropy', 'categorical_accuracy', 'precision', 'recall', 'precision_NEG', 'recall_NEG', 'precision_NEUT', 'recall_NEUT', 'precision_POS', 'recall_POS', 'lr' ] assert (~(~pd.DataFrame(column_names).isin(history_df.columns.values)).any())[0] \ , "check the format of the input data. at least 1 column name is missing" assert (len(history_df.loc[:,(column_names)].select_dtypes(include=[np.number]).columns) == len(history_df.loc[:,(column_names)].columns)) \ , "check the format of the input data. at least 1 column contains non-numeric" ###################################################################### ###################################################################### ## calculate the "F1 SCORE" columns (from "PRECISION" and "RECALL") ## ## f1_score = 2*(precision*recall)/(precision+recall+epsilon) ## ###################################################################### history_df['f1_score'] = ( 2 * (history_df['precision'] * history_df['recall']) / (history_df['precision'] + history_df['recall'] + epsilon)) history_df['val_f1_score'] = ( 2 * (history_df['val_precision'] * history_df['val_recall']) / (history_df['val_precision'] + history_df['val_recall'] + epsilon)) history_df['f1_score_NEG'] = ( 2 * (history_df['precision_NEG'] * history_df['recall_NEG']) / (history_df['precision_NEG'] + history_df['recall_NEG'] + epsilon)) history_df['val_f1_score_NEG'] = ( 2 * (history_df['val_precision_NEG'] * history_df['val_recall_NEG']) / (history_df['val_precision_NEG'] + history_df['val_recall_NEG'] + epsilon)) history_df['f1_score_NEUT'] = ( 2 * (history_df['precision_NEUT'] * history_df['recall_NEUT']) / (history_df['precision_NEUT'] + history_df['recall_NEUT'] + epsilon)) history_df['val_f1_score_NEUT'] = ( 2 * (history_df['val_precision_NEUT'] * history_df['val_recall_NEUT']) / (history_df['val_precision_NEUT'] + history_df['val_recall_NEUT'] + epsilon)) history_df['f1_score_POS'] = ( 2 * (history_df['precision_POS'] * history_df['recall_POS']) / (history_df['precision_POS'] + history_df['recall_POS'] + epsilon)) history_df['val_f1_score_POS'] = ( 2 * (history_df['val_precision_POS'] * history_df['val_recall_POS']) / (history_df['val_precision_POS'] + history_df['val_recall_POS'] + epsilon)) ###################################################################### ###################################################################### ## Actual figure plotting ## ## ('class per metric' version) ## ###################################################################### training_linestyle = (0, (3, 1, 1, 1)) plt.ioff() fig1, axes = plt.subplots(figsize=fig1_size, nrows=9, ncols=1) y = 1 line = plt.Line2D([0, 1], [y, y], transform=fig1.transFigure, color="black") fig1.add_artist(line) nrow = 0 def draw_metric(ax_, col_name, title): ax_.set_title(title) ax_.plot(history_df.index, history_df[col_name], label='training') ax_.plot(history_df.index, history_df['val_' + col_name], label='validation') def draw_class_metric(ax_, col_name, title, linestyle=None): ax_.set_title(title) ax_.plot(history_df.index, history_df[col_name], linestyle=linestyle, label='weighted avg', color='black') ax_.plot(history_df.index, history_df[col_name + '_NEG'], linestyle=linestyle, label='NEGATIVE class', color='red') ax_.plot(history_df.index, history_df[col_name + '_NEUT'], linestyle=linestyle, label='NEUTRAL class', color='#c7be1c') ax_.plot(history_df.index, history_df[col_name + '_POS'], linestyle=linestyle, label='POSITIVE class', color='green') ax_.vlines(0, ymin=ax_.get_ylim()[0], ymax=ax_.get_ylim()[1], linewidth=.5) def set_common_yaxis(ax_0, ax_1): # make sure 'ax_0' & 'ax_1' (dealing with the same performance metric) have common y-axis bounds ylim = (min(ax_0.get_ylim()[0], ax_1.get_ylim()[0]), max(ax_0.get_ylim()[1], ax_1.get_ylim()[1])) ax_0.set_ylim(ylim) ax_1.set_ylim(ylim) def gray_out_warming_up(ax_): ax_.vlines(0, ymin=ax_.get_ylim()[0], ymax=ax_.get_ylim()[1], linewidth=.5) ax_.axvspan(xmin=min(history_df.index), xmax=0, ymin=.05, ymax=.95, alpha=0.1, color='gray') def horizontal_separator(fig_, ax_, r_): bbox = ax_.get_tightbbox(r_).transformed(fig_.transFigure.inverted()) y = bbox.y0 - .003 line = plt.Line2D([0, 1], [y, y], transform=fig_.transFigure, color="black") fig_.add_artist(line) ## LOSS ## ax = axes[nrow] nrow += 1 draw_metric(ax, 'loss', 'Training Loss') ax.set_xlabel('Epoch') ax.set_ylabel('Loss') ax.legend(loc="upper right", prop={'size': 8}) gray_out_warming_up(ax) ## ACCURACY ## ax = axes[nrow] nrow += 1 draw_metric(ax, 'categorical_accuracy', 'Training Performance') ax.set_xlabel('Epoch') ax.set_ylabel('Categorical Accuracy') gray_out_warming_up(ax) ## CROSS-ENTROPY ## ax = axes[nrow] nrow += 1 draw_metric(ax, 'categorical_crossentropy', 'Training Performance') ax.set_xlabel('Epoch') ax.set_ylabel('Categorical Crossentropy') gray_out_warming_up(ax) fig1.tight_layout( ) # DO IT HERE, TO ALLOW FOR CORRECT PLACEMENT OF HORIZONTAL SEPARATORS # SEPARATOR r = fig1.canvas.get_renderer() horizontal_separator(fig1, ax, r) ## PRECISION ## val_ax = axes[nrow] nrow += 1 draw_class_metric(val_ax, 'val_precision', 'Training Performance (validation dataset)') ax = axes[nrow] nrow += 1 draw_class_metric(ax, 'precision', 'Training Performance (training dataset)', linestyle=training_linestyle) set_common_yaxis(val_ax, ax) gray_out_warming_up(val_ax) gray_out_warming_up(ax) val_ax.set_xlabel('Epoch') val_ax.set_ylabel('Precision') val_ax.legend(loc="lower right", prop={'size': 7}) ax.set_xlabel('Epoch') ax.set_ylabel('Precision') # SEPARATOR horizontal_separator(fig1, ax, r) ## RECALL ## val_ax = axes[nrow] nrow += 1 draw_class_metric(val_ax, 'val_recall', 'Training Performance (validation dataset)') ax = axes[nrow] nrow += 1 draw_class_metric(ax, 'recall', 'Training Performance (training dataset)', linestyle=training_linestyle) set_common_yaxis(val_ax, ax) gray_out_warming_up(val_ax) gray_out_warming_up(ax) val_ax.set_xlabel('Epoch') val_ax.set_ylabel('Recall') ax.set_xlabel('Epoch') ax.set_ylabel('Recall') # SEPARATOR horizontal_separator(fig1, ax, r) ## F1 SCORE ## val_ax = axes[nrow] nrow += 1 draw_class_metric(val_ax, 'val_f1_score', 'Training Performance (validation dataset)') ax = axes[nrow] nrow += 1 draw_class_metric(ax, 'f1_score', 'Training Performance (training dataset)', linestyle=training_linestyle) set_common_yaxis(val_ax, ax) gray_out_warming_up(val_ax) gray_out_warming_up(ax) val_ax.set_xlabel('Epoch') val_ax.set_ylabel('F1 score') ax.set_xlabel('Epoch') ax.set_ylabel('F1 score') # SEPARATOR y = -.005 line = plt.Line2D([0, 1], [y, y], transform=fig1.transFigure, color="black") fig1.add_artist(line) ###################################################################### ###################################################################### ## Actual figure plotting ## ## ('metric per class' version) ## ###################################################################### fig2, axes = plt.subplots(figsize=fig2_size, nrows=12, ncols=1) y = 1 line = plt.Line2D([0, 1], [y, y], transform=fig2.transFigure, color="black") fig2.add_artist(line) nrow = 0 ax = axes[nrow] nrow += 1 draw_metric(ax, 'precision', 'Training Performance') ax.set_xlabel('Epoch') ax.set_ylabel('Precision') ax.legend(loc="upper right", prop={'size': 8}) gray_out_warming_up(ax) ax = axes[nrow] nrow += 1 draw_metric(ax, 'precision_NEG', 'Training Performance (NEGATIVE class)') ax.set_xlabel('Epoch') ax.set_ylabel('Precision') gray_out_warming_up(ax) ax = axes[nrow] nrow += 1 draw_metric(ax, 'precision_NEUT', 'Training Performance (NEUTRAL class)') ax.set_xlabel('Epoch') ax.set_ylabel('Precision') gray_out_warming_up(ax) ax = axes[nrow] nrow += 1 draw_metric(ax, 'precision_POS', 'Training Performance (POSITIVE class)') ax.set_xlabel('Epoch') ax.set_ylabel('Precision') gray_out_warming_up(ax) fig2.tight_layout( ) # DO IT HERE, TO ALLOW FOR CORRECT PLACEMENT OF HORIZONTAL SEPARATORS # SEPARATOR horizontal_separator(fig2, ax, r) ax = axes[nrow] nrow += 1 draw_metric(ax, 'recall', 'Training Performance') ax.set_xlabel('Epoch') ax.set_ylabel('Recall') gray_out_warming_up(ax) ax = axes[nrow] nrow += 1 draw_metric(ax, 'recall_NEG', 'Training Performance (NEGATIVE class)') ax.set_xlabel('Epoch') ax.set_ylabel('Recall') gray_out_warming_up(ax) ax = axes[nrow] nrow += 1 draw_metric(ax, 'recall_NEUT', 'Training Performance (NEUTRAL class)') ax.set_xlabel('Epoch') ax.set_ylabel('Recall') gray_out_warming_up(ax) ax = axes[nrow] nrow += 1 draw_metric(ax, 'recall_POS', 'Training Performance (POSITIVE class)') ax.set_xlabel('Epoch') ax.set_ylabel('Recall') gray_out_warming_up(ax) # SEPARATOR horizontal_separator(fig2, ax, r) ax = axes[nrow] nrow += 1 draw_metric(ax, 'f1_score', 'Training Performance') ax.set_xlabel('Epoch') ax.set_ylabel('F1 score') gray_out_warming_up(ax) ax = axes[nrow] nrow += 1 draw_metric(ax, 'f1_score_NEG', 'Training Performance (NEGATIVE class)') ax.set_xlabel('Epoch') ax.set_ylabel('F1 score') gray_out_warming_up(ax) ax = axes[nrow] nrow += 1 draw_metric(ax, 'f1_score_NEUT', 'Training Performance (NEUTRAL class)') ax.set_xlabel('Epoch') ax.set_ylabel('F1 score') gray_out_warming_up(ax) ax = axes[nrow] nrow += 1 draw_metric(ax, 'f1_score_POS', 'Training Performance (POSITIVE class)') ax.set_xlabel('Epoch') ax.set_ylabel('F1 score') gray_out_warming_up(ax) # SEPARATOR y = -.005 line = plt.Line2D([0, 1], [y, y], transform=fig2.transFigure, color="black") fig2.add_artist(line) ###################################################################### return fig1, fig2
def visualize_genealogy(genealogy, weights=None, rejuvenation=None, colormap='jet'): """ Creates an inline figure visualizing the particle genealogy over one resampling step. @params: genealogy - Required : vector describing genealogy of resampled particles, referring to indices weights - Optional : weight of particles prior to resampling rejuvenation - Optional : vector of booleans describing whether particles were rejuvenated colormap - Optional : colormap string for visualization """ import numpy as np from IPython import get_ipython import matplotlib import matplotlib.pyplot as plt # Determine number of particles n_particles = len(genealogy) # Assign optional variables, if not provided if weights is None == True: weights = np.ones(n_particles) # if rejuvenation is None == True: # rejuvenation = np.ones((n_particles),dtype = np.bool) # Switch to inline printing get_ipython().run_line_magic('matplotlib', 'inline') # Create dummy features for the legend full_line = plt.Line2D([], [], color='black', label='inherited') dashed_line = plt.Line2D([], [], linestyle='--', color='black', label='rejuvenated') particle = plt.Line2D([], [], linestyle='None', marker='.', color='black', label='particle') # Plot legend plt.legend(handles=[dashed_line, full_line, particle], bbox_to_anchor=(0., -0.05, 1., .102), loc=3, ncol=3, mode="expand", borderaxespad=0.) # Determine colormap for particles cmap = matplotlib.cm.get_cmap(colormap) # Extract particle colors rgba = [None] * n_particles for n in range(n_particles): rgba[n] = matplotlib.colors.rgb2hex(cmap(n / (n_particles - 1))) # Create plot for n in range(n_particles): plt.plot([genealogy[n], n], [1, 2], '--', c=rgba[genealogy[n]]) # Draw genealogy of current particle # if rejuvenation[n] == False: # plt.plot([genealogy[n],n],[1,2],c=rgba[genealogy[n]]) # else: # plt.plot([genealogy[n],n],[1,2],c='w') # plt.plot([genealogy[n],n],[1,2],'--',c=rgba[genealogy[n]]) # Scatter previous and current particle index if weights[n] == 0: # Particle weight is zero - print as greyscale plt.scatter(n, 1, s=weights[n] / np.max(weights) * 55 + 5, c='xkcd:medium grey') else: plt.scatter(n, 1, s=weights[n] / np.max(weights) * 55 + 5, c=rgba[n]) plt.scatter(n, 2, s=20, c=rgba[n]) # Deactivate axes plt.axis('off') # Show, and revert to automatic printing plt.show() get_ipython().run_line_magic('matplotlib', 'qt5')
def plotParedData(dataDict): # loop through all the dat types. for dataType in dataDict.keys(): # make empty list for the legend lines and label leglines = [] leglabels = [] # assign special parameters for each data type. # linear acceleration if dataType == 'A': (xAccelList, yAccelList, zAccelList) = ([], [], []) coordinatesList = dataDict[dataType].coordinatesList for (xAccel, yAccel, zAccel) in coordinatesList: xAccelList.append(xAccel) yAccelList.append(yAccel) zAccelList.append(zAccel) listOfPlotLists = [xAccelList, yAccelList, zAccelList] # choose the colors colors = ['firebrick', 'dodgerblue', 'darkorchid'] # add things to the legend labels legLabelSeeds = [' x ', ' y ', ' z '] units = dataDict[dataType].units if units is None: units = '' # make a label for the y axis plt.ylabel("Acceleration (" + str(units) + ")") # make a title plt.title('Linear Acceleration') # rotation rate elif dataType == 'G': (xRotationRateList, yRotationRateList, zRotationRateList) = ([], [], []) coordinatesList = dataDict[dataType].coordinatesList for (xRotRate, yRotRate, zRotRate) in coordinatesList: xRotationRateList.append(xRotRate) yRotationRateList.append(yRotRate) zRotationRateList.append(zRotRate) listOfPlotLists = [ xRotationRateList, yRotationRateList, zRotationRateList ] colors = ['DarkGoldenRod', 'OliveDrab', 'Tomato'] # add things to the legend labels legLabelSeeds = [ ' x Rotation Rate ', ' y Rotation Rate ', ' z Rotation Rate ' ] units = dataDict[dataType].units if units is None: units = '' # make a label for the y axis plt.ylabel("Rotation Rate (" + str(units) + ")") # make a title plt.title('Rotation Rate About Different Axes') # magnetic Field elif dataType == 'M': (xMagFieldList, yMagFieldList, zMagFieldList) = ([], [], []) coordinatesList = dataDict[dataType].coordinatesList for (xMagField, yMagField, zMagField) in coordinatesList: xMagFieldList.append(xMagField) yMagFieldList.append(yMagField) zMagFieldList.append(zMagField) listOfPlotLists = [xMagFieldList, yMagFieldList, zMagFieldList] colors = ['CadetBlue', 'Chartreuse', 'Pink'] # add things to the legend labels legLabelSeeds = [ ' x Magnetic Field ', ' y Magnetic Field ', ' z Magnetic Field ' ] units = dataDict[dataType].units if units is None: units = '' # make a label for the y axis plt.ylabel("Magnetic Field (" + str(units) + ")") # make a title plt.title('3 Axis Magnetic Field') elif dataType == 'Pitch,Roll': (pitchList, rollList) = ([], []) coordinatesList = dataDict[dataType].coordinatesList for (pitch, roll) in coordinatesList: pitchList.append(pitch) rollList.append(roll) listOfPlotLists = [pitchList, rollList] colors = ['Chocolate', 'CornflowerBlue'] # add things to the legend labels legLabelSeeds = [' pitch ', ' roll '] units = dataDict[dataType].units if units is None: units = '' # make a label for the y axis plt.ylabel("Pitch and Roll " + units) # make a title plt.title('Pitch and Roll') else: coordinatesList = dataDict[dataType].coordinatesList dataList = [] for datum in coordinatesList: dataList.append(datum) listOfPlotLists = [dataList] colors = ['Sienna'] # add things to the legend labels legLabelSeeds = [' '] units = dataDict[dataType].units if units is None: units = '' # make a label for the y axis plt.ylabel(dataType + units) # make a title plt.title(dataType) for (listIndex, dataList) in list(enumerate(listOfPlotLists)): color = colors[listIndex] # append the legend label to a list to use later. leglabels.append(dataType + ':' + legLabelSeeds[listIndex]) # append the legend line to a list to use later. leglines.append(plt.Line2D(range(10), range(10), color=color)) # plot the data plt.plot(dataList, color=color) # make the legend plt.legend(leglines, leglabels, loc=0, numpoints=3, handlelength=4) # make a label for the x axis plt.xlabel("Number of points") # display the plot in pop-up window plt.show() return
def draw_neural_net(self,error=False): cmap = plt.get_cmap('seismic') left=0.1 right=0.91 bottom=0.1 top=0.91 fig = plt.figure(figsize=(12, 12)) ax = fig.gca() ax.axis('off') layer_sizes = list(self.topology.values()) n_layers = len(layer_sizes) v_spacing = (top - bottom)/float(max(layer_sizes)) h_spacing = (right - left)/float(len(layer_sizes) - 1) # Input-Arrows layer_top_0 = v_spacing*(layer_sizes[0] - 1)/2. + (top + bottom)/2. for m in range(layer_sizes[0]): plt.arrow(left-0.18, layer_top_0 - m*v_spacing, 0.12, 0, lw =1, head_width=0.01, head_length=0.02) # Nodes for n, layer_size in enumerate(layer_sizes): layer_top = v_spacing*(layer_size - 1)/2. + (top + bottom)/2. for m in range(layer_size): #format_value = "{:.2}".format(float(self.network[n][m].error)) #c_color = 1-float(self.network[n][m].a_value) format_value = "a-{:.2}\nz-{:.2}\ne-{:.2}".format( float(self.network[n][m].a_value), float(self.network[n][m].z_value), float(self.network[n][m].error)) c_color = 1-float(self.network[n][m].a_value) #print(format_value) circle = plt.Circle((n*h_spacing + left, layer_top - m*v_spacing), v_spacing/8., color='black', ec='k', zorder=4) if n == 0: plt.text(left-0.125, layer_top - m*v_spacing, r'$X_{'+str(m)+'}$', fontsize=15) elif (n_layers > 2) & (n > 0) & (n < n_layers): plt.text(n*h_spacing + left+0.00, layer_top - m*v_spacing+ (v_spacing/8.+0.01*v_spacing), r'$H_{'+str(m)+'}$', fontsize=15) elif n == n_layers -1: plt.text(n*h_spacing + left+0.10, layer_top - m*v_spacing, r'$y_{'+str(m)+'}$', fontsize=15) ax.add_artist(circle) ax.annotate( format_value, xy=(n*h_spacing + left, layer_top - m*v_spacing), fontsize=12,ha='center', va="center",zorder=5,color='white',fontweight='bold') # # Bias-Nodes for n, layer_size in enumerate(layer_sizes): if n < n_layers -1: x_bias = (n+0.5)*h_spacing + left y_bias = top + 0.005 circle = plt.Circle((x_bias, y_bias), v_spacing/8., color='w', ec='k', zorder=4) plt.text(x_bias-(v_spacing/8.+0.10*v_spacing+0.01), y_bias, r'$\beta$', fontsize=15) ax.add_artist(circle) # Edges # Edges between nodes for n, (layer_size_a, layer_size_b) in enumerate(zip(layer_sizes[:-1], layer_sizes[1:])): layer_top_a = v_spacing*(layer_size_a - 1)/2. + (top + bottom)/2. layer_top_b = v_spacing*(layer_size_b - 1)/2. + (top + bottom)/2. for m in range(layer_size_a): for o in range(layer_size_b): thickness = self.network[n+1][o].weights[m] line = plt.Line2D([n*h_spacing + left, (n + 1)*h_spacing + left], [layer_top_a - m*v_spacing, layer_top_b - o*v_spacing], c='black',lw=thickness*2+0.1) ax.add_artist(line) xm = (n*h_spacing + left) xo = ((n + 1)*h_spacing + left) ym = (layer_top_a - m*v_spacing) yo = (layer_top_b - o*v_spacing) rot_mo_rad = np.arctan((yo-ym)/(xo-xm)) rot_mo_deg = rot_mo_rad*180./np.pi xm1 = xm + (v_spacing/8.+0.05)*np.cos(rot_mo_rad) if n == 0: if yo > ym: ym1 = ym + (v_spacing/8.+0.12)*np.sin(rot_mo_rad) else: ym1 = ym + (v_spacing/8.+0.05)*np.sin(rot_mo_rad) else: if yo > ym: ym1 = ym + (v_spacing/8.+0.12)*np.sin(rot_mo_rad) else: ym1 = ym + (v_spacing/8.+0.04)*np.sin(rot_mo_rad) plt.text( xm1, ym1,\ "{} {:.3}".format( self.network[n+1][o].weights_annotations[m], self.network[n+1][o].weights[m]),\ rotation = rot_mo_deg, \ fontsize = 15, ) # Edges between bias and nodes for n, (layer_size_a, layer_size_b) in enumerate(zip(layer_sizes[:-1], layer_sizes[1:])): if n < n_layers-1: layer_top_a = v_spacing*(layer_size_a - 1)/2. + (top + bottom)/2. layer_top_b = v_spacing*(layer_size_b - 1)/2. + (top + bottom)/2. x_bias = (n+0.5)*h_spacing + left y_bias = top + 0.005 for o in range(layer_size_b): line = plt.Line2D([x_bias, (n + 1)*h_spacing + left], [y_bias, layer_top_b - o*v_spacing], c='k') ax.add_artist(line) xo = ((n + 1)*h_spacing + left) yo = (layer_top_b - o*v_spacing) rot_bo_rad = np.arctan((yo-y_bias)/(xo-x_bias)) rot_bo_deg = rot_bo_rad*180./np.pi xo2 = xo - (v_spacing/8.+0.01)*np.cos(rot_bo_rad) yo2 = yo - (v_spacing/8.+0.01)*np.sin(rot_bo_rad) xo1 = xo2 -0.05 *np.cos(rot_bo_rad) yo1 = yo2 -0.05 *np.sin(rot_bo_rad) plt.text( xo1, yo1,\ str(round(float(self[n+1][o].bias),4)),\ rotation = rot_bo_deg, \ fontsize = 10) layer_top_0 = v_spacing*(layer_sizes[-1] - 1)/2. + (top + bottom)/2. for m in range(layer_sizes[-1]): plt.arrow(right+0.015, layer_top_0 - m*v_spacing, 0.16*h_spacing, 0, lw =1, head_width=0.01, head_length=0.02) return ax
def plot_gate_map(backend, figsize=None, plot_directed=False, label_qubits=True, qubit_size=24, line_width=4, font_size=12, qubit_color=None, qubit_labels=None, line_color=None, font_color='w', ax=None): """Plots the gate map of a device. Args: backend (BaseBackend): A backend instance, figsize (tuple): Output figure size (wxh) in inches. plot_directed (bool): Plot directed coupling map. label_qubits (bool): Label the qubits. qubit_size (float): Size of qubit marker. line_width (float): Width of lines. font_size (int): Font size of qubit labels. qubit_color (list): A list of colors for the qubits qubit_labels (list): A list of qubit labels line_color (list): A list of colors for each line from coupling_map. font_color (str): The font color for the qubit labels. ax (Axes): A Matplotlib axes instance. Returns: Figure: A Matplotlib figure instance. Raises: QiskitError: if tried to pass a simulator. ImportError: if matplotlib not installed. """ if not HAS_MATPLOTLIB: raise ImportError('Must have Matplotlib installed.') if backend.configuration().simulator: raise QiskitError('Requires a device backend, not simulator.') input_axes = False if ax: input_axes = True mpl_data = {} mpl_data[20] = [[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [1, 0], [1, 1], [1, 2], [1, 3], [1, 4], [2, 0], [2, 1], [2, 2], [2, 3], [2, 4], [3, 0], [3, 1], [3, 2], [3, 3], [3, 4]] mpl_data[14] = [[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [0, 5], [0, 6], [1, 7], [1, 6], [1, 5], [1, 4], [1, 3], [1, 2], [1, 1]] mpl_data[16] = [[1, 0], [0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [0, 5], [0, 6], [0, 7], [1, 7], [1, 6], [1, 5], [1, 4], [1, 3], [1, 2], [1, 1]] mpl_data[5] = [[1, 0], [0, 1], [1, 1], [1, 2], [2, 1]] mpl_data[53] = [[0, 2], [0, 3], [0, 4], [0, 5], [0, 6], [1, 2], [1, 6], [2, 0], [2, 1], [2, 2], [2, 3], [2, 4], [2, 5], [2, 6], [2, 7], [2, 8], [3, 0], [3, 4], [3, 8], [4, 0], [4, 1], [4, 2], [4, 3], [4, 4], [4, 5], [4, 6], [4, 7], [4, 8], [5, 2], [5, 6], [6, 0], [6, 1], [6, 2], [6, 3], [6, 4], [6, 5], [6, 6], [6, 7], [6, 8], [7, 0], [7, 4], [7, 8], [8, 0], [8, 1], [8, 2], [8, 3], [8, 4], [8, 5], [8, 6], [8, 7], [8, 8], [9, 2], [9, 6]] config = backend.configuration() n_qubits = config.n_qubits cmap = config.coupling_map if qubit_labels is None: qubit_labels = list(range(n_qubits)) else: if len(qubit_labels) != n_qubits: raise QiskitError('Length of qubit labels ' 'does not equal number ' 'of qubits.') if n_qubits in mpl_data.keys(): grid_data = mpl_data[n_qubits] else: if not input_axes: fig, ax = plt.subplots(figsize=(5, 5)) # pylint: disable=invalid-name ax.axis('off') return fig x_max = max([d[1] for d in grid_data]) y_max = max([d[0] for d in grid_data]) max_dim = max(x_max, y_max) if figsize is None: if x_max / max_dim > 0.33 and y_max / max_dim > 0.33: figsize = (5, 5) else: figsize = (9, 3) if ax is None: fig, ax = plt.subplots(figsize=figsize) # pylint: disable=invalid-name ax.axis('off') # set coloring if qubit_color is None: qubit_color = ['#648fff'] * config.n_qubits if line_color is None: line_color = ['#648fff'] * len(cmap) # Add lines for couplings for ind, edge in enumerate(cmap): is_symmetric = False if edge[::-1] in cmap: is_symmetric = True y_start = grid_data[edge[0]][0] x_start = grid_data[edge[0]][1] y_end = grid_data[edge[1]][0] x_end = grid_data[edge[1]][1] if is_symmetric: if y_start == y_end: x_end = (x_end - x_start) / 2 + x_start elif x_start == x_end: y_end = (y_end - y_start) / 2 + y_start else: x_end = (x_end - x_start) / 2 + x_start y_end = (y_end - y_start) / 2 + y_start ax.add_artist( plt.Line2D([x_start, x_end], [-y_start, -y_end], color=line_color[ind], linewidth=line_width, zorder=0)) if plot_directed: dx = x_end - x_start # pylint: disable=invalid-name dy = y_end - y_start # pylint: disable=invalid-name if is_symmetric: x_arrow = x_start + dx * 0.95 y_arrow = -y_start - dy * 0.95 dx_arrow = dx * 0.01 dy_arrow = -dy * 0.01 head_width = 0.15 else: x_arrow = x_start + dx * 0.5 y_arrow = -y_start - dy * 0.5 dx_arrow = dx * 0.2 dy_arrow = -dy * 0.2 head_width = 0.2 ax.add_patch( mpatches.FancyArrow(x_arrow, y_arrow, dx_arrow, dy_arrow, head_width=head_width, length_includes_head=True, edgecolor=None, linewidth=0, facecolor=line_color[ind], zorder=1)) # Add circles for qubits for var, idx in enumerate(grid_data): _idx = [idx[1], -idx[0]] width = _GraphDist(qubit_size, ax, True) height = _GraphDist(qubit_size, ax, False) ax.add_artist( mpatches.Ellipse(_idx, width, height, color=qubit_color[var], zorder=1)) if label_qubits: ax.text(*_idx, s=qubit_labels[var], horizontalalignment='center', verticalalignment='center', color=font_color, size=font_size, weight='bold') ax.set_xlim([-1, x_max + 1]) ax.set_ylim([-(y_max + 1), 1]) if not input_axes: if get_backend() in [ 'module://ipykernel.pylab.backend_inline', 'nbAgg' ]: plt.close(fig) return fig return None
ys = [y0] for t in np.arange(0, 60, 0.01): # Equations of motion v_t = g * t + v0 # update the velocity of the particle at point time t y_t = y0 + (v_t**2 - v0**2) / ( 2 * g) #update the position of the particle at time t # Print out the time elapsed and the speed time_passed.set_text("Time Elapsed (s): {0}".format(np.round(t, 2))) speed.set_text("Speed (m/s): {0}".format(np.abs(np.round(v_t, 2)))) if y_t >= 0: # update the point with the new position points.set_data(x0, y_t) #draw the t,y line ts.append(t) ys.append(y_t) line_seg = plt.Line2D(ts, ys) ax[1].add_line(line_seg) else: # exit the loop if the particle hits the ground at 0 points.set_data(x0, 0) break plt.pause(0.001) plt.draw()
def plot_variant_locator(pos, step=None, ax=None, start=None, stop=None, flip=False, line_kwargs=None): """ Plot lines indicating the physical genome location of variants from a single chromosome/contig. By default the top x axis is in variant index space, and the bottom x axis is in genome position space. Parameters ---------- pos : array_like A sorted 1-dimensional array of genomic positions from a single chromosome/contig. step : int, optional Plot a line for every `step` variants. ax : axes, optional The axes on which to draw. If not provided, a new figure will be created. start : int, optional The start position for the region to draw. stop : int, optional The stop position for the region to draw. flip : bool, optional Flip the plot upside down. line_kwargs : dict-like Additional keyword arguments passed through to `plt.Line2D`. Returns ------- ax : axes The axes on which the plot was drawn """ import matplotlib.pyplot as plt # check inputs pos = SortedIndex(pos, copy=False) # set up axes if ax is None: x = plt.rcParams['figure.figsize'][0] y = x / 7 fig, ax = plt.subplots(figsize=(x, y)) fig.tight_layout() # determine x axis limits if start is None: start = np.min(pos) if stop is None: stop = np.max(pos) loc = pos.locate_range(start, stop) pos = pos[loc] if step is None: step = len(pos) // 100 ax.set_xlim(start, stop) # plot the lines if line_kwargs is None: line_kwargs = dict() # line_kwargs.setdefault('linewidth', .5) n_variants = len(pos) for i, p in enumerate(pos[::step]): xfrom = p xto = (start + ((i * step / n_variants) * (stop - start))) l = plt.Line2D([xfrom, xto], [0, 1], **line_kwargs) ax.add_line(l) # invert? if flip: ax.invert_yaxis() ax.xaxis.tick_top() else: ax.xaxis.tick_bottom() # tidy up ax.set_yticks([]) ax.xaxis.set_tick_params(direction='out') for l in 'left', 'right': ax.spines[l].set_visible(False) return ax
def plotOpticalDups(): #read in optical duplicates file, extract info data = [] with open("optical_duplicates.txt", "r") as f: for line in f: if not line.strip(): continue else: try: optRecord = line.split() t = optRecord[2] except IndexError: break optRecord = line.split() read = optRecord[0].split(":") tile = read[4] x = read[5] y = read[6] sampleID = read[0] data.append([tile, sampleID, x, y]) dfOptDups = DataFrame(data) dfOptDups.columns = ['tile', 'sampleID', 'x', 'y'] tileGroups = dfOptDups.groupby('tile') tiles = [] for name, group in tileGroups: tiles.append(name) #initalize values git = 0 #group iterator fontP = FontProperties() fontP.set_size('small') #get colors, x y values for group for i in range(0, len(tiles)): colorDict = {} currentGroup = tileGroups.get_group(tiles[git]) currentName = currentGroup.tile[0] x = map(int, currentGroup.x.tolist()) y = map(int, currentGroup.y.tolist()) xnorm = [float(i)/sum(x) for i in x] ynorm = [float(i)/sum(y) for i in y] for i in range(0, len(currentGroup.sampleID.unique())): colorDict[currentGroup.sampleID.unique()[i]] = matplotlib.colors.cnames.values()[random.randrange(1, 150)] #link random color to each sample #loop to create figures fig = plt.figure() backgroundColor = '#ffffff' ax = fig.add_subplot(111, axisbg=backgroundColor) ax.scatter(xnorm, ynorm, color=colorDict.values(), marker=',', s=5) ax.spines['top'].set_visible(False) #remove plot borders ax.spines['right'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.spines['left'].set_visible(False) plt.xlim(0, 1.0) plt.ylim(0, 1.0) plt.tick_params(bottom='off', top='off', right='off', left='off') #no tick marks plt.grid(color="white") markers = [plt.Line2D([0,0], [0,0], color=color, marker='s', linestyle='') for color in colorDict.values()] lgd = plt.legend(markers, colorDict.keys(), numpoints=1, prop=fontP, bbox_to_anchor=(0.5, -0.1), ncol=5, fancybox=True) fig.savefig(currentName + '.pdf', bbox_extra_artists=(lgd,), bbox_inches='tight', format='pdf') git += 1 print bcolors.COMPLETE + "Complete! Figures successfully generated"
def plot(simtable, associations, cmap, mask, axlabels, outfile, similarity): # reverse roworder of simtable to match plotting order = range(simtable.nrows)[::-1] simtable.rowheads = reorder(simtable.rowheads, order) simtable.data = simtable.data[order, :] simtable.update() # scale of the data tmin = np.min(simtable.data) tmax = np.max(simtable.data) crit = 0 while crit < max(abs(tmin), tmax): crit += c_simstep vmin = 0 if tmin >= 0 else -crit vmax = crit # masking if mask: mask_table(simtable, associations) # begin plotting fig = plt.figure() width = max(c_unit_w * simtable.ncols, c_min_width) width += c_char_pad * max(list(map(len, simtable.rowheads))) height = max(c_unit_h * simtable.nrows, c_min_height) height += c_char_pad * max(list(map(len, simtable.colheads))) fig.set_size_inches(width, height) span = simtable.ncols cbarspan = c_cbarspan ax = plt.subplot2grid((1, span), (0, cbarspan), rowspan=1, colspan=span - cbarspan) ax_cbar = plt.subplot2grid((2, span), (0, 0), rowspan=2, colspan=cbarspan) ax.yaxis.tick_right() ax.yaxis.set_label_position("right") ax.set_yticks([0.5 + i for i in range(simtable.nrows)]) ax.set_xticks([0.5 + i for i in range(simtable.ncols)]) ax.set_yticklabels(simtable.rowheads, size=c_large_text) ax.set_xticklabels(simtable.colheads, rotation=90, rotation_mode="anchor", ha="right", va="center", size=c_large_text) ax.xaxis.set_ticks_position('none') ax.yaxis.set_ticks_position('none') ax.set_ylim(0, len(simtable.rowheads)) ax.set_xlim(0, len(simtable.colheads)) ax.set_ylabel(axlabels[0], size=c_giant_text, fontweight='bold') ax.set_xlabel(axlabels[1], size=c_giant_text, fontweight='bold') # if masking, draw a light grid to help with orientation if mask: kwargs = {"zorder": 0, "color": c_grid_color} xmin, xmax = ax.get_xlim() ymin, ymax = ax.get_ylim() for y in ax.get_yticks(): ax.add_line(plt.Line2D([xmin, xmax], [y, y], **kwargs)) for x in ax.get_xticks(): ax.add_line(plt.Line2D([x, x], [ymin, ymax], **kwargs)) # main heatmap heatmap = ax.pcolormesh(simtable.data, cmap=cmap, vmin=vmin, vmax=vmax) # craziness for getting cbar on the left with left-facing ticks norm = matplotlib.colors.Normalize(vmin=vmin, vmax=vmax) cbar = matplotlib.colorbar.ColorbarBase( ax_cbar, norm=norm, cmap=cmap, orientation="vertical", ) cbar.set_ticks([]) twin_ax = plt.twinx(ax=cbar.ax) twin_ax.yaxis.set_label_position("left") twin_ax.yaxis.tick_left() [tick.set_size(c_large_text) for tick in twin_ax.get_yticklabels()] twin_ax.set_ylim(vmin, vmax) if similarity != "Pairwise Similarity": similarity = "Pairwise " + similarity twin_ax.set_ylabel(similarity, size=c_giant_text) #, fontsize=c_large_text ) ticks = [vmin] while ticks[-1] < vmax: ticks.append(ticks[-1] + c_simstep) twin_ax.set_yticks(ticks) # # number is used as rank of the association based on the order number = 0 # add associations for sim_rank, row_items, col_items, sig, _, _ in associations: number += 1 row_items = row_items[::-1] y1 = simtable.rowmap[row_items[0]] y2 = simtable.rowmap[row_items[-1]] x1 = simtable.colmap[col_items[0]] x2 = simtable.colmap[col_items[-1]] delx = abs(x2 - x1) + 1 dely = abs(y2 - y1) + 1 # box ax.add_patch( patches.Rectangle( (x1, y1), x2 - x1 + 1, y2 - y1 + 1, facecolor="none", edgecolor="black", linewidth=c_line_width, clip_on=False, )) # label text = str(number) size = c_label_scale * min(delx, dely) size /= 1 if len(text) == 1 else c_label_aspect * len(text) size = int(size) text = ax.text(#np.mean( [x1, x2] )+0.5+c_label_shift*size, np.mean( [x1, x2] )+.75+c_label_shift*size if (len(row_items)%2 != 0 and len(row_items)>1 and len(col_items) >1) else\ np.mean( [x1, x2] )+.5+c_label_shift*size if len(row_items) == 1 else np.mean( [x1, x2] )+0.5+c_label_shift*size , np.mean( [y1, y2] )+0.5+c_label_shift*size, text, size=size, color="white", ha="center", va="center", weight="bold", ) text.set_path_effects([ path_effects.Stroke(linewidth=c_outline_width, foreground='black'), path_effects.Normal(), ]) # craziness for hiding the border plt.setp([ child for child in ax.get_children() if isinstance(child, matplotlib.spines.Spine) ], visible=False) try: plt.tight_layout() except: pass plt.savefig(outfile, dpi=paper_dpi, papertype=None)
def _plot_configure(self): """ Creates a figure with subplots for states and actions. :return: (figure, axes) where: figure: a matplotlib Figure with subplots for state and controls axes: an AxesTuple object with references to all figure subplot axes """ plt.ion() # interactive mode allows dynamic updating of plot figure = plt.figure(figsize=(6, 11)) spec = plt.GridSpec(nrows=3, ncols=2, width_ratios=[5, 1], # second column very thin height_ratios=[6, 5, 1], # bottom row very short wspace=0.3) # create subplots axes_state = figure.add_subplot(spec[0, 0:]) axes_stick = figure.add_subplot(spec[1, 0]) axes_throttle = figure.add_subplot(spec[1, 1]) axes_rudder = figure.add_subplot(spec[2, 0]) # hide state subplot axes - text will be printed to it axes_state.axis('off') self._prepare_state_printing(axes_state) # config subplot for stick (aileron and elevator control in x/y axes) axes_stick.set_xlabel('ailerons [-]', ) axes_stick.set_ylabel('elevator [-]') axes_stick.set_xlim(left=-1, right=1) axes_stick.set_ylim(bottom=-1, top=1) axes_stick.xaxis.set_label_coords(0.5, 1.08) axes_stick.yaxis.set_label_coords(-0.05, 0.5) # make axes cross at origin axes_stick.spines['left'].set_position('zero') axes_stick.spines['bottom'].set_position('zero') # only show ticks at extremes of range axes_stick.set_xticks([-1, 1]) axes_stick.xaxis.set_ticks_position('bottom') axes_stick.set_yticks([-1, 1]) axes_stick.yaxis.set_ticks_position('left') axes_stick.tick_params(which='both', direction='inout') # show minor ticks throughout minor_locator = plt.MultipleLocator(0.2) axes_stick.xaxis.set_minor_locator(minor_locator) axes_stick.yaxis.set_minor_locator(minor_locator) # hide unneeded spines axes_stick.spines['right'].set_visible(False) axes_stick.spines['top'].set_visible(False) # config subplot for throttle: a 1D vertical plot axes_throttle.set_ylabel('throttle [-]') axes_throttle.set_ylim(bottom=0, top=1) axes_throttle.set_xlim(left=0, right=1) axes_throttle.spines['left'].set_position('zero') axes_throttle.yaxis.set_label_coords(0.5, 0.5) axes_throttle.set_yticks([0, 0.5, 1]) axes_throttle.yaxis.set_minor_locator(minor_locator) axes_throttle.tick_params(axis='y', which='both', direction='inout') # hide horizontal x-axis and related spines axes_throttle.xaxis.set_visible(False) for spine in ['right', 'bottom', 'top']: axes_throttle.spines[spine].set_visible(False) # config rudder subplot: 1D horizontal plot axes_rudder.set_xlabel('rudder [-]') axes_rudder.set_xlim(left=-1, right=1) axes_rudder.set_ylim(bottom=0, top=1) axes_rudder.xaxis.set_label_coords(0.5, -0.5) axes_stick.spines['bottom'].set_position('zero') axes_rudder.set_xticks([-1, 0, 1]) axes_rudder.xaxis.set_minor_locator(minor_locator) axes_rudder.tick_params(axis='x', which='both', direction='inout') axes_rudder.get_yaxis().set_visible(False) # only want a 1D subplot for spine in ['left', 'right', 'top']: axes_rudder.spines[spine].set_visible(False) all_axes = AxesTuple(axes_state=axes_state, axes_stick=axes_stick, axes_throttle=axes_throttle, axes_rudder=axes_rudder) # create figure-wide legend cmd_entry = ( plt.Line2D([], [], color='b', marker='o', ms=10, linestyle='', fillstyle='none'), 'Commanded Position, normalised') pos_entry = (plt.Line2D([], [], color='r', marker='+', ms=10, linestyle=''), 'Current Position, normalised') figure.legend((cmd_entry[0], pos_entry[0]), (cmd_entry[1], pos_entry[1]), loc='lower center') plt.show() plt.pause(self.PLOT_PAUSE_SECONDS) # voodoo pause needed for figure to appear return figure, all_axes
label='Series C\'s = %.1f pF, Shunt L = %i nH, %s' % (cap_value * 1e12, shunt_inductor_value * 1e9, antenna_name)) if plot_smith == True: all_ax_sm = feed.plotSmithChart(ax=all_ax_sm, linestyle=linestyle) all_ax_lm.set_xlim(0, 1000) all_ax_lm.set_ylim(logmag_lims[0], logmag_lims[1]) #Handle Legend #Get artists and labels for legend and chose which ones to display handles, labels = all_ax_lm.get_legend_handles_labels() display = numpy.arange(len(handles)) #(0,len(cu_roots)) #Create custom artists cuArtist = plt.Line2D((0, 1), (0, 0), color='k', linestyle=cu_linestyle, linewidth=linewidth) alArtist = plt.Line2D((0, 1), (0, 0), color='k', linestyle=al_linestyle, linewidth=linewidth) #Create legend from custom artist/label lists all_ax_lm.legend( [handle for i, handle in enumerate(handles) if i in display] + [cuArtist, alArtist], [label for i, label in enumerate(labels) if i in display] + ['Copper Tabbed Antenna', 'Aluminum Antenna'], fontsize=legend_fontsize, loc='lower left')
def render(self, mode='human', output_file=None): from matplotlib import animation import matplotlib.pyplot as plt plt.rcParams['animation.ffmpeg_path'] = '/usr/bin/ffmpeg' x_offset = 0.11 y_offset = 0.11 cmap = plt.cm.get_cmap('hsv', 10) robot_color = 'yellow' goal_color = 'red' arrow_color = 'red' arrow_style = patches.ArrowStyle("->", head_length=4, head_width=2) if mode == 'human': fig, ax = plt.subplots(figsize=(7, 7)) ax.set_xlim(-4, 4) ax.set_ylim(-4, 4) for human in self.humans: human_circle = plt.Circle(human.get_position(), human.radius, fill=False, color='b') ax.add_artist(human_circle) ax.add_artist( plt.Circle(self.robot.get_position(), self.robot.radius, fill=True, color='r')) plt.show() elif mode == 'traj': fig, ax = plt.subplots(figsize=(7, 7)) ax.tick_params(labelsize=16) ax.set_xlim(-5, 5) ax.set_ylim(-5, 5) ax.set_xlabel('x(m)', fontsize=16) ax.set_ylabel('y(m)', fontsize=16) robot_positions = [ self.states[i][0].position for i in range(len(self.states)) ] human_positions = [[ self.states[i][1][j].position for j in range(len(self.humans)) ] for i in range(len(self.states))] for k in range(len(self.states)): if k % 4 == 0 or k == len(self.states) - 1: robot = plt.Circle(robot_positions[k], self.robot.radius, fill=True, color=robot_color) humans = [ plt.Circle(human_positions[k][i], self.humans[i].radius, fill=False, color=cmap(i)) for i in range(len(self.humans)) ] ax.add_artist(robot) for human in humans: ax.add_artist(human) # add time annotation global_time = k * self.time_step if global_time % 4 == 0 or k == len(self.states) - 1: agents = humans + [robot] times = [ plt.text(agents[i].center[0] - x_offset, agents[i].center[1] - y_offset, '{:.1f}'.format(global_time), color='black', fontsize=14) for i in range(self.human_num + 1) ] for time in times: ax.add_artist(time) if k != 0: nav_direction = plt.Line2D( (self.states[k - 1][0].px, self.states[k][0].px), (self.states[k - 1][0].py, self.states[k][0].py), color=robot_color, ls='solid') human_directions = [ plt.Line2D((self.states[k - 1][1][i].px, self.states[k][1][i].px), (self.states[k - 1][1][i].py, self.states[k][1][i].py), color=cmap(i), ls='solid') for i in range(self.human_num) ] ax.add_artist(nav_direction) for human_direction in human_directions: ax.add_artist(human_direction) plt.legend([robot], ['Robot'], fontsize=16) plt.show() elif mode == 'video': fig, ax = plt.subplots(figsize=(7, 7)) ax.tick_params(labelsize=16) ax.set_xlim(-6, 6) ax.set_ylim(-6, 6) ax.set_xlabel('x(m)', fontsize=16) ax.set_ylabel('y(m)', fontsize=16) # add robot and its goal robot_positions = [state[0].position for state in self.states] goal = mlines.Line2D([0], [4], color=goal_color, marker='*', linestyle='None', markersize=15, label='Goal') robot = plt.Circle(robot_positions[0], self.robot.radius, fill=True, color=robot_color) ax.add_artist(robot) ax.add_artist(goal) plt.legend([robot, goal], ['Robot', 'Goal'], fontsize=16) # add humans and their numbers human_positions = [[ state[1][j].position for j in range(len(self.humans)) ] for state in self.states] humans = [ plt.Circle(human_positions[0][i], self.humans[i].radius, fill=False) for i in range(len(self.humans)) ] human_numbers = [ plt.text(humans[i].center[0] - x_offset, humans[i].center[1] - y_offset, str(i), color='black', fontsize=12) for i in range(len(self.humans)) ] for i, human in enumerate(humans): ax.add_artist(human) ax.add_artist(human_numbers[i]) # add time annotation time = plt.text(-1, 5, 'Time: {}'.format(0), fontsize=16) ax.add_artist(time) # compute attention scores if self.attention_weights is not None: attention_scores = [ plt.text(-5.5, 5 - 0.5 * i, 'Human {}: {:.2f}'.format( i + 1, self.attention_weights[0][i]), fontsize=16) for i in range(len(self.humans)) ] # compute orientation in each step and use arrow to show the direction radius = self.robot.radius if self.robot.kinematics == 'unicycle': orientation = [ ((state[0].px, state[0].py), (state[0].px + radius * np.cos(state[0].theta), state[0].py + radius * np.sin(state[0].theta))) for state in self.states ] orientations = [orientation] else: orientations = [] for i in range(self.human_num + 1): orientation = [] for state in self.states: if i == 0: agent_state = state[0] else: agent_state = state[1][i - 1] theta = np.arctan2(agent_state.vy, agent_state.vx) orientation.append( ((agent_state.px, agent_state.py), (agent_state.px + radius * np.cos(theta), agent_state.py + radius * np.sin(theta)))) orientations.append(orientation) arrows = [ patches.FancyArrowPatch(*orientation[0], color=arrow_color, arrowstyle=arrow_style) for orientation in orientations ] for arrow in arrows: ax.add_artist(arrow) global_step = 0 def update(frame_num): nonlocal global_step nonlocal arrows global_step = frame_num robot.center = robot_positions[frame_num] for i, human in enumerate(humans): human.center = human_positions[frame_num][i] human_numbers[i].set_position((human.center[0] - x_offset, human.center[1] - y_offset)) for arrow in arrows: arrow.remove() arrows = [ patches.FancyArrowPatch(*orientation[frame_num], color=arrow_color, arrowstyle=arrow_style) for orientation in orientations ] for arrow in arrows: ax.add_artist(arrow) if self.attention_weights is not None: human.set_color( str(self.attention_weights[frame_num][i])) attention_scores[i].set_text('human {}: {:.2f}'.format( i, self.attention_weights[frame_num][i])) time.set_text('Time: {:.2f}'.format(frame_num * self.time_step)) def plot_value_heatmap(): assert self.robot.kinematics == 'holonomic' for agent in [self.states[global_step][0] ] + self.states[global_step][1]: print(('{:.4f}, ' * 6 + '{:.4f}').format( agent.px, agent.py, agent.gx, agent.gy, agent.vx, agent.vy, agent.theta)) # when any key is pressed draw the action value plot fig, axis = plt.subplots() speeds = [0] + self.robot.policy.speeds rotations = self.robot.policy.rotations + [np.pi * 2] r, th = np.meshgrid(speeds, rotations) z = np.array(self.action_values[global_step % len(self.states)][1:]) z = (z - np.min(z)) / (np.max(z) - np.min(z)) z = np.reshape(z, (16, 5)) polar = plt.subplot(projection="polar") polar.tick_params(labelsize=16) mesh = plt.pcolormesh(th, r, z, vmin=0, vmax=1) plt.plot(rotations, r, color='k', ls='none') plt.grid() cbaxes = fig.add_axes([0.85, 0.1, 0.03, 0.8]) cbar = plt.colorbar(mesh, cax=cbaxes) cbar.ax.tick_params(labelsize=16) plt.show() def on_click(event): anim.running ^= True if anim.running: anim.event_source.stop() if hasattr(self.robot.policy, 'action_values'): plot_value_heatmap() else: anim.event_source.start() fig.canvas.mpl_connect('key_press_event', on_click) anim = animation.FuncAnimation(fig, update, frames=len(self.states), interval=self.time_step * 1000) anim.running = True if output_file is not None: ffmpeg_writer = animation.writers['ffmpeg'] writer = ffmpeg_writer(fps=8, metadata=dict(artist='Me'), bitrate=1800) anim.save(output_file, writer=writer) else: plt.show() else: raise NotImplementedError
def line(self, _color=None) -> plt.Line2D: return plt.Line2D((self.p.x, self.q.x), (self.p.y, self.q.y), label=self.m, color=_color)
def plot_with_smart_legend(hi): """ """ # plt the different X and chi lines: all countries in one plot #################################################################################################################### plt.figure(figsize=(12, 7)) X_axis = plt.gca() chi_axis = X_axis.twinx() colors = sb.color_palette("bright", 2) markers = ['s', 'o', 'D', 'H', '^', 'x', '1', 'p', '*', 'X', '2', '4'] fontsize = 14 lines = [] labels = [] for i, (whatever) in enumerate(whatevers): ax.plot(whatever, marker=markers[i]) axt.plot(whatever) p = plt.Line2D( (0, 1), (0, 0), color='black', linestyle='--', fillstyle='none', marker=markers[i], markersize=12, ) l = 'exports from %s to %s' % (c1, c2) lines += [p] labels += [l] X_axis.legend(lines, labels, loc='best', fontsize=fontsize, title='country pairs') chi_axis.grid(False) # add properly colored axis ################################################################################################################ customaxis( ax=X_axis, position='left', color=colors[0], label=r'trade matrix $X_{ik}$ in billion USD', scale='linear', size=fontsize, full_nrs=False, ) customaxis( ax=chi_axis, position='right', color=colors[1], label=r'ease matrix $\chi_{ik}$', scale='linear', size=fontsize, full_nrs=False, ) # add title and save to the output ################################################################################################################ plt.savefig(folder + 'all_together.pdf', bbox_inches='tight') plt.close()
def plot_eval_depth_lea_2d(evals_lea, depths_lea, evals_2d, depths_2d, path=None): """Plot LEA & 2D comparison at evaluation points along depth. Args: evals_* [P x D x 6]: superposition results at evaluation points. P is No. of points, D is No. of depth, 6 is result fields ['Displacement_X', 'Displacement_Y', 'Displacement_Z', 'Normal_X', 'Normal_Y', 'Normal_Z']. depths_* [D x 1]: depth values (negative!) path [str]: path for saving figure. None if plot only. """ # legend custom_legend = [ plt.Line2D([], [], marker='o', color='red', linestyle='None'), plt.Line2D([], [], marker='o', color='blue', linestyle='None') ] for i in range(len(evals_lea)): fig = plt.figure() ax = fig.subplots(ncols=2) # y is depth plt.suptitle('Responses at Evaluation Point {}'.format(i), y=0.01) ax[0].set_xlabel('Vertical Displacement (in.)') ax[1].set_xlabel('Vertical Stress (psi)') ax[0].set_xlim( 0, max(np.max(evals_lea[i][:, 2]), np.max(evals_2d[i][:, 2])) * 1.3) data = evals_lea[i] # D x 6 ax[0].plot(data[:, 2], depths_lea, marker='o', color='red', markersize=2) ax[1].plot(data[:, 5], depths_lea, marker='o', color='red', markersize=2) data = evals_2d[i] # D x 6 ax[0].plot(data[:, 2], depths_2d, marker='o', color='blue', markersize=2) ax[1].plot(data[:, 5], depths_2d, marker='o', color='blue', markersize=2) for j in range(2): # two subplots ax[j].xaxis.set_ticks_position('top') ax[j].xaxis.set_label_position('top') ax[j].minorticks_on() ax[j].grid(which='major', linestyle='-', color='gray') ax[j].grid(which='minor', linestyle='--') ax[j].set_ylabel('Depth (in.)') ax[j].tick_params(labelsize='small') ax[j].legend(custom_legend, ['WinJULEA', '2D Superposition'], loc='lower right', fontsize='small', framealpha=0.5) plt.tight_layout() if path != None: plt.savefig(os.path.join(path, 'eval_{}_lea_2d.png'.format(i)), dpi=300, bbox_inches='tight') plt.close(fig) else: plt.show()
def plot_multi_loss_history(self, histories, highlight_best_count=0, title="", lim_x=None, lim_y=None): # e.g. histories = { (param0, param1): {loss: ..., val_loss: ..., ...}, (param0, param1): {loss: ..., val_loss: ..., ...} } loss_histories = {} val_loss_histories = {} for parameter, hist in histories.items(): for metric, value in hist.items(): if "loss" == metric: loss_histories[parameter] = value if "val_loss" == metric: val_loss_histories[parameter] = value assert len(loss_histories) == len(val_loss_histories), ( "loss and val_loss must be of same length") fig, ax = plt.subplots(1, 1, figsize=(8, 8)) colormap = plt.cm.gist_ncar # style definition loss_style = dict(alpha=0.15 if highlight_best_count > 0 else 0.5, linestyle='-') val_loss_style = dict(alpha=0.15 if highlight_best_count > 0 else 0.5, linestyle='--') # draw loss for idx, (parameter, hist) in enumerate(loss_histories.items()): # Setup plot color color = colormap(idx / len(loss_histories)) # Plot histories ax.plot(hist, color=color, label=str(round_tuple(parameter, sig=3)), **loss_style) # draw val loss for idx, (parameter, hist) in enumerate(val_loss_histories.items()): # Setup plot color color = colormap(idx / len(val_loss_histories)) # Plot histories ax.plot(hist, color=color, **val_loss_style) # higlight the best val_loss if highlight_best_count > 0: val_loss = val_loss_histories.items() sorted_val_loss = nsmallest(len(val_loss), enumerate(val_loss), key=lambda x: x[1][1][-1]) for i in range(0, highlight_best_count): idx = sorted_val_loss[i][0] parameter = sorted_val_loss[i][1][0] color = colormap(idx / len(val_loss_histories)) highlight_style = loss_style highlight_style["alpha"] = 0.9 highlight_style["linestyle"] = "-" ax.plot(loss_histories[parameter], color=color, label=str(round_tuple(parameter, sig=3)), **highlight_style) highlight_style = val_loss_style highlight_style["alpha"] = 0.9 highlight_style["linestyle"] = "--" ax.plot(val_loss_histories[parameter], color=color, **highlight_style) if lim_x is not None: ax.set_xlim(lim_x[0], lim_x[1]) if lim_y is not None: ax.set_ylim(lim_y[0], lim_y[1]) ax.set_axisbelow(True) ax.grid(linewidth='0.5') ax.set_ylabel("Loss") ax.set_xlabel("Epoch") ax.xaxis.set_major_locator( MaxNLocator(integer=True)) # force integer values on epoch axis # Labels to display handles, labels = ax.get_legend_handles_labels() #Create custom artists cust_loss_style = loss_style cust_loss_style["alpha"] = 1.0 training = plt.Line2D((0, 1), (0, 0), color='k', **cust_loss_style) cust_loss_style = val_loss_style cust_loss_style["alpha"] = 1.0 validation = plt.Line2D((0, 1), (0, 0), color='k', **cust_loss_style) handles = [handle for i, handle in enumerate(handles) ] + [training, validation] labels = [label for i, label in enumerate(labels) ] + ['Training', 'Validation'] ## Shrink current axis by 20% # box = ax.get_position() # ax.set_position([box.x0, box.y0, box.width * 0.8, box.height]) #Create legend from custom artist/label lists ncols = ceil(len(handles) / 20) # 20 entries per column ncols = max(1, ncols) ax.legend(handles, labels, ncol=ncols, loc='center left', bbox_to_anchor=(1, 0.5)) fig.suptitle(title, fontsize=20) self._figures.append(fig)
def visualize3DData(X, scale, cmap): """Visualize data in 3d plot with popover next to mouse position. Args: X (np.array) - array of points, of shape (numPoints, 3) Returns: None """ fig = plt.figure(figsize=(16, 10)) ax = fig.add_subplot(111, projection='3d') im = ax.scatter(X[:, 0], X[:, 1], X[:, 2], c=X[:, 3], s=X[:, 4] * scale, cmap=cmap, alpha=1, picker=True) ax.set_xlabel('OBJECTIVE 1') ax.set_ylabel('OBJECTIVE 2') ax.set_zlabel('OBJECTIVE 3') cbar = fig.colorbar(im) cbar.ax.set_ylabel('OBJECTIVE 4') objs = X[:, 4] max_size = np.amax(objs) * scale / 32.0 min_size = np.amin(objs) * scale / 4.5 handles, labels = ax.get_legend_handles_labels() display = (0, 1, 2) size_max = plt.Line2D((0, 1), (0, 0), color='k', marker='o', markersize=max_size, linestyle='') size_min = plt.Line2D((0, 1), (0, 0), color='k', marker='o', markersize=min_size, linestyle='') legend1 = ax.legend( [handle for i, handle in enumerate(handles) if i in display] + [size_max, size_min], [label for i, label in enumerate(labels) if i in display] + ["%.2f" % (np.amax(objs)), "%.2f" % (np.amin(objs))], labelspacing=1.5, title='OBJECTIVE 5', loc=1, frameon=True, numpoints=1, markerscale=1) def distance(point, event): """Return distance between mouse position and given data point Args: point (np.array): np.array of shape (3,), with x,y,z in data coords event (MouseEvent): mouse event (which contains mouse position in .x and .xdata) Returns: distance (np.float64): distance (in screen coords) between mouse pos and data point """ assert point.shape == ( 3, ), "distance: point.shape is wrong: %s, must be (3,)" % point.shape # Project 3d data space to 2d data space x2, y2, _ = proj3d.proj_transform(point[0], point[1], point[2], plt.gca().get_proj()) # Convert 2d data space to 2d screen space x3, y3 = ax.transData.transform((x2, y2)) return np.sqrt((x3 - event.x)**2 + (y3 - event.y)**2) def calcClosestDatapoint(X, event): """"Calculate which data point is closest to the mouse position. Args: X (np.array) - array of points, of shape (numPoints, 3) event (MouseEvent) - mouse event (containing mouse position) Returns: smallestIndex (int) - the index (into the array of points X) of the element closest to the mouse position """ distances = [distance(X[i, 0:3], event) for i in range(X.shape[0])] return np.argmin(distances) def annotatePlot(X, index): """Create popover label in 3d chart Args: X (np.array) - array of points, of shape (numPoints, 3) index (int) - index (into points array X) of item which should be printed Returns: None """ # If we have previously displayed another label, remove it first if hasattr(annotatePlot, 'label'): annotatePlot.label.remove() # Get data point from array of points X, at position index x2, y2, _ = proj3d.proj_transform(X[index, 0], X[index, 1], X[index, 2], ax.get_proj()) annotatePlot.label = plt.annotate("index: %d" % index, xy=(x2, y2), xytext=(-20, 20), textcoords='offset points', ha='right', va='bottom', bbox=dict(boxstyle='round,pad=0.5', fc='yellow', alpha=0.5), arrowprops=dict( arrowstyle='->', connectionstyle='arc3,rad=0')) fig.canvas.draw() def onMouseMotion(event): """Event that is triggered when mouse is moved. Shows text annotation over data point closest to mouse.""" closestIndex = calcClosestDatapoint(X, event) annotatePlot(X, closestIndex) fig.canvas.mpl_connect('motion_notify_event', onMouseMotion) # on mouse motion plt.show()
# Move the final axis' ticks to the right-hand side ax = plt.twinx(axes[-1]) dim = len(axes) ax.xaxis.set_major_locator(ticker.FixedLocator([x[-2], x[-1]])) set_ticks_for_axis(dim, ax, ticks=6) ax.set_xticklabels([cols[-2], cols[-1]]) # Remove space between subplots plt.subplots_adjust(wspace=0) # Add legend to plot plt.legend( [plt.Line2D((0,1),(0,0), color=colours[cat]) for cat in df['cluster'].cat.categories], df['cluster'].cat.categories, bbox_to_anchor=(1, 0.5), loc='center left', borderaxespad=0.) plt.title("Centroides por Cluster - Data Original") plt.show()
def make_legend(categories, ax, ncol=3, legend_type=LINE, alpha=1): ''' Helper function responsible for making the legend Parameters ---------- categories : str or tuple the categories in the legend ax : axes instance the axes with which the legend is associated ncol : int the number of columns to use legend_type : {LINES, SCATTER, PATCH} whether the legend is linked to lines, patches, or scatter plots alpha : float the alpha of the artists ''' some_identifiers = [] labels = [] for i, category in enumerate(categories): color = get_color(i) if legend_type == LINE: artist = plt.Line2D([0, 1], [0, 1], color=color, alpha=alpha) # TODO elif legend_type == SCATTER: # marker_obj = mpl.markers.MarkerStyle('o') # path = marker_obj.get_path().transformed( # marker_obj.get_transform()) # artist = mpl.collections.PathCollection((path,), # sizes = [20], # facecolors = COLOR_LIST[i], # edgecolors = 'k', # offsets = (0,0) # ) # TODO work arround, should be a proper proxyartist for scatter legends artist = mpl.lines.Line2D([0], [0], linestyle="none", c=color, marker='o') elif legend_type == PATCH: artist = plt.Rectangle((0, 0), 1, 1, edgecolor=color, facecolor=color, alpha=alpha) some_identifiers.append(artist) if type(category) == tuple: label = '%.2f - %.2f' % category else: label = category labels.append(str(label)) ax.legend(some_identifiers, labels, ncol=ncol, loc=3, borderaxespad=0.1, mode='expand', bbox_to_anchor=(0., 1.1, 1., .102))
# plot the joint distribution plt.subplot(plotgrid[0, 0]) # plot the contour plot of the exact posterior (c_levels is used to give # a vector of linearly spaced values at which levels contours are drawn) c_levels = np.linspace(1e-5, Z.max(), 6)[:-1] plt.contour(t1, t2, Z, c_levels, colors='blue') # plot the samples from the joint posterior samps = plt.scatter(mu, sigma, 5, color=[0.25, 0.75, 0.25]) # decorate plt.xlim(tl1) plt.ylim(tl2) plt.xlabel('$\mu$', fontsize=20) plt.ylabel('$\sigma$', fontsize=20) plt.title('joint posterior') plt.legend((plt.Line2D([], [], color='blue'), samps), ('exact contour plot', 'samples')) # plot the marginal of mu plt.subplot(plotgrid[1, 0]) # empirical plt.plot(t1, pk_mu, color='#ff8f20', linewidth=2.5, label='empirical') # exact plt.plot(t1, pm_mu, 'k--', linewidth=1.5, label='exact') # decorate plt.xlim(tl1) plt.title('marginal of $\mu$') plt.yticks(()) plt.legend() # plot the marginal of sigma
wrist.prv3DErr *= 0 # temperature magnitude if epoch < 10000: T = 1. * utils.clipped_exp(-epoch / float(maxEpoch)) # INIT PLOTTING if epoch == startPlotting: #♣ INIT plotting fig1 = plt.figure("Workspace", figsize=(80, 80), dpi=120) gs = plt.GridSpec(1, 2, width_ratios=[3, 3]) # MAZE COORDINATES # north track line1 = plt.Line2D([4.5, 4.5], [6.2, 9.5], color='black') line2 = plt.Line2D([4.5, 5.5], [9.5, 9.5], color='black') line3 = plt.Line2D([5.5, 5.5], [6.2, 9.5], color='black') line4 = plt.Line2D([4.5, 5.5], [6.2, 6.2], color='silver') circle1 = plt.Circle((5, 9.24), 0.7, color='springgreen') edgecircle1 = plt.Circle((5, 9.24), 0.7, color='black', fill=False) # north east track line5 = plt.Line2D([5.5, 8], [6.2, 8.7], color='black') line6 = plt.Line2D([8, 8.7], [8.7, 8], color='black') line7 = plt.Line2D([8.7, 6.2], [8, 5.5], color='black') line8 = plt.Line2D([5.5, 6.2], [6.2, 5.5], color='silver') circle2 = plt.Circle((8, 8), 0.7, color='springgreen') edgecircle2 = plt.Circle((8, 8), 0.7, color='black', fill=False) # east track line9 = plt.Line2D([6.20, 9.5], [5.5, 5.5], color='black') line10 = plt.Line2D([9.5, 9.5], [5.5, 4.5], color='black')
def plot_statistics(stat_type, y1, y2): """stat_type is either "location_error" or "vorticity_bias" """ fig, ax = plt.subplots() fig.set_size_inches(6, 6) year_data_analysis = np.genfromtxt(datadir + "average_" + str(stat_type) + "_per_lead_time_vs_analysis.txt") year_data_ibtracs = np.genfromtxt(datadir + "average_" + str(stat_type) + "_per_lead_time_vs_ibtracs.txt") x = np.arange(0, 7.25, 0.25) plt.plot(x, year_data_analysis, color='k') plt.plot(x, year_data_ibtracs, color='k', linestyle='--') list_of_files = os.listdir(datadir) ib_pattern = "tr*_average_" + stat_type + "*_ibtracs.txt" an_pattern = "tr*_average_" + stat_type + "*_analysis.txt" ib_files_to_plot = [] an_files_to_plot = [] for entry in list_of_files: if fnmatch.fnmatch(entry, ib_pattern): ib_files_to_plot.append(datadir + entry) elif fnmatch.fnmatch(entry, an_pattern): an_files_to_plot.append(datadir + entry) ib_storms_stats = np.genfromtxt(ib_files_to_plot[0]) for ff, i in zip(ib_files_to_plot, range(1, len(ib_files_to_plot))): ib_data = np.genfromtxt(ff) ib_storms_stats = np.vstack([ib_storms_stats, ib_data]) an_storms_stats = np.genfromtxt(an_files_to_plot[0]) for ff, i in zip(an_files_to_plot, range(1, len(an_files_to_plot))): an_data = np.genfromtxt(ff) an_storms_stats = np.vstack([an_storms_stats, an_data]) ib_storms_stats[ib_storms_stats == 0] = np.nan an_storms_stats[an_storms_stats == 0] = np.nan ib_maxline, ib_minline, an_maxline, an_minline = (np.zeros(29) for i in range(4)) for lt in range(29): ib_maxline[lt] = np.nanmax(ib_storms_stats[:, lt]) ib_minline[lt] = np.nanmin(ib_storms_stats[:, lt]) an_maxline[lt] = np.nanmax(an_storms_stats[:, lt]) an_minline[lt] = np.nanmin(an_storms_stats[:, lt]) ax.fill_between(x, ib_minline, ib_maxline, facecolor='b', edgecolor='b', alpha=0.2, linestyle='--') ax.fill_between(x, an_minline, an_maxline, facecolor='b', edgecolor='b', alpha=0.2) plt.xlim(0, 7) plt.xticks(fontsize=8) plt.yticks(fontsize=8) plt.xlabel('Lead Time (Days)', fontsize=10) if stat_type == "location_error": plt.ylabel('Track Error (km)', fontsize=10) plt.ylim(bottom=0) elif stat_type == "mslp_bias": plt.ylabel('MSLP Bias (hPa)', fontsize=10) elif stat_type == "wind_bias": plt.ylabel(r'10m Wind Bias (ms$^{-1}$)', fontsize=10) an = plt.Line2D((0, 1), (0, 0), color='k', linewidth=0.5, label='Mean error vs. analysis') ib = plt.Line2D((0, 1), (0, 0), color='k', linestyle='--', linewidth=0.5, label='Mean error vs. IBTrACS') spread = mpatches.Patch(color='b', alpha=0.2, label='Spread across storms') legend = ax.legend(handles=[an, ib, spread], fontsize=8, loc='upper left', title="South-West Indian Ocean\n" + y1 + "-" + y2 + ", " + str(NS) + " Cyclones") legend._legend_box.align = "left" plt.setp(legend.get_title(), fontsize='8') plt.savefig(savedir + y1 + "_" + y2 + "_" + stat_type + ".png", dpi=400)