def __init__(self,img_path,label_path,num_color = 10): self.img = cv2.imread(img_path) self.img_o = cv2.imread(img_path) self.img_t = cv2.imread(img_path) create_c = np.array(cm.tab10(num_color))[:3]*255 self.color_list = [np.array(cm.tab10(color_num))[:3]*255 for color_num in range(num_color)] self.x1,self.x2,self.y1,self.y2 = 0,0,0,0 self.drawing = False self.label = label_path
def plot_orbital_list(orbital_idx, C, bases, postfix='', **kwargs): """ Visualizing all orbitals """ for j, i in enumerate(orbital_idx): if i - 1 >= C.shape[1] or i - 1 < 0: print('Orbital %d does not exist. Skipping' % i) else: plot_orbital(C[:, i - 1], bases, color=cm.tab10(j)[:3], **kwargs) mlab.text(0.05, 0.1 * j, str(i) + postfix, width=0.2, color=cm.tab10(j)[:3])
def build_plot(y_true=[], scores=[], labels=[]): """ Generates two plots: a roc plot and a preision/recall plot """ gradient = np.linspace(0, 1, 10) color_list = [cm.tab10(x) for x in gradient] fig, axes = plt.subplots(1, 2, figsize=(12, 5), sharex=True, sharey=True) ax = axes[0] n_line = 0 for i_score, score in enumerate(scores): fpr, tpr, _ = roc_curve(y_true[n_line], score, drop_intermediate=False) n_line = n_line + 1 ax.plot(fpr, tpr, linestyle='-.', c=color_list[i_score], lw=1, label=labels[i_score]) ax.set_title("ROC", fontsize=20) ax.set_xlabel('False Positive Rate', fontsize=18) ax.set_ylabel('True Positive Rate (Recall)', fontsize=18) ax.legend(loc='lower center', fontsize=8) ax = axes[1] n_line = 0 for i_score, score in enumerate(scores): precision, recall, _ = precision_recall_curve(y_true[n_line], score) n_line = n_line + 1 ax.step(recall, precision, linestyle='-.', c=color_list[i_score], lw=1, where='post', label=labels[i_score]) ax.set_title("Precision-Recall", fontsize=20) ax.set_xlabel('Recall (True Positive Rate)', fontsize=18) ax.set_ylabel('Precision', fontsize=18) ax.legend(loc='lower center', fontsize=8) plt.show()
def plot_param(kfoldres,algoname): params,acc = kfoldres ntrial = 10 fig, ax = plt.subplots() acc_mean = np.round(np.mean(acc[algoname],1)[:,0]*100) #ax.scatter(range(ntrial),acc_mean) feat_mean = np.mean(acc[algoname],1)[:,1] import matplotlib.cm as cm colors = cm.tab10(np.linspace(0, 1, ntrial)) #plt.scatter(11, 1, color='white',label = '(regwgt,thresh)') #plt.scatter(11, 1, color='white',label = 'Fisher_thresh') plt.scatter(11, 1, color='white',label = 'MP_eps') for x,(y, c) in enumerate(zip(acc_mean, colors)): #lbl = "(%f,%f)"%(params['L1_regwgt'][x], params['L1_thresh'][x]) #lbl = "%f"%(params['Fisher_thresh'][x]) lbl = "%f"%(params['MP_eps'][x]) plt.scatter(x, y, color=c,label = lbl) txt = "%d"%feat_mean[x] ax.annotate(txt, (x, acc_mean[x]),fontsize='large') ax.legend(fontsize='large') ax.tick_params(direction='out', labelsize='medium') plt.xticks(np.arange(ntrial), range(ntrial)) #plt.title('Hyperparameters tuning for %s'%algoname,fontsize='large') plt.title('Hyperparameters tuning for Matching Pursuit',fontsize='large') plt.xlabel('Trial',fontsize='large') plt.ylabel('Accuracy',fontsize='large') plt.savefig('%s.png'%algoname,bbox_inches='tight')
def plot_latent(dataLoader, model, vectors=(0,1)): """For 2D latent spaces """ digits = range(10) colors = [cm.tab10(digit/10.0) for digit in digits] coldict = {d:c for d, c in zip(digits, colors)} fig, axes = plt.subplots() # fake legend for d, c in zip(digits, colors): plt.scatter(-100, -100, c=[c], label=d) plt.legend() # get the latent space values and plot them in colors of digits for i, (data, labels) in enumerate(dataLoader): with torch.no_grad(): data = data.to(DEVICE) mu = model.forward_mu(data.view(-1, 784)) for digit, color in zip(digits, colors): digitMask = labels == digit x, y = vectors plt.scatter(mu[:, x][digitMask].cpu(), mu[:, y][digitMask].cpu(), c=[color], alpha=0.12) plt.title("Autoencoders Latent space") plt.xlabel(f"Dimension {vectors[0]}") plt.ylabel(f"Dimension {vectors[1]}") plt.xlim(-15, 15) plt.ylim(-5, 5) plt.tight_layout() return fig, axes
def _set_clusters(self): """ Set clusters colors """ # Set color for each pre-labelled cluster for i in range(len(self.cluster_names)): color = cm.tab10(i / len(self.cluster_names)) color_hex = mpl_colors.rgb2hex(color[:3]) self.cluster_colors[self.cluster_names[i]] = color_hex
def getColorPallet(palletSize=1, palletName="tab10"): pallet = [] if palletName == "tab10": for i in range(palletSize): color = tuple((np.array(cm.tab10(i))[:3]*255)) pallet.append(color) return pallet
def scatter_with_compare(X2d, y, predicted_labels, dataset_name): fig, axes = plt.subplots(1, 2, figsize=(17, 6)) plt.rcParams.update({'axes.titlesize': 'xx-large'}) axes[0].scatter(X2d[:, 0], X2d[:, 1], marker='o', color='white', alpha=1.0, linewidths=1, s=64, cmap='tab10', edgecolors=cm.tab10(y)) axes[0].set_title('Position by MPPCA, Color by True Label') axes[1].scatter(X2d[:, 0], X2d[:, 1], c=predicted_labels, s=64, alpha=0.7, cmap='tab10') axes[1].set_title('Position and Color by MPPCA') plt.tight_layout() plt.savefig('./plots/mppca_{}.png'.format(dataset_name)) plt.gcf().clear()
def make_ellipses(self, gmm, ax, clusters): colors = [] for i in range(clusters): color = cm.tab10(i / clusters) color_hex = mpl_colors.rgb2hex(color[:3]) colors.append(color_hex) for n, color in enumerate(colors): if gmm.covariance_type == 'full': covariances = gmm.covariances_[n][:2, :2] elif gmm.covariance_type == 'tied': covariances = gmm.covariances_[:2, :2] elif gmm.covariance_type == 'diag': covariances = np.diag(gmm.covariances_[n][:2]) elif gmm.covariance_type == 'spherical': covariances = np.eye(gmm.means_.shape[1]) * gmm.covariances_[n] v, w = np.linalg.eigh(covariances) u = w[0] / np.linalg.norm(w[0]) angle = np.arctan2(u[1], u[0]) angle = 180 * angle / np.pi # convert to degrees v = 2. * np.sqrt(2.) * np.sqrt(v) ell = mpl.patches.Ellipse(gmm.means_[n, :2], v[0], v[1], 180 + angle, color=color) ell.set_clip_box(ax.bbox) ell.set_alpha(0.5) ax.add_artist(ell)
def evaluate(dataset_name, id): X, y, K = load_dataset(id) gmm = GaussianMixture(n_components=K, covariance_type='diag') gmm.fit(X) predicted_labels1 = gmm.predict(X) measure_cluster(y, predicted_labels1, msg='GMM on the original dataset') pca = PCA(n_components=K) X2d = pca.fit_transform(X) gmm2 = GaussianMixture(n_components=K, covariance_type='diag') gmm2.fit(X2d) predicted_labels2 = gmm2.predict(X2d) measure_cluster(y, predicted_labels2, msg='PCA then GMM on reduced data') # plots fig, axes = plt.subplots(1, 3, figsize=(21, 7)) plt.rcParams.update({'axes.titlesize': 'xx-large'}) # True label axes[0].scatter(X2d[:, 0], X2d[:, 1], marker='o', color='white', alpha=1.0, linewidths=1, s=64, cmap='tab10', edgecolors=cm.tab10(y)) axes[0].set_title('Border color = True labels') # GMM labels # axes[1].scatter(X2d[:, 0], X2d[:, 1], marker='o', color='white', alpha=0.6, # linewidths=1, s=64, # cmap='tab10', edgecolors=cm.tab10(y)) axes[1].scatter(X2d[:, 0], X2d[:, 1], marker='o', alpha=1.0, linewidths=1, s=64, cmap='tab10', c=predicted_labels1) axes[1].set_title('Predicted labels with GMM on original data') # PCA -> GMM labels # axes[2].scatter(X2d[:, 0], X2d[:, 1], marker='o', color='white', alpha=0.6, # linewidths=1, s=64, # cmap='tab10', edgecolors=cm.tab10(y)) axes[2].scatter(X2d[:, 0], X2d[:, 1], c=predicted_labels2, s=64, alpha=1.0, cmap='tab10') axes[2].set_title('Predicted labels with GMM on reduced data by PCA') plt.tight_layout() plt.savefig('./plots/pca_gmm_{}.png'.format(dataset_name))
def _class_to_color(self, class_): if self.num_classes <= 10: colormap = cm.tab10(np.arange(self.num_classes)) else: colormap = cm.gist_stern( np.arange(self.num_classes) / self.num_classes) return tf.gather(colormap, class_, axis=0)
def color(idx): import matplotlib.cm as cm import numpy as np if idx == 0: colors = cm.tab10(np.linspace(0, 1, 10)) elif idx == 1: colors = cm.tab20(np.linspace(0, 1, 20)) return colors
def colors_1_to_255(colors_1): num_colors = len(colors_1) colors_255 = [] for i in range(num_colors): colors_255_i = tuple(np.flip(np.array(cm.tab10(i))[0:3]*255)) colors_255.append(colors_255_i) return colors_255
def setup_marker_colors(): for i in range(10): color = list(cm.tab10(i)[:3]) color[0] = int(color[0] * 255) color[1] = int(color[1] * 255) color[2] = int(color[2] * 255) color = color[:: -1] # This is a bug fix to BGR to RGB behaviour in opencv3 color = tuple(color) marker_colors.append(color)
def scatter(codes, labels, top_n=8): #fig = plt.figure() ''' if codes.shape[1] == 2: ndim = 2 ax = fig.add_subplot(111) elif codes.shape[1] == 3: ndim = 3 ax = fig.add_subplot(111, projection='3d') else: raise ValueError("Codes must have 2 or 3 dimensions") ''' ndim = codes.shape[1] plotsize = 7 counter = Counter(labels) if top_n <= len(set(labels)): nlabels = top_n else: nlabels = len(set(labels)) colors = cm.tab10(np.linspace(0, 1, nlabels)) for index, element in enumerate(counter.most_common()): if index < nlabels and element[0] != 'NA': lab = element[0] x_vals = [ codes[:, 0][i] for i in np.arange(len(labels)) if labels[i] == lab ] y_vals = [ codes[:, 1][i] for i in np.arange(len(labels)) if labels[i] == lab ] if ndim == 2: ax.scatter(x_vals, y_vals, s=plotsize, label=str(lab), color=colors[index], marker='o', alpha=0.5) elif ndim == 3: z_vals = [ codes[:, 2][i] for i in np.arange(len(labels)) if labels[i] == lab ] ax.scatter(x_vals, y_vals, z_vals, s=plotsize, label=str(lab), color=colors[index], marker='o', alpha=0.6)
def plot_planes(X, y, local_model, central_model, dist_model): sns.set_style('ticks') y = pd.DataFrame(y) y.loc[y[0] == -1, 0] = colors.to_hex(cm.Pastel2(0)) y.loc[y[0] == 1, 0] = colors.to_hex(cm.Pastel2(1)) y = y.values.T[0] w, b = get_average_best_plane(dist_model) plt.figure() draw_plane(w, b, cm.tab10(0), 1, 2.2, '-', "SVM Distribuído com C = " + str(dist_model.C) + " e " + "c = " + str(dist_model.c)) draw_plane(central_model.coef_[0], central_model.intercept_[0], cm.tab10(1), 1, 2.2, '--', "SVM Central com C = " + str(central_model.get_params()['C'])) draw_plane(local_model.coef_[0], local_model.intercept_[0], cm.tab10(2), 1, 2.2, '-.', "SVM Local com C = " + str(local_model.get_params()['C'])) plt.scatter(X[:, 0], X[:, 1], marker = 'o', c = y, alpha = 0.5) sns.despine() plt.legend(loc = 2) plt.ylim(-4.8, 4.8) file = str(plots_path) + "/simple_graph_compare.pdf" plt.savefig(file, transparent = True)
def label_to_2d_image(labels, alpha=0.5, cmap=None): """ :param labels: (x, y, z), values are label values :return: (x, y, rgba) """ labels_2d = labels.max(-1).T if cmap: rgba = cmap((labels_2d % 10 + 1) * (labels_2d > 0)) else: rgba = cm.tab10((labels_2d % 10 + 1) * (labels_2d > 0)) rgba[:, :, -1] = alpha rgba[np.where(labels_2d == 0)] = np.zeros(4) return rgba
def label_to_2d_image(labels, z='sum', alpha=0.5): """ :param labels: (x, y, z), values are label values :return: (x, y, rgba) """ if z == 'sum': labels_2d = labels.max(-1) else: labels_2d = labels[z, :, :] rgba = cm.tab10(labels_2d) rgba[:, :, -1] = alpha rgba[np.where(labels_2d == 0)] = np.zeros(4) return rgba
def get_colors(num_colors = 5,type = 'lines'): colors = [] for i in range(num_colors): if type == 'gradual': color = np.array([0, 0, 0])+i/num_colors rgb = tuple(color* 255) colors.append(rgb) elif type == 'lines': # convert to RGB rgb = tuple(np.flip(np.array(cm.tab10(i))[0:3]*255)) colors.append(rgb) return colors
def test_assign_colors(self): X = np.array([[1, 3], [4, 6], [7, 9], [10, 12]]) Y = np.array([[100, 1000], [200, 2000], [300, 3000], [400, 4000]]) ds = Dataset(X, Y, random_state=10) ds.assign_colors() arr = np.array([0., 1.]) self.assertIn('f0', ds.feature_colors.keys()) self.assertIn('f1', ds.feature_colors.keys()) self.assertIn('t0', ds.target_colors.keys()) self.assertIn('t1', ds.target_colors.keys()) self.assertTrue(np.allclose(np.array(list(ds.feature_colors.values())), cm.tab10(arr))) self.assertTrue(np.allclose(np.array(list(ds.target_colors.values())), cm.Dark2(arr)))
def waves(data, metric, title, sax=None, wax=None, rat=None, n=15, logy=True): if sax is None: fig, (sax, wax, rat) = plt.subplots(nrows=1, ncols=3, figsize=(16, 5), dpi=150) fig.set_facecolor('white') series = data[metric] minima = series.index[argrelextrema(series.values, np.less, order=n)[0]] maxima = series.index[argrelextrema(series.values, np.greater, order=n)[0]] waves = list(zip_longest(minima, maxima[1:])) series.plot(logy=logy, c='grey', ax=sax, title=title) series.loc[minima].plot(c='g', style='.', ax=sax) series.loc[maxima].plot(c='r', style='.', ax=sax) sax.title.set_fontweight('bold') df = pd.DataFrame() colours = [] maxes = [] for i, (start, end) in enumerate(waves, start=2): colour = cm.tab10(i) colours.append(colour) wave_data = data[metric].loc[start:end] wave_data.plot(ax=sax, color=colour) series = wave_data.reset_index()[metric] series -= series[0] name = f'Wave {i}, {start:%b %y}' df[name] = series maxes.append((series.max(), name)) df.index.name = 'days' df.plot(logy=logy, title='Relative to Wave Start', ax=wax, color=colours) wax.legend(loc='lower right') relative_to_name = sorted(maxes)[-1][1] relative_to = df[relative_to_name] relative_to.fillna(relative_to.max(), inplace=True) ratio = df.divide(relative_to, axis='rows') ratio.plot(ax=rat, color=colours, legend=False, title='Relative to Worst', ylim=(0, 1)) rat.yaxis.set_major_formatter( FuncFormatter(lambda y, pos: f"{y * 100:,.0f}%"))
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 plot(X,Y,model,coefs,initial_conditions,tmin,tmax,dataset,path = ''): x = Variable(torch.from_numpy(X), requires_grad=False).type(torch.FloatTensor) fig, ax = plt.subplots( nrows=1, ncols=1 ) for i in range(100): prediction = model(x)[0][:, :Y.shape[1]].data.numpy() for dim in range(Y.shape[1]): col = cm.tab10(dim) ax.plot(X, prediction[:, dim], color=col, alpha=0.1) for dim in range(Y.shape[1]): col = cm.tab10(dim) ax.scatter(X, Y[:, dim], color=col, alpha=0.1) real_x,real_y = generate_data(500, initial_conditions, coefs.flatten(), dataset, tmin, tmax) for dim in range(Y.shape[1]): col = cm.tab10(dim) ax.scatter(real_x, real_y[:, dim], color=col) if len(path) > 0: fig.savefig(path, bbox_inches='tight') plt.close(fig) else: fig.show() plt.close(fig)
def plot_clusters( X, y, dim, points, labels_prefix='cluster', points_name='centroids', colors=cm.tab10, # a qualitative map # https://matplotlib.org/examples/color/colormaps_reference.html # colors = ['brown', 'orange', 'olive', # 'green', 'cyan', 'blue', # 'purple', 'pink'], # points_color = 'red' points_color=cm.tab10( 10) # by default the last of the map (to be improved) ): """ Plot a two dimensional projection of an array of labelled points X: array with at least two columns y: vector of labels, length as number of rows in X dim: the two columns to project, inside range of X columns, e.g. (0,1) points: additional points to plot as 'stars' labels_prefix: prefix to the labels for the legend ['cluster'] points_name: legend name for the additional points ['centroids'] colors: a color map points_color: the color for the points """ # plot the labelled (colored) dataset and the points labels = np.unique(y) for i in range(len(labels)): color = colors(i / len(labels)) # choose a color from the map plt.scatter( X[y == labels[i], dim[0]], X[y == labels[i], dim[1]], s=10, c=[color], # scatter requires a sequence of colors marker='s', label=labels_prefix + str(labels[i])) plt.scatter(points[:, dim[0]], points[:, dim[1]], s=50, marker='*', c=[points_color], label=points_name) plt.legend() plt.grid() plt.show()
def overlapping_histograms( *args, **kwargs): # overlapping semi-transparent histograms from matplotlib.pyplot import gca, Axes #the first positional arg may be a subplot or the array if isinstance(args[0], Axes): sp, args = args[0], args[1:] else: sp = gca() labels = kwargs.get( 'labels', None) or ['data ' + str(n + 1) for n in range(len(args))] #remove key 'labels' from kwargs if 'labels' in kwargs: del kwargs['labels'] #make sure the lengths match assert len(labels) == len(args), "number of labels doesnt match" #handle colours list from matplotlib.cm import tab10 colors = kwargs.get('colors', None) or kwargs.get( 'colours', None) or [tab10(n) for n in range(len(args))] assert len(colors) == len(args), "number of colors does not match" #remove key 'color' & 'colours' from kwargs kwargs.pop('color') if kwargs.__contains__('color') else None kwargs.pop('colors') if kwargs.__contains__('colors') else None #let the rest of the keywords provided by the user be added to the dict which will be passes into plt.hist function d = dict(histtype='stepfilled', alpha=0.3, normed=True, bins=40) d.update(kwargs) #draw the histograms [ sp.hist(arr, **d, label=labels[i], color=colors[i]) for i, arr in enumerate(args) ] sp.legend() return sp
def Plot_predictions(self, predictions, names=[], group=[], group_name=[]): Xrange = np.linspace(self.minX, self.maxX, 30).reshape([30, 1]) scaling = self.mean_std_X[0][1] * self.max_X[0] for i in range(len(predictions)): valid_indices = np.where(np.array(predictions[i]) != 0) if len(group) > 0: col_group_sub = cm.tab10(group[i]) plt.plot(Xrange[valid_indices] * scaling + self.mean_std_X[0][0], np.array(predictions[i])[valid_indices], color=col_group_sub) else: plt.plot( Xrange[valid_indices] * scaling + self.mean_std_X[0][0], np.array(predictions[i])[valid_indices]) if len(names) > 0: max = np.int( np.where(predictions[i] == np.max(predictions[i]))[0]) plt.annotate(names[i], xy=(Xrange[max] * scaling + self.mean_std_X[0][0], predictions[i][max])) plt.title('Predicted staging') plt.show()
def print_summary(self): times = np.array(self.runtimes) mean_times = np.mean(times, axis=0) names = [ "Subsequence", "SAX", "Search", "Collision", "Filtering", "Gap Score" ] colors = [cm.tab10(i) for i in range(len(names))] plt.figure(figsize=(10, 9)) plt.title("Runtime per Section") plt.ylabel("Runtime (s)") plt.xlabel("Section") plt.bar(range(len(names)), mean_times, color=colors) plt.xticks(range(len(names)), labels=names) plt.savefig(join(getcwd(), "bar_chart.png")) normalized = 100 * mean_times / np.sum(mean_times) plt.figure(figsize=(10, 9)) plt.title("Percentage of Total Runtime by Section") plt.pie(normalized, labels=names, autopct="%2.2f%%", explode=(0.15, 0.15, 0.15, 0.15, 0.15, 0.15), colors=colors) plt.savefig(join(getcwd(), "usage_chart.png"))
bp4 = plt.boxplot(np.transpose(result_all_unet[3, :]), positions=[positions[3]], widths=width) bp5 = plt.boxplot(np.transpose(result_all_deeplab[0, :]), positions=[positions[0] + width], widths=width) bp6 = plt.boxplot(np.transpose(result_all_deeplab[1, :]), positions=[positions[1] + width], widths=width) bp7 = plt.boxplot(np.transpose(result_all_deeplab[2, :]), positions=[positions[2] + width], widths=width) bp8 = plt.boxplot(np.transpose(result_all_deeplab[3, :]), positions=[positions[3] + width], widths=width) set_box_color(bp1, cm.tab10(0), 'blue') set_box_color(bp2, cm.tab10(0), 'red') set_box_color(bp3, cm.tab10(0), 'green') set_box_color(bp4, cm.tab10(0), 'purple') set_box_color(bp5, cm.tab10(1), 'blue') set_box_color(bp6, cm.tab10(1), 'red') set_box_color(bp7, cm.tab10(1), 'green') set_box_color(bp8, cm.tab10(1), 'purple') plt.xlim([-0.25, 3.75]) plt.xticks( np.arange(len(run_types)) + width / 2, ['base', 'low diversity', 'high diversity', 'higher diversity']) plt.plot([], c=cm.tab10(0), label='U-Net') plt.plot([], c=cm.tab10(1), label='Deeplab-CRF') plt.ylim([75, 77]) plt.legend(loc='lower left')
def create_rgb(i): return tuple(np.array(cm.tab10(i)[:3]) * 255)
def tree_correlation_plot_list(correlations_list, x, y, plot_file=None, labels=[], param_dict_list=[], min_joint_number=10, scale_t=False, ylim=[-0.3, 1.1], xlim=[None, None]): mapping = { z: i for i, z in enumerate([ "x(t+dt)", "g(t+dt)", "l(t+dt)", "q(t+dt)", "x(t)", "g(t)", "l(t)", "q(t)" ]) } norm = mcolors.Normalize(vmin=0, vmax=9.9) colors_sets = {} for i, l in enumerate(labels): colors_sets[l] = cm.tab10(norm(i)) # =========== figure =========== # fig, _ = plt.subplots(figsize=(8, 4)) ax0 = plt.subplot2grid((1, 1), (0, 0)) axs = [ax0] for ax in axs: ax.spines["top"].set_visible(False) ax.spines["right"].set_visible(False) # set the x-spine ax.spines['left'].set_position('zero') # turn off the right spine/ticks ax.spines['right'].set_color('none') ax.yaxis.tick_left() # =========== plot =========== # # decide if exponential will be plotted for correlations, param_dict, label in zip(correlations_list, param_dict_list, labels): gamma = None if x[0] == "l" and y[0] == "l": gamma = param_dict["gamma_lambda"] elif x[0] == "q" and y[0] == "q": gamma = param_dict["gamma_q"] # =========== correlation =========== # rs = [] errs = [] dts = [] corr_naive = [] for i, corr in enumerate(correlations): if corr.n > min_joint_number: dts.append(corr.dt) rs.append(corr.corr_mle[mapping[x], mapping[y]]) errs.append(corr.corr_mle_err[mapping[x], mapping[y]]) corr_naive.append(corr.corr_naive[mapping[x], mapping[y]]) dts = np.array(dts).astype(float) if scale_t: dts /= (np.log(2) / param_dict["mean_lambda"]) if gamma != None: gamma *= (np.log(2) / param_dict["mean_lambda"]) else: if param_dict != None: ax0.axvline(np.log(2) / param_dict["mean_lambda"], color=colors_sets[label], alpha=0.5) ax0.errorbar(dts, rs, yerr=errs, lw=2, color=colors_sets[label], label=label) if gamma != None: ax0.plot(dts, np.exp(-dts * gamma), ls='--', color=colors_sets[label], alpha=0.6) else: ax0.plot(dts, dts * 0, color=colors_sets[label]) # ===== layout ===== # ax0.set_ylabel(r"$\langle {:s}, {:s}\rangle$".format(x, y)) ax0.set_ylim(ylim) ax0.set_xlim(xlim) ax0.legend() if scale_t: ax0.set_xlabel("norm. dt") else: ax0.set_xlabel("dt (min)") fig.tight_layout(h_pad=4) if plot_file != None: plot_output = plot_file.format(y[0], x[0]) print("Saved in", plot_output) fig.savefig(plot_output, dpi=300, facecolor="white") else: plt.show()
from nets.vgg16 import vgg16 from nets.resnet_v1 import resnetv1 import torch CLASSES = ('__background__', 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor') NETS = {'vgg16': ('vgg16_faster_rcnn_iter_%d.pth',), 'res101': ('res101_faster_rcnn_iter_%d.pth',)} DATASETS = {'pascal_voc': ('voc_2007_trainval',), 'pascal_voc_0712': ('voc_2007_trainval+voc_2012_trainval',)} COLORS = [cm.tab10(i) for i in np.linspace(0., 1., 10)] def demo(net, image_name): """Detect object classes in an image using pre-computed object proposals.""" # Load the demo image im_file = os.path.join(cfg.DATA_DIR, 'demo', image_name) im = cv2.imread(im_file) # Detect all object classes and regress object bounds timer = Timer() timer.tic() scores, boxes = im_detect(net, im) timer.toc() print('Detection took {:.3f}s for {:d} object proposals'.format(timer.total_time(), boxes.shape[0]))
def stacked_bar_plot(data, labels, legend=None, table_header=None, title=None, ax_names=None, normalize=False, normalize_factor=None, width=0.8): """Creates a stacked bar plot. Parameters ---------- data : numpy.array Multi-dimensional array. labels : list List of xtick labels. Should have the same length as `data`. title : str Title of the plot. table_header : list List with the header of the table object. Each element represents a column. title : str Title of the plot. ax_names : list List with the labels for the x-axis (first element) and y-axis (second element). normalize : bool If True, values of the `data` array will be normalized by the `normalize_factor` normalize_factor : int or float Number used to normalize values of the `data` array. Returns ------- fig : matplotlib.Figure Figure object of the plot. lgd : matplotlib.Legend Legend object of the plot. table : list Table data in list format. Each item in the list corresponds to a table row. """ plt.rcParams["figure.figsize"] = (8, 6) if normalize: data_original = np.copy(data) data = np.array([[y / normalize_factor for y in x] for x in data]) if len(labels) > 10: plt.rcParams["figure.figsize"] = (len(labels) / 3, 6) else: plt.rcParams["figure.figsize"] = (8, 6) # Use ggpot style plt.style.use("ggplot") fig, ax = plt.subplots() # Get bottom positions for stacked bar bottoms = np.cumsum(np.vstack((np.zeros(data.shape[1]), data)), axis=0)[:-1] # Get x positions xpos = [x + (width / 2) for x in range(len(labels))] for c, d in enumerate(data): if len(data) <= 10: c1 = c if c < 9 else c - 10 clr = cm.tab10(c1, 1) else: c1 = c if c < 19 else c - 20 clr = cm.tab20(c1, 1) if legend: current_lgd = legend[c] else: current_lgd = None if c == 0: bplot = ax.bar(xpos, d, width, color=clr, label=current_lgd, alpha=.9) else: bplot = ax.bar(xpos, d, width, color=clr, label=current_lgd, alpha=.9, bottom=bottoms[c]) # Set x labels plt.xticks([x + (width / 2) for x in xpos], labels, ha="right", rotation=45) # Set legend if legend: if len(legend) <= 4: cols = 1 else: cols = len(legend) if len(legend) < 3 else 3 borderpad = cols * -6 lgd = plt.legend(loc=7, fancybox=True, shadow=True, framealpha=.8, ncol=cols, borderaxespad=borderpad) else: lgd = None # Generate table structure if table_header: table = [table_header] else: table = [] if normalize: for i, lbl in enumerate(labels): table.append([lbl] + list(chain.from_iterable((int(x[i]), y[i]) for x, y in zip(*[data_original, data])))) else: for i, lbl in enumerate(labels): table.append([lbl] + [x[i] for x in data]) return fig, lgd, table