def plot_part2(filename): """ Plots the result of count ones test """ fig1 = pl.figure() iterations, runtimes, fvals = extract(filename) algos = ["SA", "GA", "MIMIC"] iters_sa, iters_ga, iters_mimic = [np.array(iterations[a]) for a in algos] runtime_sa, runtime_ga, runtime_mimic = [np.array(runtimes[a]) for a in algos] fvals_sa, fvals_ga, fvals_mimic = [np.array(fvals[a]) for a in algos] plotfunc = getattr(pl, "loglog") plotfunc(runtime_sa, fvals_sa, "bs", mew=0) plotfunc(runtime_ga, fvals_ga, "gs", mew=0) plotfunc(runtime_mimic, fvals_mimic, "rs", mew=0) # plotfunc(iters_sa, fvals_sa/(runtime_sa * iters_sa), "bs", mew=0) # plotfunc(iters_ga, fvals_ga/(runtime_ga * iters_ga), "gs", mew=0) # plotfunc(iters_mimic, fvals_mimic/(runtime_mimic * iters_mimic), "rs", mew=0) pl.xlabel("Runtime (seconds)") pl.ylabel("Objective function value") pl.ylim([min(fvals_sa) / 2, max(fvals_mimic) * 2]) pl.legend(["SA", "GA", "MIMIC"], loc=4) pl.savefig(filename.replace(".csv", ".png"), bbox_inches="tight")
def plot_field(self,x,y,u=None,v=None,F=None,contour=False,outdir=None,plot='quiver',figname='_field',format='eps'): outdir = self.set_dir(outdir) p = 64 if F is None: F=self.calc_F(u,v) plt.close('all') plt.figure() #fig, axes = plt.subplots(nrows=1) if contour: plt.hold(True) plt.contourf(x,y,F) if plot=='quiver': plt.quiver(x[::p],y[::p],u[::p],v[::p],scale=0.1) if plot=='pcolor': plt.pcolormesh(x[::4],y[::4],F[::4],cmap=plt.cm.Pastel1) plt.colorbar() if plot=='stream': speed = F[::16] plt.streamplot(x[::16], y[::16], u[::16], v[::16], density=(1,1),color='k') plt.xlabel('$x$ (a.u.)') plt.ylabel('$y$ (a.u.)') plt.savefig(os.path.join(outdir,figname+'.'+format),format=format,dpi=320,bbox_inches='tight') plt.close()
def plot_feat_hist(data_name_list, filename=None): if len(data_name_list)>1: assert filename is not None pylab.figure(num=None, figsize=(8, 6)) num_rows = 1 + (len(data_name_list) - 1) / 2 num_cols = 1 if len(data_name_list) == 1 else 2 pylab.figure(figsize=(5 * num_cols, 4 * num_rows)) for i in range(num_rows): for j in range(num_cols): pylab.subplot(num_rows, num_cols, 1 + i * num_cols + j) x, name = data_name_list[i * num_cols + j] pylab.title(name) pylab.xlabel('Value') pylab.ylabel('Fraction') # the histogram of the data max_val = np.max(x) if max_val <= 1.0: bins = 50 elif max_val > 50: bins = 50 else: bins = max_val n, bins, patches = pylab.hist( x, bins=bins, normed=1, facecolor='blue', alpha=0.75) pylab.grid(True) if not filename: filename = "feat_hist_%s.png" % name.replace(" ", "_") pylab.savefig(os.path.join(CHART_DIR, filename), bbox_inches="tight")
def check_models(self): plt.figure('Bandgap narrowing') Na = np.logspace(12, 20) Nd = 0. dn = 1e14 temp = 300. for author in self.available_models(): BGN = self.update(Na=Na, Nd=Nd, nxc=dn, author=author, temp=temp) if not np.all(BGN == 0): plt.plot(Na, BGN, label=author) test_file = os.path.join( os.path.dirname(os.path.realpath(__file__)), 'Si', 'check data', 'Bgn.csv') data = np.genfromtxt(test_file, delimiter=',', names=True) for name in data.dtype.names[1:]: plt.plot( data['N'], data[name], 'r--', label='PV-lighthouse\'s: ' + name) plt.semilogx() plt.xlabel('Doping (cm$^{-3}$)') plt.ylabel('Bandgap narrowing (K)') plt.legend(loc=0)
def plot_bernoulli_matrix(self, show_npfs=False): """ Plot the heatmap of the Bernoulli matrix @self @show_npfs - Highlight NPFS detections [Boolean] """ matrix = self.Bernoulli_matrix if show_npfs == False: plot = plt.imshow(matrix) plot.set_cmap('hot') plt.colorbar() plt.xlabel("Bootstraps") plt.ylabel("Feature") plt.show() else: for i in self.selected_features: for k in range(len(matrix[i])): matrix[i,k] = .5 plot = plt.imshow(matrix) plot.set_cmap('hot') plt.xlabel("Bootstraps") plt.ylabel("Feature") plt.colorbar() plt.show() return None
def study_sdss_density(hemi='south'): grid = grid3d(hemi=hemi) n_data = num_sdss_data_both_catalogs(hemi, grid) n_rand, weight = num_sdss_rand_both_catalogs(hemi, grid) n_rand *= ((n_data*weight).sum() / (n_rand*weight).sum()) delta = (n_data - n_rand) / n_rand delta[weight==0]=0. fdelta = np.fft.fftn(delta*weight) power = np.abs(fdelta)**2. ks = get_wavenumbers(delta.shape, grid.reso_mpc) kmag = ks[3] kbin = np.arange(0,0.06,0.002) ind = np.digitize(kmag.ravel(), kbin) power_ravel = power.ravel() power_bin = np.zeros_like(kbin) for i in range(len(kbin)): print i wh = np.where(ind==i)[0] power_bin[i] = power_ravel[wh].mean() #pl.clf() #pl.plot(kbin, power_bin) from cosmolopy import perturbation pk = perturbation.power_spectrum(kbin, 0.4, **cosmo) pl.clf(); pl.plot(kbin, power_bin/pk, 'b') pl.plot(kbin, power_bin/pk, 'bo') pl.xlabel('k (1/Mpc)',fontsize=16) pl.ylabel('P(k) ratio, DATA/THEORY [arb. norm.]',fontsize=16) ipdb.set_trace()
def make_corr1d_fig(dosave=False): corr = make_corr_both_hemi() lw=2; fs=16 pl.figure(1)#, figsize=(8, 7)) pl.clf() pl.xlim(4,300) pl.ylim(-400,+500) lambda_titles = [r'$20 < \lambda < 30$', r'$30 < \lambda < 40$', r'$\lambda > 40$'] colors = ['blue','green','red'] for i in range(3): corr1d, rcen = corr_1d_from_2d(corr[i]) ipdb.set_trace() pl.semilogx(rcen, corr1d*rcen**2, lw=lw, color=colors[i]) #pl.semilogx(rcen, corr1d*rcen**2, 'o', lw=lw, color=colors[i]) pl.xlabel(r'$s (Mpc)$',fontsize=fs) pl.ylabel(r'$s^2 \xi_0(s)$', fontsize=fs) pl.legend(lambda_titles, 'lower left', fontsize=fs+3) pl.plot([.1,10000],[0,0],'k--') s_bao = 149.28 pl.plot([s_bao, s_bao],[-9e9,+9e9],'k--') pl.text(s_bao*1.03, 420, 'BAO scale') pl.text(s_bao*1.03, 370, '%0.1f Mpc'%s_bao) if dosave: pl.savefig('xi1d_3bin.pdf')
def bar(self, key_word_sep = " ", title=None, **kwargs): """Generates a pylab bar plot from the result set. ``matplotlib`` must be installed, and in an IPython Notebook, inlining must be on:: %%matplotlib inline The last quantitative column is taken as the Y values; all other columns are combined to label the X axis. Parameters ---------- title: Plot title, defaults to names of Y value columns key_word_sep: string used to separate column values from each other in labels Any additional keyword arguments will be passsed through to ``matplotlib.pylab.bar``. """ import matplotlib.pylab as plt self.guess_pie_columns(xlabel_sep=key_word_sep) plot = plt.bar(range(len(self.ys[0])), self.ys[0], **kwargs) if self.xlabels: plt.xticks(range(len(self.xlabels)), self.xlabels, rotation=45) plt.xlabel(self.xlabel) plt.ylabel(self.ys[0].name) return plot
def study_redmapper_2d(): # I just want to know the typical angular separation for RM clusters. # I'm going to do this in a lazy way. hemi = 'north' rm = load_redmapper(hemi=hemi) ra = rm['ra'] dec = rm['dec'] ncl = len(ra) dist = np.zeros((ncl, ncl)) for i in range(ncl): this_ra = ra[i] this_dec = dec[i] dra = this_ra-ra ddec = this_dec-dec dxdec = dra*np.cos(this_dec*np.pi/180.) dd = np.sqrt(dxdec**2. + ddec**2.) dist[i,:] = dd dist[i,i] = 99999999. d_near_arcmin = dist.min(0)*60. pl.clf(); pl.hist(d_near_arcmin, bins=100) pl.title('Distance to Nearest Neighbor for RM clusters') pl.xlabel('Distance (arcmin)') pl.ylabel('N') fwhm_planck_217 = 5.5 # arcmin sigma = fwhm_planck_217/2.355 frac_2sigma = 1.*len(np.where(d_near_arcmin>2.*sigma)[0])/len(d_near_arcmin) frac_3sigma = 1.*len(np.where(d_near_arcmin>3.*sigma)[0])/len(d_near_arcmin) print '%0.3f percent of RM clusters are separated by 2-sigma_planck_beam'%(100.*frac_2sigma) print '%0.3f percent of RM clusters are separated by 3-sigma_planck_beam'%(100.*frac_3sigma) ipdb.set_trace()
def check_models(self): ''' Displays a plot of the models against that taken from a respected website (https://www.pvlighthouse.com.au/) ''' plt.figure('Intrinsic bandgap') t = np.linspace(1, 500) for author in self.available_models(): Eg = self.update(temp=t, author=author, multiplier=1.0) plt.plot(t, Eg, label=author) test_file = os.path.join( os.path.dirname(os.path.realpath(__file__)), 'Si', 'check data', 'iBg.csv') data = np.genfromtxt(test_file, delimiter=',', names=True) for temp, name in zip(data.dtype.names[0::2], data.dtype.names[1::2]): plt.plot( data[temp], data[name], '--', label=name) plt.xlabel('Temperature (K)') plt.ylabel('Intrinsic Bandgap (eV)') plt.legend(loc=0) self.update(temp=0, author=author, multiplier=1.01)
def plot(self, title=None, **kwargs): """Generates a pylab plot from the result set. ``matplotlib`` must be installed, and in an IPython Notebook, inlining must be on:: %%matplotlib inline The first and last columns are taken as the X and Y values. Any columns between are ignored. Parameters ---------- title: Plot title, defaults to names of Y value columns Any additional keyword arguments will be passsed through to ``matplotlib.pylab.plot``. """ import matplotlib.pylab as plt self.guess_plot_columns() self.x = self.x or range(len(self.ys[0])) coords = reduce(operator.add, [(self.x, y) for y in self.ys]) plot = plt.plot(*coords, **kwargs) if hasattr(self.x, 'name'): plt.xlabel(self.x.name) ylabel = ", ".join(y.name for y in self.ys) plt.title(title or ylabel) plt.ylabel(ylabel) return plot
def plot_values(self, TITLE, SAVE): plot(self.list_of_densities, self.list_of_pressures) title(TITLE) xlabel("Densities") ylabel("Pressure") savefig(SAVE) show()
def test_simple_gen(self): self_con = .8 other_con = 0.05 g = self.gen.gen_stoch_blockmodel(min_degree=1, blocks=5, self_con=self_con, other_con=other_con, powerlaw_exp=2.1, degree_seq='powerlaw', num_nodes=1000, num_links=3000) deg_hist = vertex_hist(g, 'total') res = fit_powerlaw.Fit(g.degree_property_map('total').a, discrete=True) print 'powerlaw alpha:', res.power_law.alpha print 'powerlaw xmin:', res.power_law.xmin if len(deg_hist[0]) != len(deg_hist[1]): deg_hist[1] = deg_hist[1][:len(deg_hist[0])] print 'plot degree dist' plt.plot(deg_hist[1], deg_hist[0]) plt.xscale('log') plt.xlabel('degree') plt.ylabel('#nodes') plt.yscale('log') plt.savefig('deg_dist_test.png') plt.close('all') print 'plot graph' pos = sfdp_layout(g, groups=g.vp['com'], mu=3) graph_draw(g, pos=pos, output='graph.png', output_size=(800, 800), vertex_size=prop_to_size(g.degree_property_map('total'), mi=2, ma=30), vertex_color=[0., 0., 0., 1.], vertex_fill_color=g.vp['com'], bg_color=[1., 1., 1., 1.]) plt.close('all') print 'init:', self_con / (self_con + other_con), other_con / (self_con + other_con) print 'real:', gt_tools.get_graph_com_connectivity(g, 'com')
def __call__(self, **params): p = ParamOverrides(self, params) fig = plt.figure(figsize=(5, 5)) # This one-liner works in Octave, but in matplotlib it # results in lines that are all connected across rows and columns, # so here we plot each line separately: # plt.plot(x,y,"k-",transpose(x),transpose(y),"k-") # Here, the "k-" means plot in black using solid lines; # see matplotlib for more info. isint = plt.isinteractive() # Temporarily make non-interactive for # plotting plt.ioff() for r, c in zip(p.y[::p.skip], p.x[::p.skip]): plt.plot(c, r, "k-") for r, c in zip(np.transpose(p.y)[::p.skip],np.transpose(p.x)[::p.skip]): plt.plot(c, r, "k-") # Force last line avoid leaving cells open if p.skip != 1: plt.plot(p.x[-1], p.y[-1], "k-") plt.plot(np.transpose(p.x)[-1], np.transpose(p.y)[-1], "k-") plt.xlabel('x') plt.ylabel('y') # Currently sets the input range arbitrarily; should presumably figure out # what the actual possible range is for this simulation (which would presumably # be the maximum size of any GeneratorSheet?). plt.axis(p.axis) if isint: plt.ion() self._generate_figure(p) return fig
def plot_confusion_matrix(cm, title='', cmap=plt.cm.Blues): #print cm #display vehicle, idle, walking accuracy respectively #display overall accuracy print type(cm) # plt.figure(index plt.imshow(cm, interpolation='nearest', cmap=cmap) #plt.figure("") plt.title("Confusion Matrix") plt.colorbar() tick_marks = [0,1,2] target_name = ["driving","idling","walking"] plt.xticks(tick_marks,target_name,rotation=45) plt.yticks(tick_marks,target_name,rotation=45) print len(cm[0]) for i in range(0,3): for j in range(0,3): plt.text(i,j,str(cm[i,j])) plt.tight_layout() plt.ylabel("Actual Value") plt.xlabel("Predicted Outcome")
def visualization2(self, sp_to_vis=None): if sp_to_vis: species_ready = list(set(sp_to_vis).intersection(self.all_sp_signatures.keys())) else: raise Exception('list of driver species must be defined') if not species_ready: raise Exception('None of the input species is a driver') for sp in species_ready: # Setting up figure plt.figure() plt.subplot(313) mon_val = OrderedDict() signature = self.all_sp_signatures[sp] for idx, mon in enumerate(list(set(signature))): if mon[0] == 'C': mon_val[self.all_comb[sp][mon] + (-1,)] = idx else: mon_val[self.all_comb[sp][mon]] = idx mon_rep = [0] * len(signature) for i, m in enumerate(signature): if m[0] == 'C': mon_rep[i] = mon_val[self.all_comb[sp][m] + (-1,)] else: mon_rep[i] = mon_val[self.all_comb[sp][m]] # mon_rep = [mon_val[self.all_comb[sp][m]] for m in signature] y_pos = numpy.arange(len(mon_val.keys())) plt.scatter(self.tspan[1:], mon_rep) plt.yticks(y_pos, mon_val.keys()) plt.ylabel('Monomials', fontsize=16) plt.xlabel('Time(s)', fontsize=16) plt.xlim(0, self.tspan[-1]) plt.ylim(0, max(y_pos)) plt.subplot(312) for name in self.model.odes[sp].as_coefficients_dict(): mon = name mon = mon.subs(self.param_values) var_to_study = [atom for atom in mon.atoms(sympy.Symbol)] arg_f1 = [numpy.maximum(self.mach_eps, self.y[str(va)][1:]) for va in var_to_study] f1 = sympy.lambdify(var_to_study, mon) mon_values = f1(*arg_f1) mon_name = str(name).partition('__')[2] plt.plot(self.tspan[1:], mon_values, label=mon_name) plt.ylabel('Rate(m/sec)', fontsize=16) plt.legend(bbox_to_anchor=(-0.1, 0.85), loc='upper right', ncol=1) plt.subplot(311) plt.plot(self.tspan[1:], self.y['__s%d' % sp][1:], label=parse_name(self.model.species[sp])) plt.ylabel('Molecules', fontsize=16) plt.legend(bbox_to_anchor=(-0.15, 0.85), loc='upper right', ncol=1) plt.suptitle('Tropicalization' + ' ' + str(self.model.species[sp])) # plt.show() plt.savefig('s%d' % sp + '.png', bbox_inches='tight', dpi=400)
def cdf(x,colsym="",lab="",lw=4): """ plot the cumulative density function Parameters ---------- x : np.array() colsym : string lab : string lw : int linewidth Examples -------- >>> import numpy as np """ rcParams['legend.fontsize']=20 rcParams['font.size']=20 x = np.sort(x) n = len(x) x2 = np.repeat(x, 2) y2 = np.hstack([0.0, repeat(np.arange(1,n) / float(n), 2), 1.0]) plt.plot(x2,y2,colsym,label=lab,linewidth=lw) plt.grid('on') plt.legend(loc=2) plt.xlabel('Ranging Error[m]') plt.ylabel('Cumulative Probability')
def fancy_dendrogram(*args, **kwargs): ''' Source: https://joernhees.de/blog/2015/08/26/scipy-hierarchical-clustering-and-dendrogram-tutorial/ ''' from scipy.cluster import hierarchy import matplotlib.pylab as plt max_d = kwargs.pop('max_d', None) if max_d and 'color_threshold' not in kwargs: kwargs['color_threshold'] = max_d annotate_above = kwargs.pop('annotate_above', 0) ddata = hierarchy.dendrogram(*args, **kwargs) if not kwargs.get('no_plot', False): plt.title('Hierarchical Clustering Dendrogram (truncated)') plt.xlabel('sample index or (cluster size)') plt.ylabel('distance') for i, d, c in zip(ddata['icoord'], ddata['dcoord'], ddata['color_list']): x = 0.5 * sum(i[1:3]) y = d[1] if y > annotate_above: plt.plot(x, y, 'o', c=c) plt.annotate("%.3g" % y, (x, y), xytext=(0, -5), textcoords='offset points', va='top', ha='center') if max_d: plt.axhline(y=max_d, c='k') return ddata
def plot_feat_hist(data_name_list, filename=None): pylab.clf() # import pdb;pdb.set_trace() num_rows = 1 + (len(data_name_list) - 1) / 2 num_cols = 1 if len(data_name_list) == 1 else 2 pylab.figure(figsize=(5 * num_cols, 4 * num_rows)) for i in range(num_rows): for j in range(num_cols): pylab.subplot(num_rows, num_cols, 1 + i * num_cols + j) x, name = data_name_list[i * num_cols + j] pylab.title(name) pylab.xlabel('Value') pylab.ylabel('Density') # the histogram of the data max_val = np.max(x) if max_val <= 1.0: bins = 50 elif max_val > 50: bins = 50 else: bins = max_val n, bins, patches = pylab.hist( x, bins=bins, normed=1, facecolor='green', alpha=0.75) pylab.grid(True) if not filename: filename = "feat_hist_%s.png" % name pylab.savefig(os.path.join(CHART_DIR, filename), bbox_inches="tight")
def plot_cell(self,cell_number=0,label='insert_label'): current_cell = self.cell_list[cell_number] temp = current_cell.temp cd_signal = current_cell.cd_signal cd_calc = current_cell.cd_calc() ax = pylab.gca() pylab.plot(temp,cd_signal,'o',color='black') pylab.plot(temp,cd_calc,color='black') pylab.xlabel(r'Temperature ($^{\circ}$C)') pylab.ylabel('mdeg') pylab.ylim([-25,-4]) dH = numpy.round(current_cell.dH, decimals=1) Tm = numpy.round(current_cell.Tm-273.15, decimals=1) nf = current_cell.nf nu = current_cell.nu textstr_dH = '${\Delta}H_{m}$ = %.1f kcal/mol' %dH textstr_Tm ='$T_{m}$ = %.1f $^{\circ}$C' %Tm textstr_nf ='$N_{folded}$ = %d' %nf textstr_nu ='$N_{unfolded}$ = %d'%nu ax.text(8,-6,textstr_dH, fontsize=16,ha='left',va='top') ax.text(8,-7.5,textstr_Tm, fontsize=16,ha='left',va='top') ax.text(8,-9,textstr_nf, fontsize=16,ha='left',va='top') ax.text(8,-10.5,textstr_nu, fontsize=16,ha='left',va='top') pylab.title(label) pylab.show() return
def plot_peaks(spectra, ref, zl, pl, filename=''): plt.figure(); plt.title("Debug: Peak fitting for '%s'" % filename); plt.xlabel("y-position [px]"); plt.ylabel("Intensity"); Nspectra, Npx = spectra.shape; for s in xrange(Nspectra): scale = 1./spectra.max(); offset= -s*0.1; # plot data plt.plot(spectra[s]*scale + offset,'k',linewidth=2); # plot first peak p,A,w = zl[s]; x = np.arange(-2*w, 2*w) + p; plt.plot(x,gauss(x,*zl[s])*scale + offset,'r'); # plot second peak if ref is not None: p,A = pl[s]; x = np.arange(len(ref)) - len(ref)/2 + p; plt.plot(x,ref/ref.max()*A*scale + offset,'g');
def set_axis_0(): pylab.xlabel('time (days)') pylab.gcf().subplots_adjust(top=1.0-0.13, bottom=0.2, right=1-0.02, left=0.2) a = list(pylab.axis()) na = [a[0], a[1], 0, a[3]*1.05] pylab.axis(na)
def handle(self, *args, **options): try: from matplotlib import pylab as pl import numpy as np except ImportError: raise Exception('Be sure to install requirements_scipy.txt before running this.') all_names_and_counts = RawCommitteeTransactions.objects.all().values('attest_by_name').annotate(total=Count('attest_by_name')).order_by('-total') all_names_and_counts_as_tuple_and_sorted = sorted([(row['attest_by_name'], row['total']) for row in all_names_and_counts], key=lambda row: row[1]) print "top ten attestors: (name, number of transactions they attest for)" for row in all_names_and_counts_as_tuple_and_sorted[-10:]: print row n_bins = 100 filename = 'attestor_participation_distribution.png' x_max = all_names_and_counts_as_tuple_and_sorted[-31][1] # eliminate top outliers from hist x_min = all_names_and_counts_as_tuple_and_sorted[0][1] counts = [row['total'] for row in all_names_and_counts] pl.figure(1, figsize=(18, 6)) pl.hist(counts, bins=np.arange(x_min, x_max, (float(x_max)-x_min)/100) ) pl.title('Histogram of Attestor Participation in RawCommitteeTransactions') pl.xlabel('Number of transactions a person attested for') pl.ylabel('Number of people') pl.savefig(filename)
def flipPlot(minExp, maxExp): """假定minEXPy和maxExp是正整数且minExp<maxExp 绘制出2**minExp到2**maxExp次抛硬币的结果 """ ratios = [] diffs = [] aAxis = [] for i in range(minExp, maxExp+1): aAxis.append(2**i) for numFlips in aAxis: numHeads = 0 for n in range(numFlips): if random.random() < 0.5: numHeads += 1 numTails = numFlips - numHeads ratios.append(numHeads/numFlips) diffs.append(abs(numHeads-numTails)) plt.figure() ax1 = plt.subplot(121) plt.title("Difference Between Heads and Tails") plt.xlabel('Number of Flips') plt.ylabel('Abs(#Heads - #Tails)') ax1.semilogx(aAxis, diffs, 'bo') ax2 = plt.subplot(122) plt.title("Heads/Tails Ratios") plt.xlabel('Number of Flips') plt.ylabel("#Heads/#Tails") ax2.semilogx(aAxis, ratios, 'bo') plt.show()
def plot_q(model='cem', r_min=0.0, r_max=6371.0, dr=1.0): """ Plot a radiallysymmetric Q model. plot_q(model='cem', r_min=0.0, r_max=6371.0, dr=1.0): r_min=minimum radius [km], r_max=maximum radius [km], dr=radius increment [km] Currently available models (model): cem, prem, ql6 """ import matplotlib.pylab as plt r = np.arange(r_min, r_max + dr, dr) q = np.zeros(len(r)) for k in range(len(r)): if model == 'cem': q[k] = q_cem(r[k]) elif model == 'ql6': q[k] = q_ql6(r[k]) elif model == 'prem': q[k] = q_prem(r[k]) plt.plot(r, q, 'k') plt.xlim((0.0, r_max)) plt.xlabel('radius [km]') plt.ylabel('Q') plt.show()
def plotMassFunction(im, pm, outbase, mmin=9, mmax=13, mstep=0.05): """ Make a comparison plot between the input mass function and the predicted projected correlation function """ plt.clf() nmbins = ( mmax - mmin ) / mstep mbins = np.logspace( mmin, mmax, nmbins ) mcen = ( mbins[:-1] + mbins[1:] ) /2 plt.xscale( 'log', nonposx = 'clip' ) plt.yscale( 'log', nonposy = 'clip' ) ic, e, p = plt.hist( im, mbins, label='Original Halos', alpha=0.5, normed = True) pc, e, p = plt.hist( pm, mbins, label='Added Halos', alpha=0.5, normed = True) plt.legend() plt.xlabel( r'$M_{vir}$' ) plt.ylabel( r'$\frac{dN}{dM}$' ) #plt.tight_layout() plt.savefig( outbase+'_mfcn.png' ) mdtype = np.dtype( [ ('mcen', float), ('imcounts', float), ('pmcounts', float) ] ) mf = np.ndarray( len(mcen), dtype = mdtype ) mf[ 'mcen' ] = mcen mf[ 'imcounts' ] = ic mf[ 'pmcounts' ] = pc fitsio.write( outbase+'_mfcn.fit', mf )
def plot_runtime_results(results): plt.rcParams["figure.figsize"] = 7,7 plt.rcParams["font.size"] = 22 matplotlib.rc("xtick", labelsize=24) matplotlib.rc("ytick", labelsize=24) params = {"text.fontsize" : 32, "font.size" : 32, "legend.fontsize" : 30, "axes.labelsize" : 32, "text.usetex" : False } plt.rcParams.update(params) #plt.semilogx(results[:,0], results[:,3], 'r-x', lw=3) #plt.semilogx(results[:,0], results[:,1], 'g-D', lw=3) #plt.semilogx(results[:,0], results[:,2], 'b-s', lw=3) plt.plot(results[:,0], results[:,3], 'r-x', lw=3, ms=10) plt.plot(results[:,0], results[:,1], 'g-D', lw=3, ms=10) plt.plot(results[:,0], results[:,2], 'b-s', lw=3, ms=10) plt.legend(["Chain", "Tree", "FFT Tree"], loc="upper left") plt.xticks([1e5, 2e5, 3e5]) plt.yticks([0, 60, 120, 180]) plt.xlabel("Problem Size") plt.ylabel("Runtime (sec)") return results
def fdr(p_values=None, verbose=0): """Returns the FDR associated with each p value Parameters ----------- p_values : ndarray of shape (n) The samples p-value Returns ------- q : array of shape(n) The corresponding fdr values """ p_values = check_p_values(p_values) n_samples = p_values.size order = p_values.argsort() sp_values = p_values[order] # compute q while in ascending order q = np.minimum(1, n_samples * sp_values / np.arange(1, n_samples + 1)) for i in range(n_samples - 1, 0, - 1): q[i - 1] = min(q[i], q[i - 1]) # reorder the results inverse_order = np.arange(n_samples) inverse_order[order] = np.arange(n_samples) q = q[inverse_order] if verbose: import matplotlib.pylab as mp mp.figure() mp.xlabel('Input p-value') mp.plot(p_values, q, '.') mp.ylabel('Associated fdr') return q
def plotFeaturePDF(ift, pft, outbase, fmin=0.0, fmax=1.0, fstep=0.01): """ Plot a comparison between the input feature distribution and the feature distribution of the predicted halos """ plt.clf() nfbins = ( fmax - fmin ) / fstep fbins = np.logspace( fmin, fmax, nfbins ) fcen = ( fbins[:-1] + fbins[1:] ) / 2 plt.xscale( 'log', nonposx='clip' ) plt.yscale( 'log', nonposy='clip' ) ic, e, p = plt.hist( ift, fbins, label='Original Halos', alpha=0.5, normed=True ) pc, e, p = plt.hist( pft, fbins, label='Added Halos', alpha=0.5, normed=True ) plt.legend() plt.xlabel( r'$\delta$' ) plt.savefig( outbase+'_fpdf.png' ) fdtype = np.dtype( [ ('fcen', float), ('ifcounts', float), ('pfcounts', float) ] ) fd = np.ndarray( len(fcen), dtype = fdtype ) fd[ 'mcen' ] = fcen fd[ 'imcounts' ] = ic fd[ 'pmcounts' ] = pc fitsio.write( outbase+'_fpdf.fit', fd )
def plot_corner_posteriors(self, savefile=None, labels=["T1", "R1", "Av", "T2", "R2"]): ''' Plots the corner plot of the MCMC results. ''' ndim = len(self.sampler.flatchain[0,:]) chain = self.sampler samples = chain.flatchain samples = samples[:,0:ndim] plt.figure(figsize=(8,8)) fig = corner.corner(samples, labels=labels[0:ndim]) plt.title("MJD: %.2f"%self.mjd) name = self._get_save_path(savefile, "mcmc_posteriors") plt.savefig(name) plt.close("all") plt.figure(figsize=(8,ndim*3)) for n in range(ndim): plt.subplot(ndim,1,n+1) chain = self.sampler.chain[:,:,n] nwalk, nit = chain.shape for i in np.arange(nwalk): plt.plot(chain[i], lw=0.1) plt.ylabel(labels[n]) plt.xlabel("Iteration") name_walkers = self._get_save_path(savefile, "mcmc_walkers") plt.tight_layout() plt.savefig(name_walkers) plt.close("all")
filename = 'beta_alpha.dat' # import data data = np.loadtxt(filename) # initial size of plot window plt.figure(figsize=(8, 6)) x = np.linspace(0, len(data), len(data)) # plot plt.plot(data[:, 0], '-', label=r'$\beta=$' + str(0.51)) for i in range(1, 6): plt.plot(data[:, i], '-', label=r'$\beta=$' + str(0.5 + i / 10)) # labels plt.xlabel('# gradient steps', fontsize=20) plt.ylabel(r'$\alpha$', fontsize=20) # legend plt.legend(loc='upper right') leg = plt.gca().get_legend() ltext = leg.get_texts() plt.setp(ltext, fontsize=12) # axis limits) plt.ylim(0.05, 0.25) # tick fontsize plt.xticks(fontsize=12) plt.yticks(fontsize=12) plt.title('Convergence of ' + r'$\alpha$' + ' for different ' + r'$\beta$' '') plt.savefig('4_alpha_convergence.png')
plt.rc('ytick',labelsize=0.5) #RESID = RESID1 import seaborn as sns def create_dataset(dataset, look_back): dataX, dataY = [], [] for i in range(len(dataset)-look_back): a = dataset[i:(i+look_back)] dataX.append(a) dataY.append(dataset[i + look_back]) return np.array(dataX), np.array(dataY) x,y = create_dataset(DATA[:,1],4) sns.distplot(RESID[k]) plt.xlabel('Residual size',fontsize = 13) plt.ylabel('Residual counts',fontsize = 13) plt.plot(RESID[k]) plt.ylabel('Residual amplitude',fontsize = 13) plt.xlabel('Week',fontsize = 13) import statsmodels.api as sm sm.graphics.tsa.plot_acf(RESID[k],lags=25) np.array(abs(RESID[k])).sum()/(len(RESID[k])) from statsmodels.stats.diagnostic import het_breuschpagan from statsmodels.stats.diagnostic import het_white df_resid = pd.DataFrame(RESID[k],columns = ['resid']) X= np.concatenate((np.ones(30).reshape(-1,1),x[-30:,:]),axis = 1)
Created on Sun May 16 13:33:21 2021 @author: Dhiraj Wagh """ #Importing the Libraries. import numpy as np import pandas as pd import matplotlib.pylab as plt dataset = pd.read_csv('Ads_CTR_Optimisation.csv') # IMPLEMENTING THE ALGORITHM RANDEM SELECTION import random N = 10000 d = 10 ads_selected = [] total_reward = 0 for n in range(0, N): ad = random.randrange(d) ads_selected.append(ad) reward = dataset.values[n, ad] total_reward = total_reward + reward #Visualizing the results - Histogram plt.hist(ads_selected) plt.title('Histogram of ads selections') plt.xlabel('Ads') plt.ylabel('Number of times each ad was selected') plt.show()
# set the inital conditions for the two populations R0 = 10 C0 = 5 RC0 = sc.array([R0, C0]) # now, numerically integrate this system forwards from these conditions pops, infodict = intergrate.odeint(dCR_dt, RC0, t, full_output=True) # plot it f1 = p.figure() p.plot(t, pops[:, 0], 'g-', label='Resource density') # Plot p.plot(t, pops[:, 1], 'b-', label='Consumer density') p.grid() p.legend(loc='best') p.xlabel('Time') p.ylabel('Population density') p.title('Consumer-Resource population dynamics') # add the parameter values to the plot. Currently in the plot but for # multiple plots as part of a pipeline this should be substituted for # something outside the plot grid. p.text(6, 15, "r = {}, a = {}, z = {}, e = {}, K = {}".format(r, a, z, e, K)) # save the figure as a pdf` f1.savefig('../Results/Plots/LV2_model.pdf') # plot the second circular figure. this just has the values from above as axis f2 = p.figure() p.plot(pops[:, 0], pops[:, 1], 'r-') # Plot p.grid()
return 0.01 * x ** 2 + 0.1 * x def function_2(x): return x[0] ** 2 + x[1] ** 2 print(numerical_gradient(function_2, np.array([3.0, 4.0]))) print(numerical_gradient(function_2, np.array([0.0, 2.0]))) print(numerical_gradient(function_2, np.array([3.0, 0.0]))) init_x = np.array([-3.0, 4.0]) t = gradient_descent(function_2, init_x=init_x, lr=0.1, step_num=100) print(t) ''' x = np.arange(0.0, 20.0, 0.1) y = function_1(x) plt.xlabel('x') plt.ylabel('f(x)') plt.plot(x, y) k1 = numerical_diff(function_1, 5) y1 = k1 * x + (function_1(5) - k1 * 5) plt.plot(x, y1) k2 = numerical_diff(function_1, 15) y2 = k2 * x + (function_1(15) - k2 * 15) plt.plot(x, y2) plt.show()
nwalk = 10000 nstep = 100 x = np.zeros(nwalk) y = np.zeros(nwalk) r2 = np.zeros(nwalk) sum_walk = np.zeros(nstep) for iwalk in range(nwalk): random.seed(None) x[iwalk] = 0 y[iwalk] = 0 r2[iwalk] = 0 for istep in range(nstep): dx = 2*random.random()-1 dy = 2*random.random()-1 dr = np.sqrt(dx**2+dy**2) x[iwalk] = x[iwalk] + dx/dr y[iwalk] = y[iwalk] + dy/dr r2[iwalk] = x[iwalk]**2 + y[iwalk]**2 sum_walk[istep] = sum_walk[istep] + r2[iwalk] for istep in range(nstep): sum_walk[istep] = sum_walk[istep]/nwalk time = np.arange(nstep) pl.plot(time, sum_walk, 'r-', label='distribution',linewidth=1.0) pl.xlim(0,100) pl.ylim(0,120) pl.xlabel(r'walk steps', fontsize=20) pl.ylabel(r'<r2>', fontsize=20) pl.show()
get_ipython().run_line_magic('matplotlib', 'inline') import matplotlib.pylab as plt import numpy as np import sympy as sym import time sym.init_printing(use_unicode=True) # In[2]: H = [20,25,30,35,40,45,50] f = [101,115, 92,64,60,50,49] plt.scatter(H,f) plt.xlabel('Hormone Level') plt.ylabel('Fatalities') f = np.matrix(f).T # We want to determine a line that is expressed by the following equation # # $$f = aH + b,$$ # # to approximate the connection between Hormone dosage ($H$) and Fatalities $f$. # That is, we want to find $a$ (slope) and $b$ (y-intercept) for this line. First we define the variable $ # x = \left[ # \begin{matrix} # a \\ # b # \end{matrix}
from statsmodels.tsa.seasonal import seasonal_decompose '''Decomposiçãp da série temporal para o produção total onshore de gás natural''' #Preparação do dataframe para a decomposição temporal dateparse = lambda dates: pd.datetime.strptime(dates, '%Y') data = pd.read_csv('Produção_gas_natural_total_onshore_serie_temporal.csv', parse_dates = ['Ano'], index_col = 'Ano', date_parser = dateparse) data = data.drop('Unnamed: 0', axis = 1) #Visualização do gráfico da série temporal ts = data['Produção de gás natural (m³)'] plt.figure(figsize = (10, 5)) plt.xlabel('Anos') plt.ylabel('Produção de gás natural (m³)') plt.plot(ts) #Aplicação da decomposição da série temporal decomposicao = seasonal_decompose(ts) tendencia = decomposicao.trend sazonal = decomposicao.seasonal residuo = decomposicao.resid plt.plot(tendencia) plt.plot(sazonal) plt.plot(residuo) plt.figure(figsize = (10, 5)) plt.subplot(4, 1, 1)
#!/usr/bin/python3 import numpy as np import matplotlib.pylab as plt from scipy.stats import linregress data = np.loadtxt("ns_128.txt") y, x = np.histogram(data, bins=200, range=[0, 200]) x = x[:200] x = np.log10(x) y = np.log10(y) mask = np.isfinite(x) & np.isfinite(y) slope, intercept, r_value, p_value, std_err = linregress(x[mask], y[mask]) # Tengo errores de division por cero # Hay que eliminar los ceros primero # Puedo usar menos bins # Ademas para el ajuste necesito quedarme solo # con la parte lineal, eso hay que hacerlo a mano plt.plot(x[mask], y[mask], 'ro') plt.plot(x[mask], slope * x[mask] + intercept, 'b') plt.ylabel(r'$n_{s}(p_c)$ (log)') plt.xlabel(r'Tamaño de cluster s (log)') plt.savefig('nspctau.png') print("Tau: ", -slope) plt.show()
solver_params['collision_model']='srt' solver_params['phrqc_flags']={} solver_params['phrqc_flags']['only_interface']=True #solver_params['phrqc_flags']['smart_run']=True #solver_params['phrqc_smart_run_tol']=1e-8 rt= yantra.PhrqcReactiveTransport('AdvectionDiffusion', domain, domain_params,{},solver_params) #%%run model time=[] AvgCa =[] iters = 2 while rt.iters < iters: #rt.time<=1:#20 rt.advance() AvgCa.append(np.sum(rt.fluid.Ca.c)/np.sum(rt.fluid.Ca.nodetype<=0)) time.append(rt.time) #%%plot results plt.figure() plt.plot(time,AvgCa) plt.xlabel('Time [s]') plt.ylabel('Avg. Ca conc in aqeuous phase [mM]') plt.show() plt.figure() plt.imshow(rt.fluid.Ca.c) plt.colorbar() plt.title('Ca concentarion [mol/l]') plt.show() print(rt.fluid.Ca._ss[3:8,3:8] + rt.fluid.Ca._c[3:8,3:8]) print(rt.solid.portlandite.c[5,5])
# specify the lasso regression model model = LassoLarsCV(cv=10, precompute=False).fit(pred_train, tar_train) # print variable names and regression coefficients print(dict(zip(predictors.columns, model.coef_))) # plot coefficient progression m_log_alphas = -np.log10(model.alphas_) ax = plt.gca() plt.plot(m_log_alphas, model.coef_path_.T) plt.axvline(-np.log10(model.alpha_), linestyle='--', color='k', label='alpha CV') plt.ylabel('Regression Coefficients') plt.xlabel('-log(alpha)') plt.title('Regression Coefficients Progression for Lasso Paths') # plot mean square error for each fold m_log_alphascv = -np.log10(model.cv_alphas_) plt.figure() plt.plot(m_log_alphascv, model.mse_path_, ':') plt.plot(m_log_alphascv, model.mse_path_.mean(axis=-1), 'k', label='Average across the folds', linewidth=2) plt.axvline(-np.log10(model.alpha_), linestyle='--', color='k', label='alpha CV')
####output f = open('workfile','w') f.write("r1\ttheta\tsexp\tstheo\tmiller\ta\n") for i in range(0,len(a1)): f.write(str(round(r1_mess[i],2))+ "\t" + str( round(theta1[i],2)) + "\t" + str( round(s_exp1[i],2)) + "\t" + str(round(s_theo1[i],2)) + "\t" + str(h1[i])+str(k1[i])+str(l1[i]) +str("\t") + str(round(a1[i],2))) f.write("\n") f.write("\n\n\n") f.write("r2\ttheta\tsexp\tstheo\tmiller\ta\n") for i in range(0,len(a2)): f.write(str(round(r2_mess[i],2))+ "\t" + str( round(theta2[i],2)) + "\t" + str( round(s_exp2[i],2)) + "\t" + str(round(s_theo2[i],2)) + "\t" + str(h2[i])+str(k2[i])+str(l2[i]) +str("\t")+ str(round(a2[i],2))) f.write("\n") f.close() plt.plot(x,fit1) plt.xlim((0,1)) plt.title("Korrektur zum Gitterparameter der ersten Probe") plt.xlabel(r"cos$^2 (\theta)$") plt.ylabel("Gitterparameter $a$") #plt.legend(loc=2) #plt.plot(x,fit2) ax.scatter(cosSquare1, a1) #plt.savefig("a1",dpi=100) #ax.scatter(cosSquare2, a2) #plt.savefig("a2",dpi=100) plt.show()
def df(x): return 0.02 * x + 0.1 def analyticLine(f, x): a = df(x) b = f(x) - a * x return lambda t: a * t + b def numLine(f, x): a = numericalDifferentiation(f, x) b = f(x) - a * x return lambda t: a * t + b x = np.arange(0.0, 20.0, 0.1) #x = np.arange(0.0, 100.0, 0.1) plt.xlabel('x') plt.ylabel('f(x)') plt.plot(x, f(x)) plt.plot(x, analyticLine(f, 5)(x)) plt.plot(x, analyticLine(f, 10)(x)) plt.plot(x, numLine(f, 5)(x), linestyle='--') plt.plot(x, numLine(f, 10)(x), linestyle='--') #for i in range(1, 100): # plt.plot(x, numLine(f, i)(x)) plt.show()
# mean_auc = auc(mean_fpr, mean_tpr) # std_auc = np.std(aucs) # plt.plot(mean_fpr, mean_tpr, color='b', # label=r'Mean ROC (AUC = %0.3f $\pm$ %0.3f)' % (mean_auc, std_auc), # lw=2, alpha=.8) # std_tpr = np.std(tprs, axis=0) # tprs_upper = np.minimum(mean_tpr + 3*std_tpr, 1) # tprs_lower = np.maximum(mean_tpr - 3*std_tpr, 0) # plt.fill_between(mean_fpr, tprs_lower, tprs_upper, color='grey', alpha=.5, # label=r'$\pm$ 3 std. dev.') plt.xlim([0, 1]) plt.ylim([0, 1]) plt.plot([0, 1], [0, 1], 'k--') plt.xlabel('False Positive Rate') plt.ylabel('True Positive Rate') plt.title('Receiver operating characteristic example') plt.legend(loc="lower right") epochs_list = range(1, epochs+1) plt.figure(2) for i in range(nb_K_Fold-1): plt.plot(epochs_list, acc_list[i], 'blue', label='Training acc') plt.plot(epochs_list, val_acc_list[i], 'red', label='Validation acc') plt.figure(3)
def plot_table(*positional_parameters, errorbars=None, xrange=None, yrange=None, title="", xtitle="", ytitle="", show=1, legend=None, legend_position=None, color=None, xlog=False, ylog=False): n_arguments = len(positional_parameters) if n_arguments == 0: return fig = plt.figure() if n_arguments == 1: y = positional_parameters[0] x = np.arange(y.size) plt.plot(x, y, label=legend) elif n_arguments == 2: x = positional_parameters[0] y = positional_parameters[1] if len(y.shape) == 1: y = np.reshape(y, (1, y.size)) if isinstance(legend, str): legend = [legend] if isinstance(color, str): color = [color] for i in range(y.shape[0]): if legend is None: ilegend = None else: ilegend = legend[i] if color is None: icolor = None else: icolor = color[i] if errorbars is None: plt.plot(x, y[i], label=ilegend, color=icolor) else: plt.errorbar(x, y[i], yerr=errorbars[i], label=ilegend, color=icolor) else: raise Exception("Incorrect number of arguments") ax = plt.subplot(111) if xlog: ax.set_xscale("log") if ylog: ax.set_yscale("log") if legend is not None: if legend_position is None: legend_position = (1.1, 1.05) ax.legend(bbox_to_anchor=legend_position) plt.xlim(xrange) plt.ylim(yrange) plt.title(title) plt.xlabel(xtitle) plt.ylabel(ytitle) if show: plt.show() return fig
import numpy as np import matplotlib.pylab as plt from p47_ステップ関数のグラフ import step_function from p48_シグモイド関数 import sigmoid if __name__ == '__main__': x = np.arange(-5.0, 5.0, 0.1) y1 = step_function(x) y2 = sigmoid(x) plt.plot(x, y1, label="step") plt.plot(x, y2, linestyle="--", label="sigmoid") # 破線で描画 plt.xlabel("x") plt.ylabel("y") plt.title("step & sigmoid") plt.legend( ) # plt.legend(bbox_to_anchor=(1, 1), loc='upper right', borderaxespad=0, fontsize=18) plt.ylim(-0.1, 1.1) plt.show()
# 1エポックごとに認識精度算出 if i % iter_per_epoch == 0: train_acc = network.accuracy(x_train, t_train) test_acc = network.accuracy(x_test, t_test) train_acc_list.append(train_acc) test_acc_list.append(test_acc) # 経過表示 print(f"[更新数]{i: >4} [損失関数の値]{loss:.4f} " f"[訓練データの認識精度]{train_acc:.4f} [テストデータの認識精度]{test_acc:.4f}") #! 損失関数の値の推移を描画 x = np.arange(len(train_loss_list)) plt.plot(x, train_loss_list, label='loss') plt.xlabel("iteration") plt.ylabel("loss") plt.xlim(left=0) plt.ylim(bottom=0) plt.show() #! 訓練データとテストデータの認識制度の推移を描画 x2 = np.arange(len(train_acc_list)) plt.plot(x2, train_acc_list, label='train acc') plt.plot(x2, test_acc_list, label='test acc', linestyle='--') plt.xlabel("epochs") #?エポック数:一つの訓練データを何回繰り返して学習させるか plt.ylabel("accuracy") plt.xlim(left=0) plt.ylim(0, 1.0) plt.legend(loc='lower right') #?アンカーの位置(loc)を右下にする plt.show()
def plot(*positional_parameters, title="", xtitle="", ytitle="", xrange=None, yrange=None, show=1, legend=None, legend_position=None, color=None, marker=None, linestyle=None, xlog=False, ylog=False): if isinstance(positional_parameters, tuple): if len(positional_parameters ) == 1: # in the cvase that input is a tuple with all curves positional_parameters = positional_parameters[0] n_arguments = len(positional_parameters) if n_arguments == 0: return fig = plt.figure() if n_arguments == 1: y = positional_parameters[0] x = np.arange(y.size) if linestyle == None: linestyle = '-' plt.plot(x, y, label=legend, marker=marker, color=color, linestyle=linestyle) elif n_arguments == 2: x = positional_parameters[0] y = positional_parameters[1] if linestyle == None: linestyle = '-' plt.plot(x, y, label=legend, color=color, marker=marker, linestyle=linestyle) elif n_arguments == 4: x1 = positional_parameters[0] y1 = positional_parameters[1] x2 = positional_parameters[2] y2 = positional_parameters[3] if legend is None: legend1 = None legend2 = None else: legend1 = legend[0] legend2 = legend[1] if color is None: color1 = None color2 = None else: color1 = color[0] color2 = color[1] if marker is None: marker1 = None marker2 = None else: marker1 = marker[0] marker2 = marker[1] if linestyle is None: linestyle1 = '-' linestyle2 = '-' else: linestyle1 = linestyle[0] linestyle2 = linestyle[1] plt.plot(x1, y1, label=legend1, marker=marker1, linestyle=linestyle1, color=color1) plt.plot(x2, y2, label=legend2, marker=marker2, linestyle=linestyle2, color=color2) elif n_arguments == 6: x1 = positional_parameters[0] y1 = positional_parameters[1] x2 = positional_parameters[2] y2 = positional_parameters[3] x3 = positional_parameters[4] y3 = positional_parameters[5] if legend is None: legend1 = None legend2 = None legend3 = None else: legend1 = legend[0] legend2 = legend[1] legend3 = legend[2] if color is None: color1 = None color2 = None color3 = None else: color1 = color[0] color2 = color[1] color3 = color[2] if marker is None: marker1 = None marker2 = None marker3 = None else: marker1 = marker[0] marker2 = marker[1] marker3 = marker[2] if linestyle is None: linestyle1 = '-' linestyle2 = '-' linestyle3 = '-' else: linestyle1 = linestyle[0] linestyle2 = linestyle[1] linestyle3 = linestyle[2] plt.plot(x1, y1, label=legend1, marker=marker1, linestyle=linestyle1, color=color1) plt.plot(x2, y2, label=legend2, marker=marker2, linestyle=linestyle2, color=color2) plt.plot(x3, y3, label=legend3, marker=marker3, linestyle=linestyle3, color=color3) elif n_arguments == 8: x1 = positional_parameters[0] y1 = positional_parameters[1] x2 = positional_parameters[2] y2 = positional_parameters[3] x3 = positional_parameters[4] y3 = positional_parameters[5] x4 = positional_parameters[6] y4 = positional_parameters[7] if legend is None: legend1 = None legend2 = None legend3 = None legend4 = None else: legend1 = legend[0] legend2 = legend[1] legend3 = legend[2] legend4 = legend[3] if color is None: color1 = None color2 = None color3 = None color4 = None else: color1 = color[0] color2 = color[1] color3 = color[2] color4 = color[3] if marker is None: marker1 = None marker2 = None marker3 = None marker4 = None else: marker1 = marker[0] marker2 = marker[1] marker3 = marker[2] marker4 = marker[3] if linestyle is None: linestyle1 = '-' linestyle2 = '-' linestyle3 = '-' linestyle4 = '-' else: linestyle1 = linestyle[0] linestyle2 = linestyle[1] linestyle3 = linestyle[2] linestyle4 = linestyle[3] plt.plot(x1, y1, label=legend1, marker=marker1, linestyle=linestyle1, color=color1) plt.plot(x2, y2, label=legend2, marker=marker2, linestyle=linestyle2, color=color2) plt.plot(x3, y3, label=legend3, marker=marker3, linestyle=linestyle3, color=color3) plt.plot(x4, y4, label=legend4, marker=marker4, linestyle=linestyle4, color=color4) else: raise Exception("Incorrect number of arguments, maximum 4 data sets") # x = positional_parameters[0] # y = positional_parameters[1] # plt.plot(x,y,label=legend) ax = plt.subplot(111) if legend is not None: ax.legend(bbox_to_anchor=legend_position) if xlog: ax.set_xscale("log") if ylog: ax.set_yscale("log") plt.xlim(xrange) plt.ylim(yrange) plt.title(title) plt.xlabel(xtitle) plt.ylabel(ytitle) if show: plt.show() return fig
plt.figure(figsize=(10, 7.5)) # Remove the plot frame lines. ax = plt.subplot(111) ax.spines["top"].set_visible(False) ax.spines["bottom"].set_visible(False) ax.spines["right"].set_visible(False) ax.spines["left"].set_visible(False) ax.get_xaxis().tick_bottom() ax.get_yaxis().tick_left() plt.ylabel("Bikes in use", fontsize=15) plt.title("DublinBikes average weekday usage", fontsize=22) plt.xlabel("\nData source: CityBikes http://api.citybik.es/ | " "Author: James Lawlor @lawlorino", fontsize=10) ax.plot(ts, df['mean'], color='black') ax.fill_between(ts, df['mean'] - df['std'], df['mean'] + df['std'], facecolor='blue', alpha=0.1) # ax.grid() plt.xlim(ts[0],ts[-1]) # plt.ylim(0, np.max(df['mean'] + df['std']) + 100) ax.set_ylim(bottom = 0) ax.xaxis.set_major_locator(dates.HourLocator(interval=2)) hfmt = dates.DateFormatter('%H:%M') ax.xaxis.set_major_formatter(hfmt) plt.show()
# #np.savetxt('results/data/rho_norm_x001.out', rho_norm) plot1 =plt.plot( rho_norm/sqrt(len(rho_norm))) ax=plt.subplot(111) ax.set_xlim(1, 100) plt.annotate(r'$ \Delta x_{PDE} = \Delta x_{SDE} = 0.005$', xy=(60, 0.15), xytext=(55, 0.20), fontsize=13) plt.annotate(r'$ N=10000$', xy=(60, 0.15), xytext=(55, 0.18), fontsize=13) #plt.xscale('log') #plt.yscale('log') #pl.ylabel(r'$T^*$', fontsize = 20) plt.xlabel('m', fontsize = 16) #plt.ylabel(r'$||\mathbb{E}(\mathbf{J}(\mathbf{U}_{SDE}) \cdot \mathbf{V})||_2 - ||\mathbf{J}(\mathbf{U}_{FP}) \cdot \mathbf{V})||_2 $', fontsize = 20) #plt.ylabel(r'$||\mathbb{E}\left[\mathbf{J}(\mathbf{U}_{SDE}) \cdot \mathbf{V} \right]- \mathbf{J}(\mathbf{U}_{FP}) \cdot \mathbf{V} )||_2 $', fontsize = 20) plt.ylabel(r'$\frac{||\mathbb{E}[\mathbf{\rho}_{SDE}(m) - \mathbf{\rho}_{FP}] ||_2 } {|| \mathbf{1}||_2} $', fontsize = 20) #plt.legend([plot1, plot2], loc='best') #, ['x=0.05', 'x=0.01']) #, loc='best') #, numpoints=1) #pl.legend([line1, line2, line3], 'best') #pl.legend( loc='best', numpoints = 1 ) #first_legend = pl.legend([line1], loc=1) #plt.legend(bbox_to_anchor=(1, 1), numpoints = 1 ) #pl.legend([line3], bbox_to_anchor=(0.3, 0.6)) #ax = pl.gca().add_artist(first_legend) #plt.savefig("results/Jve_sde-Jv_pde_compare.pdf") plt.show()
def sub_seek_dist(lists_cmd, options): ''' seek_dist_record=sub_seek_dist(lists_cmd,options) seek distance calcuation inputs lists_cmd: n samples x 3 for LBA, size, flags options: control parameters plot_fontsize: the figure's font size plot_figure: >=1: plot the figure; otherwise not; default 1 save_figure: >=1: save the figures export_report: >=1: export the figure/data into a ppt report_name: report name output_foldername: the output folder name for figures and report; default ='' offset_time: some trace is not started from zone. in this case. need to find the starting time of first event. spec_stack=[10,20,30]; % a vector specify the stack distance, for which we can collect the statistical value and output to the ppt file. for very large dataset ; otherwise specify some small numbers outputs seek_dist_record: structure for statistics of seek distance Author: [email protected] ''' if hasattr(options, 'plot_fontsize'): plot_fontsize = options.plot_fontsize else: plot_fontsize = 10 if hasattr(options, 'save_figure'): save_figure = options.save_figure else: save_figure = 1 if hasattr(options, 'plot_figure'): plot_figure = options.plot_figure else: plot_figure = 1 if hasattr(options, 'queue_len_setting'): queue_len_setting = options.queue_len_setting else: queue_len_setting = 2**(arange(0, 8, 1)) num_queue_setting = shape(queue_len_setting)[0] if hasattr(options, 'plot_flags'): plot_flags = options.plot_flags else: plot_flags = [ 'r', 'k--', 'b-.', 'b:', 'y--', 'r:', 'y:', 'r-.', 'k-.', 'y', 'g:' ] if len(plot_flags) < num_queue_setting: print('Error! The figure flags for legend is smaller than required') return seek_write_only = zeros((num_queue_setting, 10)) # 1 total R/W IO number, 2 sequnce number, 3 mean, 4 mean abs, 5 median, 6 mode, 7 mode couter, 8 min abs, 9 max abs, 10 std abs seek_read_only = zeros((num_queue_setting, 10)) seek_all = zeros((num_queue_setting, 10)) for queue_id in arange(0, num_queue_setting): print('Now check queue ID = ' + str(queue_id)) # write seq_cmd_count, write_cmd_count, total_cmd, queued_lba_distance = seek_distance_stack( queue_len_setting[queue_id], lists_cmd, 0, 0) if write_cmd_count > 0: x, xi = mode(queued_lba_distance) seek_write_only[queue_id, :] = [ total_cmd - write_cmd_count, seq_cmd_count, mean(queued_lba_distance), mean(abs(queued_lba_distance)), median(queued_lba_distance), x, xi, min(abs(queued_lba_distance)), max(abs(queued_lba_distance)), std(abs(queued_lba_distance)) ] # read seq_cmd_count, read_cmd_count, total_cmd, queued_lba_distance = seek_distance_stack( queue_len_setting[queue_id], lists_cmd, 1, 0) if read_cmd_count > 0: x, xi = mode(queued_lba_distance) seek_read_only[queue_id, :] = [ total_cmd - read_cmd_count, seq_cmd_count, mean(queued_lba_distance), mean(abs(queued_lba_distance)), median(queued_lba_distance), x, xi, min(abs(queued_lba_distance)), max(abs(queued_lba_distance)), std(abs(queued_lba_distance)) ] # combined seq_cmd_count, all_cmd_count, total_cmd, queued_lba_distance = seek_distance_stack( queue_len_setting[queue_id], lists_cmd, 2, 0) if all_cmd_count: x, xi = mode(queued_lba_distance) # write command number, sequential command number, average queue LBA distance, average absolute queue LBA distance, median, mode value,mode frequency,min, max, std seek_all[queue_id, :] = [ total_cmd - all_cmd_count, seq_cmd_count, mean(queued_lba_distance), mean(abs(queued_lba_distance)), median(queued_lba_distance), x, xi, min(abs(queued_lba_distance)), max(abs(queued_lba_distance)), std(abs(queued_lba_distance)) ] seek_dist_record = [] seek_dist_record = seek_dist_record_class(queue_len_setting, seek_all, seek_write_only, seek_read_only) if plot_figure == 1: figure() # hold(True) plot(transpose(queue_len_setting), seek_write_only[:, 6], 'b-') plot(transpose(queue_len_setting), seek_read_only[:, 6], 'r:') plot(transpose(queue_len_setting), seek_all[:, 6], 'k-.') xlabel('Queue length ') ylabel('Frequency') title('Mode Counter') legend(['write', 'read', 'combined']) savefig('sk_mode.eps') savefig('sk_mode.png') figure() # hold(True) plot(transpose(queue_len_setting), seek_write_only[:, 2], 'b-') plot(transpose(queue_len_setting), seek_read_only[:, 2], 'r:') plot(transpose(queue_len_setting), seek_all[:, 2], 'k-.') xlabel('Queue length ') ylabel('Value') title('Mean Value') legend(['write', 'read', 'combined']) savefig('sk_mean.eps') savefig('sk_mean.png') figure() # hold(True) plot(transpose(queue_len_setting), seek_write_only[:, 3], 'b-') plot(transpose(queue_len_setting), seek_read_only[:, 3], 'r:') plot(transpose(queue_len_setting), seek_all[:, 3], 'k-.') xlabel('Queue length ') ylabel('Value') title('Mean Absolute Value') legend(['write', 'read', 'combined']) savefig('sk_abs_mean.eps') savefig('sk_abs_mean.png') figure() # hold(True) plot(transpose(queue_len_setting), seek_write_only[:, 8], 'b-') plot(transpose(queue_len_setting), seek_read_only[:, 8], 'r:') plot(transpose(queue_len_setting), seek_all[:, 8], 'k-.') xlabel('Queue length ') ylabel('Value') title('Maximum Seek Distance') legend(['write', 'read', 'combined']) savefig('sk_max.eps') savefig('sk_max.png') # if options.export_report: # options.section_name='Seek Distance' # generate_ppt(options) # # string0=string_generate([queue_len_setting';seek_write_only(:,6)],20); # string0=['Mode value (write)=',string0]; # saveppt2(options.report_name,'f',0,'t',string0); # # string0=string_generate([queue_len_setting';seek_write_only(:,7)],20); # string0=['Mode count (write)=',string0]; # saveppt2(options.report_name,'f',0,'t',string0); # # string0=string_generate([queue_len_setting';seek_read_only(:,6)],20); # string0=['Mode value (read)=',string0]; # saveppt2(options.report_name,'f',0,'t',string0); # # string0=string_generate([queue_len_setting';seek_read_only(:,7)],20); # string0=['Mode count (read)=',string0]; # saveppt2(options.report_name,'f',0,'t',string0); return seek_dist_record
numImages = tiffStack.shape[0] # get first image zeroImage = tiffStack[0, :, :] # calculate threshold value adjImage = adjust(tiffStack[23, :, :], zeroImage) thresh = skf.threshold_triangle(adjImage) intensityArray = [] timeArray = [] timeMinutes = 0 for i in range(5, numImages, 6): iImage = tiffStack[i, :, :] adjImage = adjust(iImage, zeroImage) binaryImage = adjImage > thresh intensityTotal = np.sum(adjImage[binaryImage]) intensityArray.append(intensityTotal) timeArray.append(timeMinutes) timeMinutes = timeMinutes + 30 outFile.write('%8.2f\t%8.4e\n' % (timeMinutes, intensityTotal)) outFile.close() plt.plot(timeArray, intensityArray, linestyle='', marker='o') plt.xlabel('t [min]') plt.ylabel('N [rel]') plt.savefig(graphFileName, dpi=300) plt.show()
print(y_test.shape) model.eval() z = model(x_test) _,yhat = torch.max(z.data,1) correct += (yhat == y_test).sum().item() accuracy = correct/n_test print(accuracy) accuracy_list.append(accuracy) torch.save(model.state_dict(), "") x = np.arange(len(loss_list)) plt.plot(x,loss_list) plt.title('Average Loss per Epoch vs epoch') plt.xlabel('Epoch') plt.ylabel('Average loss per epoch') plt.show() x = np.arange(N_EPOCHS) plt.plot(x,accuracy_list) plt.title('Accuracy per Epoch vs epoch') plt.xlabel('Epoch') plt.ylabel('Accuracy') plt.show() #Testing look_up = {0: 'predicted: $5' , 1: 'predicted: $10' , 2: 'predicted: $20' , 3: 'predicted: $50'
count = 1 for avg_index in range(N_avg): for noise in noises: print('working on run {} of {}'.format(count, N_avg*N_noise)) print(' noise = {}'.format(noise)) count += 1 log_stream.flush() # run the demo on company metric_list = run_demo('company', noise=noise) for i, e in enumerate(cases): f1s[e][avg_index].append(metric_list[-4+i]['f1']) for case, f1_list in f1s.items(): # compute the average over all runs for each noise level f1s_T = list(map(list, zip(*f1_list))) avgs = [sum(f)/N_avg for f in f1s_T] plt.plot(noises, avgs) plt.legend(cases) plt.xlabel('noise') plt.ylabel('f1s') plt.show()
import sklearn # print(sklearn.metrics.accuracy_score(label_test,prediction)) print('f1: '+str(sklearn.metrics.f1_score(label_test,prediction,average='weighted'))) #weighted #macro #binary import matplotlib.pyplot as plt plt.plot() plt.scatter(feature_test['length'][np.bitwise_and(label_test == prediction,label_test=='car')], feature_test['width'][np.bitwise_and(label_test== prediction,label_test=='car')],color='g') plt.scatter(feature_test['length'][np.bitwise_and(label_test == prediction,label_test=='truck')], feature_test['width'][np.bitwise_and(label_test== prediction,label_test=='truck')],color='r') plt.scatter(feature_test['length'][label_test!=prediction],feature_test['width'][label_test!=prediction],color='k') plt.title('car_truck_classification_result')#显示图表标题 plt.xlabel('length')#x轴名称 plt.ylabel('width')#y轴名称 plt.legend(['car','truck','wrong']) # plt.grid(True)#显示网格线 plt.show()
from matplotlib import pylab # tripolar to uniform 2560 x 5120 nprocs = [ 1, 2, 4, 8, 16, ] times = [2.12e3, 1.18e3, 637, 368, 203] pylab.plot(nprocs, [times[0] / t for t in times], 'ko', nprocs, [times[0] / t for t in times], 'b-') pylab.title('ESMF conserve tripolar to uniform 2560x5120') pylab.plot(nprocs, nprocs, 'k--') pylab.xlabel('number of procs') pylab.ylabel('speedup') pylab.show()
import matplotlib.pylab as plt import numpy as np from matplotlib.backends.backend_pdf import PdfPages # mp.rc('font', family = 'serif', serif = 'cmr10') mp.rcParams['mathtext.fontset'] = 'cm' mp.rcParams.update({'font.size': 16}) n=3 α = np.array([0.8,1.0,1.2]) X = np.array([8/15,5/15,2/15]) with PdfPages('water_filling_plot.pdf') as pdf: axis = np.arange(0.5,n+1.5,1) index = axis+0.5 # X = np.asarray(x).flatten() Y = α + X # to include the last data point as a step, we need to repeat it A = np.concatenate((α,[α[-1]])) X = np.concatenate((X,[X[-1]])) Y = np.concatenate((Y,[Y[-1]])) plt.xticks(index) plt.xlim(0.5,n+0.5) plt.ylim(0,1.5) plt.step(axis,A,where='post',label =r'$\alpha$',lw=2) plt.step(axis,Y,where='post',label=r'$\alpha + x$',lw=2) plt.legend(loc='lower right') plt.xlabel('channel number') plt.ylabel('power level') pdf.savefig(bbox_inches='tight')
laynames = record_all.Layer.unique() layermap = {nm: i for i, nm in enumerate(laynames)} layermap_inall = {'conv1':0,'conv2':1,'conv3':2,'conv4':3,'conv5':4,'conv6':5,'conv7':6,'conv8':7,'conv9':8,\ 'conv10':9,'conv11':10,'conv12':11,'conv13':12,'fc1':13,'fc2':14,'fc3':15} #%% ax = plt.subplot() plt.scatter( record_all.manifMax.apply(lambda a: a[0]), record_all.manifMax_rf.apply(lambda a: a[0]), alpha=0.3, c=record_all.Layer.map(layermap_inall), ) plt.ylabel("Resized to match RF") plt.xlabel("Full size") addDiagonal(ax) ax.set_aspect(1) plt.title("Comparison of Max Score in Manifold Full vs Resized") plt.savefig(join(sumdir, "xscatter_MaxScore_cmp.png")) plt.savefig(join(sumdir, "xscatter_MaxScore_cmp.pdf")) plt.show() #%% def pairedJitter(ax, tab, varlist, jitter=True, xoffset=0, xsigma=0.25): if jitter: xjit = np.random.randn(tab.shape[0]) * xsigma else: xjit = np.zeros(tab.shape[0]) for i, varnm in enumerate(varlist):
1. Read in GDP per capita """ from pandas.io import wb wb.search('gdp.*capita.*const').iloc[:,:2] dat = wb.download(indicator='NY.GDP.PCAP.KD', country=['US', 'CA', 'MX'], start=2005, end=2008) dat['NY.GDP.PCAP.KD'].groupby(level=0).mean() wb.search('cell.*%').iloc[:,:2] ind = ['NY.GDP.PCAP.KD', 'IT.MOB.COV.ZS'] dat = wb.download(indicator=ind, country='all', start=2011, end=2011).dropna() dat.columns = ['gdp', 'cellphone'] """ 2. Read in complete csv (see Sargent-Stachurski) """ #%% # OLD PLOTS FROM ANOTHER PROGRAM plt.plot(calls_strikes, calls_mid, 'r', lw=2, label='calls') #plt.plot(calls_strikes, calls_ask, 'r', lw=2, label='calls ask') plt.plot(puts_strikes, puts_mid, 'b', lw=2, label='puts') plt.axis([120, 250, 0, 50]) plt.axvline(x=atm, color='k', linestyle='--', lw=2, label='atm') plt.xlabel('Strike') plt.ylabel('Option Price') plt.legend(loc='upperleft')
import matplotlib.pylab as plt days = [1, 2, 3, 4, 5] sleeping = [7, 8, 6, 11, 7] eating = [2, 3, 4, 3, 2] working = [7, 8, 7, 2, 2] playing = [8, 5, 7, 8, 13] plt.plot([], [], color='red', label=sleeping, linewidth=5) plt.plot([], [], color='blue', label=eating, linewidth=5) plt.plot([], [], color='green', label=working, linewidth=5) plt.plot([], [], color='black', label=playing, linewidth=5) plt.stackplot(days, sleeping, eating, working, playing, colors=['red', 'blue', 'green', 'black']) plt.xlabel('X') plt.ylabel('Y') plt.legend() plt.title('Intresting Graph\nCheck it Out') plt.show()