def plot(): plt.figure(figsize=(20, 10)) width = 0.5 index = np.arange(26) print 'SUM PLOT 1', sum(row[0] for row in data) print 'SUM PLOT 2', sum(row[1] for row in data) print 'SUM PLOT 3', sum(row[2] for row in data) print data[0] p0 = plt.bar(index, data[0], width, color='y') # people p1 = plt.bar(index, data[1], width, color='g') # nature p2 = plt.bar(index, data[2], width, color='r') # activity p3 = plt.bar(index, data[3], width, color='b') # food p4 = plt.bar(index, data[4], width, color='c') # symbols p5 = plt.bar(index, data[5], width, color='m') # objects p6 = plt.bar(index, data[6], width, color='k') # flags p7 = plt.bar(index, data[7], width, color='w') # uncategorized plt.ylabel('Usage') plt.title('Emoji category usage per city') plt.xticks(index + width/2.0, cities) plt.yticks(np.arange(0, 1, 0.1)) plt.legend((p0[0], p1[0], p2[0], p3[0], p4[0], p5[0], p6[0], p7[0]), categories_names) plt.show()
def plot_single(df_metrics): """ APFD plot for single Embedding Neural Network model :param df_metrics: :return: """ apfd = df_metrics['apfd'] miu = np.round(np.mean(apfd), 2) sigma = np.round(np.std(apfd), 2) label = 'regression' + '\n $\mu$ - ' + str(miu) + ' $\sigma$ - ' + str( sigma) sns.distplot(apfd, kde=True, bins=int(180 / 5), color=sns.color_palette()[0], hist_kws={'edgecolor': 'black'}, kde_kws={ 'linewidth': 4, 'clip': (0.0, 1.0) }, label=label) plt.legend(frameon=True, loc='upper left', prop={'size': 20}) plt.xlabel('APFD') #plt.title('APFD Distribution - 100 revisions ') plt.show()
def show(self, w): """ illustrate the learning curve Parameters ---------- w : int, window size for smoothing the curve """ # plot data plt.subplot(121) plt.plot(self.tn_it, self.tn_err, 'b.', alpha=0.2) plt.plot(self.tt_it, self.tt_err, 'r.', alpha=0.2) # plot smoothed line xne,yne = self._smooth( self.tn_it, self.tn_err, w ) xte,yte = self._smooth( self.tt_it, self.tt_err, w ) plt.plot(xne, yne, 'b') plt.plot(xte, yte, 'r') plt.xlabel('iteration'), plt.ylabel('cost energy') plt.subplot(122) plt.plot(self.tn_it, self.tn_cls, 'b.', alpha=0.2) plt.plot(self.tt_it, self.tt_cls, 'r.', alpha=0.2) # plot smoothed line xnc, ync = self._smooth( self.tn_it, self.tn_cls, w ) xtc, ytc = self._smooth( self.tt_it, self.tt_cls, w ) plt.plot(xnc, ync, 'b', label='train') plt.plot(xtc, ytc, 'r', label='test') plt.xlabel('iteration'), plt.ylabel( 'classification error' ) plt.legend() plt.show() return
def show(self, w): """ illustrate the learning curve Parameters ---------- w : int, window size for smoothing the curve """ # plot data plt.subplot(121) plt.plot(self.tn_it, self.tn_err, 'b.', alpha=0.2) plt.plot(self.tt_it, self.tt_err, 'r.', alpha=0.2) # plot smoothed line xne, yne = self._smooth(self.tn_it, self.tn_err, w) xte, yte = self._smooth(self.tt_it, self.tt_err, w) plt.plot(xne, yne, 'b') plt.plot(xte, yte, 'r') plt.xlabel('iteration'), plt.ylabel('cost energy') plt.subplot(122) plt.plot(self.tn_it, self.tn_cls, 'b.', alpha=0.2) plt.plot(self.tt_it, self.tt_cls, 'r.', alpha=0.2) # plot smoothed line xnc, ync = self._smooth(self.tn_it, self.tn_cls, w) xtc, ytc = self._smooth(self.tt_it, self.tt_cls, w) plt.plot(xnc, ync, 'b', label='train') plt.plot(xtc, ytc, 'r', label='test') plt.xlabel('iteration'), plt.ylabel('classification error') plt.legend() plt.show() return
def AddRegressor(): rng = np.random.RandomState(1) # 和random_state的用法一致 在这可以固定生成的随机数 x = np.sort(5 * rng.rand(80, 1), axis=0) # rng.rand(80,1) 生成80行1列的随机数 乘以5就是生成0-5的随机数 y = np.sin(x).ravel() # ravel()降维 y[::5] += 0.3 * (0.5 - rng.rand(16)) # plt.show() reg1 = tree.DecisionTreeRegressor(max_depth=2) reg2 = tree.DecisionTreeRegressor(max_depth=5) reg1.fit(x, y) reg2.fit(x, y) test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis] y1 = reg1.predict(test) y2 = reg2.predict(test) #plt.figure() plt.figure() plt.scatter(x, y, label='dian') plt.plot(test, y1, color='red', label='max_depth=2') plt.plot(test, y2, color='yellow', label="max_depth=5") plt.xlabel('data') plt.ylabel('target') plt.legend(loc='upper right') plt.show()
def __init__(self, dir_name='/home/steve/Data/FusingLocationData/0010/'): if not dir_name[-1] is '/': dir_name = dir_name + '/' imu_left = np.loadtxt(dir_name + 'LEFT_FOOT.data', delimiter=',') imu_right = np.loadtxt(dir_name + 'RIGHT_FOOT.data', delimiter=',') imu_head = np.loadtxt(dir_name + 'HEAD.data', delimiter=',') uwb_head = np.loadtxt(dir_name + 'uwb_result.csv', delimiter=',') beacon_set = np.loadtxt(dir_name + 'beaconSet.csv', delimiter=',') print('average time interval of left:', float(imu_left[-1, 1] - imu_left[0, 1]) / float(imu_left.shape[0])) print('average time interval of right:', float(imu_right[-1, 1] - imu_right[0, 1]) / float(imu_right.shape[0])) print('average time interval of head:', float(imu_head[-1, 1] - imu_head[0, 1]) / float(imu_head.shape[0])) plt.figure() plt.plot(imu_left[1:, 1] - imu_left[:-1, 1], label='time left') plt.plot(imu_right[1:, 1] - imu_right[:-1, 1], label='time right') # time_diff = imu_left[1:,1] - imu_left[:-1,1] # plt.plot(time_diff-time_diff.mean(),label='time diff') plt.plot(imu_head[1:, 1] - imu_head[:-1, 1], label=' time head') plt.grid() plt.legend() plt.show()
def plotting(sim_context1,sim_context2,diff,data_df,total_samples): plt.plot(sim_context1,label="Context 1") plt.plot(sim_context2,label="Context 2") x_labels_word1 = data_df["word1"] x_labels_word2 = data_df["word2"] xlabels = [0] * total_samples xticks_x = [0] * total_samples for wp in range (total_samples): xlabels[wp] = x_labels_word1[wp]+ "\n"+x_labels_word2[wp] xticks_x[wp] = wp+1 plt.plot(diff,label="Difference") plt.legend(loc='center right') # Add title and x, y labels plt.title("Elmo Embedding Model Results", fontsize=16, fontweight='bold') plt.xlabel("Word") plt.ylabel("Similarity") plt.xticks(xticks_x, xlabels) plt.show()
def plot_first_factors(X_data, y_data, analysis_type="lda"): """Generate scatterplot of two principal components (pca or lda) of data set.""" le = preprocessing.LabelEncoder() le.fit(y_data) colours = [ 'blue', 'green', 'red', 'cyan', 'magenta', 'yellow', 'darkgreen', 'darkorange', 'yellow', 'black' ] if analysis_type == "pca": transform = PCA(n_components=2) XX_data = transform.fit(X_data).transform(X_data) elif analysis_type == "lda": transform = LinearDiscriminantAnalysis(n_components=2) XX_data = transform.fit(X_data, y_data).transform(X_data) else: print("Type", analysis_type, "not recognised, use either 'pca' or 'lda'.") return plt.figure() for i, j in enumerate(le.classes_): plt.scatter(XX_data[y_data == j, 0], XX_data[y_data == j, 1], alpha=0.8, color=colours[i], label=str(j)) plt.legend(loc='best', shadow=False, scatterpoints=1) plt.title(analysis_type)
def graph(train_df, test_df, p_forecast, f_forecast, metric, key): fig = plt.figure(figsize=(40,10)) forecast_ds = np.array(f_forecast["ds"]) print(len(forecast_ds)) print(len(train_df)) forecast_ds = forecast_ds[int(train_df["values"].count()):] plt.plot(np.array(train_df["ds"]), np.array(train_df["y"]),'b', label="train", linewidth=3) plt.plot(np.array(test_df["ds"]), np.array(test_df["y"]), 'k', label="test", linewidth=3) plt.savefig( "../testing/compare_fourier_prophet/" + str(key) + "_raw_" + metric + ".png", transparent=True) prophet = np.array(p_forecast["yhat"]) prophet_upper = np.array(p_forecast["yhat_upper"]) prophet_lower = np.array(p_forecast["yhat_lower"]) fourier = f_forecast["yhat"] fourier = fourier[len(train_df["values"]):] print(len(forecast_ds)) print(len(fourier)) plt.plot(forecast_ds, fourier, 'g', label="fourier_yhat", linewidth=3) plt.savefig( "../testing/compare_fourier_prophet/" + str(key) + "_fourier_" + metric + ".png", transparent=True) prophet = prophet[len(train_df["values"]):] prophet_upper = prophet_upper[len(train_df["values"]):] prophet_lower = prophet_lower[len(train_df["values"]):] plt.plot(forecast_ds, prophet, '*y', label="prophet_yhat", linewidth=3) plt.plot(forecast_ds, prophet_upper, 'y', label="yhat_upper", linewidth=3) plt.plot(forecast_ds, prophet_lower, 'y', label="yhat_lower", linewidth=3) plt.plot() plt.xlabel("Timestamp") plt.ylabel("Value") plt.legend(loc=1) plt.title("Prophet Model Forecast") plt.savefig( "../testing/compare_fourier_prophet/" + str(key) + "_compare_" + metric + ".png", transparent=True) plt.close() fig = plt.figure(figsize=(40,10)) forecast_ds = np.array(f_forecast["ds"]) forecast_ds = forecast_ds[len(train_df["values"]):] plt.plot(np.array(train_df["ds"]), np.array(train_df["y"]),'b', label="train", linewidth=3) plt.plot(np.array(test_df["ds"]), np.array(test_df["y"]), 'k', label="test", linewidth=3) prophet = np.array(p_forecast["yhat"]) prophet_upper = np.array(p_forecast["yhat_upper"]) prophet_lower = np.array(p_forecast["yhat_lower"]) prophet = prophet[len(train_df["values"]):] prophet_upper = prophet_upper[len(train_df["values"]):] prophet_lower = prophet_lower[len(train_df["values"]):] plt.plot(forecast_ds, prophet, '*y', label="prophet_yhat", linewidth=3) plt.plot(forecast_ds, prophet_upper, 'y', label="yhat_upper", linewidth=3) plt.plot(forecast_ds, prophet_lower, 'y', label="yhat_lower", linewidth=3) plt.savefig( "../testing/compare_fourier_prophet/" + str(key) + "_prophet_" + metric + ".png", transparent=True) plt.close()
def plot_error(self, train_errors): n = len(train_errors) training, = plt.plot(range(n), train_errors, label="Training Error") plt.legend(handles=[training]) plt.title("Error Plot") plt.ylabel('Error') plt.xlabel('Iterations') plt.show()
def plot_accuracy(self, train_acc, test_acc): n = len(train_acc) plt.plot(range(n), train_acc, label="train") plt.plot(range(n), test_acc, label="test") plt.legend(loc='lower right') plt.title("Overfit") plt.ylabel('accuracy') plt.xlabel('epoch') plt.show()
def pretty_plot_metrics(name, data): plt.plot(data['labeled_acc'], '-', color='b', label='Labeled Accuracy') plt.plot(data['labeled_loss'], ':', color='b', label='Labeled Loss') plt.plot(data['unlabeled_acc'], '-', color='r', label='Unsupervised Accuracy') plt.plot(data['unlabeled_loss'], ':', color='r', label='Unsupervised Loss') plt.legend() plt.savefig(name + '.png')
def multiplot_gen_property_type(): # # font = {'family': 'Liberation Serif', # 'weight': 'normal', # 'size': 15 # } # # # play around with the font size if it is too big or small # matplotlib.rcParams['axes.titlesize'] = 12 # matplotlib.rcParams['axes.labelsize'] = 12 # matplotlib.rc('font', **font) # # matplotlib.rcParams['text.usetex'] = True # matplotlib.rcParams['pdf.fonttype'] = 42 # matplotlib.rcParams['pdf.use14corefonts'] = True x = list(data.keys()) y1=[] y2=[] y3=[] y4=[] y5=[] y6=[] for year in data.keys(): for option_name, count in data[year].items(): if option_name == 'domain': y1.append(count) if option_name == 'sitekey': y2.append(count) if option_name == 'third-party': y3.append(count) if option_name == 'websocket': y4.append(count) if option_name == 'webrtc': y5.append(count) if option_name == 'csp': y6.append(count) plt.plot(x, y1,'-o',label='domain') plt.plot(x, y2,'-v',label='sitekey') plt.plot(x, y3,'-^',label='third-party') plt.plot(x, y4,'-<',label='websocket') plt.plot(x, y5,'->',label='webrtc') plt.plot(x, y6,'-1',label='csp') plt.xticks(rotation='vertical') plt.xlabel('Year') plt.ylabel('Count') plt.legend(ncol=2) plt.tight_layout() plt.savefig('easylist-property-type.pdf ', format='pdf', dpi=1200)
def convergence_plots(self): obj_value_plot = [] obj_value_DIFT_plot = [] obj_value_APT_plot = [] iteration_number = [] t_sim_avg_reward = 1000 avergae_value_DIFT = [] avergae_value_APT = [] average_reward_DIFT = [] average_reward_APT = [] for tt in range(0, self.t_sim, 500): Eval_Func_Obj = Eval_and_Plots( self.Policy_Data, tt, self.N_ss, self.stage_ID, self.ss_entry_dest, self.CD, self.APT_win, self.APT_drop, self.DIFT_win, self.DIFT_lose, self.trap_set, self.state_transition_matrix, self.FN, self.s0, self.V_Data) Output_Data_average_reward = Eval_Func_Obj.find_average_reward( t_sim_avg_reward) rho_Data = [] rho_Data.append(Output_Data_average_reward[0][t_sim_avg_reward - 1]) rho_Data.append(Output_Data_average_reward[1][t_sim_avg_reward - 1]) average_reward_DIFT.append( Output_Data_average_reward[0][t_sim_avg_reward - 1]) average_reward_APT.append( Output_Data_average_reward[1][t_sim_avg_reward - 1]) #Caculating the avrage value avergae_value_DIFT.append(mean(self.V_Data[tt][0])) avergae_value_APT.append(mean(self.V_Data[tt][1])) Output_Data_obj_evaluate = Eval_Func_Obj.obj_evaluate(rho_Data) obj_value_plot.append(Output_Data_obj_evaluate[0]) obj_value_DIFT_plot.append(Output_Data_obj_evaluate[1]) obj_value_APT_plot.append(Output_Data_obj_evaluate[2]) iteration_number.append(tt) plt.plot(avergae_value_DIFT) plt.plot(avergae_value_APT) plt.show() plt.plot(average_reward_DIFT) plt.plot(average_reward_APT) plt.show() plt.plot(obj_value_plot, label="Obj") plt.plot(obj_value_DIFT_plot, label="DIFT Obj") plt.plot(obj_value_APT_plot, label="APT Obj") plt.legend(loc='lower left') plt.show()
def _build_plot_static(self, metric_group): metrics = self.get_metrics_history() if metric_group not in metrics: raise ValueError("can't find metric group") for name, values in metrics[metric_group].items(): plt.plot(values, label=name) plt.legend(loc='best') plt.title(metric_group, fontsize=16, fontweight='bold') plt.xlabel("Generations") plt.show() return None
def plot_graph(self, auroc_results, y_label: str): for ad_key, ad_label in AD_NAMES.items(): plt.plot(self.x_axis, numpy.asarray(auroc_results[ad_key], ), label=ad_label) plt.legend(loc='lower left') plt.xlabel(self.x_axis_label) plt.ylabel(ylabel=y_label) to_print = plt.gcf() plt.show() file_name_with_metric = y_label + "-" + self.file_name to_print.savefig(file_name_with_metric, bbox_inches='tight')
def plot(ranks): plt.figure(figsize=(20, 10)) plt.title("A2.3 PageRank (s-Sensibility)") plt.xlabel("Node ID") plt.ylabel("Pagerank") for row in ranks: plt.plot(row) plt.legend(['s = %.2f' % s for s in numpy.arange(0.0, 1.0, 0.05)], loc='upper right', prop={'size': 7}) plt.savefig("submission/pagerank.png")
def update_data(args, show_seconds=20, subsampling=10): # load previous metadata1 = np.load(os.path.join(args.session1, 'metadata.npy'), allow_pickle=True).item() data1 = np.load(os.path.join(args.session1, 'NIdaq.npy'), allow_pickle=True).item() t1 = np.arange(len(data1['analog'][0,:]))/metadata1['NIdaq-acquisition-frequency'] metadata2 = np.load(os.path.join(args.session2, 'metadata.npy'), allow_pickle=True).item() data2 = np.load(os.path.join(args.session2, 'NIdaq.npy'), allow_pickle=True).item() t2 = np.arange(len(data2['analog'][0,:]))/metadata1['NIdaq-acquisition-frequency'] metadata = np.load(os.path.join(args.session1, 'metadata.npy'), allow_pickle=True).item() data = np.load(os.path.join(args.session, 'NIdaq.npy'), allow_pickle=True).item() t = np.arange(len(data['analog'][0,:]))/metadata1['NIdaq-acquisition-frequency'] tstart = np.min([t.max(), t1.max(), t2.max()])-show_seconds # showing the last 5 seconds # checking that the two realisations are the same: plt.figure(figsize=(7,5)) plt.plot(t1[t1>tstart][::subsampling], data1[args.type][args.channel,t1>tstart][::subsampling], label='session #1') plt.plot(t2[t2>tstart][::subsampling], data2[args.type][args.channel,t2>tstart][::subsampling], label='session #2') plt.plot(t[t>tstart][::subsampling], data[args.type][args.channel,t>tstart][::subsampling], label='session') plt.legend() plt.show() y = input(' /!\ ----------------------- /!\ \n Confirm that you want to replace\n the "%s" data of channel "%s" in session:\n "%s"\n by the data of session #1 ? [yes/No]' % (args.type, args.channel, args.session)) if y in ['y', 'Y', 'yes', 'Yes']: temp = str(tempfile.NamedTemporaryFile().name)+'.npy' print(""" ---> moving the old data to the temporary file directory as: "%s" [...] """ % temp) shutil.move(os.path.join(args.session, 'NIdaq.npy'), temp) print('applying changes [...]') data[args.type][args.channel,:] = data1[args.type][args.channel,:len(data[args.type][args.channel,:])] np.save(os.path.join(args.session, 'NIdaq.npy'), data) print('done !') else: print('--> data update aborted !! ')
def f3(): xs = [0, 1, 2, 5] ys = [0, 0, 1, 1] fig, ax = plt.subplots() ax.set_yticklabels([]) ax.set_xticklabels([]) plt.plot(xs, ys, label="$f_n(x)$") plt.xticks(xs, ['', r'$n-1$', r'$n$', '']) plt.yticks([1], ['$1$']) plt.legend() ax.spines['left'].set_position('zero') ax.spines['right'].set_color('none') ax.spines['bottom'].set_position('zero') ax.spines['top'].set_color('none') ax.axis('equal') plt.show()
def plt_score(history): plt.figure() plt.plot() plt.plot(history.history['acc']) plt.plot(history.history['val_acc']) plt.title('model accuracy') plt.ylabel('accuracy') plt.xlabel('epoch') plt.legend(['train', 'test'], loc='upper left') plt.savefig('acc.png') # loss plt.figure() plt.plot(history.history['loss']) plt.plot(history.history['val_loss']) plt.title('model loss') plt.ylabel('loss') plt.xlabel('epoch') plt.legend(['train', 'test'], loc='upper left') plt.savefig('loss.png')
def update_NIdaq_data(args, window=20, subsampling=100): metadata = np.load(os.path.join(args.datafolder, 'metadata.npy'), allow_pickle=True).item() if os.path.isfile(os.path.join(args.datafolder, 'NIdaq.start.npy')): NIdaq_Tstart = np.load(os.path.join(args.datafolder, 'NIdaq.start.npy'))[0] NIdaq_Tstart = np.load(os.path.join(args.datafolder, 'NIdaq.start.npy'))[0] data = np.load(os.path.join(args.datafolder, 'NIdaq.npy'), allow_pickle=True).item() t = np.arange(len(data['analog'][0,:]))/float(metadata['NIdaq-acquisition-frequency']) # checking that the two realisations are the same: fig, ax = plt.subplots(1, figsize=(7,5)) cond = (t>(args.time-window)) & (t<(args.time+window)) ax.plot(t[cond][::subsampling], data['analog'][0,cond][::subsampling], label='data') ax.plot(args.time*np.ones(2), ax.get_ylim(), 'r-', label='reset point') plt.legend() plt.show() y = input(' /!\ ----------------------- /!\ \n Confirm that you want to remove episodes after the reset point ? [yes/No]\n') if y in ['y', 'Y', 'yes', 'Yes']: temp = str(tempfile.NamedTemporaryFile().name)+'.npy' print(""" ---> moving the old data to the temporary file directory as: "%s" [...] """ % temp) shutil.move(os.path.join(args.datafolder, 'NIdaq.npy'), temp) print('applying changes [...]') cond = (t>args.time) data['analog'][0,cond] = data['analog'][0,cond][0] np.save(os.path.join(args.datafolder, 'NIdaq.npy'), data) print('done !') else: print('--> data update aborted !! ')
def f4(): capped_xs = np.linspace(-0.94, 0.8, 1000) xs = np.linspace(-1, 1, 1000) ys = [1 / (1 - x) for x in capped_xs] def getN(N): def fN(x): total = 0.0 for i in range(N + 1): total += x**i return total return fN yss = [] for N in range(1, 4): fN = getN(N) yss.append([fN(x) for x in xs]) fig, ax = plt.subplots() ax.set_yticklabels([]) ax.set_xticklabels([]) plt.plot(capped_xs, ys, label=r"$\frac{1}{1-x}$") for i, ys in enumerate(yss): plt.plot(xs, ys, label="$N={}$".format(i + 1), alpha=0.3) plt.plot([1, 1], [0, 5], "k--", alpha=0.3) plt.plot(-1, 0.5, 'o', markerfacecolor='None', markeredgecolor='C0', markersize=5) plt.xticks([-1, 1], ['-1', '1']) plt.legend() ax.spines['left'].set_position('zero') ax.spines['right'].set_color('none') ax.spines['bottom'].set_position('zero') ax.spines['top'].set_color('none') ax.axis('equal') plt.show()
def print_all_results(collected_results, versions, args): test_type = args.test_type model_name = args.model for test_name in collected_results: test_results = collected_results[test_name] x, y = [], [] for version in versions: if (version in test_results): x.append(version) y.append(test_results[version]['mean']) plt.plot(x, y, label=test_name) plt.xticks(np.arange(len(x)), x) plt.xlabel(XLABELS[test_type]) plt.ylabel('average absolute effect size') plt.legend(loc='best') plt.title("SEAT effect sizes on {} with {}".format(model_name, TITLES[test_type])) plot_path = os.path.join(args.eval_results_dir, "plots", "{}-{}.png".format(model_name, test_type)) plt.savefig(plot_path)
def exact(): W = Lea.fastMax(W0 + U, 0) for k in range(1, 21): if k % 5 == 0: plt.plot(W.support(), W.pmf(), label="k={}".format(k)) W = Lea.fastMax(W + U, 0) return W.support(), W.pmf() plt.figure() plt.axis([0, 20, 0, 0.3]) plt.title("Exact") xex, yex = exact() plt.legend() tikz_save('waiting_time_1.tex', figureheight='5cm', figurewidth='5cm') plt.close() plt.figure() plt.axis([0, 20, 0, 0.3]) plt.title("Simulation") xsim, ysim = simulate() plt.legend() tikz_save('waiting_time_2.tex', figureheight='5cm', figurewidth='5cm') plt.close() plt.figure() plt.axis([0, 20, 0, 0.3]) plt.title("Sim/Exact") plt.plot(xsim, ysim, label="sim")
test_scores_mean = np.mean(test_scores, axis=1) test_scores_std = np.std(test_scores, axis=1) plt.grid() plt.fill_between(train_sizes, train_scores_mean - train_scores_std, train_scores_mean + train_scores_std, alpha=0.1, color="r") plt.fill_between(train_sizes, test_scores_mean - test_scores_std, test_scores_mean + test_scores_std, alpha=0.1, color="g") plt.plot(train_sizes, train_scores_mean, '-', color="r", label="Training score") plt.plot(train_sizes, test_scores_mean, '-', color="g", label="Cross-validation score") plt.ylim(0,1.2) plt.xlim(0,200) plt.legend(loc="best") plt.xlabel("Train test size") plt.savefig("learning_curves.png") plt.close("all") # plot the model vs the predictions for what_plot in [0,1,2,3]: fig=plt.figure(figsize=(16,8)) # ax1 = fig.add_subplot(1,2,1); ax2 = fig.add_subplot(1,2,2) ax1.tick_params(labelsize=20); ax2.tick_params(labelsize=20) # if(what_plot==3): # actual data
import pandas as pd import numpy as np from matplotlib.pylab import plt #load plot library df = pd.read_csv("../data/well_monthly_2017.csv", header=0) months = range(1, 13) for well_i in range(1, 18): data_i = df[df["well"] == well_i] data_i.drop(columns=["month", "well"], inplace=True) data = data_i.values.flatten() plt.plot(months, data, label="Well " + str(well_i)) print("well ", well_i) plt.legend(loc='top left') plt.xlabel("Month") plt.ylabel("Pumped Amount 2017") plt.show()
ax[0][2].set_xlabel(r'$v [km s^{-1}]$') ax[0][2].set_ylabel('(g - i)') ax[0][2].set_xticks(np.arange(-500, 2600,500)) # - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - x = GCs['R'].copy().sort_values() y = np.arange(1,len(GCs)+1) plt.plot(x,y,label='GCs') x = stars['R'].copy().sort_values() y = np.arange(1,len(stars)+1) plt.plot(x,y,label='Stars') plt.legend() # - - - - - - - - - - - - - - - - - - - - - - - # - - - - - - - - - - - - - - - - - - - - - - - mask = (((result['g_auto'] - result['r_auto']) < (0.2 + 0.6 * (result['g_auto'] - result['i_auto']))) & ((result['g_auto'] - result['r_auto']) > (-0.2 + 0.6 * (result['g_auto'] - result['i_auto']))) & ((result['g_auto'] - result['i_auto']) > 0.5) & ((result['g_auto'] - result['i_auto']) < 1.3) & ((result['i_auto']) < 24)) subset = result[mask] subset = subset.sample(n=1000) plt.figure()
BergondGCs = Bergond[Bergond['Type'] =='gc'] BergondGCs[['RAJ2000', 'DEJ2000']].to_csv('/Volumes/VINCE/OAC/imaging/BergondGCs_RADEC.reg', index = False, sep =' ', header = None) cat1 = coords.SkyCoord(GCs['RA_g'], GCs['DEC_g'], unit=(u.degree, u.degree)) cat2 = coords.SkyCoord(BergondGCs['RAJ2000'], BergondGCs['DEJ2000'], unit=(u.degree, u.degree)) index,dist2d, _ = cat1.match_to_catalog_sky(cat2) mask = dist2d.arcsec < 0.3 new_idx = index[mask] VIMOS = GCs.ix[mask].reset_index(drop = True) BergondMatch = BergondGCs.ix[new_idx].reset_index(drop = True) print len(BergondMatch) x = VIMOS['VREL_helio'] xerr = VIMOS['VERR'] y = BergondMatch['HRV'] yerr = BergondMatch['e_HRV'] plt.errorbar(x, y, yerr= yerr, xerr = xerr, fmt = 'o', c ='red',label = 'Bergond et al.') plt.rc('text', usetex=True) plt.rc('font', family='serif') plt.xlabel(r'Velocity from this work [km s$^-1$ ]') plt.ylabel(r'Velocity from the literature [km s$^-1$ ]') plt.legend(loc = 'upper left') plt.tight_layout() plt.show() print 'rms (VIMOS - Bergond) GCs = ', np.std(x-y)
index, dist2d, _ = cat1.match_to_catalog_sky(cat2) mask = dist2d.arcsec < 0.3 new_idx = index[mask] VIMOS = GCs.ix[mask].reset_index(drop=True) BergondMatch = BergondGCs.ix[new_idx].reset_index(drop=True) print len(BergondMatch) x = VIMOS['VREL_helio'] xerr = VIMOS['VERR'] y = BergondMatch['HRV'] yerr = BergondMatch['e_HRV'] plt.errorbar(x, y, yerr=yerr, xerr=xerr, fmt='o', c='red', label='Bergond et al.') plt.rc('text', usetex=True) plt.rc('font', family='serif') plt.xlabel(r'Velocity from this work [km s$^-1$ ]') plt.ylabel(r'Velocity from the literature [km s$^-1$ ]') plt.legend(loc='upper left') plt.tight_layout() plt.show() print 'rms (VIMOS - Bergond) GCs = ', np.std(x - y)
xdot = [[], []] xdot[0] = dy xdot[1] = my_func(K, y, dy) return xdot time = np.linspace(a, b, 11) z2 = odeint(model, [y0, y1], time) print('Вбудована функція') print(' y', ' ' * 13, 'z') print(z2) # plt.plot(z1['time'],z1['y'],'r-') # plt.plot(z1['time'],z1['dy'],'b--') plt.plot(time, z2[:, 0], 'g:') plt.plot(time, z2[:, 1], 'k-.') plt.legend(['y (Python)', 'dy/dt (Python)']) # plt.show() def getXY(x0, y1, a, b, h): # numbers = [int, float] # # if type(x0) not in numbers or type(y1) not in numbers or type(a) not in numbers or type(b) not in numbers or type(h) not in numbers: # raise TypeError('All input data must be numbers') # # if x0 < a or x0 > b: # raise ValueError('x0 must be in bounds') # # if h > b - a: # raise ValueError('step can`t be more than segment')
for layername in fclaynms + laynms: SV_all[layername] = SgVals[layername] #%% #%% fig, ax = plt.subplots() colormap = plt.get_cmap('jet') ax.set_prop_cycle(cycler(color=[colormap(k) for k in np.linspace(0, 1, 12)])) for layername, SV in SV_all.items(): print(layername, SV.shape) SVnum = np.prod(SV.shape) plt.plot(np.arange(SVnum) / SVnum, np.sort(SV, axis=None)[::-1]) # np.sort(SV.reshape(-1))) plt.ylabel("SV") plt.xlabel("Singular Value Id (Ratio of All SV that layer)") plt.title("Singular Value per Layer in FC6 GAN") plt.legend(fclaynms + laynms) plt.savefig(join(figdir, "SV_per_layer_ratio.png")) plt.savefig(join(figdir, "SV_per_layer_ratio.pdf")) plt.show() #%% fig, ax = plt.subplots() colormap = plt.get_cmap('jet') ax.set_prop_cycle(cycler(color=[colormap(k) for k in np.linspace(0, 1, 12)])) for layername, SV in SV_all.items(): print(layername, SV.shape) plt.plot(np.sort(SV, axis=None)[::-1]) plt.ylabel("SV") plt.xlabel("Singular Value Id") plt.title("Singular Value per Layer in FC6 GAN") plt.legend(fclaynms + laynms) plt.savefig(join(figdir, "SV_per_layer.png"))
plt.scatter(x2, y2, color=secondcloudcolor, alpha=1, marker='+', s=60, label='second distribution') plt.scatter(xL, yL, color='k', marker='P', s=135, label='release location') plt.xlabel('$^{\circ}$E', fontsize=18) ax.tick_params(labelbottom=False, labelleft=False) plt.title('(c)', fontsize=18) plt.xlim(-40, 40) plt.ylim(-40, 40) plt.legend(bbox_to_anchor=(1.92, 1.05)) step = 8 xs, ys = np.mgrid[-44:48:step, -44:48:step] vs = np.ones(xs.shape, dtype=bool) xss = xs[:, 0] yss = ys[0] boxes = [] for i in range(len(x1)): nex = find_nearest_index(xss, x1[i]) ney = find_nearest_index(yss, y1[i]) if (xss[nex] < x1[i]): lbx = xss[nex] hbx = xss[nex + 1]
# sample code: remove before submitting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> # process one frame #10 image_number = 10 image_file = rf'elephant/image{image_number:03d}.png' green_file = rf'green/image{image_number:03d}.png' process_file = rf'processed/image{image_number:03d}.png' start_time = timeit.default_timer() create_new_frame(image_file, green_file, process_file) print( f'\nTime To Process all images = {timeit.default_timer() - start_time}' ) # <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< log.write( f'Total Time for ALL processing: {timeit.default_timer() - all_process_time}' ) # create plot of results and also save it to a PNG file plt.plot(xaxis_cpus, yaxis_times, label=f'{FRAME_COUNT}') plt.title('CPU Core yaxis_times VS CPUs') plt.xlabel('CPU Cores') plt.ylabel('Seconds') plt.legend(loc='best') plt.tight_layout() plt.savefig(f'Plot for {FRAME_COUNT} frames.png') plt.show()
dfs = {} for csv_tuple in csv_paths: csv_path, produce_item = csv_tuple df = pd.read_csv(csv_path, sep=',', quotechar='"', skiprows=8, header=0, index_col=0) df1 = df.loc[2010:] dfs[produce_item] = df1 stacked_dfs = [] for key in dfs: produce_df = dfs[key] produce_df_stacked = produce_df.stack() stacked_dfs.append(produce_df_stacked) produce_df_stacked.plot(kind='bar', color='c') title = '{0} CPI'.format(key) y_label = '{0} Average Price/lb'.format(key) x_label = 'Month' plt.title(title) plt.ylabel(y_label) plt.xlabel(x_label) plt.legend(loc='best') fig = gcf() fig.set_size_inches(18.5, 14.5) figure_name = 'plots\\{0}.png'.format(key) fig.savefig(figure_name) s_df_0 = stacked_dfs[0] s_df_0.index.names = ['year', 'month'] # print(s_df_0) # s_df_0_2011 = s_df_0.loc[(2011, 'Feb'):(2014, 'Mar')] # print(s_df_0_2011)
def show(self, w): """ illustrate the learning curve Parameters ---------- w : int, window size for smoothing the curve """ if len(self.tn_mc) > 0: # malis training, increase number of subplots nsp = 5 else: nsp = 3 # print the maximum iteration self.print_max_update() # using K as iteration unit tn_it = self.tn_it for i in xrange(len(tn_it)): tn_it[i] = tn_it[i] / float(1000) tt_it = self.tt_it for i in xrange(len(tt_it)): tt_it[i] = tt_it[i] / float(1000) # plot data plt.subplot(1,nsp, 1) plt.plot(tn_it, self.tn_err, 'b.', alpha=0.2) plt.plot(tt_it, self.tt_err, 'r.', alpha=0.2) # plot smoothed line xne,yne = self._smooth( tn_it, self.tn_err, w ) xte,yte = self._smooth( tt_it, self.tt_err, w ) plt.plot(xne, yne, 'b') plt.plot(xte, yte, 'r') plt.xlabel('iteration (K)'), plt.ylabel('cost energy') plt.subplot(1,nsp,2) plt.plot(tn_it, self.tn_cls, 'b.', alpha=0.2) plt.plot(tt_it, self.tt_cls, 'r.', alpha=0.2) # plot smoothed line xnc, ync = self._smooth( tn_it, self.tn_cls, w ) xtc, ytc = self._smooth( tt_it, self.tt_cls, w ) plt.plot(xnc, ync, 'b', label='train') plt.plot(xtc, ytc, 'r', label='test') plt.xlabel('iteration (K)'), plt.ylabel( 'classification error' ) if len(tn_it) == len( self.tn_re ): plt.subplot(1, nsp, 3) plt.plot(tn_it, self.tn_re, 'b.', alpha=0.2) plt.plot(tt_it, self.tt_re, 'r.', alpha=0.2) # plot smoothed line xnr, ynr = self._smooth( tn_it, self.tn_re, w ) xtr, ytr = self._smooth( tt_it, self.tt_re, w ) plt.plot(xnr, ynr, 'b', label='train') plt.plot(xtr, ytr, 'r', label='test') plt.xlabel('iteration (K)'), plt.ylabel( 'rand error' ) if len(tn_it) == len( self.tn_mc ): plt.subplot(1, nsp, 4) plt.plot(tn_it, self.tn_mc, 'b.', alpha=0.2) plt.plot(tt_it, self.tt_mc, 'r.', alpha=0.2) # plot smoothed line xnm, ynm = self._smooth( tn_it, self.tn_mc, w ) xtm, ytm = self._smooth( tt_it, self.tt_mc, w ) plt.plot(xnm, ynm, 'b', label='train') plt.plot(xtm, ytm, 'r', label='test') plt.xlabel('iteration (K)'), plt.ylabel( 'malis weighted cost energy' ) if len(tn_it) == len( self.tn_me ): plt.subplot(1, nsp, 5) plt.plot(tn_it, self.tn_me, 'b.', alpha=0.2) plt.plot(tt_it, self.tt_me, 'r.', alpha=0.2) # plot smoothed line xng, yng = self._smooth( tn_it, self.tn_me, w ) xtg, ytg = self._smooth( tt_it, self.tt_me, w ) plt.plot(xng, yng, 'b', label='train') plt.plot(xtg, ytg, 'r', label='test') plt.xlabel('iteration (K)'), plt.ylabel( 'malis weighted pixel error' ) plt.legend() plt.show() return
def surface_plot(name: str = 'start_date_analysis1.pkl'): """ 3D plot of data cleaning steps :param name: :return: """ df = pd.read_pickle(name) # set up a figure twice as wide as it is tall fig = plt.figure(figsize=plt.figaspect(0.5)) # =============== # First subplot # =============== # set up the axes for the first plot ax = fig.add_subplot(1, 2, 1, projection='3d') ax.set_title('Modifications per File') ax.set_xlabel('Date (Months)') ax.set_ylabel('Threshold Individual') for idx, row in enumerate(sorted(df['threshold_pairs'].unique())): data = df[df['threshold_pairs'] == row] label = 'Threshold pairs ' + str(row) # Plot the surface. surf = ax.plot_trisurf(data['date'], data['threshold'], data['mpf'], alpha=0.7, linewidth=0, antialiased=False, label=label) surf._facecolors2d = surf._facecolors3d surf._edgecolors2d = surf._edgecolors3d # =============== # Second subplot # =============== # set up the axes for the second plot ax = fig.add_subplot(1, 2, 2, projection='3d') ax.set_title('Transitions per Test') ax.set_xlabel('Date (Months)') ax.set_ylabel('Threshold Individual') for idx, row in enumerate(sorted(df['threshold_pairs'].unique())): data = df[df['threshold_pairs'] == row] label = 'Threshold pairs ' + str(row) # Plot the surface. surf = ax.plot_trisurf(data['date'], data['threshold'], data['tpt'], alpha=0.7, linewidth=0, antialiased=False, label=label) surf._facecolors2d = surf._facecolors3d surf._edgecolors2d = surf._edgecolors3d # cbar = fig.colorbar(surf) # cbar.locator = LinearLocator(numticks=10) # cbar.update_ticks() plt.suptitle('Threshold Start Date Analysis 3D', fontsize=14) plt.legend() plt.show()
def multiplot_gen_content_type(): font = {'family': 'Liberation Serif', 'weight': 'normal', 'size': 15 } # play around with the font size if it is too big or small matplotlib.rcParams['axes.titlesize'] = 12 matplotlib.rcParams['axes.labelsize'] = 12 matplotlib.rc('font', **font) # matplotlib.rcParams['text.usetex'] = True matplotlib.rcParams['pdf.fonttype'] = 42 matplotlib.rcParams['pdf.use14corefonts'] = True x = list(data.keys()) y1 =[] y2 =[] y3 =[] y4 =[] y5 =[] y6 =[] y7 =[] y8 =[] y9 =[] y10 =[] y11 =[] y12 =[] y13 =[] y14 =[] y15 =[] print("---",y1) for year in data.keys(): for option_name, count in data[year].items(): if option_name == 'script': y1.append(count) if option_name == 'xmlhttprequest': y2.append(count) if option_name == 'document': y3.append(count) if option_name == 'elemhide': y4.append(count) if option_name == 'subdocument': y5.append(count) if option_name == 'image': y6.append(count) if option_name == 'popup': y7.append(count) if option_name == 'ping': y8.append(count) if option_name == 'stylesheet': y9.append(count) if option_name == 'object': y10.append(count) if option_name == 'generichide': y11.append(count) if option_name == 'font': y12.append(count) if option_name == 'media': y13.append(count) if option_name == 'genericblock': y14.append(count) if option_name == 'other': y15.append(count) print("x-->",x) print("y-->",y1) print("y-->",y2) plt.xticks(rotation='vertical') plt.xlabel('Year') plt.ylabel('Count') plt.legend(ncol=2) plt.tight_layout() plt.savefig('easylist-content-type.pdf ', format='pdf', dpi=1200)