def plot_box_like_distrib(X, mapping, ax, color, marker, label, val_color=50, max_val=np.inf, div=1., reverse=False): Y_med, Y_25, Y_75 = [], [], [] X_ = [] for k in X: if k < max_val: X_.append(k) if reverse: Y_med.append(100 - 100 * np.median(mapping[k]) / div) Y_25.append(100 - 100 * np.percentile(mapping[k], 25) / div) Y_75.append(100 - 100 * np.percentile(mapping[k], 75) / div) else: Y_med.append(100 * np.median(mapping[k]) / div) Y_25.append(100 * np.percentile(mapping[k], 25) / div) Y_75.append(100 * np.percentile(mapping[k], 75) / div) ax.plot(X_, Y_med, '-o', color=cm.Paired(color), marker=marker, label=label, lw=2, ms=8) ax.fill_between(X_, Y_25, Y_75, color=cm.Paired(color), alpha=.2) return Y_med, Y_25, Y_75
def __base_bar(self, ax, data): """ Plot stacked bar chart with `origin`, `thresed`, `final` data """ kwa = self.__bar_kwa(mcm.Paired(.6), y="origin") data.plot(ax=ax, **kwa) kwa = self.__bar_kwa(mcm.Paired(.3), y="thresed", ha="x") data.plot(ax=ax, **kwa) kwa = self.__bar_kwa(mcm.Paired(.1), y="final", ha="o") data.plot(ax=ax, **kwa)
def roc_plot(outfile, plot_x, plot_y, ids=None): if ids is None: ids = [] fig = plt.figure() fig.add_subplot(111, aspect="equal") colors = [cm.Paired(256 / 11 * i) for i in range(11)] if type(plot_x[0]) == type(np.array([])): for i,(x,y) in enumerate(zip(plot_x, plot_y)): plt.plot(x, y, color=colors[(i * 2) % 10 + 1]) else: plt.plot(plot_x,plot_y, color=colors[(0 * 2) % 10 + 1]) plt.axis([0,1,0,1]) plt.xlabel("1 - Specificity") plt.ylabel("Sensitivity") if len(ids) > 0: plt.legend(ids, loc=(1.03,0.2)) if not os.path.splitext(outfile)[-1] in VALID_EXTENSIONS: outfile += ".png" plt.savefig(outfile, dpi=300, bbox_inches='tight') plt.close(fig)
def plot_cube(cube, name='voxel', angle=20, IMG_DIM=80, num_class=12): from mpl_toolkits.mplot3d import Axes3D # cube = normalize(cube) # Note that cm.Paired has 12 colors and Set2 has 8 colors # cube[np.where(cube > num_class)] = 10 if num_class == 12: cube[cube < 0] = 0 cube[cube == 255] = 0 facecolors = cm.Paired((np.round(cube) / 13)) facecolors[:, :, :, -1] = 0.2 * np.tanh( cube * 1000) + 0.7 * (cube > 5) + 0.1 * (cube == 2) elif num_class == 4: facecolors = cm.Dark2((np.round(cube) / 9)) facecolors[:, :, :, -1] = 0.4 * np.tanh(cube * 1000) elif num_class == 3: # cube[cube == -1] = 3 cube[cube < 0] = 0 facecolors = cm.Set2((np.round(cube) / 9)) facecolors[:, :, :, -1] = 0.03 * np.tanh(cube * 1000) + 0.6 * (cube == 1) elif num_class == 1: cube[cube < 0] = 0 facecolors = cm.Dark2((np.round(cube) / 1)) facecolors[:, :, :, -1] = 0.5 * (cube == 1) # make the alpha channel more similar to each others while 0 is still 0 facecolors = explode(facecolors) filled = facecolors[:, :, :, -1] != 0 x, y, z = expand_coordinates( np.indices(np.array(filled.shape) + 1).astype(float)) # Here is a loop for generating demo files for idx, val in enumerate(np.arange(160, 170, 10)): fig = plt.figure(figsize=(45 / 2.54, 45 / 2.54)) # , dpi=150) # plot ax1 = fig.add_subplot(111, projection='3d') # For samples in SUNCG, 20, -40 is a good choice for visualization # ax1.view_init(np.abs(90-val/2), val) ax1.view_init(angle, val) ax1.set_xlim(right=IMG_DIM * 2) ax1.set_ylim(top=IMG_DIM * 2) ax1.set_zlim(top=IMG_DIM * 2) ax1.set_axis_off() ax1.voxels(x, y, z, filled, facecolors=facecolors, edgecolors=np.clip(2 * facecolors - 0.5, 0, 1), linewidth=0.5) # plt.show() plt.savefig(name + '_' + format(idx, '03d') + '.png', bbox_inches='tight', pad_inches=0, transparent=True) plt.close(fig) """
def plotSimDataPQTime(fig, time_snapshots, time_sim, p_sim, q_sim, compression='negative'): # Get snapshots from sim data time_snap, p_snap = getDataTimeSnapshots(time_snapshots, time_sim, p_sim) time_snap, q_snap = getDataTimeSnapshots(time_snapshots, time_sim, q_sim) # Activate the figure plt.figure(fig.number) # Plot sigma_a vs. time if (compression == 'positive'): p_data = list(map(lambda p : -p, p_sim)) q_data = list(map(lambda q : -q, q_sim)) plt.plot(time_sim, p_data, '--r', label='$p$ (sim)') plt.plot(time_sim, q_data, '--b', label='$q$ (sim)') else: plt.plot(time_sim, p_sim, '--r', label='$p$ (sim)') plt.plot(time_sim, q_sim, '--b', label='$q$ (sim)') # Plot filled circles at time snapshots for ii in range(0, len(time_snap)): # Choose the Paired colormap plt_color = cm.Paired(float(ii)/len(time_snap)) if (compression == 'positive'): plt.plot(time_snap[ii], -p_snap[ii], 'o', color=plt_color) plt.plot(time_snap[ii], -q_snap[ii], 'o', color=plt_color) else: plt.plot(time_snap[ii], p_snap[ii], 'o', color=plt_color) plt.plot(time_snap[ii], q_snap[ii], 'o', color=plt_color) return time_snap, p_snap, q_snap
def visualize_2D_gmm(points, w, mu, stdev, model_id, c, export=False): ''' plots points and their corresponding gmm model in 2D Input: points: N X 2, sampled points w: n_gaussians, gmm weights mu: 2 X n_gaussians, gmm means stdev: 2 X n_gaussians, gmm standard deviation (assuming diagonal covariance matrix) Output: None ''' n_gaussians = mu.shape[1] N = int(np.round(points.shape[0] / n_gaussians)) # Visualize data axes = plt.gca() colors = cmx.Accent(np.linspace( 0, 1, n_gaussians)) if id == 'human' else cmx.Paired( np.linspace(0, 1, n_gaussians)) for i in range(n_gaussians): idx = range(i * N, (i + 1) * N) for j in range(4): axes.add_patch( patches.Ellipse(mu[:, i], width=(j + 1) * stdev[0, i], height=(j + 1) * stdev[1, i], alpha=0.4, fill=True, color=colors[i])) plt.xlabel('Dim 1') plt.ylabel('Dim 2')
def plotExtractedStress(test_name, pdf_name, sim_data, I1_data, X_OPERATION, x_scale, X_VARIABLE_LABEL, J2_data, Y_OPERATION, y_scale, Y_VARIABLE_LABEL, capX_data, alpha_I1_data, yieldParams): print "Variables: ", X_VARIABLE_LABEL, ", ", Y_VARIABLE_LABEL # Convert and scale data if needed x_data = map( lambda xx: convertAndScaleData(np.asarray(xx), X_OPERATION, x_scale), I1_data) y_data = map( lambda yy: convertAndScaleData(np.asarray(yy), Y_OPERATION, y_scale), J2_data) # Choose a paired colormap colors = map(lambda ii: cm.Paired(ii), np.linspace(0.0, 1.0, len(x_data))) # Create a figure fig = plt.figure(figsize=(8, 6)) res = map( lambda X, alpha, COLOR, time, PEAKI1, FSLOPE, STREN, YSLOPE: computeAndPlotYieldSurface( yieldParams, time, PEAKI1, FSLOPE, STREN, YSLOPE, X, alpha, X_OPERATION, x_scale, Y_OPERATION, y_scale, COLOR, pdf_name), capX_data, alpha_I1_data, colors, sim_data.time, sim_data.PEAKI1, sim_data.FSLOPE, sim_data.STREN, sim_data.YSLOPE) #ax1 = plt.subplot(111) x_data = np.array(x_data) y_data = np.array(y_data) plt.quiver(x_data[:-1], y_data[:-1], x_data[1:] - x_data[:-1], y_data[1:] - y_data[:-1], scale_units='xy', angles='xy', scale=1.0, width=0.001, headwidth=7, headlength=10, linewidth=0.5, edgecolor='r', color='k') #plt.plot(x_data, y_data, 'r-', linewidth = 1) plt.xlabel(X_VARIABLE_LABEL, fontsize=16) plt.ylabel(Y_VARIABLE_LABEL, fontsize=16) plt.title(test_name, fontsize=16) # Legend text (material parameters) legend_text = yieldParams['legend'] plt.subplots_adjust(right=0.75) plt.figtext(0.77, 0.90, legend_text, ha='left', va='top', size='x-small') plt.grid() plt.savefig(pdf_name + ".pdf", bbox_inches='tight') #plt.show() plt.close(fig) return
def plot_shelxe_contrast(shelxe_contrast, png_file, add_legend=False): '''Plot contrast vs. cycle number from SHELXE.''' fig, ax = plt.subplots(figsize=(6, 4)) for l, solvent_fraction in enumerate(sorted(shelxe_contrast.keys()), 1): contrast_vals = shelxe_contrast[solvent_fraction] cycles_orig, contrast_orig = contrast_vals['original'] cycles_other, contrast_other = contrast_vals['inverted'] lb_orig = 'Orig. {}'.format(solvent_fraction) lb_inv = 'Inv. {}'.format(solvent_fraction) color = cm.Paired(float(l) / 12) ax.plot(cycles_orig, contrast_orig, lw=1, c=color, label=lb_orig) ax.plot(cycles_other, contrast_other, ls='dashed', label=lb_inv, lw=1, c=color) plt.xlabel('Cycle', fontsize=14) plt.ylabel('Contrast', fontsize=14) plt.tick_params(labelsize=14) if add_legend: lgd = ax.legend(bbox_to_anchor=[.2, 1.02], loc=3, ncol=2) plt.savefig(png_file, bbox_extra_artists=(lgd, ), bbox_inches='tight') else: plt.savefig(png_file, bbox_inches='tight') plt.close()
def test_dna_assembly_example(tmpdir): spreadsheet_path = os.path.join('examples', 'examples_data', "dna_assembly.xls") colors = (cm.Paired(0.21 * i % 1.0) for i in range(30)) resources = resources_from_spreadsheet( spreadsheet_path=spreadsheet_path, sheetname="resources") processes = [ tasks_from_spreadsheet(spreadsheet_path=spreadsheet_path, sheetname="process", resources_dict=resources, tasks_color=next(colors), task_name_prefix="WU%d_" % (i + 1)) for i in range(5) ] print("NOW OPTIMIZING THE SCHEDULE, BE PATIENT...") new_processes = schedule_processes_series( processes, est_process_duration=5000, time_limit=6) # PLOT THE TASKS DEPENDENCY TREE ax = plot_tasks_dependency_graph(processes[0]) ax.set_title("PLAN OF A WORK UNIT") ax.figure.savefig("basic_example_work_unit.pdf", bbox_inches="tight") # PLOT THE OPTIMIZED SCHEDULE ax = plot_schedule([t for process in new_processes for t in process]) ax.figure.set_size_inches((8, 5)) ax.set_xlabel("time (min)") ax.figure.savefig(os.path.join(str(tmpdir), "basic_example_schedule.png"), bbox_inches="tight")
def create_roc_plots(self, pwm_file, fg_fasta, bg_fasta, name): motifs = dict([(m.id, m) for m in pwmfile_to_motifs(pwm_file)]) jobs = {} for id,m in motifs.items(): jobs[id] = self.job_server().submit(get_roc_values, (motifs[id],fg_fasta,bg_fasta,)) roc_img_file = os.path.join(self.imgdir, "%s_%s_roc.png") for id in motifs.keys(): error, x, y = jobs[id]() if error: self.logger.error("Error in thread: %s" % error) sys.exit(1) fig = plt.figure() try: # matplotlib >= 0.99 rect = fig.patch # a rectangle instance except: # matplotlib 0.98 rect = fig.figurePatch # a rectangle instance plt.xlim(0,0.2) plt.ylim(0,1.0) colors = [cm.Paired(256 / 11 * i) for i in range(11)] plt.plot(x, y, color=colors[(0 * 2) % 10 + 1]) plt.axis([0,1,0,1]) plt.xlabel("1 - Specificity") plt.ylabel("Sensitivity") plt.savefig(roc_img_file % (id,name), format="png")
def plot_pie(grid, std, rstd, Na, title, stride, shift): pb = perc_better(std, rstd) std = std / Na f1 = std[(std <= 0.023)].shape[0] f2 = std[(std > 0.023) & (std <= 0.05)].shape[0] f3 = std[(std > 0.05)].shape[0] labels = ['s <= 0.023', '0.023 < s <= 0.05', 's > 0.05'] fracs = [f1, f2, f3] x_pos = np.arange(len(labels)) print(x_pos) print(fracs) from matplotlib import cm cs = cm.Paired([0.2, 0.9, 0.42]) plt.subplot(grid, aspect=0.002) plt.bar(x_pos, fracs, align='center', alpha=0.5) plt.xticks(x_pos, labels) plt.title(title + ' (Improv.: ' + "{:.1f}".format(pb) + '%;' + str(int((pb / 100.0) * rstd.shape[0])) + ')', bbox={ 'facecolor': '0.8', 'pad': 5 })
def plot_shelxe_fom_mapcc(fom_mapcc, png_file): '''Plot contrast vs. cycle number from SHELXE.''' fig, (ax1, ax2) = plt.subplots(2, figsize=(6, 4), sharex=True) for l, solvent_fraction in enumerate(sorted(fom_mapcc.keys()), 1): vals = fom_mapcc[solvent_fraction] orig, other = vals['original'], vals['inverted'] lb_orig = 'Orig. {}'.format(solvent_fraction) lb_inv = 'Inv.' color = cm.Paired(float(l) / 12) x = range(len(orig['resol'])) ax1.plot(x, orig['fom'], lw=1, label=lb_orig, c=color) ax1.plot(x, other['fom'], ls='dashed', label=lb_inv, lw=1, c=color) ax2.plot(x, orig['mapcc'], lw=1, label=lb_orig, c=color) ax2.plot(x, other['mapcc'], ls='dashed', label=lb_inv, lw=1, c=color) plt.xlabel('Resolution / $\mathregular{\AA}$') ax1.set_ylabel('<FOM>') ax2.set_ylabel('<mapCC>') ax1.xaxis.set_major_formatter( ticker.FuncFormatter(lambda x, p: orig['resol'][p])) lgd = ax1.legend(bbox_to_anchor=[1.02, 1.], loc=2, ncol=2, fontsize=10) plt.savefig(png_file, bbox_extra_artists=(lgd, ), bbox_inches='tight') plt.close()
def plot_packet_size_cdf_ssl(conn, node): cur = conn.cursor() cur.execute('''SELECT port,packet_size,count FROM packet_sizes_per_port WHERE node_id = %s AND (port = 443 OR port = 993 OR port = 465 OR port = 995 OR port = 636 OR port = 5223)''', (node,)) port_data = defaultdict(dict) for row in cur: port_data[row[0]][row[1]] = row[2] xs = range(1500) fig = plt.figure() fig.suptitle('CDF of SSL packet sizes for router %s' % node) ax = fig.add_subplot(111) for seq, (port, samples) in enumerate(port_data.items()): ys = [] total = 0 for idx in range(1500): if idx in samples: total += samples[idx] ys.append(total) ys = map(lambda y: y/float(total), ys) plt.plot(xs, ys, label='Port %d' % port, color=cm.Paired(seq*100)) ax.legend(loc='lower right', prop={'size':10}) ax.set_xlabel('Packet size') ax.set_ylabel('CDF') plt.savefig('%s_packet_size_cdf.pdf' % node)
def LinePlot(self, axis, data_x, data_y, labels, ax_label): from matplotlib import cm as cm import numpy as np axis.cla() colors = cm.Paired(np.linspace(0, 1, len(data_x) + 2)) for ii in range(0, len(data_x)): axis.plot(data_x[ii], data_y[ii], lw=3, c=colors[ii], label=labels[ii], zorder=-1) axis.scatter(data_x[ii], data_y[ii], color=colors[ii], alpha=0.75, s=150, lw=1.00, edgecolor='black') axis.set_xlabel(ax_label[0], fontsize=Abstract2DPlot.font_size) axis.set_ylabel(ax_label[1], fontsize=Abstract2DPlot.font_size) axis.tick_params(axis='x', colors='black', labelsize=Abstract2DPlot.font_size, width=2) axis.tick_params(axis='y', colors='black', labelsize=Abstract2DPlot.font_size, width=2) axis.legend(fontsize=Abstract2DPlot.font_size) for ax in ['top', 'bottom', 'left', 'right']: axis.spines[ax].set_linewidth(3) return
def WriteMapParti(p, i): shortname = (p[1].replace(' ', '')).encode('ascii', 'ignore').replace('.', '') c = np.multiply(cm.Paired(i * 10)[:3], 255) s = ''' function pop_''' + shortname + '''(feature, layer) { var popupContent = '<table><tr><th scope="row">Navn</th><td>' + Autolinker.link(String(feature.properties['Navn'])) + '</td></tr><tr><th scope="row">Postnummer</th><td>' + Autolinker.link(String(feature.properties['Postnummer'])) + '</td></tr><tr><th scope="row">By</th><td>' + Autolinker.link(String(feature.properties['By'])) + '</td></tr><tr><th scope="row">Dato</th><td>' + Autolinker.link(String(feature.properties['Dato'])) + '</td></tr></table>'; layer.bindPopup(popupContent); } function doStyle''' + shortname + '''(feature) { return { color: '#000000', fillColor: '#''' + '%02x%02x%02x' % (c[0], c[1], c[2]) + '''', weight: 1.3, dashArray: '', opacity: 0.466666666667, fillOpacity: 0.466666666667 };''' s += '''} var exp_''' + shortname + '''JSON = new L.geoJson(exp_''' + shortname + ''',{ onEachFeature: pop_''' + shortname + ''', style: doStyle''' + shortname + ''' }); layerOrder[layerOrder.length] = exp_''' + shortname + '''JSON; ''' # for (index = 0; index < layerOrder.length; index++) { # feature_group.removeLayer(layerOrder[index]);feature_group.addLayer(layerOrder[index]); # } # //add comment sign to hide this layer on the map in the initial view. # feature_group.addLayer(exp_'''+shortname+'''JSON); return s
def main(): w2v_path = sys.argv[1] w2v = Word2Vec.load(w2v_path) vec_list = [] country_list = [] for line in sys.stdin: country = line.strip() try: vec = w2v.wv.get_vector(country).reshape(w2v.vector_size) except: vec = None if vec is not None: vec_list.append(vec) country_list.append(country) clusters = KMeans(n_clusters=5).fit_predict(vec_list) vec_reduced = TSNE(n_components=2).fit_transform(vec_list) print(vec_reduced.shape) plt.figure(figsize=(12, 9)) plt.scatter(vec_reduced[:, 0], vec_reduced[:, 1], c=['w' for _ in clusters]) for d, l, c in zip(vec_reduced, clusters, country_list): plt.text(d[0], d[1], f'{l}:{c}', fontdict={'color': cm.Paired(l)}) plt.savefig('knock99.png')
def collate_family_defining(filename): """ scan a filename and list all 'FAMILY-DEFINING' features """ oh = open(filename, "rU") doms = [] for line in oh: if "FAMILY-DEFINING" in line: line = line.strip().split() doms.append(line[5]) set_of_doms = set(doms) for d in set_of_doms: print("%s\t%s" % (doms.count(d), d)) cols = cm.Paired( numpy.arange(len(set_of_doms)) / (len(set_of_doms) * 1.0))[:, :-1] print(cols) print(cols) print() print("Suggested ColourMap:") print("col_map = {") for i, d in enumerate(set_of_doms): print("\t'%s': '%s'," % (d, '#%02x%02x%02x' % tuple(cols[i] * 255))) print("\t}") oh.close()
def plot_multiclass_roc_curve(y_true, y_score, n_classes): print "x" ''' Compute ROC curve and ROC area for each class ''' fpr = dict() tpr = dict() roc_auc = dict() for i in range(n_classes): fpr[i], tpr[i], _ = roc_curve(y_true[:, i], y_score[:, i]) roc_auc[i] = auc(fpr[i], tpr[i]) all_fpr = np.unique(np.concatenate([fpr[i] for i in range(n_classes)])) mean_tpr = np.zeros_like(all_fpr) for i in range(n_classes): mean_tpr += interp(all_fpr, fpr[i], tpr[i]) mean_tpr /= n_classes fpr["macro"] = all_fpr tpr["macro"] = mean_tpr roc_auc["macro"] = auc(fpr["macro"], tpr["macro"]) lw = 2 plt.figure(figsize=(9, 9)) plt.plot(fpr["macro"], tpr["macro"], label='macro-average ROC curve (area = {0:0.2f})' ''.format(roc_auc["macro"]), color='green', linestyle=':', linewidth=4) colors = cycle(cm.Paired(np.linspace(0, 1, n_classes))) for i, color in zip(range(n_classes), colors): plt.plot(fpr[i], tpr[i], color=color, lw=lw, label='ROC curve of class {0} (area = {1:0.2f})' ''.format(i, roc_auc[i])) plt.plot([0, 1], [0, 1], 'k--', color='red', lw=lw) plt.xlim([-0.01, 1.01]) plt.ylim([-0.01, 1.01]) plt.annotate('Random Guess', (.5, .48), color='red') plt.xlabel('False Positive Rate') plt.ylabel('True Positive Rate') plt.title('Receiver Operating Characteristic') plt.legend(loc="lower right") plt.show()
def plotSimDataSigmaTime(fig, time_snapshots, time_sim, sigma_a_sim, sigma_r_sim, sigma_ar_sim, labelxx='$\sigma_a$ (sim)', labelyy='$\sigma_r$ (sim)', labelxy='$\sigma_{ar}$ (sim)', compression='negative'): # Get snapshots from data time_snap, sigma_a_snap = getDataTimeSnapshots(time_snapshots, time_sim, sigma_a_sim) time_snap, sigma_r_snap = getDataTimeSnapshots(time_snapshots, time_sim, sigma_r_sim) time_snap, sigma_ar_snap = getDataTimeSnapshots(time_snapshots, time_sim, sigma_ar_sim) # Activate the figure plt.figure(fig.number) # Plot sigma_a vs. time if (compression == 'positive'): sigma_a_data = list(map(lambda p: -p, sigma_a_sim)) sigma_r_data = list(map(lambda p: -p, sigma_r_sim)) sigma_ar_data = list(map(lambda p: -p, sigma_ar_sim)) plt.plot(time_sim, sigma_a_data, '--r', label=labelxx) plt.plot(time_sim, sigma_r_data, '--b', label=labelyy) plt.plot(time_sim, sigma_ar_data, '--g', label=labelxy) else: plt.plot(time_sim, sigma_a_sim, '--r', label=labelxx) plt.plot(time_sim, sigma_r_sim, '--b', label=labelyy) plt.plot(time_sim, sigma_ar_sim, '--g', label=labelxy) # Plot filled circles at time snapshots for ii in range(0, len(time_snap)): # Choose the Paired colormap plt_color = cm.Paired(float(ii) / len(time_snap)) if (compression == 'positive'): plt.plot(time_snap[ii], -sigma_a_snap[ii], 'o', color=plt_color) plt.plot(time_snap[ii], -sigma_r_snap[ii], 'o', color=plt_color) else: plt.plot(time_snap[ii], sigma_a_snap[ii], 'o', color=plt_color) plt.plot(time_snap[ii], sigma_r_snap[ii], 'o', color=plt_color) #plt.plot(time_snap[ii], sigma_ar_snap[ii], 'o', color=plt_color) return time_snap, sigma_a_snap, sigma_r_snap, sigma_ar_snap
def _create_categorical_colors(n_categories: int): if n_categories > 51: raise ValueError( f"Maximum number of colors (51) exceeded: `{n_categories}`.") colors = [cm.Set1(i) for i in range(cm.Set1.N)][:n_categories] colors += [cm.Set2(i) for i in range(cm.Set2.N)][:n_categories - len(colors)] colors += [cm.Set3(i) for i in range(cm.Set3.N)][:n_categories - len(colors)] colors += [cm.tab10(i) for i in range(cm.tab10.N)][:n_categories - len(colors)] colors += [cm.Paired(i) for i in range(cm.Paired.N)][:n_categories - len(colors)] return _convert_to_hex_colors(colors)
def autocolor_quote_sources(quote, hues=(0.635, 0.047, 0.117), saturations=(0.9, 0.7, 0.5, 0.3), min_lum=0.2, max_lum=0.8): """Auto-add a `_report_color` field to the sources in in quote.sources. Sources at the same depth share the same luminance """ colors = itertools.cycle([ rgb_to_hex(*[255*e**0.4 for e in cm.Paired(0.21 * i % 1.0)][:3]) for i in range(30) ]) for name, source in sorted(quote.sources.items()): color = next(colors) source._report_color = color
def plot_model_results_hor(model, init_pos, nb, ax, col, space=2, values=None, error_bars=None, hatch=''): if values is None: a, b, c, d, e, f = model.retrieve_the_cat() else: a, b, c, d, e, f = values p1 = init_pos + .2 p2 = init_pos + .2 ax.barh(p1, a / float(a + b) * 100 - 1, left=1, height=1.6, color=cm.Paired(.4), lw=2) ax.barh(p2, -e / float(e + f) * 100 + 1, left=-1, height=1.6, color=cm.Paired(0), lw=2) if not error_bars is None: ax.errorbar([a / float(a + b) * 100, -e / float(e + f) * 100], [p1, p2], xerr=[error_bars[0], error_bars[4]], fmt='none', ecolor='k', linewidth=3, mew=3, alpha=.7)
def decision_boundary(data_set, classifier): fig = plt.figure() ax = fig.add_subplot(1, 1, 1) h = 0.01 X, labels = data_set x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1 y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1 xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h)) output_data = classifier.evaluate(np.c_[xx.ravel(), yy.ravel()]) Z = np.array(output_data).reshape(xx.shape) ax.contourf(xx, yy, Z, cm="Paited") # Replot the scatter data data_separated, total_class = separate_data_by_class(data_set) data_visual = [] for item in data_separated.values(): data_visual.append(item) # Building Color based on max class # print(total_class) x = np.arange(total_class) ys = [i + x + (i * x)**2 for i in range(total_class)] COLORS = cm.Paired(np.linspace(0, 1, len(ys))) i = 1 for d, color in zip(data_visual, COLORS): x, y = d ax.scatter(x, y, alpha=0.8, color=color, s=20, label=i) i += 1 # Limit X, Y Axis ax.axis((0, 1, 0, 1)) # Shrink 10% figure from top box = ax.get_position() ax.set_position( [box.x0, box.y0 + box.height * 0.1, box.width, box.height * 0.9]) plt.title('Data set visualization') plt.legend(title="Class Legend", loc='upper center', ncol=int(total_class / 3) + 1, bbox_to_anchor=(0.5, -0.05)) plt.show()
def colors_cycle(lightness_factor=1.0, color_shift=0): if MATPLOTLIB_AVAILABLE: cycle = itertools.cycle([ cm.Paired(color_shift + 0.21 * i % 1.0) for i in range(30) ]) return ( '#%02x%02x%02x' % tuple([int(255 * c * lightness_factor) for c in rgb_tuple[:3]]) for rgb_tuple in cycle ) else: return itertools.cycle([ "#f1cccc", "#f1e5cc", "#e3f1cc", "#ccf1e3", "#ccd7f1", "#e0ccf1", "f1cce7" ])
def generate_map(typ, y_min, x_min, y_max, x_max, g_max, list_traj, dico_annotation): """ Generate Open Street Map HTML page """ xmean = np.mean([x_min, x_max]) ymean = np.mean([y_min, y_max]) if typ == 1: list_traj = sorted(list_traj, key=itemgetter(6), reverse=True) elif typ == 2: list_traj = sorted(list_traj, key=itemgetter(6), reverse=True) my_map = folium.Map(location=[ymean, xmean], tiles='Stamen Terrain', zoom_start=6) town_set = set() dico_traj_size = dict() for data in list_traj: #data y1, x1, y2, x2, m1, m2, g = data #get color cm_object = cm.Paired(1. * g / g_max) rgb = cm_object[:3] hexa = colors.rgb2hex(rgb) #trajectory folium.PolyLine([(y1, x1), (y2, x2)], color=hexa, weight=g, opacity=1).add_to(my_map) #marker if m1 not in town_set: folium.Marker( [y1, x1], popup=m1 + "\n" + dico_annotation[m1.encode('iso8859_15')][0]).add_to(my_map) town_set.add(m1) if m2 not in town_set: folium.Marker( [y2, x2], popup=m2 + "\n" + dico_annotation[m2.encode('iso8859_15')][0]).add_to(my_map) town_set.add(m2) for key in dico_annotation.keys(): if key.decode('iso8859_15') not in town_set: pass #folium.Marker([dico_annotation[m2.encode('iso8859_15')][1], dico_annotation[m2.encode('iso8859_15')][2]], popup=key+"\n"+dico_annotation[m2.encode('iso8859_15')][0]; color="black").add_to(my_map) filename = 'map_' + str(typ) + '.html' my_map.save(filename) webbrowser.open(filename)
def plot_stacked_histograms(counts, edges, fhand=None, axes=None, vlines=None, no_interactive_win=False, figsize=None, mpl_params=None, bin_labels=None, **kwargs): 'counts should be a dictionary' if mpl_params is None: mpl_params = {} print_figure = False if axes is None: print_figure = True axes, canvas, fig = _get_mplot_axes(axes, fhand, figsize=figsize) width = edges[1:] - edges[:-1] bottom = None for idx, (label, this_counts) in enumerate(counts.items()): color = cm.Paired(1. * idx / len(counts)) axes.bar(edges[:-1], this_counts, width=width, bottom=bottom, color=color, label=label, **kwargs) if bottom is None: bottom = this_counts else: bottom += this_counts if bin_labels is not None: assert len(bin_labels) == len(list(edges)) - 1 ticks = edges[:-1] + width / 2 axes.set_xticks(ticks) xticklabels = list(map(str, bin_labels)) axes.set_xticklabels(xticklabels, rotation='vertical') if vlines is not None: ymin, ymax = axes.get_ylim() axes.vlines(vlines, ymin=ymin, ymax=ymax) for function_name, params in mpl_params.items(): function = getattr(axes, function_name) function(*params.get('args', []), **params.get('kwargs', {})) if len(counts) > 1: axes.legend() fig.tight_layout() if print_figure: _print_figure(canvas, fhand, no_interactive_win=no_interactive_win) return
def draw_geometry(omgeo, coords, num, colormap=None): colors = [] if colormap: mint = min(colormap.values()) maxt = max(colormap.values()) colormap = dict( (key,((colormap[key]-mint)/maxt)) for key in colormap.keys() ) for omkey, omgeo in omgeo: if omgeo.position.z > 1200: continue if(colormap): if omkey in colormap: colors.append( cm.Paired(colormap[omkey]) ) else: colors.append( (0,0,0,0) ) if( colormap ): basic_scatter(num,coords, colors, [mint,maxt]) else: basic_scatter(num,coords, colors)
def VisualizeHidden(embed_tsne, embed_pca, label, types, title): embed_tsne = (embed_tsne - min(embed_tsne[:, 0])) / ( max(embed_tsne[:, 0]) - min(embed_tsne[:, 0])) embed_pca = (embed_pca - min(embed_pca[:, 0])) / (max(embed_pca[:, 0]) - min(embed_pca[:, 0])) label_unique = np.unique(label) colors = cm.Paired(np.linspace(0, 1, len(label_unique))) fig = plt.figure() plot_time = 0 for this_label, c, this_type in zip(label_unique, colors, types): id = (label == this_label).nonzero() plt.scatter(embed_tsne[id, 0], embed_tsne[id, 1], color=c, label=str(this_type)) plot_time += 1 lgd = plt.legend(loc='upper left', scatterpoints=1) plt.xlim((-0.1, 1)) fig.savefig(title + '_TSNE.png', bbox_extra_artists=(lgd, ), bbox_inches='tight') fig = plt.figure() ax = p3.Axes3D(fig) plot_time = 0 for this_label, c, this_type in zip(label_unique, colors, types): id = (label == this_label).nonzero() ax.scatter(embed_pca[id, 0], embed_pca[id, 1], embed_pca[id, 2], color=c, label=str(this_type)) plot_time += 1 lgd = plt.legend(loc='upper left', bbox_to_anchor=(1.01, 1), scatterpoints=1) plt.xlim((-0.1, 1)) fig.savefig(title + '_PCA.png', bbox_extra_artists=(lgd, ), bbox_inches='tight') return embed_tsne, embed_pca
def posterior_viz(gp): """ Visualization and exploration of posterior distribution, after model has been fit to observations. Visualizes (1) the observed data along with (2) several draws from the learned posterior distribution and (3) the full poster confidence intervals. Output plot is saved in current directory. Parameters ---------- gp: GaussianProcess """ if not gp.is_fitted: raise ValueError(""" You probably want to fit this model to some observations. Otherwise, the visualizations won't be very interesting. """) fig = plt.figure() gs = GridSpec(2, 1) ax1 = fig.add_subplot(gs[0, 0]) plt.plot(gp.x_observed, gp.y_observed, 'k+', markersize=15) for i in range(0, 5): f = gp.sample(1)[0] plt.plot(gp.x_test, f, '--', color=cm.Paired(i * 30), linewidth=1) ax1 = fig.add_subplot(gs[1, 0]) plt.plot(gp.x_observed, gp.y_observed, 'k+', markersize=15) plt.xlim([min(gp.x_test), max(gp.x_test)]) (mean, upper_conf, lower_conf) = gp.predict() plt.plot(gp.x_test, mean, 'k-', linewidth=1, alpha=.5) ax1.fill_between(gp.x_test, upper_conf, lower_conf, alpha=.5, color="#3690C0", linewidth=0) plt.savefig('gp_posterior.png')
def TrajPlot(self, axis, traj_data_x, traj_data_y, traj_data_z, traj_label): from matplotlib import cm as cm import numpy as np axis.cla() axis.set_xlim([-1, 1]) axis.set_ylim([-1, 1]) axis.set_zlim([-1, 1]) # draw sphere u, v = np.mgrid[0:2 * np.pi:200j, 0:np.pi:100j] x = np.cos(u) * np.sin(v) y = np.sin(u) * np.sin(v) z = np.cos(v) axis.plot_wireframe(x, y, z, color="gray", linewidth=0.1) axis.set_xticks([-1, 0, 1]) axis.set_yticks([-1, 0, 1]) axis.set_zticks([-1, 0, 1]) colors = cm.Paired(np.linspace(0, 1, len(traj_data_x) + 2)) for ii in range(len(traj_data_x)): axis.plot(traj_data_x[ii], traj_data_y[ii], traj_data_z[ii], c=colors[ii], lw=3, label=traj_label[ii]) axis.legend(fontsize=Abstract2DPlot.font_size) axis.tick_params(axis='x', colors='black', labelsize=Abstract2DPlot.font_size, width=2) axis.tick_params(axis='y', colors='black', labelsize=Abstract2DPlot.font_size, width=2) axis.tick_params(axis='z', colors='black', labelsize=Abstract2DPlot.font_size, width=2) axis.set_xlabel(r'M$_x$', fontsize=Abstract2DPlot.font_size) axis.set_ylabel(r'M$_y$', fontsize=Abstract2DPlot.font_size) axis.set_zlabel(r'M$_z$', fontsize=Abstract2DPlot.font_size) return