def my_legend(ax, pl_list, text, x, y, size, which, plt): l = Legend(ax, pl_list[which - 1:which], (text, ), loc=(x, y)) ltext = l.get_texts() # all the text.Text instance in the legend #plt.setp(ltext, fontsize='medium', linespacing=1) # the legend text fontsize plt.setp(ltext, fontsize=size, linespacing=1) # the legend text fontsize l.draw_frame(False) # don't draw the legend frame ax.add_artist(l)
def checkboxLegend(parent, *args, **kwargs): """ Creates a Legend with checkboxes to toggle visibility of all elements corresponding to entries in the legend Parameters ---------- parent : `~matplotlib.axes.Axes` or `.Figure` The artist that contains the legend. """ # get user genarated handler_map, and set handlelength to a default of 3 custom_handler_map = kwargs.get('handler_map', {}) if kwargs.get('handlelength', None) is None: kwargs['handlelength'] = 3 # update a default handler map to include user genarated handler_map hm = Legend.get_default_handler_map().copy() hm.update(custom_handler_map) # create interactive version of the new handler map for handler in hm: hm[handler] = VisibilityHandler( handler=Legend.get_legend_handler(hm, handler)) kwargs['handler_map'] = hm # return interactive legend return parent.legend(*args, **kwargs)
def plot_traps_legend(): plt.subplot(1, 3, 1) Legend.update_default_handler_map({str: TextHandlerB()}) plt.legend(handles=["S", "N", "R"], labels=["Security", "Normal", "Risky"], title="Dices", loc='center') plt.axis('off') plt.subplot(1, 3, 2) # handle1 = mpatches.FancyBboxPatch((0,0), 10, 10, boxstyle='Square, pad=0.5', facecolor='#f6f4f4', lw=0, label="False") # handle2 = mpatches.FancyBboxPatch((0,0), 10, 10, boxstyle='Circle, pad=0.5', facecolor='#f6f4f4', lw=0, label="False") handle1, = Line2D([0], [0], marker='s', color='w', label='False', markerfacecolor='lightgray', markersize=11), handle2, = Line2D([0], [0], marker='o', color='w', label='True', markerfacecolor='lightgray', markersize=11), plt.legend(handles=[handle1, handle2], loc='center', title='Circle') plt.axis('off') plt.subplot(1, 3, 3) handles = [] for i, label in enumerate(traps_label): if label: patch = mpatches.Patch(label=label, color=traps_color[i]) handles.append(patch) plt.legend(handles=handles, loc='center', title="Traps") plt.axis('off')
def plot_dos(self, filename='dos.png', smear=None, styles='t', xlim=[-3, 3]): """export dos""" efermi = self.values['calculation']['efermi'] tdos = np.array(self.values['calculation']['tdos'][0]) tdos[:, 0] -= efermi e = tdos[:, 0] rows = (e > xlim[0]) & (e < xlim[1]) e = e[rows] plt_obj = {} for option in styles.split('+'): if option == 'spd': option = ['s', 'p', 'd'] else: option = [option] for style in option: mydos, labels = self.get_dos(rows, style) for data, label in zip(mydos, labels): plt_obj[label] = data fig, ax = plt.subplots() lines1 = [] lines2 = [] labels1 = [] labels2 = [] for label in plt_obj.keys(): e = np.reshape(e, [len(e), 1]) data = np.reshape(plt_obj[label], [len(e), 1]) if smear is not None: data = np.hstack((e, data)) data = smear_data(data, smear) data = data[:, 1] if label.find('down') > 0: lines2 += ax.plot(e, data) labels2.append(label) else: lines1 += ax.plot(e, data) labels1.append(label) leg1 = ax.legend(lines1, [label for label in labels1], fancybox=True, loc='upper right') leg1.get_frame().set_alpha(0.5) if len(lines2) > 0: from matplotlib.legend import Legend leg2 = Legend(ax, lines2, [label for label in labels2], fancybox=True, loc='lower right') ax.add_artist(leg2) leg2.get_frame().set_alpha(0.5) plt.xlabel("Energy (eV)") plt.ylabel("DOS") plt.xlim(xlim) plt.savefig(filename)
def test_checkbox_legend_default_handler_set(): line1, = plt.plot([1, 2], [1, 2], color='r', lw=2) handler_map = {line1: ExampleHandler()} Legend.set_default_handler_map(handler_map) legend = checkboxLegend(plt, [line1], ["R"], fontsize=16) assert isinstance(legend.get_legend_handler_map()[line1], VisibilityHandler) assert isinstance(legend.get_legend_handler_map()[line1].handler, ExampleHandler)
def plot_scatter(dfs, sig1, sig2, hue='agent', alpha='dose', color_dict=None, marker='o', plot_legend=True, ax=None): if ax is None: fig, ax = plt.subplots(1, 1) labels = dfs[hue].unique() if color_dict is None: colrs = sns.color_palette("husl", len(labels)) color_dict = {} for i, label in enumerate(labels): color_dict[label] = colrs[i] + (1,) for ftr in dfs[hue].unique(): dfis = dfs[dfs[hue] == ftr] x = dfis[sig1].tolist() y = dfis[sig2].tolist() rgba_colors = np.zeros((dfis.shape[0], 4)) rgba_colors[:, :] = color_dict[ftr] edge_colors = rgba_colors.copy() if alpha is not None: amin = dfs[alpha].min() amax = dfs[alpha].max() rgba_colors[:, 3] = [1 - (al-amin)/amax for al in dfis[alpha].tolist()] sizes = [100 * al for al in dfis[alpha].tolist()] ax.scatter(y, x, s=sizes, facecolor=rgba_colors, edgecolor=edge_colors, lw=1, marker=marker) # Legends # ------- if plot_legend: hue_recs = [] for label in color_dict.keys(): hue_recs.append(mpatches.Rectangle((0, 0), 1, 1, fc=color_dict[label])) alpha_circles = [] amin = dfs[alpha].min() amax = dfs[alpha].max() for ds in np.sort(dfs[alpha].unique()): alpha_val = 1 - (ds - amin)/amax gray_alpha = (128/255, 128/255, 128/255) + (alpha_val,) alpha_circles.append( mpatches.Circle((0, 0), radius=5, fc=gray_alpha)) legend1 = Legend(parent=ax, handles=hue_recs, labels=color_dict.keys(), loc=(0.6, 0.02), title='drug') legend2 = Legend(parent=ax, handles=alpha_circles, labels=[1 * d for d in np.sort(dfs['dose'].unique())], loc=4, title='dose', handler_map={mpatches.Circle: HandlerEllipse()}) ax.add_artist(legend2).get_frame().set_edgecolor("black") ax.add_artist(legend1).get_frame().set_edgecolor("black")
def add_legends(self, legend_infos: List[LegendInfo]) -> None: """Adds the legends """ # # old way (keep it for fast hacking of plots if need be) # # this creates a legend box on the bottom, and algorithm names on the right with some angle to avoid overlapping # self._overlays.append(self._ax.legend(fontsize=7, ncol=2, handlelength=3, # loc='upper center', bbox_to_anchor=(0.5, -0.2))) # upperbound = self._ax.get_ylim()[1] # filtered_legend_infos = [i for i in legend_infos if i.y <= upperbound] # for k, info in enumerate(filtered_legend_infos): # angle = 30 - 60 * k / len(legend_infos) # self._overlays.append(self._ax.text(info.x, info.y, info.text, {'ha': 'left', 'va': 'top' if angle < 0 else 'bottom'}, # rotation=angle)) # new way ax = self._ax trans = ax.transScale + ax.transLimits fontsize = 10.0 display_y = (ax.transAxes.transform((1, 1)) - ax.transAxes.transform((0, 0)))[1] # height in points shift = (2.0 + fontsize) / display_y legend_infos = legend_infos[::-1] # revert order for use in compute_best_placements values = [float(np.clip(trans.transform((0, i.y))[1], -0.01, 1.01)) for i in legend_infos] placements = compute_best_placements(values, min_diff=shift) for placement, info in zip(placements, legend_infos): self._overlays.append( Legend(ax, info.line, [info.text], loc="center left", bbox_to_anchor=(1, placement), frameon=False, fontsize=fontsize) ) ax.add_artist(self._overlays[-1])
def legendbox(text, ax=None, loc=0, *args, **kwargs): """Create a legend from class matplotlib.legend.Legend and add it to axis. `text` is a list of strings to be passed to `labels` parameter in Legend. Unclear how line styles are set (probably none). """ from matplotlib.patches import Patch from matplotlib.legend import Legend #------ SAME BUT WITH CUSTOM LEGEND (DOESN'T ERASE OTHER LEGENDS) #plt.plot([1,2],[2,3],label='cane') #plt.legend(loc=1) #pdb.set_trace() if np.size(text) == 1 and not isinstance(text, list): text = [text] if ax is None: ax = plt.gca() p = [Patch(label=ll, visible=False) for ll in text] leg = Legend(ax, p, text, loc=loc, handletextpad=0, handlelength=0, *args, **kwargs) ax.add_artist(leg) return leg
def plotLines(dataSource, feature, loc1, loc2, filename): fig = plt.figure(figsize=(6, 6), dpi=720) requests_plot = fig.add_subplot(1, 1, 1) lines, legends = [], [] for method in ['direct', 'nginx']: if dataSource == 'locust': df0 = locust[method] if dataSource == 'cmonitor': df0 = cmonitor[method] for wsgi in ['gunicorn', 'uwsgi', 'uwsgi-http', 'werkzeug']: if wsgi in df0.keys(): df = df0[wsgi] legends.append(wsgi) lines += requests_plot.plot(df['Timestamp'], df[feature], linestyle=linestyles[method], color=colors[wsgi]) requests_plot.legend(lines[0:3], legends[0:3], loc=loc1, prop={'size': 10}, frameon=True) leg = Legend(requests_plot, lines[3:7], legends[3:7], loc=loc2, prop={'size': 10}, frameon=True) requests_plot.add_artist(leg) fig.savefig(folder + '/' + filename + '.png', format='png', dpi=720) plt.close(fig)
def add_legends(self, legend_infos: tp.List[LegendInfo]) -> None: """Adds the legends """ ax = self._ax trans = ax.transScale + ax.transLimits fontsize = 10.0 display_y = (ax.transAxes.transform((1, 1)) - ax.transAxes.transform( (0, 0)))[1] # height in points shift = (2.0 + fontsize) / display_y legend_infos = legend_infos[:: -1] # revert order for use in compute_best_placements values = [ float(np.clip(trans.transform((0, i.y))[1], -0.01, 1.01)) for i in legend_infos ] placements = compute_best_placements(values, min_diff=shift) for placement, info in zip(placements, legend_infos): self._overlays.append( Legend(ax, info.line, [info.text], loc="center left", bbox_to_anchor=(1, placement), frameon=False, fontsize=fontsize)) ax.add_artist(self._overlays[-1])
def _plot_distributions_and_alignment(X, Y, R=None, thr=.1, title=None, tick_params=tick_params): fig, ax = plt.subplots(figsize=(3.5, 3.5)) plt.plot(X[:, 0], X[:, 1], 'og', label='Source samples') plt.plot(Y[:, 0], Y[:, 1], 'or', label='Target samples') plt.legend() if R is not None: # if R has some negative coeffs, plot them too in red if not (R >= 0).all(): _plot2D_samples_mat(X, Y, -R, thr=thr, c=[1, 0.2, 0.2]) colors = ['blue', 'red'] lines = [Line2D([0], [0], color=c, linewidth=2) for c in colors] labels = ['Positive coeffs', 'Negative coeffs'] leg = Legend(ax, lines, labels, loc='upper left', fontsize=10) ax.add_artist(leg) plt.legend() # Then plot R positive coeffs above a threshold in blue _plot2D_samples_mat(X, Y, R, thr=thr, c=[0.2, 0.2, 1]) plt.rcParams.update({ 'font.size': 12, 'ytick.labelsize': 14, 'xtick.labelsize': 14, 'axes.titlesize': 14, "axes.labelsize": 12 }) plt.xlabel('Contrast 1', fontsize=14) plt.ylabel('Contrast 2', fontsize=14) plt.tick_params(**tick_params) plt.title(title, fontsize=16)
def MultiPlot3(DF, Tsample1): #region -------- Generating Title ------------ print("*** Title already begins with 'Graph to show ' ***") title = input("Enter Desired Graph Title:") GraphName = title GraphName = GraphName.replace(" ", "_") #endregion #region -------- Plot Dimensions ------------- fig, ax = plt.subplots(num=None, figsize=(8, 3.5), facecolor='w', edgecolor='k') #endregion #region ---------- Plot Data ----------------- # - empty lists for Styles & Data lines = [] MeanLines = [] Collumns = [] styles = ['-', '--'] for col in DF.columns: Collumns.append(col) # - Solid Lines Styling and Data lines += ax.plot(DF[col].resample("2T").mean(), styles[0], alpha=0.7, color=Clr_Palete[col][2], linewidth=0.75) # - Average lines Styling and Data MeanLines += ax.plot(DF[col].resample('{}H'.format(Tsample1)).mean(), styles[1], color=Clr_Palete[col][4], linewidth=1.5) #endregion #region ---------- Plot Legend --------------- # specify the lines and labels of the first legend ax.legend(lines, Collumns, loc='upper right', frameon=False) # Create the second legend and add the artist manually. Collumns = [ '{} / {} Hours'.format(element, Tsample1) for element in Collumns ] leg = Legend(ax, MeanLines, Collumns, loc='upper left', frameon=False) ax.add_artist(leg) #endregion #region ------- Plot Periferals -------------- # - - Graph Title plt.title("Graph to show {}".format(title)) # - - - Puts "$" infront of Y axis tick = mtick.FormatStrFormatter('$%.0f') ax.yaxis.set_major_formatter(tick) # - - - - Reduces White Boarder Size plt.tight_layout() #endregion #region --------- Saving Plot --------------- plt.savefig("Graphs/Predictions/CompoundPlots/{}_avg{}.png".format( GraphName, Tsample1), dpi=My_DPI) #endregion plt.show()
def tag(tagstr, **kwargs): from matplotlib.legend import Legend ax = plt.gca() h, = ax.plot(np.NaN, np.NaN, '-', color='none') # empty line for legend leg = Legend(ax, (h,), (tagstr,), handlelength=0, handletextpad=0, **kwargs) for item in leg.legendHandles: item.set_visible(False) ax.add_artist(leg)
def scatter_football(x, y, ax=None, **kwargs): """ Scatter plot of football markers. Plots two scatter plots one for the hexagons and one for the pentagons of the football. Parameters ---------- x, y : array-like or scalar. Commonly, these parameters are 1D arrays. ax : matplotlib.axes.Axes, default None The axis to plot on. **kwargs : All other keyword arguments are passed on to matplotlib.axes.Axes.scatter. Returns ------- (paths, paths) : a tuple of matplotlib.collections.PathCollection """ linewidths = kwargs.pop('linewidths', 0.5) hexcolor = kwargs.pop('c', 'white') pentcolor = kwargs.pop('edgecolors', 'black') s = kwargs.pop('s', 500) sc_hex = ax.scatter(x, y, edgecolors=pentcolor, c=hexcolor, linewidths=linewidths, marker=football_hexagon_marker, s=s, **kwargs) if 'label' in kwargs.keys(): Legend.update_default_handler_map({sc_hex: HandlerFootball()}) del kwargs['label'] sc_pent = ax.scatter(x, y, edgecolors=pentcolor, c=pentcolor, linewidths=linewidths, marker=football_pentagon_marker, s=s, **kwargs) return sc_hex, sc_pent
def individual_plot(data_dir, plot_dir, mode): variants = OrderedDict() variants['1_near'] = ([], []) variants['2_near'] = ([], []) variants['1_far'] = ([], []) variants['2_far'] = ([], []) variants['1_near_1_far'] = ([], []) labels = [] lines = [] fig, ax = plt.subplots(1, 1, figsize=(4, 3)) for (var, data) in variants.items(): x_vals, y_vals = data get_bandwidth(f"{data_dir}/sequential_{mode}_{var}", var, x_vals, y_vals) print(f"{mode}: {x_vals}") color, marker = VAR_TO_STYLE[var] label = var.replace('_', ' ').replace(' sockets', '').replace(' socket', '').title() labels.append(label) lines += ax.plot(x_vals, y_vals, color=color, marker=marker, markersize=8, label=label) xticks = [1, 4, 8, 16, 18, 24, 32, 36] xtick_labels = ['1', '4', '8', '', '18', '24', '32', '36'] ylim_max = 85 if mode == "read" else 27 if "dram" in data_dir: ylim_max = 200 if mode == "read" else 140 ax.set_xticks(xticks) ax.set_xticklabels(xtick_labels) ax.yaxis.grid(True) ax.set_axisbelow(True) ax.set_ylim(0, ylim_max) ax.set_ylabel('Bandwidth [GB/s]', fontsize=18) ax.set_xlabel('Threads per Socket [#]', fontsize=18) SET_LABEL_SIZE(ax) ax.legend(labels[:-1], frameon=False, bbox_to_anchor=(0.4, 1.35), loc='upper center', fontsize=18, columnspacing=0.4, handletextpad=0.3, labelspacing=0.0, ncol=3, handlelength=1.6) legend_1n1f = Legend(ax, lines[-1:], labels[-1:], frameon=False, bbox_to_anchor=(0.58, 1.25), loc='upper center', fontsize=18, handlelength=1.6, handletextpad=0.3, labelspacing=0.5, ncol=1) ax.add_artist(legend_1n1f) plot_suffix = "_dram" if "dram" in data_dir else "" plot_path = f'{plot_dir}/{mode}_multiple_sockets{plot_suffix}' SAVE_PLOT(plot_path)
def axlegend_vel(ax): 'add custom legend (storm velocity) to axes' # velocity legend lls_vel = [ Line2D([0], [0], color = 'black', ls = 'solid'), Line2D([0], [0], color = 'black', ls = 'dashed'), Line2D([0], [0], color = 'black', ls = 'dashdot'), Line2D([0], [0], color = 'black', ls = 'dotted'), ] leg_vel = Legend( ax, lls_vel, ['> 60 km/h', '> 40 km/h', '> 20 km/h', '< 20 km/h'], title = 'Velocity', bbox_to_anchor = (1.01, 0.7), loc= 'upper left', ) ax.add_artist(leg_vel)
def plot_list(L_value_list, optpdf, color, alpha): class TextHandlerB(HandlerBase): def create_artists(self, legend, text, xdescent, ydescent, width, height, fontsize, trans): tx = Text(width / 2., height / 2, text, fontsize=fontsize, ha="center", va="center", fontweight="normal") return [tx] Legend.update_default_handler_map({str: TextHandlerB()}) f = plt.figure(figsize=(8, 4)) (mu, sigma) = norm.fit(L_value_list) pvalue = norm.pdf(48, mu, sigma) pvalue = "%.2e" % pvalue ax=sns.distplot(pd.Series(L_value_list),bins=np.arange(25,36,1),fit=norm,kde=False,\ kde_kws={"label":"Smooth",'linewidth':1.5,"linestyle":"--","color":"K"},\ fit_kws={'label': 'Normal','linewidth':1.5, "color": "r"},hist_kws={'linewidth':0.05,"color": color,"edgecolor":"black","alpha":alpha,"align":"mid","rwidth":1},label=str(pvalue))#,ax=ax) plt.axvline(48, color='r') legend_i = ax.get_legend_handles_labels() smooth_normal_handles = legend_i[0][:1] smooth_normal_handles.append("Pvalue ") plt.xticks(np.arange(min(L_value_list) - 2, 55, 1)) #max(L_value_list)+3,1)) plt.legend(smooth_normal_handles, legend_i[1], loc='upper right', framealpha=0) plt.ylabel("Probability", fontsize=10, fontweight='semibold') plt.xlabel("Bottleneck Size,n", fontsize=10, fontweight='semibold') plt.title("The distribution of n", fontsize=12, fontweight='bold') plt.tight_layout() plt.savefig(optpdf, dpi=200)
def test_path_collection(self): # Create a small scatter plot plot = plt.scatter([1, 2, 3], [2, 3, 4], c=[3, 4, 5], cmap=cmr.rainforest) # Add a cmap legend entry set_cmap_legend_entry(plot, 'Test') # Check if the plot now has a special handler assert plot in Legend.get_default_handler_map() # Create a legend plt.legend() # Close the plot plt.close()
def LogMag(self): ''' Plots the log values of magnetism versus temperature as well as the lines that divide the sections where we search for the maxium logmag value Parameters : None ''' data = self.data color = self.color _, ax = plt.subplots(1, len(data), sharey=True) TMAX = self.CalcTMax() T_under = np.linspace(2.1, TMAX, 4) T_over = np.linspace(TMAX, 2.8, 4) T = np.sort(np.append(T_under, T_over)) for i, d in enumerate(data): for j, tt in enumerate(T): df = pd.read_csv(d) df = df[df['T'] < tt] logt = np.log10(tt - df['T']) logm = df['LOGM'] ax[i].scatter(logt, logm, color=color[j % len(color)]) if tt == TMAX: line = np.polyfit(logt, logm, 1) line_f = np.poly1d(line) line1 = ax[i].plot(logt, line_f(logt), color=color[j % len(color)], label='Original') ax[i].legend(line1, ['T is %s and Slope is %s' % (tt, line[0])], loc=3) logt_r = np.log10(tt - df['T']) line = np.polyfit(logt_r, logm, 1) line_f = np.poly1d(line) line2 = ax[i].plot(logt, line_f(logt), color='black', label='Outliers Removed') leg = Legend(ax[i], line2, ['T is %s and Slope is %s' % (tt, line[0])], loc=2) ax[i].add_artist(leg) ax[i].grid(b=True) plt.show()
def draw(self, colors, ylim, step=1.5, width=0.2): n = 0 cs = cycle(colors) move = (len(self.cols) - 1) / 2 self.f, ax = plt.subplots(figsize=(16, 9), facecolor=(.18, .31, .31)) ax.set_facecolor('#eafff5') for ms, color in zip(self.getMeanStd(), cs): n += 1 center = ((n - 1) // len(self.cols) + 1) * step x = (move - ((n - 1) % 6)) * width x = center - x ax.bar(x, ms[0], width=width, yerr=ms[1], color=color) ax.set_ylim(ylim) ax.spines['bottom'].set_color('#caaca8') ax.spines['right'].set_color('#caaca8') ax.spines['left'].set_color('#caaca8') ax.spines['top'].set_color('#caaca8') ax.spines['bottom'].set_linewidth(1.5) ax.spines['left'].set_linewidth(1.5) ax.spines['top'].set_linewidth(1.5) ax.spines['right'].set_linewidth(1.5) ax.tick_params(direction='in', which='both', labelsize=12, width=0.3, color='#caaca8') ax.set_xticks(np.arange(step, step * len(self.idxs) + step, step)) ax.set_xticklabels(self.idxs) ax.grid(ls='--', color='#caaca8', axis="y") legend = [mlines.Line2D([0], [0], color=c, lw=12) for c in colors] leg = Legend( ax, legend, labels=self.cols, ncol=1, #bbox_to_anchor=(8.1, 0.7), edgecolor='white', borderpad=0.6, facecolor='#eafff5') ax.add_artist(leg) ax.tick_params(labelcolor='tab:orange')
def axlegend_categ(ax): 'add custom legend (storm category) to axes' # category legend lls_cat = [ Line2D([0], [0], color = 'black'), Line2D([0], [0], color = 'purple'), Line2D([0], [0], color = 'red'), Line2D([0], [0], color = 'orange'), Line2D([0], [0], color = 'yellow'), Line2D([0], [0], color = 'green'), ] leg_cat = Legend( ax, lls_cat, ['5','4','3','2','1','0'], title = 'Category', bbox_to_anchor = (1.01, 1), loc='upper left', ) ax.add_artist(leg_cat)
def plot_losses(losses_dict, path): """ plots the losses over the epochs for a dictionary of model losses """ epochs = list(range(1, len(next(iter(losses_dict.values()))) + 1)) color_mapper = { 'single': 'C0', '10': 'C1', 'curriculum': 'C2', 'dynamic': 'C3' } linestyle_mapper = {'lots': 'solid', 'pgd': 'dashed'} fig, ax = plt.subplots() for setting, losses in losses_dict.items(): if setting == 'base': linestyle, color = 'solid', 'black' else: attack, training = setting.split('-') color = color_mapper[training] linestyle = linestyle_mapper[attack] ax.plot(epochs, losses, linestyle=linestyle, color=color) color_legend_handles = [] for v in color_mapper.values(): color_legend_handles.append(Line2D([0], [0], color=v, lw=1)) ax.legend(color_legend_handles, list(color_mapper.keys()), loc='upper right') shape_legend_handles = [] for v in linestyle_mapper.values(): shape_legend_handles.append( Line2D([0], [0], color='black', lw=1, linestyle=v)) ax.add_artist( Legend(ax, shape_legend_handles, list(linestyle_mapper.keys()), loc='upper center')) plt.title('Losses') plt.xlabel('Epoch') plt.ylabel('Negative Log Likelihood Loss') filename = '{}training_losses.png'.format(path) plt.savefig(filename, transparent=False) plt.close()
def metrics_scatter(ax, data, colors, sizes, metrics=['sensitivity', 'specificity'], show_legend=True, legend_cols=2): assert len(metrics) == 2 for k, (label, row) in enumerate(data.iterrows()): ax.scatter(row[metrics[0]], row[metrics[1]], label=label, color='none', edgecolors=colors[k], s=sizes[k], facecolors='none', lw=1, alpha=0.85) legend = Legend(ax, *ax.get_legend_handles_labels(), handletextpad=-0.1, columnspacing=0.7, loc='lower right', ncol=legend_cols) if show_legend: ax.add_artist(legend) ax.set_xlabel(metrics[0].capitalize()) ax.set_ylabel(metrics[1].capitalize()) ax.set_xlim(-0.015, 1.05) ax.set_ylim(-0.015, 1.05) ax.axvline(0.5, color='0.6', lw=0.25) ax.axhline(0.5, color='0.6', lw=0.25) return ax
def survival(time, status, pGroups=None): kmf = KaplanMeierFitter() if pGroups is None: order = [i for i in range(2, len(time)) if time[i] != "" and status[i] != ""] t = [float(time[i]) for i in order] s = [int(status[i]) for i in order] kmf.fit(t, s) ax = kmf.plot(color='red') return ax else: ax = None groups = [ "" for i in time] for k in range(len(pGroups)): df = pd.DataFrame() order = [i for i in pGroups[k][2] if time[i] != "" and status[i] != ""] if len(order) <= 0: continue for i in order: groups[i] = k t = [float(time[i]) for i in order] s = [int(status[i]) for i in order] kmf.fit(t, s, label = pGroups[k][0]) if ax is None: ax = kmf.plot(color=pGroups[k][1], ci_show=False, show_censors=True) else: ax = kmf.plot(ax = ax, color=pGroups[k][1], ci_show=False, show_censors=True) order = [i for i in range(len(groups)) if groups[i] != ""] if len(order) > 0: t = [float(time[i]) for i in order] s = [int(status[i]) for i in order] g = [int(groups[i]) for i in order] from lifelines.statistics import multivariate_logrank_test from matplotlib.legend import Legend res = multivariate_logrank_test(t, g, s) leg = Legend(ax, [], [], title = "p = %.2g" % res.p_value, loc='lower left', frameon=False) ax.add_artist(leg); return ax
def multiple_legends(): fig, ax = plt.subplots() lines = [] styles = ['-', '--', '-.', ':'] x = np.linspace(0, 10, 1000) for i in range(4): lines += ax.plot(x, np.sin(x - i * np.pi / 2), styles[i], color='black') ax.axis('equal') # specify the lines and labels of the first legend ax.legend(lines[:2], ['line A', 'line B'], loc='upper right', frameon=False) # Create the second legend and add the artist manually. leg = Legend(ax, lines[2:], ['line C', 'line D'], loc='lower right', frameon=False) ax.add_artist(leg) plt.show()
def set_cmap_legend_entry(artist, label): """ Sets the label of the provided `artist` to `label`, and creates a legend entry using a miniature version of the colormap of `artist` as the legend icon. This function can be used to add legend entries for *MPL* artists that use a colormap, like those made with :func:`~matplotlib.pyplot.hexbin`; :func:`~matplotlib.pyplot.hist2d`; :func:`~matplotlib.pyplot.scatter`; or any :mod:`~matplotlib.pyplot` function that takes `cmap` as an input argument. Keep in mind that using this function will override any legend entry that already exists for `artist`. Parameters ---------- artist : :obj:`~matplotlib.artist.Artist` object Any artist object that has the `cmap` attribute, for which a legend entry must be made using its colormap as the icon. label : str The string that must be set as the label of `artist`. """ # Obtain the colormap of the provided artist cmap = getattr(artist, 'cmap', None) # If cmap is None, raise error if cmap is None: raise ValueError("Input argument 'artist' does not have attribute " "'cmap'!") # Set the label of this artist artist.set_label(label) # Add the HandlerColorPolyCollection to the default handler map for artist Legend.get_default_handler_map()[artist] = _HandlerColorPolyCollection()
extra, extra, extra, extra, extra, extra, extra, extra, extra, extra ], ("loss: " + loss_function, "learning rate: " + str(learning_rate), "batch_size: " + str(batch_size), "speed_bucket_size: " + speed_bucket_size, "epochs: " + str(training_epochs), "input_num_timestamps: " + str(input_num_timestamps), "num_labels: " + str(len(labels_to_number)), "evaluation metric 1:" + accuracy_reporting_metric_1, "evaluation metric 2:" + accuracy_reporting_metric_2, "evaluation metric 3:" + accuracy_reporting_metric_3, "note:" + plot_note), bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.) leg = Legend(ax1, lines[0:], ['Train Eval 1', 'Dev Eval 1', 'Train Eval 1', 'Dev Eval 2'], loc='right', frameon=False) ax1.add_artist(leg) plot_filename = str(time.time()) + "User-" + str( socket.gethostname()) + plot_note # add plot not to identify this plot plt.savefig("../plots/" + plot_filename + "_AccuracyVsEpoch.png", bbox_inches="tight") #fig.tight_layout() plt.show() # #### Record results of a model in a table:
def visualize_genome(genome: Genome, show_learning_rules: bool = True, with_legend: bool = True): def get_color(node: NodeGene): if isinstance(node, InputNodeGene): return GREEN elif isinstance(node, (HiddenNodeGene, OutputNodeGene)): if node.is_inhibitory: if node.bias: return PINK else: return RED else: if node.bias: return CYAN else: return BLUE def legend_circle(color: str): return Line2D([0], [0], color=color, marker='o', linewidth=0) g, nodes, edges = genome_to_graph(genome) pos = get_node_coordinates(genome) labels = { key: f"{node.learning_rule.value if isinstance(node, NeuralNodeGene) else key}{'↩' if (key, key) in edges else ''}" for key, node in genome.nodes.items()} if show_learning_rules \ else {node: f"{node}{'↩' if (node, node) in edges else ''}" for node in nodes} node_color = [get_color(genome.nodes[node]) for node in nodes] edgecolors = [ 'k' if isinstance(genome.nodes[node], OutputNodeGene) else get_color( genome.nodes[node]) for node in nodes ] nx.draw_networkx_nodes(g, pos=pos, nodes=nodes, node_color=node_color, edgecolors=edgecolors, node_size=400) nx.draw_networkx_labels(g, pos=pos, labels=labels) nx.draw_networkx_edges(g, pos=pos, connectionstyle="arc3, rad=0.05") # nx.draw_networkx(g, pos=pos, with_labels=True, labels=labels, nodes=nodes, node_color=node_color, node_size=400, # font_size=10, connectionstyle="arc3, rad=0.05") Legend.update_default_handler_map({Text: CustomTextHandler()}) legend_dict = { legend_circle(GREEN): 'input node', Line2D([0], [0], color='w', markeredgecolor='k', marker='o', linewidth=0): 'output node', legend_circle(BLUE): 'excitatory, without bias', legend_circle(RED): 'inhibitory, without bias', legend_circle(CYAN): 'excitatory, with bias', legend_circle(PINK): 'inhibitory, with bias', Text(text='AH'): 'asymmetric hebbian', Text(text='AA'): 'asymmetric anti-hebbian', Text(text='SH'): 'symmetric hebbian', Text(text='SA'): 'symmetric anti-hebbian' } if with_legend: plt.figlegend(handles=legend_dict.keys(), labels=legend_dict.values(), loc='upper right') plt.box(False) plt.show()
plt2 = ax.scatter(predictor_amici_x, predictor_amici_y, c='green', label='Prediction is better than Amicis default setting') plt3 = ax.scatter(equal_x, equal_y, c='blue', label='Both are equally good') ax.plot(z) ax.set_xlim([0.5, 250]) ax.set_ylim([0.5, 250]) ax.set_xscale('log') ax.set_yscale('log') ax.set_xlabel('Amicis default simulation time [ms]', fontsize=12, fontweight='bold') ax.set_ylabel('Predictors simulation time [ms]', fontsize=12, fontweight='bold') ax.set_title('Amici default vs. predictor settings', fontsize=24, fontweight='bold') ax.legend(loc=2) # second legend #second_legend = plt.legend(handles=[plt1, plt2, plt3], loc='lower right') leg = Legend(ax, [plt1, plt2, plt3], [str(round(len(amici_predictor_x)/len(amici_tsv_file['t_intern_ms'])*100, 2)) + ' %', str(round(len(predictor_amici_x)/len(amici_tsv_file['t_intern_ms'])*100, 2)) + ' %', str(round(len(equal_x)/len(amici_tsv_file['t_intern_ms'])*100, 2)) + ' %'], loc='lower right', frameon=True) ax.add_artist(leg) # better layout plt.tight_layout() # change plotting size fig = plt.gcf() fig.set_size_inches(18.5, 10.5) # save figure plt.savefig('../bachelor_thesis/New_Figures/Figures_study_5/Predictor_vs_Amici_166SBML.pdf') # show figure plt.show()
"loss: " + loss_function, "learning rate: " + str(learning_rate), "batch_size: " + str(batch_size), "speed_bucket_size: " + speed_bucket_size, "epochs: "+str(training_epochs), "input_window_size: " + str(input_window_size), "num_labels: " + str(len(labels_to_number)), "evaluation metric 1:"+accuracy_reporting_metric_1, "evaluation metric 2:"+accuracy_reporting_metric_2, "evaluation metric 3:"+accuracy_reporting_metric_3, "note:" + plot_note), bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.) leg = Legend(ax1, lines[0:], ['Train ACC', 'Dev ACC','Train Eval 1','Dev Eval 1'], loc='bestoutside', frameon=False) ax1.add_artist(leg); plt.savefig(folder_head_loc + "Learning Curves/" + str(file_name) + "_AccuracyPerEpoch_Image.png", bbox_inches = "tight") plt.show() # #### Record results of the model in a table # In[29]: # Add the results of the most recent run to the results file for documentation if model_architecture == 'FCN': a=[[model_architecture, file_name,
fsp.plot(lon, lat, marker='^', ls='', mec='k', mfc='k') for (x, y, code, name) in USGS_SW: fsp.annotate(" " + code, basemap(x, y), **annotate_args) # fsp.set_xlim(98400., 482300.) fsp.set_ylim(33627., 228051.) fsp.set_position((0.05, 0.35, 0.90, 0.6)) draw_default_args = dict(ax=fsp, resol=1, xoffset=0.001) basemap.draw_default_parallels(**draw_default_args) basemap.draw_default_meridians(**draw_default_args) usgslabel = "USGS\n" usgslabel += "\n".join(["%s : %s" % (a, b) for (_, _, a, b) in (USGS_SE + USGS_SW)]) coapslabel = "COAPS\n" coapslabel += "\n".join(["%s : %s" % (a, b) for (_, _, a, b) in (COAPS_SE + COAPS_SW)]) from matplotlib.legend import Legend leg = Legend(fig, (usgs,), (usgslabel,), loc="lower left", numpoints=1) for t in leg.get_texts(): t.set_fontsize(10) fig.legends.append(leg) leg = Legend(fig, (coaps,), (coapslabel,), loc="lower right", numpoints=1) for t in leg.get_texts(): t.set_fontsize(10) fig.legends.append(leg) fig.savefig('station_location.png', dpi=600) #mpl.show()
self._patch_func = patch_func def create_artists (self, legend, orig_handle, xdescent, ydescent, width, height, fontsize, trans): x0, y0 = xdescent, ydescent width, height = width, height linewidth = orig_handle.get_linewidth () [0] if len (orig_handle.get_linewidth ()) != 0 else None patch = matplotlib.patches.Rectangle([x0, y0], width, height, hatch=orig_handle.get_hatch (), lw=linewidth, transform=trans) cmap = orig_handle.get_cmap () patch.set_facecolor (orig_handle.get_cmap () (0.5)) patch.set_edgecolor (orig_handle.get_edgecolor () [0]) return [patch] Legend.update_default_handler_map({matplotlib.collections.PolyCollection: PolyCollectionHandler()}) class KippenhahnPlot(object): """This object takes a matplotlib axis and attaches a Kippenhahn plot to it associated with the given CNVFile""" def __init__(self, axis, cnv_file, useModels = False): super(KippenhahnPlot, self).__init__() self.axis = axis self.cnv_file = cnv_file self.times = (u.Quantity ([model ['timesec'] for model in self.cnv_file], 's').to ('year')).value if (not useModels): self.x = self.times else: self.x = list (range (len (self.times)))
legline1.set_transform(trans) legline2.set_transform(trans) return [legline1, legline2] class HandlerPatch2(HandlerBase): """ Handler for Patch instances. """ def __init__(self, **kw): HandlerBase.__init__(self, **kw) def create_artists(self, legend, orig_handle, xdescent, ydescent, width, height, fontsize, trans): p1 = Rectangle(xy=(-xdescent, -ydescent), width=width, height=height) p2 = Rectangle(xy=(-xdescent, -ydescent), width=width, height=height) self.update_prop(p1, orig_handle, legend) self.update_prop(p2, orig_handle, legend) p2.set_facecolor('none') p1.set_transform(trans) p2.set_transform(trans) return [p1,p2] Legend.update_default_handler_map({ErrorLine2D: HandlerErrorLine2D()}) Legend.update_default_handler_map({Patch: HandlerPatch2()})