def square_root_diffusion_exact(initial_val=0.05, kappa=3.0, theta=0.02, sigma=0.1, time_year=2, num_samples=10000, num_time_interval_discretization=50): x = np.zeros((num_time_interval_discretization + 1, num_samples)) x[0] = initial_val dt = time_year / num_time_interval_discretization for t in range(1, num_time_interval_discretization + 1): df = 4 * theta * kappa / sigma**2 c = (sigma**2 * (1 - np.exp(-kappa * dt))) / (4 * kappa) nc = np.exp(-kappa * dt) / c * x[t - 1] x[t] = c * npr.noncentral_chisquare(df, nc, size=num_samples) plt.figure(figsize=(10, 6)) plt.hist(x[-1], bins=50) plt.title("Square root diffusion Exact") plt.xlabel('value') plt.ylabel('frequency') plt.show() plt.figure(figsize=(10, 6)) plt.plot(x[:, :10], lw=1.5) plt.xlabel('time') plt.ylabel('index level') plt.title('Sample Path SRD Exact') plt.show() return x
def geometric_brownian_motion_option_pricing( initial_val=100, num_samples=10000, riskless_rate=0.05, volatility_sigma=0.25, time_year=2.0, num_time_interval_discretization=50): dt = time_year / num_time_interval_discretization samples = np.zeros((num_time_interval_discretization + 1, num_samples)) samples[0] = initial_val for t in range(1, num_time_interval_discretization + 1): samples[t] = samples[t - 1] * np.exp( (riskless_rate - 0.5 * (volatility_sigma**2)) * dt + volatility_sigma * np.sqrt(dt) * npr.standard_normal(num_samples)) print(45 * "=") print(samples[1]) plt.figure(figsize=(10, 6)) plt.hist(samples[50], bins=50) plt.title("Geometric Brownian Motion") plt.xlabel('index level') plt.ylabel('frequency') plt.show() plt.figure(figsize=(10, 6)) plt.plot(samples[:, :10], lw=1.5) plt.xlabel('time') plt.ylabel('index level') plt.title('Sample Path') plt.show() return samples
def square_root_diffusion_euler(initial_val=0.05, kappa=3.0, theta=0.02, sigma=0.1, time_year=2, num_samples=10000, num_time_interval_discretization=50): dt = time_year / num_time_interval_discretization xh = np.zeros((num_time_interval_discretization + 1, num_samples)) x = np.zeros_like(xh) xh[0] = initial_val x[0] = initial_val for t in range(1, num_time_interval_discretization + 1): xh[t] = (xh[t - 1] + kappa * (theta - np.maximum(xh[t - 1], 0)) * dt + sigma * np.sqrt(np.maximum(xh[t - 1], 0)) * math.sqrt(dt) * npr.standard_normal(num_samples)) x = np.maximum(xh, 0) plt.figure(figsize=(10, 6)) plt.hist(x[-1], bins=50) plt.xlabel('value') plt.ylabel('frequency') plt.title('Square root diffusion Approx Euler') plt.show() plt.figure(figsize=(10, 6)) plt.plot(x[:, :10], lw=1.5) plt.xlabel('time') plt.ylabel('index level') plt.title('Sample Path SRD approx') plt.show() return x
def square_root_diffusion_euler(): x0 = 0.25 kappa = 3.0 theta = 0.15 sigma = 0.1 I = 10000 M = 50 dt = T / M xh = np.zeros((M + 1, I)) x = np.zeros_like(xh) xh[0] = x0 x[0] = x0 for t in range(1, M + 1): xh[t] = (xh[t - 1] + kappa * (theta - np.maximum(xh[t - 1], 0)) * dt + sigma * np.sqrt(np.maximum(xh[t - 1], 0)) * math.sqrt(dt) * npr.standard_normal(I)) x = np.maximum(xh, 0) plt.figure(figsize=(10, 6)) plt.hist(x[-1], bins=50) plt.xlabel('value(SRT(T)') plt.ylabel('frequency') plt.show() plt.figure(figsize=(10, 6)) plt.plot(x[:, :100], lw=1.5) plt.xlabel('time') plt.ylabel('index level') plt.show() return x
def plot_fit(self, size=None, tol=0.1, axis_on=True): n, d = self.D.shape if size: nrows, ncols = size else: sq = np.ceil(np.sqrt(n)) nrows = int(sq) ncols = int(sq) ymin = np.nanmin(self.D) ymax = np.nanmax(self.D) print('ymin: {0}, ymax: {1}'.format(ymin, ymax)) numplots = np.min([n, nrows * ncols]) plt.figure() for n in range(numplots): plt.subplot(nrows, ncols, n + 1) plt.ylim((ymin - tol, ymax + tol)) plt.plot(self.L[n, :] + self.S[n, :], 'r') plt.plot(self.L[n, :], 'b') if not axis_on: plt.axis('off')
def lagger(): global cols, scores lag_counts = range(1, lags + 1) cols = [] scores = [] for lag in range(1, lags + 1): col = 'lag_{}'.format(lag) data[col] = np.sign(data['returns'].shift(lag)) cols.append(col) data.dropna(inplace=True) print('Iteration number: {}'.format(lag)) %time model.fit(data[cols], np.sign(data['returns'])) model.predict(data[cols]) data['prediction'] = model.predict(data[cols]) data['prediction'].value_counts() score = accuracy_score(data['prediction'], np.sign(data['returns'])) scores.append(score) plt.figure() plt.plot(lag_counts, scores, lw=2) plt.xlabel('# of Lags') plt.ylabel('Test Score') return scores, cols
def plot_inv_conv(fvals, name, direc): plt.figure() plt.semilogy(fvals, 'ko-') plt.xlabel('Iterations') plt.ylabel('Cost Function') plt.savefig(os.path.join(direc, name + '.png'), dpi=300) plt.close()
def test_screenstate_1(self): from gdesk import gui from pylab import plt from pathlib import Path gui.load_layout('console') samplePath = Path(r'./samples') gui.img.select(1) gui.img.open(samplePath / 'kodim05.png') gui.img.zoom_fit() plt.plot(gui.vs.mean(2).mean(1)) plt.title('Column means of image 1') plt.xlabel('Column Number') plt.ylabel('Mean') plt.grid() plt.show() gui.img.select(2) gui.img.open(samplePath / 'kodim23.png') gui.img.zoom_full() plt.figure() plt.plot(gui.vs.mean(2).mean(0)) plt.title('Row means of image 2') plt.xlabel('Row Number') plt.ylabel('Mean') plt.grid() plt.show()
def jump_diffusion(): S0 = 100.0 r = 0.05 sigma = 0.2 lamb = 0.05 mu = -0.6 delta = 0.25 rj = lamb * (math.exp(mu + 0.5 * delta**2) - 1) T = 1.0 M = 50 I = 10000 dt = T / M S = np.zeros((M + 1, I)) S[0] = S0 sn1 = npr.standard_normal((M + 1, I)) sn2 = npr.standard_normal((M + 1, I)) poi = npr.poisson(lamb * dt, (M + 1, I)) for t in range(1, M + 1, 1): S[t] = S[t - 1] * (np.exp( (r - rj - 0.5 * sigma**2) * dt + sigma * math.sqrt(dt) * sn1[t]) + (np.exp(mu + delta * sn2[t]) - 1) * poi[t]) S[t] = np.maximum(S[t], 0) plt.figure(figsize=(10, 6)) plt.hist(S[-1], bins=50) plt.xlabel('value') plt.ylabel('frequency') plt.show() plt.figure(figsize=(10, 6)) plt.plot(S[:, :100], lw=1.) plt.xlabel('time') plt.ylabel('index level') plt.show()
def plot2(self, figNum, time1, data1, time2, data2, title='', units='', options=''): plt.figure(figNum) # plt.hold(True); plt.grid(True) if title: self.title = title if not units: self.units = units # plt.cla() if self.preTitle: fig = plt.gcf() fig.canvas.set_window_title("Figure %d - %s" % (figNum, self.preTitle)) plt.title("%s" % (self.title)) plt.plot(time1, data1, options) plt.plot(time2, data2, options) plt.ylabel('(%s)' % (self.units)) plt.xlabel('Time (s)') plt.margins(0.04)
def test_run(self): # 生成几何布朗运动市场环境 me_gbm = MarketEnvironment('me_gbm', dt.datetime(2020, 1, 1)) me_gbm.add_constant('initial_value', 36.0) me_gbm.add_constant('volatility', 0.2) me_gbm.add_constant('final_date', dt.datetime(2020, 12, 31)) me_gbm.add_constant('currency', 'EUR') me_gbm.add_constant('frequency', 'M') me_gbm.add_constant('paths', 1000) csr = ConstantShortRate('csr', 0.06) me_gbm.add_curve('discount_curve', csr) # 生成几何布朗运动模拟类 gbm = GeometricBrownianMotion('gbm', me_gbm) gbm.generate_time_grid() # 生成跳跃扩散市场环境 me_jd = MarketEnvironment('me_jd', dt.datetime(2020, 1, 1)) me_jd.add_constant('lambda', 0.3) me_jd.add_constant('mu', -0.75) me_jd.add_constant('delta', 0.1) me_jd.add_environment(me_gbm) # 生成跳跃扩散模拟类 jd = JumpDiffusion('jd', me_jd) paths_3 = jd.get_instrument_values() jd.update(lamb=0.9) paths_4 = jd.get_instrument_values() # 绘制图形 plt.figure(figsize=(10, 6)) p1 = plt.plot(gbm.time_grid, paths_3[:, :10], 'b') p2 = plt.plot(gbm.time_grid, paths_4[:, :10], 'r-') lengend1 = plt.legend([p1[0], p2[0]], ['low intensity', 'high intensity'], loc=3) plt.gca().add_artist(lengend1) plt.xticks(rotation=30) plt.show()
def subplotSingle2x(self, figNum, plotNum, numRows, numCols, time, data, title='', units='', options=''): print("subplotSingle2x") plt.figure(figNum) if title: self.title = title if not units: self.units = units if self.preTitle: fig = plt.gcf() fig.canvas.set_window_title("%s" % (figNum, self.preTitle)) if not figNum in self.sharex.keys(): self.sharex[figNum] = plt.subplot(numRows, numCols, plotNum) plt.plot(time, data, options) plt.subplot(numRows, numCols, plotNum, sharex=self.sharex[figNum]) # plt.hold(True); plt.grid(True) plt.title("%s" % (self.title)) plt.plot(time, data, options) plt.ylabel('(%s)' % (self.units)) plt.margins(0.04)
def visual_results(Image_data, preds, Labels=None, Top=0): from pylab import plt pred_age_value = preds['age'] pred_gender_value = preds['gender'] pred_smile_value = preds['smile'] pred_glass_value = preds['glass'] Num = Image_data.shape[0] if Top == 0 else Top for k in xrange(Num): print k, Num plt.figure(1) plt.imshow(de_preprocess_image(Image_data[k])) title_str = 'Prediction: Age %0.1f, %s, %s, %s.' % ( pred_age_value[k], gender_list[pred_gender_value[k]], glass_list[pred_glass_value[k]], smile_list[pred_smile_value[k]]) x_label_str = 'GT: ' try: x_label_str = x_label_str + 'Age %0.1f' % Labels['age'][k] except: pass try: x_label_str = x_label_str + '%s, %s, %s' % (gender_list[int( Labels['gender'][k])], glass_list[int( Labels['glass'][k])], smile_list[int(Labels['smile'][k])]) except: pass plt.title(title_str) plt.xlabel(x_label_str) plt.show()
def graph_error_mean_per_hour(dataset, pred, column): data = dataset.iloc[dataset.shape[0] - len(pred):] data["Pred"] = np.around(pred, 5) if column == "Diff": res = np.delete(data["Close"].to_numpy(), -1) res = np.insert(res, 0, 0) data["Pred"] = data["Pred"] + res data["AEM"] = np.abs(np.around(data.Close - data.Pred, 5)) data['Hour'] = data.Date.apply(lambda x: x.hour) data["Diff"] = data.Close.diff().apply(abs).fillna(0) plt.figure(figsize=(14, 6)) plt.hist(data.where((data.Hour > 5) & (data.Hour < 20)).dropna()["AEM"], 150, density=True, range=(0, 0.003)) plt.show() diff_mean = data.groupby("Hour").mean().Diff x_ch = diff_mean.index y_ch = diff_mean diff_mean_aem = data.groupby("Hour").mean().AEM x = diff_mean_aem.index y = diff_mean_aem plt.figure(figsize=(14, 6)) plt.bar(x_ch, y_ch, color="green") plt.bar(x, y, color="r", alpha=0.7) plt.title( "Absolute mean of error in predictions per hour compared to absolute mean of price changes", fontsize=16) plt.show()
def plot_response(data, plate_name, save_folder = 'Figures/'): """ """ if not os.path.isdir(save_folder): os.makedirs(save_folder) for block in data: # group = group_similar(data[block].keys()) names = data[block].keys() names.sort() # plt.figure(figsize=(16, 4 + len(names)/8), dpi=300) # for i, name in enumerate(names): a, b, c = get_index(group, name) color, pattern = color_shade_pattern(a, b, c, group) mean = data[block][name]['mean'][0] std = data[block][name]['std'][0] plt.barh([i], [mean], height=1.0, color=color, hatch=pattern) plt.errorbar([mean], [i+0.5], xerr=[std], ecolor = [0,0,0], linestyle = '') plt.yticks([i+0.5 for i in xrange(len(names))], names, size = 8) plt.title(plate_name) plt.ylim(0, len(names)) plt.xlabel('change') plt.tight_layout() plt.savefig(save_folder + 'response_' + str(block + 1)) # return None
def run_evo_plot(self): """ Awesome! All agents become chips!""" t_max = 100 culture_length = 5 env = Environment(culture_length=culture_length, t_max=t_max, n_agent=1000, influence_type='linear') all_possible_cultures = list( product([False, True], repeat=culture_length)) all_time_cul = np.zeros((t_max, len(all_possible_cultures))) #TODO: try to understand why #all_time_cul = np.zeros((t_max, len(all_possible_cultures))) # do not work print(len(all_possible_cultures)) print(2**culture_length) # env.plot() for t in tqdm(range(t_max)): env.one_step() for agent in env.agents: all_time_cul[ t, all_possible_cultures.index(tuple(agent.culture))] += 1 plt.figure() plt.plot(all_time_cul)
def test_run(self): plt.style.use('seaborn') mpl.rcParams['font.family'] = 'serif' # 生成市场环境 me_gbm = MarketEnvironment('me_gbm', dt.datetime(2020, 1, 1)) me_gbm.add_constant('initial_value', 36.0) me_gbm.add_constant('volatility', 0.2) me_gbm.add_constant('final_date', dt.datetime(2020, 12, 31)) me_gbm.add_constant('currency', 'EUR') me_gbm.add_constant('frequency', 'M') me_gbm.add_constant('paths', 1000) csr = ConstantShortRate('csr', 0.06) me_gbm.add_curve('discount_curve', csr) # 生成几何布朗运动模拟类 gbm = GeometricBrownianMotion('gbm', me_gbm) gbm.generate_time_grid() print('时间节点:{0};'.format(gbm.time_grid)) paths_1 = gbm.get_instrument_values() print('paths_1: {0};'.format(paths_1.round(3))) gbm.update(volatility=0.5) paths_2 = gbm.get_instrument_values() # 可视化结果 plt.figure(figsize=(10, 6)) p1 = plt.plot(gbm.time_grid, paths_1[:, :10], 'b') p2 = plt.plot(gbm.time_grid, paths_2[:, :10], 'r-') legend1 = plt.legend([p1[0], p2[0]], ['low volatility', 'high volatility'], loc=2) plt.gca().add_artist(legend1) plt.xticks(rotation=30) plt.show()
def MakePlot(x, y, styles, labels, axlabels): plt.figure(figsize=(10, 6)) for i in range(len(x)): plt.plot(x[i], y[i], styles[i], label=labels[i]) plt.xlabel(axlabels[0]) plt.ylabel(axlabels[1]) plt.legend(loc=0)
def test_run(self): # 生成几何布朗运动市场环境 me_gbm = MarketEnvironment('me_gbm', dt.datetime(2020, 1, 1)) me_gbm.add_constant('initial_value', 36.0) me_gbm.add_constant('volatility', 0.2) me_gbm.add_constant('final_date', dt.datetime(2020, 12, 31)) me_gbm.add_constant('currency', 'EUR') me_gbm.add_constant('frequency', 'M') me_gbm.add_constant('paths', 1000) csr = ConstantShortRate('csr', 0.06) me_gbm.add_curve('discount_curve', csr) # 生成几何布朗运动模拟类 gbm = GeometricBrownianMotion('gbm', me_gbm) gbm.generate_time_grid() # 生成跳跃扩散市场环境 me_srd = MarketEnvironment('me_srd', dt.datetime(2020, 1, 1)) me_srd.add_constant('initial_value', .25) me_srd.add_constant('volatility', 0.05) me_srd.add_constant('final_date', dt.datetime(2020, 12, 31)) me_srd.add_constant('currency', 'EUR') me_srd.add_constant('frequency', 'W') me_srd.add_constant('paths', 10000) # specific to simualation class me_srd.add_constant('kappa', 4.0) me_srd.add_constant('theta', 0.2) me_srd.add_curve('discount_curve', ConstantShortRate('r', 0.0)) srd = SquareRootDiffusion('srd', me_srd) srd_paths = srd.get_instrument_values()[:, :10] plt.figure(figsize=(10, 6)) plt.plot(srd.time_grid, srd.get_instrument_values()[:, :10]) plt.axhline(me_srd.get_constant('theta'), color='r', ls='--', lw=2.0) plt.xticks(rotation=30) plt.show()
def link_level_bars(levels, usages, quantiles, scheme, direction, color, nnames, lnames, admat=None): """ Bar plots of nodes' link usage of links at different levels. """ if not admat: admat = np.genfromtxt('./settings/eadmat.txt') if color == 'solar': cmap = Oranges_cmap elif color == 'wind': cmap = Blues_cmap elif color == 'backup': cmap = 'Greys' nodes, links = usages.shape usageLevels = np.zeros((nodes, levels)) usageLevelsNorm = np.zeros((nodes, levels)) for node in range(nodes): nl = neighbor_levels(node, levels, admat) for lvl in range(levels): ll = link_level(nl, lvl, nnames, lnames) ll = np.array(ll, dtype='int') usageSum = sum(usages[node, ll]) linkSum = sum(quantiles[ll]) usageLevels[node, lvl] = usageSum / linkSum if lvl == 0: usageLevelsNorm[node, lvl] = usageSum else: usageLevelsNorm[node, lvl] = usageSum / usageLevelsNorm[node, 0] usageLevelsNorm[:, 0] = 1 # plot all nodes usages = usageLevels.transpose() plt.figure(figsize=(11, 3)) ax = plt.subplot() plt.pcolormesh(usages[:, loadOrder], cmap=cmap) plt.colorbar().set_label(label=r'$U_n^{(l)}$', size=11) ax.set_yticks(np.linspace(.5, levels - .5, levels)) ax.set_yticklabels(range(1, levels + 1)) ax.yaxis.set_tick_params(width=0) ax.xaxis.set_tick_params(width=0) ax.set_xticks(np.linspace(1, nodes, nodes)) ax.set_xticklabels(loadNames, rotation=60, ha="right", va="top", fontsize=10) plt.ylabel('Link level') plt.savefig(figPath + '/levels/' + str(scheme) + '/' + 'total' + '_' + str(direction) + '_' + color + '.pdf', bbox_inches='tight') plt.close() # plot all nodes normalised to usage of first level usages = usageLevelsNorm.transpose() plt.figure(figsize=(11, 3)) ax = plt.subplot() plt.pcolormesh(usages[:, loadOrder], cmap=cmap) plt.colorbar().set_label(label=r'$U_n^{(l)}$', size=11) ax.set_yticks(np.linspace(.5, levels - .5, levels)) ax.set_yticklabels(range(1, levels + 1)) ax.yaxis.set_tick_params(width=0) ax.xaxis.set_tick_params(width=0) ax.set_xticks(np.linspace(1, nodes, nodes)) ax.set_xticklabels(loadNames, rotation=60, ha="right", va="top", fontsize=10) plt.ylabel('Link level') plt.savefig(figPath + '/levels/' + str(scheme) + '/' + 'total_norm_cont_' + str(direction) + '_' + color + '.pdf', bbox_inches='tight') plt.close()
def plot3setYspan(self, figNum, yspan=None): plt.figure(figNum) if yspan is None: return if not figNum in self.sharex.keys(): self.sharex[figNum] = plt.subplot(3, 1, 1) # Plot 1 subplt = plt.subplot(3, 1, 1, sharex=self.sharex[figNum]) yl = subplt.get_ylim() med = (yl[1] - yl[0]) * 0.5 + yl[0] yl = [med - yspan * 0.5, med + yspan * 0.5] subplt.set_ylim(yl) # Plot 2 subplt = plt.subplot(3, 1, 2, sharex=self.sharex[figNum]) yl = subplt.get_ylim() med = (yl[1] - yl[0]) * 0.5 + yl[0] yl = [med - yspan * 0.5, med + yspan * 0.5] subplt.set_ylim(yl) # Plot 3 subplt = plt.subplot(3, 1, 3, sharex=self.sharex[figNum]) yl = subplt.get_ylim() med = (yl[1] - yl[0]) * 0.5 + yl[0] yl = [med - yspan * 0.5, med + yspan * 0.5] subplt.set_ylim(yl)
def plot_fit(self, size=None, tol=0.1, axis_on=True): n, d = self.D.shape if size: nrows, ncols = size else: sq = np.ceil(np.sqrt(n)) nrows = int(sq) ncols = int(sq) ymin = np.nanmin(self.D) ymax = np.nanmax(self.D) print 'ymin: {0}, ymax: {1}'.format(ymin, ymax) numplots = np.min([n, nrows * ncols]) plt.figure() for n in xrange(numplots): plt.subplot(nrows, ncols, n + 1) plt.ylim((ymin - tol, ymax + tol)) plt.plot(self.L[n, :] + self.S[n, :], 'r') plt.plot(self.L[n, :], 'b') if not axis_on: plt.axis('off')
def create_image(csv_path): csv_data, _, _ = read_csv_data(csv_path) plt.figure() plt.plot(csv_data) plt.axis('off') plt.savefig('wind_data.png', bbox_inches='tight', dpi=500)
def generate_start_time_figures(self): recording_time_grouped_by_patient = self.pain_data[["PatientID", "NRSTimeFromEndSurgery_mins"]].groupby("PatientID") recording_start_minutes = recording_time_grouped_by_patient.min() fig1 = "fig1.pdf" fig2 = "fig2.pdf" plt.figure(figsize=[8,4]) plt.title("Pain score recording start times", fontsize=14).set_y(1.05) plt.ylabel("Occurrences", fontsize=14) plt.xlabel("Recording Start Time (minutes)", fontsize=14) plt.hist(recording_start_minutes.values, bins=20, color="0.5") plt.savefig(os.path.join(self.tmp_directory, fig1), bbox_inches="tight") plt.figure(figsize=[8,4]) plt.title("Pain score recording start times, log scale", fontsize=14).set_y(1.05) plt.ylabel("Occurrences", fontsize=14) plt.xlabel("Recording Start Time (minutes)", fontsize=14) plt.hist(recording_start_minutes.values, bins=20, log=True, color="0.5") plt.savefig(os.path.join(self.tmp_directory, fig2), bbox_inches="tight") #save the figures in panel format f = open(os.path.join(self.tmp_directory, "tmp.tex"), 'w') f.write(r""" \documentclass[% ,float=false % this is the new default and can be left away. ,preview=true ,class=scrartcl ,fontsize=20pt ]{standalone} \usepackage[active,tightpage]{preview} \usepackage{varwidth} \usepackage{graphicx} \usepackage[justification=centering]{caption} \usepackage{subcaption} \usepackage[caption=false,font=footnotesize]{subfig} \renewcommand{\thesubfigure}{\Alph{subfigure}} \begin{document} \begin{preview} \begin{figure}[h] \begin{subfigure}{0.5\textwidth} \includegraphics[width=\textwidth]{""" + fig1 + r"""} \caption{Normal scale} \end{subfigure}\begin{subfigure}{0.5\textwidth} \includegraphics[width=\textwidth]{""" + fig2 + r"""} \caption{Log scale} \end{subfigure} \end{figure} \end{preview} \end{document} """) f.close() subprocess.call(["pdflatex", "-halt-on-error", "-output-directory", self.tmp_directory, os.path.join(self.tmp_directory, "tmp.tex")]) shutil.move(os.path.join(self.tmp_directory, "tmp.pdf"), os.path.join(self.output_directory, "pain_score_start_times.pdf"))
def plot_charts(self): print(self.final_portfolio_valuation) plt.figure(figsize=(10, 6)) plt.hist( self.final_portfolio_valuation, bins=100) plt.title("Final Exit Valuation complete Portfolio after {} year as Geometric Brownian Motion".format(self.max_year)) plt.xlabel('Exit Valuation') plt.ylabel('frequency'); plt.show()
def plot(self, new_plot=False, xlim=None, ylim=None, title=None, figsize=None, xlabel=None, ylabel=None, fontsize=None, show_legend=True, grid=True): """ Plot data using matplotlib library. Use show() method for matplotlib to see result or :: %pylab inline in IPython to see plot as cell output. :param bool new_plot: create or not new figure :param xlim: x-axis range :param ylim: y-axis range :type xlim: None or tuple(x_min, x_max) :type ylim: None or tuple(y_min, y_max) :param title: title :type title: None or str :param figsize: figure size :type figsize: None or tuple(weight, height) :param xlabel: x-axis name :type xlabel: None or str :param ylabel: y-axis name :type ylabel: None or str :param fontsize: font size :type fontsize: None or int :param bool show_legend: show or not labels for plots :param bool grid: show grid or not """ xlabel = self.xlabel if xlabel is None else xlabel ylabel = self.ylabel if ylabel is None else ylabel figsize = self.figsize if figsize is None else figsize fontsize = self.fontsize if fontsize is None else fontsize self.fontsize_ = fontsize self.show_legend_ = show_legend title = self.title if title is None else title xlim = self.xlim if xlim is None else xlim ylim = self.ylim if ylim is None else ylim new_plot = self.new_plot or new_plot if new_plot: plt.figure(figsize=figsize) plt.xlabel(xlabel, fontsize=fontsize) plt.ylabel(ylabel, fontsize=fontsize) plt.title(title, fontsize=fontsize) plt.tick_params(axis='both', labelsize=fontsize) plt.grid(grid) if xlim is not None: plt.xlim(xlim) if ylim is not None: plt.ylim(ylim) self._plot() if show_legend: plt.legend(loc='best', scatterpoints=1)
def create_plot(x, y, styles, labels, axlabels): plt.figure(figsize=(10, 6)) plt.scatter(x[0], y[0]) plt.scatter(x[1], y[1]) plt.xlabel(axlabels[0]) plt.ylabel(axlabels[1]) plt.legend(loc=0) plt.show()
def displayRetireWRate(month, rates, terms): plt.figure('retireRate') plt.clf() for rate in rates: xvals, yvals = retire(month, rate, terms) plt.plot(xvals, yvals, label='monthly: ' + str(month) + ' rate of: ' + str(int(rate * 100))) plt.legend(loc='upper left')
def convert_all_to_png(vis_path, out_dir="maps_png", size=None): units = { 'gas_density': 'Gas Density [g/cm$^3$]', 'Tm': 'Temperature [K]', 'Tew': 'Temperature [K]', 'S': 'Entropy []', 'dm': 'DM Density [g/cm$^3$]', 'v': 'Velocity [km/s]' } log_list = ['gas_density'] for vis_file in os.listdir(vis_path): if ".dat" not in vis_file: continue print "converting %s" % vis_file map_type = re.search('sigma_(.*)_[xyz]', vis_file).group(1) (image, pixel_size, axis_values) = read_visualization_data(vis_path + "/" + vis_file, size) print "image width in Mpc/h: ", axis_values[-1] * 2.0 x, y = np.meshgrid(axis_values, axis_values) cmap_max = image.max() cmap_min = image.min() ''' plotting ''' plt.figure(figsize=(5, 4)) if map_type in log_list: plt.pcolor(x, y, image, norm=LogNorm(vmax=cmap_max, vmin=cmap_min)) else: plt.pcolor(x, y, image, vmax=cmap_max, vmin=cmap_min) cbar = plt.colorbar() if map_type in units.keys(): cbar.ax.set_ylabel(units[map_type]) plt.axis( [axis_values[0], axis_values[-1], axis_values[0], axis_values[-1]]) del image plt.xlabel(r"$Mpc/h$", fontsize=18) plt.ylabel(r"$Mpc/h$", fontsize=18) out_file = vis_file.replace("dat", "png") plt.savefig(out_dir + "/" + out_file, dpi=150) plt.close() plt.clf()
def displayRetireWMonthlies(monthlies, rate, terms): plt.figure('retireMonth') plt.clf() for monthly in monthlies: xvals, yvals = retire( monthly, rate, terms) # using base and savings list as x and y values plt.plot(xvals, yvals, label='retire with monthly inst of ' + str(monthly)) plt.legend()
def detect(self, img): bboxes = None # pnet if not self.pnet: return None bboxes = self.detect_pnet(img) if bboxes is None: return None ## 可视化PNET的结果 if SHOW_FIGURE: plt.figure() tmp = img.copy() for i in bboxes: x0 = int(i[0]) y0 = int(i[1]) x1 = x0 + int(i[2]) y1 = y0 + int(i[3]) cv2.rectangle(tmp, (x0, y0), (x1, y1), (0, 0, 255), 2) plt.imshow(tmp[:, :, ::-1]) plt.title("pnet result") # rnet if not self.rnet: return bboxes bboxes = bboxes[:, 0:4].astype(np.int32) bboxes = self.detect_ronet(img, bboxes, 24) if bboxes is None: return None ## 可视化RNET的结果 if SHOW_FIGURE: plt.figure() tmp = img.copy() for i in bboxes: x0 = int(i[0]) y0 = int(i[1]) x1 = x0 + int(i[2]) y1 = y0 + int(i[3]) cv2.rectangle(tmp, (x0, y0), (x1, y1), (0, 0, 255), 2) plt.imshow(tmp[:, :, ::-1]) plt.title("rnet result") #onet if not self.onet: return bboxes bboxes = bboxes[:, 0:4].astype(np.int32) bboxes = self.detect_ronet(img, bboxes, 48) return bboxes
def plot_treward(agent): ''' Function to plot the total reward per training eposiode. ''' plt.figure(figsize=(10, 6)) x = range(1, len(agent.averages) + 1) y = np.polyval(np.polyfit(x, agent.averages, deg=3), x) plt.plot(x, agent.averages, label='moving average') plt.plot(x, y, 'r--', label='regression') plt.xlabel('episodes') plt.ylabel('total reward') plt.legend()
def displayRetireWMonthsandRates(monthlies, rates, terms): plt.figure('retire both') plt.clf() plt.xlim(30 * 12, 40 * 12) # focusing only on the last 10 years of investment for monthly in monthlies: for rate in rates: xvals, yvals = retire(monthly, rate, terms) plt.plot(xvals, yvals, label='retire with ' + str(monthly) + ":" + str(int(rate * 100))) plt.legend(loc='upper left')
def convert_all_to_png(vis_path, out_dir = "maps_png", size = None) : units = { 'gas_density' : 'Gas Density [g/cm$^3$]', 'Tm' : 'Temperature [K]', 'Tew' : 'Temperature [K]', 'S' : 'Entropy []', 'dm' : 'DM Density [g/cm$^3$]', 'v' : 'Velocity [km/s]' } log_list = ['gas_density'] for vis_file in os.listdir(vis_path) : if ".dat" not in vis_file : continue print "converting %s" % vis_file map_type = re.search('sigma_(.*)_[xyz]', vis_file).group(1) (image, pixel_size, axis_values) = read_visualization_data(vis_path+"/"+vis_file, size) print "image width in Mpc/h: ", axis_values[-1]*2.0 x, y = np.meshgrid( axis_values, axis_values ) cmap_max = image.max() cmap_min = image.min() ''' plotting ''' plt.figure(figsize=(5,4)) if map_type in log_list: plt.pcolor(x,y,image, norm=LogNorm(vmax=cmap_max, vmin=cmap_min)) else : plt.pcolor(x,y,image, vmax=cmap_max, vmin=cmap_min) cbar = plt.colorbar() if map_type in units.keys() : cbar.ax.set_ylabel(units[map_type]) plt.axis([axis_values[0], axis_values[-1],axis_values[0], axis_values[-1]]) del image plt.xlabel(r"$Mpc/h$", fontsize=18) plt.ylabel(r"$Mpc/h$", fontsize=18) out_file = vis_file.replace("dat", "png") plt.savefig(out_dir+"/"+out_file, dpi=150 ) plt.close() plt.clf()
def draw_spectrum(data_list): T = 3600 amp_spec, power_spec, freq = spectrum(data_list, T) print('Max amp in spectrum: {np.max(amp_spec)}') plt.figure(figsize=(18, 5)) plt.subplot(131) x = list(range(len(data_list))) y = data_list plt.title("Observation wind data of Kyoto") plt.xlabel('Hours') plt.ylabel('Observation wind data of Kyoto') plt.plot(x, y, color='green') data_len = len(x) plt.subplot(132) plt.title("Power Spectrum of Wind ") x = freq[int(data_len / 2):] y = power_spec[int(data_len / 2):] # set 0 to 0Hz (DC component) y[0] = 0 plt.xlabel('Frequency (Hz)') plt.ylabel('Intensity') plt.plot(x, y, color='orange') ax = plt.gca() x = x[1:] y = y[1:] ax.xaxis.set_major_formatter(mtick.FormatStrFormatter('%.0e')) coeffs = np.polyfit(np.log(x), np.log(y), 1) beta = -coeffs[0] dimension = 1 + (3 - beta) / 2 print(beta) print("The fractal dimension is", dimension) plt.subplot(133) plt.title("the Curve of log(power-spectrum) and log(frequency)") plt.scatter(np.log(x), np.log(y), marker='o', s=10, c=list(range(len(x)))) # plt.plot(np.log(x), np.log(y), 'o', mfc='none') plt.plot(np.log(x), np.polyval(coeffs, np.log(x))) plt.xlabel('log freq') plt.ylabel('log intensity') plt.savefig("../pics/kyoto_wind.png") plt.show()
def drawAdoptionNetworkMPL(G, fnum=1, show=False, writeFile=None): """Draws the network to matplotlib, coloring the nodes based on adoption. Looks for the node attribute 'adopted'. If the attribute is True, colors the node a different color, showing adoption visually. This function assumes that the node attributes have been pre-populated. :param networkx.Graph G: Any NetworkX Graph object. :param int fnum: The matplotlib figure number. Defaults to 1. :param bool show: :param str writeFile: A filename/path to save the figure image. If not specified, no output file is written. """ Gclean = G.subgraph([n for n in G.nodes() if n not in nx.isolates(G)]) plt.figure(num=fnum, figsize=(6,6)) # clear figure plt.clf() # Blue ('b') node color for adopters, red ('r') for non-adopters. nodecolors = ['b' if Gclean.node[n]['adopted'] else 'r' \ for n in Gclean.nodes()] layout = nx.spring_layout(Gclean) nx.draw_networkx_nodes(Gclean, layout, node_size=80, nodelist=Gclean.nodes(), node_color=nodecolors) nx.draw_networkx_edges(Gclean, layout, alpha=0.5) # width=4 # TODO: Draw labels of Ii values. Maybe vary size of node. # TODO: Color edges blue based on influences from neighbors influenceEdges = [] for a in Gclean.nodes(): for n in Gclean.node[a]['influence']: influenceEdges.append((a,n)) if len(influenceEdges)>0: nx.draw_networkx_edges(Gclean, layout, alpha=0.5, width=5, edgelist=influenceEdges, edge_color=['b']*len(influenceEdges)) #some extra space around figure plt.xlim(-0.05,1.05) plt.ylim(-0.05,1.05) plt.axis('off') if writeFile != None: plt.savefig(writeFile) if show: plt.show()
def initWidgets(self): self.fig = plt.figure(1) self.manager=get_current_fig_manager() self.img = subplot(2,1,1) self.TempGraph=subplot(2,1,2) x1=sp.linspace(0.0,5.0) y1=sp.cos(2*sp.pi*x1)*sp.exp(-x1) plt.plot(x1,y1) row=0 self.grid() self.lblPower=tk.Label(self,text="Power") self.lblPower.grid(row=row,column=0) self.sclPower=tk.Scale(self,from_=0,to_=100000,orient=tk.HORIZONTAL) self.sclPower.grid(row=row,column=1,columnspan=3) #lastrow row=row+1 self.btnOne=tk.Button(master=self,text="Run") self.btnOne["command"]=self.Run self.btnOne.grid(row=row,column=0) self.btnTwo=tk.Button(master=self,text="Soak") self.btnTwo["command"]=self.Soak self.btnTwo.grid(row=row,column=2) self.QUIT=tk.Button(master=self,text="QUIT") self.QUIT["command"]=self.quit self.QUIT.grid(row=row,column=3)
def main(): s = 2.0 img = imread('cameraman.png') # Create all the images with each a differen order of convolution img1 = gD(img, s, 0, 0) img2 = gD(img, s, 1, 0) img3 = gD(img, s, 0, 1) img4 = gD(img, s, 2, 0) img5 = gD(img, s, 0, 2) img6 = gD(img, s, 1, 1) fig = plt.figure() ax1 = fig.add_subplot(2, 3, 1) ax1.set_title("Fzero") ax1.imshow(img1, cmap=cm.gray) ax2 = fig.add_subplot(2, 3, 2) ax2.set_title("Fx") ax2.imshow(img2, cmap=cm.gray) ax3 = fig.add_subplot(2, 3, 3) ax3.set_title("Fy") ax3.imshow(img3, cmap=cm.gray) ax4 = fig.add_subplot(2, 3, 4) ax4.set_title("Fxx") ax4.imshow(img4, cmap=cm.gray) ax5 = fig.add_subplot(2, 3, 5) ax5.set_title("Fyy") ax5.imshow(img5, cmap=cm.gray) ax6 = fig.add_subplot(2, 3, 6) ax6.set_title("Fxy") ax6.imshow(img6, cmap=cm.gray) show()
def createCoreDiffusionPlot(experimentCaseLog, outFilePath, plotTitle=None): """Function to generate the Core Diffusion vs Peripheral Density plot. (Basically a clone of `createPeripheralDiffusionPlot`) """ # Generate plot of Core Diffusion vs. Nx density beyond the core # x axis: pties/total possible ties # y axis: # core adopters / # core nodes mc = marker_cycle() fig = plt.figure() ax = fig.add_subplot(111) for Ai in experimentCaseLog.keys(): # x axis is peripheral density, y axis is the core diffusion x,y = experimentCaseLog[Ai][0], experimentCaseLog[Ai][2] ax.plot(x,y, label="Ambiguity=%d"%Ai, marker=mc.next()) ax.set_xlabel("Network Density Beyond the Core") ax.set_ylabel("Core Diffusion") ax.legend(loc="best") if plotTitle == None: ax.set_title("Extent of Core Diffusion for Varying Ambiguity " "and Network Density") else: ax.set_title(plotTitle) outPlotFilename = "Plot-CoreDiffusionVsDensity.png" fig.savefig(pathjoin(outFilePath, outPlotFilename))
def render_confusion(file_name, queue, vmin, vmax, divergent, array_shape): from pylab import plt import matplotlib.animation as animation plt.close() fig = plt.figure() def update_img((expected, output)): plt.cla() plt.ylim((vmin, vmin+vmax)) plt.xlim((vmin, vmin+vmax)) ax = fig.add_subplot(111) plt.plot([vmin, vmin+vmax], [vmin, vmin+vmax]) ax.grid(True) plt.xlabel("expected output") plt.ylabel("network output") plt.legend() expected = expected*vmax + vmin output = output*vmax + vmin #scat.set_offsets((expected, output)) scat = ax.scatter(expected, output) return scat ani = animation.FuncAnimation(fig, update_img, frames=IterableQueue(queue)) ani.save(file_name, fps=30, extra_args=['-vcodec', 'libvpx', '-threads', '4', '-b:v', '1M'])
def initWidgets(self): self.fig = plt.figure(1) self.img = subplot(111) self.manager=get_current_fig_manager() self.img = subplot(2,1,2) self.TempGraph=subplot(2,1,1) row=0 self.grid() self.lblPower=tk.Label(self,text="Power") self.lblPower.grid(row=row,column=0) self.sclPower=tk.Scale(self,from_=0,to_=100,orient=tk.HORIZONTAL) self.sclPower.grid(row=row,column=1,columnspan=3) row=row+1 self.lblTime=tk.Label(self,text="Time={0}".format(self.time)) self.lblTime.grid(row=row,column=0) #lastrow row=row+1 self.btnOne=tk.Button(master=self,text="Run") self.btnOne["command"]=self.Run self.btnOne.grid(row=row,column=0) self.btnTwo=tk.Button(master=self,text="Soak") self.btnTwo["command"]=self.Soak self.btnTwo.grid(row=row,column=2) self.QUIT=tk.Button(master=self,text="QUIT") self.QUIT["command"]=self.quit self.QUIT.grid(row=row,column=3)
def plotter(mode,Bc,Tc,Q): col = ['#000080','#0000FF','#4169E1','#6495ED','#00BFFF','#B0E0E6'] plt.figure() ax = plt.subplot(111) for p in range(Bc.shape[1]): plt.plot(Tc[:,p],Bc[:,p],'-',color=str(col[p])) plt.xlabel('Tc [TW]') plt.ylabel('Bc normalised to total EU load') plt.title(str(mode)+' flow') # Shrink current axis by 25% to make room for legend box = ax.get_position() ax.set_position([box.x0, box.y0, box.width * 0.75, box.height]) plt.legend(\ ([str(Q[i]*100) for i in range(len(Q))]),\ loc='center left', bbox_to_anchor=(1, 0.5),title='Quantiles') plt.savefig('figures/bctc_'+str(mode)+'.eps')
def show_prediction_result(image, label_image, clf): size = (8, 8) plt.figure(figsize=(15, 10)) plt.imshow(image, cmap='gray_r') candidates = [] predictions = [] for region in regionprops(label_image): # skip small images # if region.area < 100: # continue # draw rectangle around segmented coins minr, minc, maxr, maxc = region.bbox # make regions square maxwidth = np.max([maxr - minr, maxc - minc]) minr, maxr = int(0.5 * ((maxr + minr) - maxwidth)) - 3, int(0.5 * ((maxr + minr) + maxwidth)) + 3 minc, maxc = int(0.5 * ((maxc + minc) - maxwidth)) - 3, int(0.5 * ((maxc + minc) + maxwidth)) + 3 rect = mpatches.Rectangle((minc, minr), maxc - minc, maxr - minr, fill=False, edgecolor='red', linewidth=2, alpha=0.2) plt.gca().add_patch(rect) # predict digit candidate = image[minr:maxr, minc:maxc] candidate = np.array(imresize(candidate, size), dtype=float) # invert # candidate = np.max(candidate) - candidate # print im # rescale to 16 in integer candidate = (candidate - np.min(candidate)) if np.max(candidate) == 0: continue candidate /= np.max(candidate) candidate[candidate < 0.2] = 0.0 candidate *= 16 candidate = np.array(candidate, dtype=int) prediction = clf.predict(candidate.reshape(-1)) candidates.append(candidate) predictions.append(prediction) plt.text(minc - 10, minr - 10, "{}".format(prediction), fontsize=50) plt.xticks([], []) plt.yticks([], []) plt.tight_layout() plt.show() return candidates, predictions
def plotScale(imgFile, minVal, maxVal): imgSize = (2, 4) fig = plt.figure(figsize=imgSize, dpi=100, frameon=True, facecolor='w') for i in xrange(10): val = minVal + i * (maxVal - minVal) / 10 col = getColor(val, minVal, maxVal) X = [float(i) / 10, float(i + 1) / 10, float(i + 1) / 10, float(i) / 10, float(i) / 10] Y = [1, 1, 0, 0, 1] fill(X, Y, col, lw=1, ec=col) savefig(imgFile) close()
def plot_wireframe(df, ax=None, *args, **kwargs): if ax is None: fig = plt.figure() ax = Axes3D(fig) res = _3d_values(df) X, Y, Z = res['values'] x_name, y_name = res['labels'] ax.plot_wireframe(X, Y, Z, *args, **kwargs) ax.set_xlabel(x_name) ax.set_ylabel(y_name) return ax
def main(args=sys.argv[1:]): # there are some cases when this script is run on systems without DISPLAY variable being set # in such case matplotlib backend has to be explicitly specified # we do it here and not in the top of the file, as inteleaving imports with code lines is discouraged import matplotlib matplotlib.use('Agg') from pylab import plt, ylabel, grid, xlabel, array parser = argparse.ArgumentParser() parser.add_argument("rst_file", help="location of rst file in TRiP98 format", type=str) parser.add_argument("output_file", help="location of PNG file to save", type=str) parser.add_argument("-s", "--submachine", help="Select submachine to plot.", type=int, default=1) parser.add_argument("-f", "--factor", help="Factor for scaling the blobs. Default is 1000.", type=int, default=1000) parser.add_argument("-v", "--verbosity", action='count', help="increase output verbosity", default=0) parser.add_argument('-V', '--version', action='version', version=pt.__version__) args = parser.parse_args(args) file = args.rst_file sm = args.submachine fac = args.factor a = pt.Rst() a.read(file) # convert data in submachine to a nice array b = a.machines[sm] x = [] y = [] z = [] for _x, _y, _z in b.raster_points: x.append(_x) y.append(_y) z.append(_z) title = "Submachine: {:d} / {:d} - Energy: {:.3f} MeV/u".format(sm, len(a.machines), b.energy) print(title) cc = array(z) cc = cc / cc.max() * fac fig = plt.figure() ax = fig.add_subplot(111) ax.scatter(x, y, c=cc, s=cc, alpha=0.75) ylabel("mm") xlabel("mm") grid(True) plt.title(title) plt.savefig(args.output_file) plt.close()
def my_2D_plot_of_arrays(xa, ya, title, xlabel, ylabel, *add_graphs): fig = plt.figure() ax = fig.add_subplot(111) lines=ax.plot(xa, ya, 'b-o', markersize=2, color="green") line = lines[0] line.set_linewidth( 1.5 ) line.set_color( 'green' ) line.set_linestyle( '-' ) line.set_marker('s') line.set_markerfacecolor('red') line.set_markeredgecolor( '0.1' ) line.set_markersize( 3 ) ## format the ticks adl = mdates.AutoDateLocator() ax.xaxis.set_major_locator(adl) myformatter = MyAutoDateFormatter(adl) #myformatter = mdates.AutoDateFormatter(adl) ax.xaxis.set_major_formatter(myformatter) ax.set_title(title) ax.set_xlabel(xlabel) ax.set_ylabel(ylabel) labels = getp(ax, 'xticklabels') setp(labels, color='g', fontsize=9, fontname="Verdana" ) labels = getp(ax, 'yticklabels') setp(labels, color='g', fontsize=9, fontname="Verdana" ) ax.grid(True) fig.autofmt_xdate(bottom=0.18, rotation=60) min_y=min(ya) max_y=max(ya) if (min_y<0) and (max_y >0): ax.axhline(0, color='r', lw=4, alpha=0.5) ax.fill_between(xa, ya, facecolor='red', alpha=0.5, interpolate=True) #plot additional graphs if len(add_graphs): draw_add_2D_plot_of_arrays(add_graphs, ax) plt.show()
def start_plot(self,w=1.3,connect=False): self.fig=plt.figure() self.ax=plt.axes() plt.axhline(y=0,color='grey', zorder=-1) plt.axvline(x=0,color='grey', zorder=-2) self.plot_data(connect=connect) #plt.axis('equal') self.ax.set_aspect('equal', 'datalim') if self.center is not None: cx,cy=self.center.real,self.center.imag; r=self.radius self.ax.axis([cx-w*r,cx+w*r,cy-w*r,cy+w*r]) else: xmx=amax(self.x); ymn,ymx=amin(self.y),amax(self.y) cx=0.5*xmx; cy=0.5*(ymn+ymx); r=0.5*(ymx-ymn) self.ax.axis([cx-w*r,cx+w*r,cy-w*r,cy+w*r]) if self.ZorY == 'Z': plt.xlabel(r'resistance $R$ in Ohm'); plt.ylabel(r'reactance $X$ in Ohm') if self.ZorY == 'Y': plt.xlabel(r'conductance $G$ in Siemens'); plt.ylabel(r'susceptance $B$ in Siemens')
def draw_tag_volume(labels, volumes, levels=None, xlabel="tag", ylabel="UAX", title="Expenses grouped by tags."): ''' - It draws a graph tag/volume. @testable = false ''' all_colors = 'rgbkymc'; fig = plt.figure(figsize=(15, 5), dpi=400) axes = fig.add_axes([0.1, 0.1, 0.8, 0.8]) # left, bottom, width, height (range 0 to 1) ticks = range(len(labels)) axes.set_xticks(ticks) axes.set_xticklabels(labels, fontsize=8) if levels == None: colors = None else: colors = [ all_colors[level] for level in levels ] axes.bar(ticks, volumes, color=colors) axes.set_xlabel(xlabel) axes.set_ylabel(ylabel) axes.set_title(title);
def plotLive(combine_Type, combine_Name, lat_Name, long_Name, massFlow_Name, filename): data = pd.read_csv(filename) if combine_Type != 0: comb_df = data[data[combine_Name] == combine_Type] lat_df = comb_df[lat_Name] lon_df = comb_df[long_Name] y = comb_df[massFlow_Name] else: lat_df = data[lat_Name] lon_df = data[long_Name] y = data[massFlow_Name] e,n = convertToUTM(lat_df, lon_df) def makeFig(): plt.plot(x,y) plt.ylabel('Easting') plt.xlabel('Northing') plt.ion() # enable interactivity plt.grid() fig = plt.figure() # make a figure x=list() y=list() for i in arange(len(n)): x.append(n[i]) y.append(e[i]) i+=1 drawnow(makeFig)
def get_parameters(self, case): parameters = case.keys(iotype = 'in', flatten = True) numParms = range(len(parameters)) self.data = [] place = [] self.scaleList = [] for parm in numParms: self.data.append([]) self.data.append([]) self.fig = plt.figure() self.ax = self.fig.add_subplot(111) self.ax.set_title(self.title) self.ax.set_xlabel('Iterations') self.ax.set_ylabel('Value') self.ax.grid() self.fig.canvas.mpl_connect('pick_event', self.onpick) output_keys = case.keys(iotype='out', flatten=True) self.labels = case.keys(iotype='in', flatten=True) self.labels.append(output_keys[0]) self.lineColors = ['b', 'g', 'r', 'c', 'm', 'y', 'k', \ 'b--', 'g--', 'r--', 'c--', 'm--', 'y--', 'k--', \ 'b:', 'g:', 'r:', 'c:', 'm:', 'y:', 'k:'] i = 0 for line in self.data: self.ax.plot(place, self.data[i], self.lineColors[i], lw=2 ) self.leg = self.ax.legend(self.labels, fancybox=True, shadow=True) self.leg.get_frame().set_alpha(0.6) i += 1 if self.logscale: plt.yscale('symlog')
def render_weights(file_name, queue, vmin, vmax, divergent, array_shape): from pylab import plt import matplotlib.animation as animation plotter = WeightsPlotter() fig = plt.figure(facecolor='gray', frameon=False) ax = fig.add_subplot(111) ax.set_aspect('equal') ax.get_xaxis().set_visible(False) ax.get_yaxis().set_visible(False) ax.axis('off') if divergent: my_colormap = brewer2mpl.get_map('PiYG', 'diverging', 11).mpl_colormap else: my_colormap = brewer2mpl.get_map('OrRd', 'sequential', 9).mpl_colormap my_colormap.set_bad('#6ECFF6', 1.0) im = {} def update_img(array): array = plotter.plot_weights(array) if im.get('im', None) is None: im['im'] = ax.imshow(array, cmap=my_colormap, interpolation='nearest', vmin=vmin, vmax=vmax) aspect = array.shape[0] / float(array.shape[1]) fig.set_size_inches([7.2, 7.2*aspect]) # 720 pixels wide, variable height fig.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=None, hspace=None) im['im'].set_data(array) return im['im'] #legend(loc=0) ani = animation.FuncAnimation(fig,update_img, frames=IterableQueue(queue)) #writer = animation.writers['ffmpeg'](fps=30, bitrate=27*1024) ani.save(file_name, fps=30, extra_args=['-vcodec', 'libvpx', '-threads', '4', '-b:v', '1M'])
del cpa_calcs print cpa_space cpa_covs = CpaCovs(cpa_space,scale_spatial=(1.0) * 10, scale_value=2, left_blk_rel_scale=1, right_vec_scale=1) mu = cpa_space.get_zeros_theta() Avees = cpa_space.theta2Avees(np.random.multivariate_normal(mean=mu,cov=cpa_covs.cpa_cov)) As=cpa_space.Avees2As(Avees) cpa_space.update_pat(Avees) plt.close('all') if TF.plot: plt.figure() params_flow_int_ref = copy.deepcopy(params_flow_int) N = int(params_flow_int_ref.nTimeSteps) * 1 # in general, this doesn't have to evenly spaced. Just in the right range. x_dense=cpa_space.get_x_dense(nPts=1000) # This needs to be evenly spaced. interval = np.linspace(-3,3,x_dense.size) Nvals = range(N) Nvals=Nvals[-1:]
print 'int_data_domain = ', int_data_domain print 'int_data =',[round( int_data[g], 3 ) for g in range(len(int_data))] #create lisets for the the vel and acc data vel_data = [(int_data[i+1]-int_data[i])/h for i in range(len(int_data)-1)] print 'vel_data = ',vel_data acc_data = [(vel_data[i+1]-vel_data[i])/h for i in range(len(vel_data)-1)] print 'acc_data =',acc_data acc_domain = int_data_domain[1:-1] #import matplotlib.gridspec as gridspec #gs = gridspec.GridSpec(1,3) fig = plt.figure() x_plot = fig.add_subplot(111)#gs[0,0])#----------------------linear displacements plt.plot(int_data_domain, int_data, 'bo', wpt_domain, wpt, 'ro',acc_domain,acc_data) title('interpolated data',fontsize=10) ''' dx_plot = fig.add_subplot(gs[0,1]) plt.plot(int_data_domain[:-1], vel_data) title('velocity',fontsize=10) ddx_plot = fig.add_subplot(gs[0,2]) plt.plot(int_data_domain[:-2],acc_data) title('acceleration',fontsize=10) ''' show() #==================================================================================
xx = xx.astype(np.float) yy = yy.astype(np.float) dimx = float(dimx) dimy=float(dimy) nTimesInX = np.floor(xx / M).max() + 1 seg_cpu = np.floor(yy / M) * nTimesInX + np.floor(xx / M) seg_cpu = seg_cpu.astype(np.int32) return seg_cpu def random_permute_seg(seg): p=np.random.permutation(seg.max()+1) seg2 = np.zeros_like(seg) for c in range(seg.max()+1): seg2[seg==c]=p[c] return seg2.astype(np.int32) if __name__ == "__main__": tic = time.clock() seg= get_init_seg(500, 500,17,True) # seg= get_init_seg(512, 512,50,False) toc = time.clock() print toc-tic print 'k = ', seg.max()+1 plt.figure(1) plt.clf() plt.imshow(seg,interpolation="Nearest") plt.axis('scaled')
# Create some increasing function y = cdf_1d_gaussian(x,mu=-4,sigma=1) y *=0.3 y += 0.7*cdf_1d_gaussian(x,mu=4,sigma=2) y *=10 y +=3 range_start=y.min() range_end=y.max() # Add noise y += 0.4*np.random.standard_normal(y.shape) if 1: plt.figure(0) of.plt.set_figure_size_and_location(1000,0,1000,500) plt.clf() plt.subplot(121) plt.cla() plt.plot(x,y,'.',lw=3) plt.title('data') ax = plt.gca() ax.tick_params(axis='y', labelsize=50) ax.tick_params(axis='x', labelsize=30)
def plot_variable(u, name, direc, cmap=cmaps.parula, scale='lin', numLvls=100, umin=None, umax=None, \ tp=False, \ tpAlpha=1.0, show=False, hide_ax_tick_labels=False, label_axes=True, title='', use_colorbar=True, hide_axis=False, colorbar_loc='right'): """ show -- whether to show the plot on the screen tp -- show triangle cmap -- colors: gist_yarg - grey gnuplot, hsv, gist_ncar jet - typical colors """ mesh = u.function_space().mesh() v = u.compute_vertex_values(mesh) x = mesh.coordinates()[:,0] y = mesh.coordinates()[:,1] t = mesh.cells() if not os.path.isdir( direc ): os.makedirs(direc) full_path = os.path.join(direc, name) if umin != None: vmin = umin else: vmin = v.min() if umax != None: vmax = umax else: vmax = v.max() # countour levels : if scale == 'log': v[v < vmin] = vmin + 1e-12 v[v > vmax] = vmax - 1e-12 from matplotlib.ticker import LogFormatter levels = np.logspace(np.log10(vmin), np.log10(vmax), numLvls) tick_numLvls = min( numLvls, 8 ) tick_levels = np.logspace(np.log10(vmin), np.log10(vmax), tick_numLvls) formatter = LogFormatter(10, labelOnlyBase=False) norm = colors.LogNorm() elif scale == 'lin': v[v < vmin] = vmin + 1e-12 v[v > vmax] = vmax - 1e-12 from matplotlib.ticker import ScalarFormatter levels = np.linspace(vmin, vmax, numLvls) tick_numLvls = min( numLvls, 8 ) tick_levels = np.linspace(vmin, vmax, tick_numLvls) formatter = ScalarFormatter() norm = None elif scale == 'bool': from matplotlib.ticker import ScalarFormatter levels = [0, 1, 2] formatter = ScalarFormatter() norm = None fig = plt.figure(figsize=(5,5)) ax = fig.add_subplot(111) c = ax.tricontourf(x, y, t, v, levels=levels, norm=norm, cmap=plt.get_cmap(cmap)) plt.axis('equal') if tp == True: p = ax.triplot(x, y, t, '-', lw=0.2, alpha=tpAlpha) ax.set_xlim([x.min(), x.max()]) ax.set_ylim([y.min(), y.max()]) if label_axes: ax.set_xlabel(r'$x$') ax.set_ylabel(r'$y$') if hide_ax_tick_labels: ax.set_xticklabels([]) ax.set_yticklabels([]) if hide_axis: plt.axis('off') # include colorbar : if scale != 'bool' and use_colorbar: divider = make_axes_locatable(plt.gca()) cax = divider.append_axes(colorbar_loc, "5%", pad="3%") cbar = plt.colorbar(c, cax=cax, format=formatter, ticks=tick_levels) tit = plt.title(title) if use_colorbar: plt.tight_layout(rect=[.03,.03,0.97,0.97]) else: plt.tight_layout() plt.savefig( full_path + '.eps', dpi=300) if show: plt.show() plt.close(fig)
def plot_const(u, name , direc): if not os.path.isdir( direc ): os.makedirs(direc) full_path = os.path.join(direc, name) full_mesh = os.path.join(direc, 'mesh.svg') mesh = u.function_space().mesh() v = u.compute_vertex_values(mesh) x = mesh.coordinates()[:,0] y = mesh.coordinates()[:,1] t = mesh.cells() vmin = v.min() vmax = v.max() v[v < vmin] = vmin + 1e-12 v[v > vmax] = vmax - 1e-12 numLvls=100 from matplotlib.ticker import ScalarFormatter levels = np.linspace(vmin, vmax, numLvls) tick_numLvls = min( numLvls, 8 ) tick_levels = np.linspace(vmin, vmax, tick_numLvls) formatter = ScalarFormatter() norm = None n = mesh.num_vertices() d = mesh.geometry().dim() # Create the triangulation mesh_coordinates = mesh.coordinates().reshape((n, d)) triangles = np.asarray([cell.entities(0) for cell in cells(mesh)]) triangulation = tri.Triangulation(mesh_coordinates[:, 0], mesh_coordinates[:, 1], triangles) # Plot the mesh # plt.figure() # plt.triplot(triangulation) # plt.savefig( full_mesh ) # Plot of scalar field V = u.function_space() #FunctionSpace(mesh, 'CG', 2) #f_exp = Expression('sin(2*pi*(x[0]*x[0]+x[1]*x[1]))') #f = interpolate(f_exp, V) fig = plt.figure(figsize=(5,5)) ax = fig.add_subplot(111) # Get the z values for each vertex # cmap = plt.cm.jet cmap = cmaps.parula c = ax.tricontourf(x, y, t, v, levels=levels, norm=norm, cmap=plt.get_cmap(cmap)) plt.ioff() #fig = plt.figure() z = np.asarray([u(point) for point in mesh_coordinates]) plt.tripcolor(triangulation, z, cmap=cmap) # alt plt.tricontourf(...) plt.colorbar() # plt.savefig( full_path, bbox_inches='tight' ) plt.savefig( full_path + '.eps', dpi=300) plt.close( fig )
def plotCircle(imgFile, label, centerColHex=rgb(255, 255, 255).tohex(), circleCols=[[rgb(200, 200, 200).tohex()]], innerRadTotal=0.2, outerRadTotal=0.5, width=5, tstep=0.01): """Plot and save a circlePlot image using matplotlib module.""" ## image settings imgSize = (width, width) fig = plt.figure(figsize=imgSize, dpi=100, frameon=True, facecolor='w') axes([0, 0, 1, 1], frameon=True, axisbg='w') axis('off') circleWid = (outerRadTotal - innerRadTotal) / float(len(circleCols)) ## color center outerRadCenter = innerRadTotal outerRadCenter -= .01 X = [] Y = [] x, y = polar(outerRadCenter, 0) X.append(x) Y.append(y) ti = 0 while ti < 1: x, y = polar(outerRadCenter, ti) X.append(x) Y.append(y) ti += tstep if ti > 1: break x, y = polar(outerRadCenter, 1) X.append(x) Y.append(y) if centerColHex == None: # transparent center fill(X, Y, rgb(255, 255, 255).tohex(), lw=1, ec='none', fill=False) else: # color-filled center fill(X, Y, centerColHex, lw=1, ec=centerColHex) time0 = time() ## color rings # this part is slow ~0.6 sec for one dataset (536 samples) for i in xrange(len(circleCols)): innerRadRing = (i * circleWid) + innerRadTotal outerRadRing = ((i + 1) * circleWid) + innerRadTotal - .01 for j in xrange(len(circleCols[i])): t0 = float(j) / len(circleCols[i]) t1 = float(j + 1) / len(circleCols[i]) X = [] Y = [] x, y = polar(innerRadRing, t0) X.append(x) Y.append(y) ti = t0 while ti < t1: x, y = polar(outerRadRing, ti) X.append(x) Y.append(y) ti += tstep if ti > t1: break x, y = polar(outerRadRing, t1) X.append(x) Y.append(y) ti = t1 while ti > t0: x, y = polar(innerRadRing, ti) X.append(x) Y.append(y) ti -= tstep if ti < t0: break x, y = polar(innerRadRing, t0) X.append(x) Y.append(y) fill(X, Y, circleCols[i][j], lw=1, ec=circleCols[i][j]) # log("%s to get ring colors\n" % (time() - time0)) time0 = time() ## save image text(0, 0, label, ha='center', va='center', size='xx-large') xlim(-0.5, 0.5) ylim(-0.5, 0.5) savefig(imgFile, transparent=True) close() # log("%s to savefig\n" % (time() - time0)) time0 = time()