示例#1
0
文件: Depth.py 项目: airanmehr/bio
def plotDepth():
    sns.set_style("whitegrid", {"grid.color": "1", 'axes.linewidth': .5, "grid.linewidth": ".09"})
    sns.set_context("notebook", font_scale=1.4, rc={"lines.linewidth": 2.5})
    d = pd.read_pickle(utl.outpath + 'real/CD.F59.df').xs('D', level='READ', axis=1)
    (d.min(1) > 50).sum()

    (d > 50).sum().sum()

    z = pd.Series(np.ndarray.flatten(d.values))
    fontsize = 6
    mpl.rcParams.update({'font.size': fontsize})
    plt.figure(figsize=(6, 4), dpi=300);
    plt.subplot(2, 2, 1);
    z.value_counts().sort_index().plot()
    plt.xlim([0, 200]);
    plt.xlabel('Depth');
    plt.ylabel('Number of Measurments' + '\n (out of {:.1f}M)'.format(z.shape[0] / 1e6));
    plt.ticklabel_format(axis='y', style='sci', scilimits=(0, 0))
    plt.title('Scaled PDF')
    pplt.annotate('(A)', xpad=0.85, ypad=0.45, fontsize=fontsize)
    plt.axvline(50, linestyle='--', linewidth=1, color='k')
    pplt.setSize(plt.gca(), fontsize)
    plt.subplot(2, 2, 2);

    z.value_counts().sort_index().cumsum().plot()
    plt.xlim([0, 200])
    plt.ylim([-3e5, 2.05 * 1e7])
    plt.xlabel('Depth');
    plt.title('Scaled CDF')
    pplt.annotate('(B)', xpad=0.85, ypad=0.45, fontsize=fontsize)
    plt.axvline(50, linestyle='--', linewidth=1, color='k')
    pplt.setSize(plt.gca(), fontsize)
    plt.subplot(2, 2, 3);
    d.min(1).value_counts().sort_index().plot()
    plt.xlim([0, 100]);
    plt.xlabel('Minimum Depth of each Variant');
    plt.ylabel('Number of Variants' + '\n (out of {:.1f}M)'.format(d.shape[0] / 1e6));
    plt.ticklabel_format(axis='y', style='sci', scilimits=(0, 0))
    plt.rc('font', size=fontsize)
    pplt.annotate('(C)', xpad=0.85, ypad=0.45, fontsize=fontsize)
    plt.axvline(50, linestyle='--', linewidth=1, color='k')
    pplt.setSize(plt.gca(), fontsize)
    plt.subplot(2, 2, 4);
    d.min(1).value_counts().sort_index().cumsum().plot()
    plt.xlim([0, 60])
    plt.ylim([0.25 * -1e5, plt.ylim()[1]])
    plt.xlabel('Minimum Depth of each Variant');
    plt.ticklabel_format(axis='y', style='sci', scilimits=(0, 0))
    pplt.annotate('(D)', xpad=0.85, ypad=0.45, fontsize=fontsize)
    plt.axvline(50, linestyle='--', linewidth=1, color='k')
    pplt.setSize(plt.gca(), fontsize)
    plt.gcf().subplots_adjust(bottom=0.15)
    plt.gcf().tight_layout(h_pad=0.1)
    fontsize = 6
    mpl.rc('font', **{'family': 'serif', 'serif': ['Computer Modern'], 'size': fontsize});
    mpl.rc('text', usetex=True)
    mpl.rcParams.update({'font.size': 1})

    pplt.savefig('depth', 300)
    plt.show()
示例#2
0
def analyseHill(ekindicts):
    """make hist of n coefficents for hill fits"""

    import pylab
    pylab.rc('text', usetex=True)
    f=pylab.figure()
    f.suptitle('n distributions- No linear (case 3)')
    i=1
    for e in ekindicts:
        ekindata = ekindicts[e]
        proteins = ekindata.keys()
        nvals = []
        for prot in proteins:
            edata = ekindata[prot]
            E = EkinProject(data=edata)
            for d in E.datasets:
                fdata = E.getMetaData(d)
                if fdata != None and fdata.has_key('model'):
                    if fdata['model'] == 'Modified Hill':
                        n=fdata['n']
                        if n<5 and n>-5:
                            nvals.append(n)
                            print 'n=', n

        ax = f.add_subplot(2,2,i)
        n, b, patches = pylab.hist(nvals, 30, histtype='bar', alpha=0.8)
        std = round(numpy.std(nvals), 2)
        ave = round(numpy.mean(nvals), 2)
        ax.set_title(e +' mean= '+str(ave)+r' $\sigma$= '+str(std))
        i+=1
    f.subplots_adjust(hspace=0.4)
    f.savefig('n_hist.png')
    return
示例#3
0
def main():
    src_cv_img_1 = cv.LoadImage("data/gorskaya/images/1/g126.jpg")
    src_cv_img_gray_1 = cv.LoadImage("data/gorskaya/images/1/g126.jpg", 
        cv.CV_LOAD_IMAGE_GRAYSCALE)

    src_cv_img_2 = cv.LoadImage("data/gorskaya/images/1/g127.jpg")
    src_cv_img_gray_2 = cv.LoadImage("data/gorskaya/images/1/g127.jpg", 
        cv.CV_LOAD_IMAGE_GRAYSCALE)

    (keypoints_1, descriptors_1) = \
        cv.ExtractSURF(src_cv_img_gray_1, None, cv.CreateMemStorage(), 
            (0, 30000, 3, 1))
    (keypoints_2, descriptors_2) = \
        cv.ExtractSURF(src_cv_img_gray_2, None, cv.CreateMemStorage(), 
            (0, 30000, 3, 1))

    print("Found {0} and {1} keypoints".format(
        len(keypoints_1), len(keypoints_2)))

    src_arr_1 = array(src_cv_img_1[:, :])[:, :, ::-1]
    src_arr_2 = array(src_cv_img_2[:, :])[:, :, ::-1]

    pylab.rc('image', interpolation='nearest')

    pylab.subplot(121)
    pylab.imshow(src_arr_1)
    pylab.plot(*zip(*[k[0] for k in keypoints_1]), 
        marker='.', color='r', ls='')

    pylab.subplot(122)
    pylab.imshow(src_arr_2)
    pylab.plot(*zip(*[k[0] for k in keypoints_2]), 
        marker='.', color='r', ls='')

    pylab.show()
示例#4
0
def plot_all():
	from pylab import xlabel, ylabel, xlim, ylim, subplot, title, rc
	rc('text', usetex=True)
	subplot(141)
	title(r'(a)')
	plot_poly('xi',1,[.1,.2,.3],[.1,-10,-.5])
	xlabel(r'$\xi$')
	ylabel(r'$p_\xi$')
	subplot(142)
	title(r'(b)')
	plot_poly('xi',1,[.6,.2,.3],[.1,.5,-.5])
	xlim(-3,3)
	ylim(-12,12)
	xlabel(r'$\xi$')
	ylabel(r'$p_\xi$')
	subplot(143)
	title(r'(c)')
	plot_poly('xi',1,[.8,.2,.3],[.1,.5,-.5])
	xlim(-3,3)
	ylim(-12,12)
	xlabel(r'$\xi$')
	ylabel(r'$p_\xi$')
	subplot(144)
	title(r'(d)')
	plot_poly('eta',1,[70.,.2,.3],[.1,.5,-.5])
	xlim(-10,10)
	ylim(-200,200)
	xlabel(r'$\eta$')
	ylabel(r'$p_\eta$')
示例#5
0
def sim_results(obs, modes, stars, model, data):


    synth = model.generate_data(modes)
    synth_stats = model.summary_stats(synth)
    obs_stats = model.summary_stats(obs)


    f = plt.figure(figsize=(15,3))
    plt.suptitle('Obs Cand.:{}; Sim Cand.:{}'.format(obs.size, synth.size))
    plt.rc('legend', fontsize='xx-small', frameon=False)
    plt.subplot(121)
    bins = opt_bin(obs_stats[0],synth_stats[0])
    plt.hist(obs_stats[0], bins=bins, histtype='step', label='Data', lw=2)
    plt.hist(synth_stats[0], bins=bins, histtype='step', label='Simulation', lw=2)
    plt.xlabel(r'$\xi$')
    plt.legend()

    plt.subplot(122)
    bins = opt_bin(obs_stats[1],synth_stats[1])
    plt.hist(obs_stats[1], bins=np.arange(bins.min()-0.5, bins.max()+1.5,
                                          1),
             histtype='step', label='Data', log=True, lw=2)
    plt.hist(synth_stats[1], bins=np.arange(bins.min()-0.5, bins.max()+1.5,
                                            1),
             histtype='step', label='Simulation', log=True, lw=2)
    plt.xlabel(r'$N_p$')
    plt.legend()
def plot_earth_moon_obliquity():
	from numpy import linspace, array, arange
	from pylab import rc, plot, xlim, xticks, xlabel, ylabel
	import matplotlib.pyplot as plt
	import mpmath
	rc('text', usetex=True)
	fig = plt.figure()
	# Initial params.
	#params = {'m2':1.9e27,'r2':70000.e3,'rot2':0.00017585125448028,\
	#	'r1':1,'rot1':6.28*100,'i_a':0.5,'ht': 0,\
	#	'a':421700E3 / 4,'e':0.01,'i':0.8,'h':2}
	rot1 = 7.978282018665196e-08
	rot2 = 2.972e-06
	params = {'m2':1.98892e30,'r2':695500000.0,'rot2':rot2,\
		'r1':384748.e3,'rot1':rot1,'i_a':10. * 2*mpmath.pi()/360,'ht': 0,\
		'a':149597870700. * 0.1,'e':0.017,'i':7. * 2*mpmath.pi()/360,'h':mpmath.pi()/2}
	# Set parameters.
	sp.parameters = params
	# Period.
	period = sp.wp_period
	ob = sp.obliquity_time
	lspace = linspace(0,5*period,250)
	xlim(0,float(lspace[-1]))
	xlabel(r'$\textnormal{Time (Ma)}$')
	ylabel(r'$\textnormal{Obliquity }\left( ^\circ \right)$')
	ob_series = array([ob(t).real*(360/(2*mpmath.pi())) for t in lspace])
	plot(lspace,ob_series,'k-',linewidth=2)
	xticks(arange(xlim()[0],xlim()[1],365*24*3600*100000000),[r'$'+str(int(_)*100)+r'$' for _ in [t[0] for t in enumerate(arange(xlim()[0],xlim()[1],365*24*3600*100000000))]])
def plot_io_obliquity_2():
	from numpy import linspace, array, arange
	from pylab import rc, plot, xlim, xticks, xlabel, ylabel
	import matplotlib.pyplot as plt
	import mpmath
	rc('text', usetex=True)
	fig = plt.figure()
	# Initial params.
	#params = {'m2':1.9e27,'r2':70000.e3,'rot2':0.00017585125448028,\
	#	'r1':1,'rot1':6.28*100,'i_a':0.5,'ht': 0,\
	#	'a':421700E3 / 4,'e':0.01,'i':0.8,'h':2}
	params = {'m2':1.9e27,'r2':70000.e3,'rot2':0.00017585125448028,\
		'r1':1821E3,'rot1':6.28/(21 * 3600),'i_a':0.17453,'ht': 0,\
		'a':421700E3,'e':0.05,'i':0.349,'h':0.35}
	# Set parameters.
	sp.parameters = params
	# Period.
	period = sp.wp_period
	ob = sp.obliquity_time
	lspace = linspace(0,5*period,250)
	xlim(0,float(lspace[-1]))
	xlabel(r'$\textnormal{Time (Ma)}$')
	ylabel(r'$\textnormal{Obliquity }\left( ^\circ \right)$')
	ob_series = array([ob(t).real*(360/(2*mpmath.pi())) for t in lspace])
	plot(lspace,ob_series,'k-',linewidth=2)
	xticks(arange(xlim()[0],xlim()[1],365*24*3600*1000000),[r'$'+str(int(_)*1)+r'$' for _ in [t[0] for t in enumerate(arange(xlim()[0],xlim()[1],365*24*3600*1000000))]])
def plot_pulsar_obliquity():
	from numpy import linspace, array, arange
	from pylab import rc, plot, xlim, xticks, xlabel, ylabel
	import matplotlib.pyplot as plt
	import mpmath
	rc('text', usetex=True)
	fig = plt.figure()
	# Initial params.
	rot1 = 1.76e-4
	rot2 = 1256.
	params = {'m2': 1.4 * 1.98892e30,'r2':20000.0,'rot2':rot2,\
		'r1':70000.e3/2,'rot1':rot1,'i_a':.5,'ht':0.,\
		'a':600000.e3,'e':.1,'i':0.8,'h':2}
	# Set parameters.
	sp.parameters = params
	# Period.
	period = sp.wp_period
	ob = sp.obliquity_time
	lspace = linspace(0,5*period,250)
	xlim(0,float(lspace[-1]))
	xlabel(r'$\textnormal{Time (years)}$')
	ylabel(r'$\textnormal{Obliquity }\left( ^\circ \right)$')
	ob_series = array([ob(t).real*(360/(2*mpmath.pi())) for t in lspace])
	plot(lspace,ob_series,'k-',linewidth=2)
	xticks(arange(xlim()[0],xlim()[1],365*24*3600*20),[r'$'+str(int(_)*20)+r'$' for _ in [t[0] for t in enumerate(arange(xlim()[0],xlim()[1],365*24*3600*20))]])
	return
	params = {'m2': 1.4 * 1.98892e30,'r2':20000.0,'rot2':rot2,\
		'r1':15000.e3/2,'rot1':rot1,'i_a':.5,'ht':0.,\
		'a':600000.e3,'e':.1,'i':0.8,'h':2}
	# Set parameters.
	sp.parameters = params
	# Period.
	ob = sp.obliquity_time
	ob_series2 = array([ob(t).real*(360/(2*mpmath.pi())) for t in lspace])
	plot(lspace,ob_series-ob_series2,'k-',linewidth=2)
def plot_probe_earth_obliquity():
	from numpy import linspace, array, arange
	from pylab import rc, plot, xlim, xticks, xlabel, ylabel
	import matplotlib.pyplot as plt
	import mpmath
	rc('text', usetex=True)
	fig = plt.figure()
	# Initial params.
	#params = {'m2':5.97E24,'r2':6371.e3,'rot2':6.28/(24.*3600),\
		#'r1':0.038,'rot1':6.28*3500/60,'i_a':0.5,'ht': 0,\
		#'a':7027E3,'e':0.01,'i':0.8,'h':2}
	params = {'m2':5.97E24,'r2':6371.e3,'rot2':6.28/(24.*3600),\
		'r1':0.038,'rot1':6.28*3400/60,'i_a':90.007 * 2*mpmath.pi()/360,'ht': 0,\
		'a':7013E3,'e':0.0014,'i':mpmath.pi()/2,'h':-mpmath.pi()/2}
	# Set parameters.
	sp.parameters = params
	# Period.
	period = sp.wp_period
	ob = sp.obliquity_time
	lspace = linspace(0,5*period,250)
	xlim(0,float(lspace[-1]))
	xlabel(r'$\textnormal{Time (ka)}$')
	ylabel(r'$\textnormal{Obliquity }\left( ^\circ \right)$')
	ob_series = array([ob(t).real*(360/(2*mpmath.pi())) for t in lspace])
	plot(lspace,ob_series,'k-',linewidth=2)
示例#10
0
def usetexTrue():
    py.rc('text', usetex=True)
    #py.rc('font', family='serif', size=16)
    py.rc('font', **{'family':'sans-serif', 'size':16})
    py.rc('axes', titlesize=20, labelsize=20)
    py.rc('xtick', labelsize=16)
    py.rc('ytick', labelsize=16)
示例#11
0
def plot_masses(ps, rs, scs, save=False, name=''):
    p.figure
    p.rc('text', usetex=True)
    p.rc('font', size=18)
    p.xlabel('$am_1 + am_2$')
    p.ylabel('$aM_{vs}$')
    legend = ()
    
    # Pions.
    xs, ys, es = zip(*[q.pt for q in ps])  # Unpack data.
    legend += p.errorbar(xs, ys, es, fmt='o')[0],

    # Rhoxs.
    #xs, ys, es = zip(*[r.pt for r in rxs])  # Unpack data.
    #legend += p.errorbar(xs, ys, es, fmt='o')[0],

    # Rhos.
    xs, ys, es = zip(*[r.pt for r in rs])  # Unpack data.
    legend += p.errorbar(xs, ys, es, fmt='o')[0],

    # Scalars.
    xs, ys, es = zip(*[r.pt for r in scs])  # Unpack data.
    legend += p.errorbar(xs, ys, es, fmt='o')[0],
    
    p.legend(legend, ('$\pi$', r'$\rho$', '$a_0$'), 'best')
    if save:
        p.savefig(name)
    else:
        p.show()
def plot_dis_sessions(sessions):
    fig=plt.figure(figsize=(12, 10), dpi=80)
    leg=[]
    sum=np.zeros(22)
    count =np.zeros(22)
    for i in range(0,len(sessions)-1):
        for j in range(i+1,len(sessions)):
            userA= get_rating_vector(sessions[i])
            userB= get_rating_vector(sessions[j])
            if len(userA)<len(userB):
                userB=userB[:len(userA)]
            elif len(userA)>len(userB):
                userA=userA[:len(userB)]
#             leg.append( ' vs '.join( [ get_name_from_session(sessions[i])  , get_name_from_session(sessions[j])]))
            dis=[get_kappa(A, B) for A,B in zip(userA, userB)]
            dis.append(0)
            dis=dis[-1:] + dis[:-1]
            sum[:len(dis)] += np.array(dis)
            count[:len(dis)] +=1
    idx= np.where(count)
    meandis= sum[idx]/count[idx]
    plt.plot(range(len(meandis)),meandis,linewidth=2)
    plt.rc('font', **{'family': 'serif', 'size':20, 'serif': ['Computer Modern']})
#     plt.rc('text', usetex=True)
    plt.xlabel('Iteration',fontsize=30)
    plt.title('Avg Pairwise Disagreement between Subjects ',fontsize=30, y=1.02)
    plt.ylabel('$\kappa$',fontsize=30)
    plt.grid()
    plt.savefig(path+'dis.png')
    plt.xlim([-0.5,plt.xlim()[1]+1])
    plt.ylim([-0.1,plt.ylim()[1]+1])
    plt.legend(['Avg Pairwise Disagreement'])
    
    plt.show()
示例#13
0
def plot_dwaf_data(realtime, file_name='data_plot.png', gauge=True):
    x = pl.date2num(realtime.date)
    y = realtime.q

    pl.clf()
    pl.figure(figsize=(7.5, 4.5))
    pl.rc('text', usetex=True)# TEX fonts
    pl.plot_date(x,y,'b-',linewidth=1)
    pl.grid(which='major')
    pl.grid(which='minor')

    if gauge:
        pl.ylabel(r'Flow rate (m$^3$s$^{-1}$)')
        title = 'Real-time flow -- %s [%s]' % (realtime.station_id[0:6], realtime.station_desc)
    else:
        title = 'Real-time capacity -- %s [%s]' % (realtime.station_id[0:6], realtime.station_desc)
        pl.ylabel('Percentage of F.S.C')

    labeled_days = DayLocator(interval=3)
    ticked_days = DayLocator()
    dayfmt = DateFormatter('%d/%m/%Y')

    ax = pl.gca()
    ax.xaxis.set_major_locator(labeled_days)
    ax.xaxis.set_major_formatter(dayfmt)
    ax.xaxis.set_minor_locator(ticked_days)

    pl.xticks(fontsize=10)
    pl.yticks(fontsize=10)

    pl.title(title, fontsize=14)

    pl.savefig(file_name, dpi=100)
def myfig( fig, small=True, marker=False ):
    all_defaults = get_all_defaults( small )
    params = get_params( small )
    pylab.rcParams.update( params )
    pylab.rc('font', **all_defaults[ 'font' ])
    for i, line in enumerate( fig.axes[0].lines ):
        defaults = get_defaults( i )
        keys = defaults.keys()
        keys.sort()
        for k in keys:
            k2=k
            if k.find('_marker') > -1:
                if marker:
                    k2 = k[:-7]
                else:
                    continue
            attr = getattr( line, 'set_' + k2, 'NOTFOUND' )
            if attr == 'NOTFOUND':
                continue
            attr( defaults[ k ] )
    leg = fig.axes[0].legend()
    if leg <> None:
        leg.set_visible(True)
    pylab.ion()
    return fig
示例#15
0
def computePlotROCs(paths,mode,mutpaths):
	allalphas = set()
	exps = []
	pylab.rc('text', usetex=True)
	for i in range(len(paths)):
		path = paths[i]
		mutpath = mutpaths[i]
		mutseq = open(mutpath,"r").readlines()[0]
		seq,struc,nbMut,profiles = loadMutationalProfiles(path)
		mutpos = getMutatedPositions(seq,mutseq)
		exps.append((path,mutseq,seq,struc,nbMut,profiles,mutpos))
		allalphas.update(profiles.keys())
	rocs = []
	lbls = []
	alphas = list(allalphas)
	alphas.sort()
	for alpha in alphas:
		c = []
		delta = 0
		for (path,mutseq,seq,struc,nbMut,profiles,mutpos) in exps:
			c += classifyProfile(profiles[alpha],seq,struc,mode,mutseq)
			delta += evaluatePrediction(profiles[alpha],seq,len(mutpos))
		roc = ROCData(c)
		rocs.append(roc)
		lbls.append("$\\alpha=%.1f,$ {\\sf AUC} $=%.1f\\%%$"%(alpha,(100.*roc.auc(0))))
		if len(paths)==1:
			cap = paths[0].split(os.sep)[-1]
		else:
			cap = "Multiple"
		print "%s\t%s\t%s\t%.2f\t%s\t%s\t%s" % (cap,mode,alpha,(100.*roc.auc(0)),delta,nbMut,len(mutpos))
	plt = plot_multiple_roc(rocs,"", lbls) 
	return plt
示例#16
0
 def setOptions(self, shape=None, grid=None, xscale=None, yscale=None,
                 showlegend=None, legendloc=None, linewidth=None,
                 graphtype=None, font=None, fontsize=None):
     """Set the options before plotting"""
     if shape != None:
         self.shape = shape
     if grid != None:
         self.grid = grid
     if xscale != None:
         self.xscale = xscale
     if yscale != None:
         self.yscale = yscale
     if showlegend != None:
         self.showlegend = showlegend
     if legendloc != None:
         self.legendloc = legendloc
     if linewidth != None:
         self.linewidth = linewidth
     if graphtype !=None:
         self.graphtype = graphtype
     if font != None:
         self.font = font
     if fontsize != None:
         self.fontsize = fontsize
     pylab.rc("font", family=self.font, size=self.fontsize)
     return
示例#17
0
文件: analyser.py 项目: kbstn/spotpy
def plot_objectivefunctiontraces(results,evaluation,algorithms,filename='Like_trace'):
    import matplotlib.pyplot as plt
    from matplotlib import colors
    cnames=list(colors.cnames)
    font = {'family' : 'calibri',
        'weight' : 'normal',
        'size'   : 20}
    plt.rc('font', **font)   
    fig=plt.figure(figsize=(16,3))
    xticks=[5000,15000]
    
    for i in range(len(results)):
        ax  = plt.subplot(1,len(results),i+1)
        likes=calc_like(results[i],evaluation)  
        ax.plot(likes,'b-')
        ax.set_ylim(0,25)
        ax.set_xlim(0,len(results[0]))
        ax.set_xlabel(algorithms[i])
        ax.xaxis.set_ticks(xticks)
        if i==0:
            ax.set_ylabel('RMSE')
            ax.yaxis.set_ticks([0,10,20])   
        else:
            ax.yaxis.set_ticks([])        
        
    plt.tight_layout()
    fig.savefig(str(filename)+'.png')
示例#18
0
def stellar_massftn():
    gadget2msun=10.e10
    boxsize = 47.0
    max_mag=-16.
    min_mag = -23.
    nbins=14
    hubble_h = 0.7
    #subfind_folder = "/mnt/lustre/scratch/cs390/nIFTy/62.5_dmSF/outputs/"
    #ahf_folder = "/mnt/lustre/scratch/cs390/nIFTy/62.5_dm/outputs/"
    
    firstfile = first1
    lastfile = last1

    filter = LGalaxyStruct.properties_used
    filter['DiskMass'] = True
    filter['BulgeMass'] = True

    #file_prefix = "SA_z0.00"    
    (nTrees,nGals,nTreeGals,gal) = read_lgal.readsnap_lgal(folder1,file_prefix,first1,last1,filter)
    massf = gadget2msun*gal['DiskMass']+gadget2msun*gal['BulgeMass']
    mass = numpy.log10(massf)
    stellarmass = pylab.histogram(mass,bins=20,range=(9.0,14.0))
    print stellarmass
    massftn_y = stellarmass[0]
    massftn_x = []
    for i in range(len(stellarmass[0])):
        massftn_x.append((stellarmass[1][i]+stellarmass[1][i+1])/2.)

    delta_logM = massftn_x[1]-massftn_x[0]
    pylab.rc('text', usetex=True)
    fig = pylab.figure()
    ax = fig.add_subplot(111)
    ax.plot(massftn_x,massftn_y/boxsize1**3./delta_logM,'r-',label=label1)

    firstfile = first2
    lastfile = last2

     
    (nTrees,nGals,nTreeGals,gal) = read_lgal.readsnap_lgal(folder2,file_prefix,first2,last2,filter)
    massf = gadget2msun*gal['DiskMass']+gadget2msun*gal['BulgeMass']
    mass = numpy.log10(massf)
    stellarmass = pylab.histogram(mass,bins=20,range=(9.0,14.0))
    print stellarmass
    massftn_y = stellarmass[0]
    massftn_x = []
    for i in range(len(stellarmass[0])):
        massftn_x.append((stellarmass[1][i]+stellarmass[1][i+1])/2.)
    ax.set_xlabel(r"$\log(M_\star/M_\odot$ $h)$")
    ax.set_ylabel(r"galaxies$/(Mpc^3 h^{-3})/\Delta \log(M_\star/M_\odot$ $h)$")
    ax.plot(massftn_x,massftn_y/boxsize2**3./delta_logM,'b-',label=label2)

    print "Stellar mass"
    for i in range(len(massftn_x)):
        print massftn_x[i],"\t",massftn_y[i]/boxsize**3./delta_logM
    ax.set_yscale("log")
    ax.legend(loc='upper right',ncol=1, fancybox=True)


    #pylab.show()
    pylab.savefig('stellar_mass.pdf',bbox_inches='tight')
示例#19
0
文件: tool.py 项目: abalckin/cwavenet
def plot(t, inp, wavenet, param, orig=None, target=None, xlabel='', ylabel=''):
    plb.rc('font', family='serif')
    plb.rc('font', size=13)
    plb.figure('Апроксимация')
    plb.subplot(212)
    if target is not None:
        plb.plot(t, target, label='d(t)', linestyle=':')
    if orig is not None:
        plb.plot(t, orig, label='y(t)')
    plb.xlabel('t')
    plb.plot(t, wavenet.sim(t, inp), linestyle='--', label='$\hat{y}(t)$')
    plb.legend(loc=0)
    plb.subplot(211)
    plb.ylabel('Энергия ошибки, E')
    plb.plot(param['e'][0])
    plb.xlabel('Эпохи, n')

    plb.figure("Основные веса")
    plb.subplot(131)
    plb.title('Масштабы, a')
    plb.plot(np.transpose(param['a']))
    plb.subplot(132)
    plb.title('Сдвиги, b')
    plb.plot(np.transpose(param['b']))
    plb.subplot(133)
    plb.title('Веса, w')
    plb.plot(np.transpose(param['w']))
    plb.figure("Расширенные веса")
    plb.subplot(121)
    plb.title('Параметры, p')
    plb.plot(np.transpose(param['p']))
    plb.subplot(122)
    plb.title('Смещение, c')
    plb.plot(param['c'][0])
示例#20
0
def plot_measurements(time_points, ydata):

    pl.rc("text", usetex = True)
    pl.rc("font", family="serif")

    pl.subplot2grid((4, 2), (0, 0))
    pl.plot(time_points, ydata[:,0])
    pl.title("Considered measurement data")
    pl.xlabel("t")
    pl.ylabel("X", rotation = 0, labelpad = 20)

    pl.subplot2grid((4, 2), (1, 0))
    pl.plot(time_points, ydata[:,1])
    pl.xlabel("t")
    pl.ylabel("Y", rotation = 0, labelpad = 15)

    pl.subplot2grid((4, 2), (2, 0))
    pl.plot(time_points, ydata[:,2])
    pl.xlabel("t")
    pl.ylabel(r"\phi", rotation = 0, labelpad = 15)

    pl.subplot2grid((4, 2), (3, 0))
    pl.plot(time_points, ydata[:,3])
    pl.xlabel("t")
    pl.ylabel("v", rotation = 0, labelpad = 20)

    pl.subplot2grid((4, 2), (0, 1), rowspan = 4)
    pl.plot(ydata[:,0], ydata[:, 1])
    pl.title("Considered racecar track (measured)")
    pl.xlabel("X")
    pl.ylabel("Y", rotation = 0, labelpad = 20)
    pl.show()
示例#21
0
def plot_simulation_results_initial_controls(time_points, y_sim):

    pl.rc("text", usetex = True)
    pl.rc("font", family="serif")

    pl.subplot2grid((4, 2), (0, 0))
    pl.plot(time_points, y_sim[:,0])
    pl.title("Simulation results for initial controls")
    pl.xlabel("t")
    pl.ylabel("X", rotation = 0, labelpad = 20)

    pl.subplot2grid((4, 2), (1, 0))
    pl.plot(time_points, y_sim[:,1])
    pl.xlabel("t")
    pl.ylabel("Y", rotation = 0, labelpad = 15)

    pl.subplot2grid((4, 2), (2, 0))
    pl.plot(time_points, y_sim[:,2])
    pl.xlabel("t")
    pl.ylabel(r"\phi", rotation = 0, labelpad = 15)

    pl.subplot2grid((4, 2), (3, 0))
    pl.plot(time_points, y_sim[:,3])
    pl.xlabel("t")
    pl.ylabel("v", rotation = 0, labelpad = 20)

    pl.subplot2grid((4, 2), (0, 1), rowspan = 4)
    pl.plot(y_sim[:,0], y_sim[:, 1])
    pl.title("Simulated race car path for initial controls")
    pl.xlabel("X")
    pl.ylabel("Y", rotation = 0, labelpad = 20)
    pl.show()
示例#22
0
文件: galex.py 项目: ivh/PyStarburst
def fooplot(curs,ax1=None,ax2=None):
    #P.figure(figsize=(10,4.96))
    if not ax1: ax1=P.axes([0.38,0.01,0.30,0.32])
    if not ax2: ax2=P.axes([0.68,0.01,0.31,0.32],sharey=ax1)
    P.rc('xtick.major', pad=-12)
    P.rc('xtick', labelsize=10)

    curs.execute('SELECT DISTINCT sid,z,Ha_w from sel ORDER BY fuv_lum desc')
    data=curs.fetchall()
    for sid,z,ha in data:
        fuv,beta=curs.execute('select max(fuv_lum),beta from sel where objID=%s'%sid).fetchone()

        if ha < 70: color='g';marker='o'
        elif ha > 70 and ha < 140: color='y';marker='s'
        elif ha > 140: color='r';marker='D'
        ax1.plot(-1*(beta or N.nan),N.log10(fuv),color=color,marker=marker)
        ax2.plot(N.log10(ha),N.log10(fuv),color=color,marker=marker)

    P.setp(ax1.get_yticklabels(), visible=False)
    P.setp(ax2.get_yticklabels(), fontsize=10)
    ax1.xaxis.labelpad=-19
    ax2.xaxis.labelpad=-19
    ax2.set_xlabel(r'$\log\,W(H_\alpha)$')
    ax1.set_ylabel(r'$\log(L_{FUV})$')
    ax1.set_xlabel(r'$\beta$')
    ax1.axis([-0.4,-1.8,8.75,10.45])
    ax2.axis([1.55,2.45,8.75,10.45])
    ax1.set_yticks([8.8, 9.2, 9.6,10,10.4])
    ax1.set_xticks([-0.5,-1.0,-1.5])
    ax2.set_xticks([1.8,2.0,2.2,2.4])
示例#23
0
def plot_ge( name_plot ):

	# distance between axes and ticks
	pl.rcParams['xtick.major.pad']='8'
	pl.rcParams['ytick.major.pad']='8'

	# set latex font
	pl.rc('text', usetex=True)
	pl.rc('font', **{'family': 'serif', 'serif': ['Computer Modern'], 'size': 20})


	pl.close('all')
	fig = pl.figure(figsize=(10.0, 5.0))
	ax = fig.add_subplot(111)
	fig.suptitle('GE, Janaury-February 2007', fontsize=20, fontweight='bold')

	den = 0.008
	N_max_day = 50
	
	sel_side = (df_ge.side==1) & (df_ge.day_trade_n < N_max_day)
	df_ge_buy = df_ge[sel_side]
	pl.hlines(df_ge_buy.day_trade_n, df_ge_buy.mm_s, df_ge_buy.mm_e, linestyles='solid', lw= pl.array(df_ge_buy.eta/den), color='blue', alpha=0.3)

	sel_side = (df_ge.side==-1) & (df_ge.day_trade_n < N_max_day)
	df_ge_sell = df_ge[sel_side]
	pl.hlines(df_ge_sell.day_trade_n, df_ge_sell.mm_s, df_ge_sell.mm_e, linestyles='solid', lw= pl.array(df_ge_sell.eta/den), color='red', alpha=0.3)


	ax.set_xlim([0,390])
	ax.set_ylim([N_max_day,-1])
	ax.set_aspect('auto')
	ax.set_xlabel('Trading minute')
	ax.set_ylabel('Trading day')
	pl.subplots_adjust(bottom=0.15)
	pl.savefig("../plot/" + name_plot + ".pdf")
def plot_benchmark_time_per_frame(ball_quantities, benchmark_results,
                                  title, pic_filename):
    import pylab
    fig = pylab.figure(figsize=(6.0, 11.0)) #size in inches
    fig.suptitle(title, fontsize=12)

    pylab.axis([0.0, 500, -10 * len(benchmark_results), 150]) # axis extension
    pylab.rc('axes', linewidth=3)     # thickening axes
 
    # axis labels
    pylab.xlabel(r"num balls", fontsize = 12, fontweight='bold')
    pylab.ylabel(r"time per frame in ms", fontsize = 12, fontweight='bold')

    # plot cases
    x = ball_quantities
    case_names = [ k for k in benchmark_results]
    case_names.sort()
    colors = [ 'b', 'r', 'g', 'm', '#95B9C7', '#EAC117', '#827839' ]
    for case, color in zip(case_names, colors):
        # convert time to ms
        res = [ v*1000 for v in benchmark_results[case]] 
        pylab.plot(x, res, color=color, label=case)

    # show the plot labels
    pylab.legend(loc='lower center')

    #pylab.show() # show the figure in a new window
    pylab.savefig(pic_filename)
示例#25
0
def plot_tmp_imp( name_plot ):

	# distance between axes and ticks
	pl.rcParams['xtick.major.pad']='8'
	pl.rcParams['ytick.major.pad']='8'

	# set latex font
	pl.rc('text', usetex=True)
	pl.rc('font', **{'family': 'serif', 'serif': ['Computer Modern'], 'size': 20})

	# plotting
	x_plf = pow(10,pl.linspace(-6,0,1000))

	pl.clf()
	p_pl, = pl.plot(x_plf,ff_pl(x_plf,par_pl[0],par_pl[1]), ls='--', color='Red')
	p_lg, = pl.plot(x_plf,ff_lg(x_plf,par_lg[0],par_lg[1]), ls='-', color='RoyalBlue')
	p_points, = pl.plot(df_imp_1d.pi,df_imp_1d.imp,'.', color='Black',ms=10)
	pl.xscale('log')
	pl.yscale('log')
	pl.xlabel('$\phi$')
	pl.ylabel('$\mathcal{I}_{tmp}(\Omega=\{ \phi \})$')
	pl.grid()
	pl.axis([0.00001,1,0.0001,0.1])

	leg_1 = '$\hat{Y} = $' + str("%.4f" % round(par_pl[0],4)) + '$\pm$' + str("%.4f" % round(vv_pl[0][0],4)) + ' $\hat{\delta} = $' + str("%.4f" % round(par_pl[1],4)) + '$\pm$' + str("%.4f" % round(vv_pl[1][1],4)) + ' $E_{RMS} = $' + str("%.4f" % round(pl.sqrt(chi_pl/len(df_imp_1d.imp)),4))
	leg_2 = '$\hat{a} = $' + str("%.3f" % round(par_lg[0],3)) + '$\pm$' + str("%.3f" % round(vv_lg[0][0],3)) + ' $\hat{b} = $' + str("%.0f" % round(par_lg[1],3)) + '$\pm$' + str("%.0f" % round(vv_lg[1][1],3)) + ' $E_{RMS} = $' + str("%.4f" % round(pl.sqrt(chi_lg/len(df_imp_1d.imp)),4))
	l1 = pl.legend([p_pl,p_lg], ['$f(\phi) = Y\phi^{\delta}$', '$g(\phi)= a \log_{10}(1+b\phi)$'], loc=2, prop={'size':15})
	l2 = pl.legend([p_pl,p_lg], [leg_1 ,leg_2 ], loc=4, prop={'size':15})
	pl.gca().add_artist(l1)
	pl.subplots_adjust(bottom=0.15)
	pl.subplots_adjust(left=0.17)
	pl.savefig("../plot/" + name_plot + ".pdf")
示例#26
0
文件: model.py 项目: kdz/pystemm
def graph_file(obj, func_name, param, range, highlights):
    ## plots the named function on obj, taking param over its range (start, end)
    ## highlights are pairs of (x_value, "Text_to_show") to annotate on the graph plot
    ## saves the plot to a file and returns full file name

    import numpy, pylab

    func = getattr(obj, func_name)
    f = numpy.vectorize(func)
    x = numpy.linspace(*range)
    y = f(x)
    pylab.rc('font', family='serif', size=20)
    pylab.plot(x, y)
    pylab.xlabel(param)
    pylab.ylabel(func_name)
    hi_pts = [pt for pt, txt in highlights]
    pylab.plot(hi_pts, f(hi_pts), 'rD')
    for pt, txt in highlights:
        pt_y = func(pt)
        ann = txt + "\n(%s,%s)" % (pt, pt_y)
        pylab.annotate(ann, xy=(pt, pt_y))

    import os, time

    file = os.path.dirname(__file__) + "/generated_graphs/%s.%s.%s.pdf" % (type(obj).__name__, func_name, time.time())
    pylab.savefig(file, dpi=300)
    pylab.close()
    return file
示例#27
0
文件: tool.py 项目: abalckin/cwavenet
def plot(t, inp, target, wavenet, param, orig=None, xlabel='', ylabel=''):
    plb.rc('font', family='serif')
    plb.rc('font', size=13)
    plb.figure('Апроксимация')
    plb.subplot(212)
    plb.plot(t, target, label='Модельный сигнал')
    if orig is not None:
        plb.plot(t, orig, label='Оригинал')
    plb.plot(t, wavenet.sim(t, inp), linestyle='--', label='Аппроксимация')
    plb.legend(loc=0)
    plb.subplot(211)
    plb.title('Суммарная квадратичная ошибка')
    plb.plot(param['e'][0])
    plb.xlabel('Эпохи')

    plb.figure("Основные веса")
    plb.subplot(131)
    plb.title('Масштабы, a')
    plb.plot(np.transpose(param['a']))
    plb.subplot(132)
    plb.title('Сдвиги, b')
    plb.plot(np.transpose(param['b']))
    plb.subplot(133)
    plb.title('Веса, w')
    plb.plot(np.transpose(param['w']))
    plb.figure("Расширенные веса")
    plb.subplot(121)
    plb.title('Параметры, p')
    plb.plot(np.transpose(param['p']))
    plb.subplot(122)
    plb.title('Смещение, c')
    plb.plot(param['c'][0])
示例#28
0
文件: bar.py 项目: ShannonCeb/viamics
def generate(sample_sequence_tuples, save_path = None):
    samples = [x[0] for x in sample_sequence_tuples]
    number_of_sequences = [x[1] for x in sample_sequence_tuples]

    pos = pylab.arange(len(number_of_sequences))+.5

    width = len(samples) / 5
    if width < 5:
        width = 5

    if width > 15:
        width = 15

    fig = pylab.figure(figsize=(width, 4))

    pylab.rcParams.update({'axes.linewidth' : 0, 'axes.axisbelow': False})
    pylab.rc('grid', color='0.80', linestyle='-', linewidth=0.1)
    pylab.grid(True)
    pylab.bar(pos, number_of_sequences, align='center', color='#EFADAD', linewidth=0.1)
    pylab.xticks(pos, samples, rotation=90, size='xx-small')
    pylab.xlim(xmax=len(samples))
    pylab.yticks(size='xx-small')
    pylab.ylabel('Number of sequences (%d samples)' % len(samples), size="small")

    if save_path:
        pylab.savefig(save_path)
    else:
        pylab.show()
def plot_color_maps(reverse=False):
    """
    Simple plotting function to run through and plot each color map
    Help for choosing which colormap to use
    """
    import pylab as plt
    from numpy import outer
    plt.rc('text', usetex=False)
    a=outer(plt.ones(10,),plt.arange(0,1,0.01))
    plt.figure(figsize=(5,15))
    plt.subplots_adjust(top=0.8,bottom=0.08,left=0.03,right=0.99)
    if reverse:
        maps=[m for m in plt.cm.datad]
        rr = 2
    else:
        maps=[m for m in plt.cm.datad if not m.endswith("_r")]
        rr = 1
    maps.sort()
    l=len(maps)+1
    title_dict = {'fontsize': 10,
                  'verticalalignment': 'center',
                  'horizontalalignment': 'left'}
    for i, m in enumerate(maps):
        plt.subplot(l,rr,i+1)
        plt.axis("off")
        plt.imshow(a,aspect='auto',cmap=plt.get_cmap(m),origin="lower")
        plt.text(1.01,0.5,m,fontdict=title_dict,transform=plt.gca().transAxes)
示例#30
0
    def plot(self):
        specs = pl.array( list(set([ l['spec'] for l in self.lines ])) )
        specs.sort()
        self.specs = specs

        pl.figure()
        pl.hold('on')
        pl.grid('on')
        pl.jet()

        lines = [] 
        lines_spec = list(pl.zeros(len(specs)))
        for i in range(0,len(self.lines)):
            ispc = pl.find( specs == self.lines[i]['spec'] )
            self.colr = pl.cm.get_cmap()( float(ispc)/len(specs) )
            wl = self.lines[i]['wave']
            ri = float(self.lines[i]['rel_int'])
            lines.append( pl.plot( [wl, wl], [0., ri if not isnan(ri) else 0.], '.-', color=self.colr )[0] )
            lines_spec[ispc] = lines[-1]
        datacursor(lines,formatter='x={x:8.3f}\ny={y:8.3f}'.format)

        pl.rc('text',usetex=True)
        pl.xlabel('$\lambda ~ [\AA]$')
        pl.ylabel('relative intensity [arb]')
        pl.title('Spectrum for '+self.spec+' from NIST ASD')

        if len(specs) > 1:
            pl.legend( lines_spec,specs )

        pl.show()
示例#31
0
文件: publish.py 项目: hdszju/autoxd
 def rc(self, *args, **kwargs):
     pl.rc(*args, **kwargs)
示例#32
0
                 order='F')
msk[msk < 0.01] = np.nan
pl.ylim([0, ylimit])
pl.imshow(msk, cmap='hot', alpha=.3)
pl.axis('off')
pl.subplot(3, 1, 3)
pl.imshow(np.reshape(A.tocsc()[:, sure_in_idx[idx_to_show]].mean(-1),
                     dims,
                     order='F'),
          cmap='hot')
pl.ylim([0, ylimit])
pl.axis('off')

font = {'family': 'Myriad Pro', 'weight': 'regular', 'size': 30}

pl.rc('font', **font)
#%

pl.figure()
counter = 0
for iid in sure_in_idx[np.hstack([idx_to_show, 7])]:
    counter += 1
    pl.subplot(7, 7, counter)
    mmsk = np.reshape(A.tocsc()[:, iid].todense(), dims, order='F')
    cx, cy = scipy.ndimage.measurements.center_of_mass(np.array(mmsk))
    cx = np.int(cx)
    cy = np.int(cy)
    print((cx, cy))
    pl.imshow(mmsk[np.maximum(cx - 15, 0):cx + 15,
                   np.maximum(cy - 15, 0):cy + 15],
              cmap='gray')
    def createKerdenSOMPlots(self):
        apFile.removeFilePattern(
            os.path.join(self.params['rundir'],
                         self.spectraTemporalFilesMask + ".png"))

        #logging.debug('Inside createKerdenSOMPlots')
        apDisplay.printMsg("Create Plots")
        codeVectorFileName = os.path.join(self.params['rundir'],
                                          self.timestamp + '.cod')
        f1 = open(codeVectorFileName, 'r')
        #Read first line, I need number of harmonic plus size
        line = f1.readline()
        splitline = line.split()
        numberHarmonic = int(splitline[0])
        xx = int(splitline[2])
        yy = int(splitline[3])
        numberCodevectors = xx * yy

        xmin = int(self.params['spectralowharmonic'])
        xmax = int(self.params['spectrahighharmonic'])
        #array with x and y values
        xvalues = []
        #fill x array with harmonic number
        for colNo in pylab.arange(xmin, xmax + 1):
            xvalues.append(colNo)

        #figure size in inches
        pylab.rcParams['figure.figsize'] = 1, 1
        pylab.rc("lines", linewidth=1.5)
        pylab.rc(('xtick', 'ytick', 'axes'), labelsize=4.0)  #fontsize

        #read code vector
        #compute y maximum
        ymax = 0.
        ymin = 150.
        for rowNo in range(numberCodevectors):
            line = f1.readline()
            splitLine = line.split()
            for colNo in pylab.arange(numberHarmonic):
                yval = float(splitLine[colNo])
                if ymax < yval:
                    ymax = yval
                if ymin > yval:
                    ymin = yval
        f1.close()
        ymax = math.ceil(ymax) + 1
        print "ymax ", ymax
        ymin = max(math.floor(ymin) - 1, 0)
        print "ymin ", ymin

        f1 = open(codeVectorFileName, 'r')
        #skip first line
        line = f1.readline()
        for rowNo in range(numberCodevectors):
            line = f1.readline()
            splitLine = line.split()
            #print line
            data = []
            for colNo in pylab.arange(numberHarmonic):
                data.append(float(splitLine[colNo]))
            print xvalues
            print data
            #clear previous plot
            pylab.clf()
            lines = pylab.plot(xvalues, data)
            pylab.ylim(ymin, ymax)
            pylab.xlim(xmin, xmax)
            pylab.xlabel('fold symmetry')
            pylab.ylabel('likelihood')
            pylab.xticks(xvalues)
            basefilename = os.path.join(
                self.params['rundir'],
                self.spectraTemporalFiles % (int(rowNo / yy), rowNo % xx))
            pylab.savefig(basefilename + ".png", dpi=256, format='png')
示例#34
0
def plotter(xaxis, yaxis, options, mode, colorless=0, legend=''):
    '''
	FORMAT AXES
	'''
    matplotlib.rc('xtick', labelsize=16)
    matplotlib.rc('ytick', labelsize=16)

    font = {'weight': 'bold', 'size': 16}
    matplotlib.rc('font', **font)

    #ax=plt.axes(frameon=False)
    ax = plt.axes()
    pylab.rc("axes", linewidth=2.0)

    yaxislabel = options.yaxislabel
    xaxislabel = options.yaxislabel

    if not yaxislabel:
        yaxislabel = "Y"
    if not xaxislabel:
        xaxislabel = "X"

    if options.logplot and yaxislabel:
        if "log" not in yaxislabel and "LOG" not in yaxislabel:
            yaxislabel = 'LOG(' + yaxislabel + ')'

    pylab.xlabel(options.xaxislabel, fontsize=14, fontweight='bold')
    pylab.ylabel(options.yaxislabel, fontsize=14, fontweight='bold')

    #pylab.ylim([-1,ylimvalmax+10])
    #xmin = min(xaxis)

    #pylab.xlim([-1,float(max(xaxis))+10])

    ax.get_xaxis().tick_bottom()
    ax.get_yaxis().tick_left()
    #ax.axes.get_xaxis().set_visible(True)
    #ax.axes.get_yaxis().set_visible(True)

    #xmin, xmax = ax.get_xaxis().get_view_interval()
    #ymin, ymax = ax.get_yaxis().get_view_interval()

    #ax.add_artist(Line2D((xmin, xmax+10), (ymin, ymin), color='k', linewidth=4))
    #ax.add_artist(Line2D((xmin, xmin), (ymin, ymax+10), color='k', linewidth=4))
    ax.tick_params(axis='both', reset=False, which='both', length=8, width=3)

    markernum = ''
    idee = ''

    #print "BOLD IS ON!"
    LW = 3
    if not markernum:
        LW = 2

    if colorless:
        #if not yminnonconvex:
        #
        #	print "in colorless plot, linest is", linest
        if mode != 'scatter':
            linest = '-'
            plt.plot(xaxis,
                     yaxis,
                     linewidth=LW,
                     linestyle=linest,
                     alpha=1,
                     color='k',
                     zorder=0,
                     label=idee)
        else:
            plt.scatter(xaxis,
                        yaxis,
                        marker='x',
                        edgecolor='k',
                        alpha=1,
                        zorder=1,
                        s=40,
                        facecolor='white',
                        linewidth=2)

        #	if idee and options.legend:
        #		#print "Idee is", idee
        #		legend(loc='upper left')
        #elif yminnonconvex:
        #plt.plot(xaxis, yaxis, linewidth=LW,linestyle=linest,alpha=1,color='k',zorder=0,label=idee)
        #plt.scatter(xaxis,yaxis,marker='x',edgecolor='k',alpha=1,zorder=1,s=40,facecolor='white',linewidth=2)

        if idee and legend:
            print("Idee is", idee)
            legend(loc='upper left')

        #if mark:
        #	plt.scatter(xaxis,yaxis,marker=mark,edgecolor='k',alpha=1,zorder=1,s=40,facecolor='white',linewidth=2)

    else:
        #if not yminnonconvex:
        #	print "I did NOT receive yminnonxonvex"
        #

        if mode != 'scatter':
            plt.plot(xaxis, yaxis, linewidth=LW, alpha=1, zorder=0, label=idee)
        else:
            plt.scatter(xaxis,
                        yaxis,
                        marker='x',
                        alpha=1,
                        zorder=1,
                        s=40,
                        linewidth=2)

        #
        #	if idee and options.legend:
        #		print "Idee is", idee
        #		legend(loc='upper left')
        #elif yminnonconvex:
        #	print "I DID receive yminnonxonvex"
        #	plt.plot(xaxis, yaxis, linewidth=LW,linestyle=linest,alpha=1,zorder=0,label=idee)

        if idee and legend:
            print("Idee is", idee)
            legend(loc='upper left')
            #plt.scatter(xaxis,yaxis,marker='x',alpha=0.5,zorder=1,s=40,linewidth=2)

        #if mark:
        #	plt.scatter(xaxis,yaxis,marker=mark,alpha=0.5,zorder=1,s=40,linewidth=2)
    return
示例#35
0
def spinparam_2x2():
    #Ez=[0.00, 0.05, 0.10, 0.20, 0.25, 0.30, 0.40, 0.50, 0.75, 1.00, 3.00]
    #Rz=[0.00, 0.25, 0.31, 0.39, 0.50, 0.75, 1.00, 1.50, 2.01, 2.64, 3.00, 3.55, 4.00, 5.06]
    #Rz=[1.00, 1.50, 2.01, 2.64, 3.00, 3.55, 4.00, 5.06]
    #Az=[1.532, 1.82, 3.00, 4.94]
    #Artz=[2.03, 2.99, 4.0]
    #Fz=[0.80, 0.90, 1.00, 1.10, 1.20, 1.30, 1.40, 1.50, 1.60, 1.70, 1.80, 1.90, 2.00, 2.20, 2.50, 2.60, 2.80, 3.00, 3.40, 3.82, 3.90, 4.00, 4.50, 5.00]
    #Fz=[1.00, 1.10, 1.20, 1.30, 1.40, 1.50, 1.60, 1.70, 1.80, 1.90, 2.00, 2.20, 2.50, 2.60, 2.80, 3.00, 3.40, 3.82, 3.90, 4.00, 4.50, 5.00]
    #Fz=[1.70, 1.80, 1.90, 2.00, 2.20, 2.50, 2.60, 2.80, 3.00, 3.40, 3.82, 3.90, 4.00, 4.50, 5.00]
    Ez = [1.00, 3.00]
    Rz = [1.00, 1.50, 2.01, 2.64, 3.00]
    Az = [1.532, 1.82, 2.0, 3.00]
    Artz = [2.03, 2.33, 2.99]
    Fz = [1.00, 1.20, 1.40, 1.60, 1.80, 2.00, 2.20, 2.50, 2.60, 2.80, 3.00]
    E_LBtime = cosmo.lookback_time(Ez)
    R_LBtime = cosmo.lookback_time(Rz)
    A_LBtime = cosmo.lookback_time(Az)
    Art_LBtime = cosmo.lookback_time(Artz)
    F_LBtime = cosmo.lookback_time(Fz)

    endstring = "_spinparameters.txt"  #this will average over everything in the halo

    #create 2-D numpy arrays.  First index is redshift, 2nd index is which lambda parameter:  Xz_array[redshift,lambda]
    simulation = "Enzo"
    redshift_array = Ez
    Ez_array = np.zeros(E_LBtime.shape[0] * 7).reshape(E_LBtime.shape[0], 7)
    for i in range(E_LBtime.shape[0]):
        fname = "saved_data/" + simulation + "_z" + str(
            abs(round(redshift_array[i], 2))) + endstring
        names, trash, Ez_array[i][:] = np.loadtxt(fname,
                                                  dtype={
                                                      'names':
                                                      ('variable_name',
                                                       'equalsign', 'value'),
                                                      'formats':
                                                      ('|S15', '|S8', np.float)
                                                  },
                                                  unpack=True)

    simulation = "Ramses"
    redshift_array = Rz
    Rz_array = np.zeros(R_LBtime.shape[0] * 7).reshape(R_LBtime.shape[0], 7)
    for i in range(R_LBtime.shape[0]):
        fname = "saved_data/" + simulation + "_z" + str(
            abs(round(redshift_array[i], 2))) + endstring
        names, trash, Rz_array[i][:] = np.loadtxt(fname,
                                                  dtype={
                                                      'names':
                                                      ('variable_name',
                                                       'equalsign', 'value'),
                                                      'formats':
                                                      ('|S15', '|S8', np.float)
                                                  },
                                                  unpack=True)

    simulation = "Art"
    redshift_array = Artz
    Artz_array = np.zeros(Art_LBtime.shape[0] * 7).reshape(
        Art_LBtime.shape[0], 7)
    for i in range(Art_LBtime.shape[0]):
        fname = "saved_data/" + simulation + "_z" + str(
            abs(round(redshift_array[i], 2))) + endstring
        names, trash, Artz_array[i][:] = np.loadtxt(
            fname,
            dtype={
                'names': ('variable_name', 'equalsign', 'value'),
                'formats': ('|S15', '|S8', np.float)
            },
            unpack=True)

    simulation = "Arepo"
    redshift_array = Az
    Az_array = np.zeros(A_LBtime.shape[0] * 7).reshape(A_LBtime.shape[0], 7)
    for i in range(A_LBtime.shape[0]):
        fname = "saved_data/" + simulation + "_z" + str(
            abs(round(redshift_array[i], 2))) + endstring
        names, trash, Az_array[i][:] = np.loadtxt(fname,
                                                  dtype={
                                                      'names':
                                                      ('variable_name',
                                                       'equalsign', 'value'),
                                                      'formats':
                                                      ('|S15', '|S8', np.float)
                                                  },
                                                  unpack=True)

    simulation = "Fire"
    redshift_array = Fz
    Fz_array = np.zeros(F_LBtime.shape[0] * 7).reshape(F_LBtime.shape[0], 7)
    for i in range(F_LBtime.shape[0]):
        fname = "saved_data/" + simulation + "_z" + str(
            abs(round(redshift_array[i], 2))) + endstring
        names, trash, Fz_array[i][:] = np.loadtxt(fname,
                                                  dtype={
                                                      'names':
                                                      ('variable_name',
                                                       'equalsign', 'value'),
                                                      'formats':
                                                      ('|S15', '|S8', np.float)
                                                  },
                                                  unpack=True)

    endstring = "_spinparameters_haloONLY.txt"  #this will average over everything in the halo but exclude the innter 0.1Rvir of material

    #create 2-D numpy arrays.  First index is redshift, 2nd index is which lambda parameter:  Xz_array[redshift,lambda]
    simulation = "Enzo"
    redshift_array = Ez
    Ez_array_H = np.zeros(E_LBtime.shape[0] * 7).reshape(E_LBtime.shape[0], 7)
    for i in range(E_LBtime.shape[0]):
        fname = "saved_data/" + simulation + "_z" + str(
            abs(round(redshift_array[i], 2))) + endstring
        names, trash, Ez_array_H[i][:] = np.loadtxt(
            fname,
            dtype={
                'names': ('variable_name', 'equalsign', 'value'),
                'formats': ('|S15', '|S8', np.float)
            },
            unpack=True)

    simulation = "Ramses"
    redshift_array = Rz
    Rz_array_H = np.zeros(R_LBtime.shape[0] * 7).reshape(R_LBtime.shape[0], 7)
    for i in range(R_LBtime.shape[0]):
        fname = "saved_data/" + simulation + "_z" + str(
            abs(round(redshift_array[i], 2))) + endstring
        names, trash, Rz_array_H[i][:] = np.loadtxt(
            fname,
            dtype={
                'names': ('variable_name', 'equalsign', 'value'),
                'formats': ('|S15', '|S8', np.float)
            },
            unpack=True)

    simulation = "Art"
    redshift_array = Artz
    Artz_array_H = np.zeros(Art_LBtime.shape[0] * 7).reshape(
        Art_LBtime.shape[0], 7)
    for i in range(Art_LBtime.shape[0]):
        fname = "saved_data/" + simulation + "_z" + str(
            abs(round(redshift_array[i], 2))) + endstring
        names, trash, Artz_array_H[i][:] = np.loadtxt(
            fname,
            dtype={
                'names': ('variable_name', 'equalsign', 'value'),
                'formats': ('|S15', '|S8', np.float)
            },
            unpack=True)

    simulation = "Arepo"
    redshift_array = Az
    Az_array_H = np.zeros(A_LBtime.shape[0] * 7).reshape(A_LBtime.shape[0], 7)
    for i in range(A_LBtime.shape[0]):
        fname = "saved_data/" + simulation + "_z" + str(
            abs(round(redshift_array[i], 2))) + endstring
        names, trash, Az_array_H[i][:] = np.loadtxt(
            fname,
            dtype={
                'names': ('variable_name', 'equalsign', 'value'),
                'formats': ('|S15', '|S8', np.float)
            },
            unpack=True)

    simulation = "Fire"
    redshift_array = Fz
    Fz_array_H = np.zeros(F_LBtime.shape[0] * 7).reshape(F_LBtime.shape[0], 7)
    for i in range(F_LBtime.shape[0]):
        fname = "saved_data/" + simulation + "_z" + str(
            abs(round(redshift_array[i], 2))) + endstring
        names, trash, Fz_array_H[i][:] = np.loadtxt(
            fname,
            dtype={
                'names': ('variable_name', 'equalsign', 'value'),
                'formats': ('|S15', '|S8', np.float)
            },
            unpack=True)

    print Ez_array[:, 5]
    print Ez_array_H[:, 5]

    #FOR PLOTS RECALL: First index is redshift, 2nd index is which lambda parameter:  Xz_array[redshift,lambda]
    #FOR lambda variables, recall the order is: tot, dark, stars, particles, gas, cold, hot

    z_tick_values = [4, 3, 2, 1.5, 1.25, 1.0,
                     0.9]  #max and min of this are limits of the plot.
    z_tick_value_labels = [' ', '3', '2', '1.5', '1.25', '1',
                           ' ']  #max and min of this are limits of the plot.
    z_tick_locations = cosmo.lookback_time(z_tick_values).value
    LBT_max = cosmo.lookback_time(np.max(z_tick_values)).value
    LBT_min = cosmo.lookback_time(np.min(z_tick_values)).value

    #make a 2x2 shared axes plot of the following 4 individual plots (shown afterwards)
    #fig = plt.figure(figsize=(10,10))
    fig, ((ax1, ax2), (ax3, ax4), (ax5, ax6)) = plt.subplots(3,
                                                             2,
                                                             sharex='col',
                                                             sharey='row',
                                                             figsize=(10, 15))
    fig.subplots_adjust(hspace=0)
    fig.subplots_adjust(wspace=0)
    ax1.set_ylabel('Spin Parameter $\lambda$')
    ax3.set_ylabel('Spin Parameter $\lambda$')
    ax5.set_ylabel('Spin Parameter $\lambda$')
    ax3.set_xlabel('Lookback Time [Gyr]')
    ax4.set_xlabel('Lookback Time [Gyr]')
    ax5.set_xlabel('Lookback Time [Gyr]')
    ax6.set_xlabel('Lookback Time [Gyr]')
    ax1.set_ylim(0.01, 0.3)
    ax3.set_ylim(0.00, 0.3)
    ax5.set_ylim(0.00, 0.3)
    ax3.set_xlim(LBT_max, LBT_min)
    ax4.set_xlim(LBT_max, LBT_min)
    ax1b = ax1.twiny()
    ax1b.set_xlabel('Redshift')
    ax1b.set_xlim(LBT_max, LBT_min)
    ax1b.set_xticks(z_tick_locations)
    ax1b.set_xticklabels(z_tick_value_labels)
    ax2b = ax2.twiny()
    ax2b.set_xlabel('Redshift')
    ax2b.set_xlim(LBT_max, LBT_min)
    ax2b.set_xticks(z_tick_locations)
    ax2b.set_xticklabels(z_tick_value_labels)
    ax1.plot(E_LBtime, Ez_array[:, 1], color='k', linewidth=2)
    ax1.plot(E_LBtime, Ez_array_H[:, 2], '--', color='y', linewidth=2)
    #ax1.plot(E_LBtime,Ez_array[:,4], color='m', linewidth=2)
    ax1.plot(E_LBtime, Ez_array_H[:, 5], ':', color='b', linewidth=2)
    ax1.plot(E_LBtime, Ez_array_H[:, 6], '-.', color='r', linewidth=2)
    ax2.plot(R_LBtime, Rz_array[:, 1], color='k', linewidth=2)
    ax2.plot(R_LBtime, Rz_array_H[:, 2], '--', color='y', linewidth=2)
    #ax2.plot(R_LBtime,Rz_array[:,4], color='m', linewidth=2)
    ax2.plot(R_LBtime, Rz_array_H[:, 5], ':', color='b', linewidth=2)
    ax2.plot(R_LBtime, Rz_array_H[:, 6], '-.', color='r', linewidth=2)
    ax3.plot(A_LBtime, Az_array[:, 1], color='k', linewidth=2)
    ax3.plot(A_LBtime, Az_array_H[:, 2], '--', color='y', linewidth=2)
    #ax3.plot(A_LBtime,Az_array[:,4], color='m', linewidth=2)
    ax3.plot(A_LBtime, Az_array_H[:, 5], ':', color='b', linewidth=2)
    ax3.plot(A_LBtime, Az_array_H[:, 6], '-.', color='r', linewidth=2)
    ax4.plot(F_LBtime, Fz_array[:, 1], color='k', linewidth=2)
    ax4.plot(F_LBtime, Fz_array_H[:, 2], '--', color='y', linewidth=2)
    #ax4.plot(F_LBtime,Fz_array[:,4], color='m', linewidth=2)
    ax4.plot(F_LBtime, Fz_array_H[:, 5], ':', color='b', linewidth=2)
    ax4.plot(F_LBtime, Fz_array_H[:, 6], '-.', color='r', linewidth=2)
    ax5.plot(Art_LBtime, Artz_array[:, 1], color='k', linewidth=2)
    ax5.plot(Art_LBtime, Artz_array_H[:, 2], '--', color='y', linewidth=2)
    #ax5.plot(Art_LBtime,Artz_array[:,4], color='m', linewidth=2)
    ax5.plot(Art_LBtime, Artz_array_H[:, 5], ':', color='b', linewidth=2)
    ax5.plot(Art_LBtime, Artz_array_H[:, 6], '-.', color='r', linewidth=2)
    #ax6.plot(Art_LBtime,Artz_array[:,6]*0, '-.', color='k', linewidth=2)
    ax2.legend(("Dark", "Stars", "Cold Gas", "Hot Gas"), frameon=False, loc=2)
    #ax6.legend(("Dark", "Stars", "Cold Gas", "Hot Gas"), frameon=False, loc=2)
    ax1.text(9.0, 0.27, 'Enzo', size='x-large')
    ax2.text(9.0, 0.27, 'Ramses', size='x-large')
    ax3.text(9.0, 0.27, 'Arepo', size='x-large')
    ax4.text(9.5, 0.27, 'Gizmo-PSPH', size='x-large')
    ax5.text(9.0, 0.27, 'Art', size='x-large')
    plt.savefig("ALL_2x2_allspins_vs_time.png", bbox_inches='tight')
    plt.close()

    Ecold_ratio = Ez_array_H[:, 5] / Ez_array[:, 1]
    Rcold_ratio = Rz_array_H[:, 5] / Rz_array[:, 1]
    Acold_ratio = Az_array_H[:, 5] / Az_array[:, 1]
    Fcold_ratio = Fz_array_H[:, 5] / Fz_array[:, 1]
    Artcold_ratio = Artz_array_H[:, 5] / Artz_array[:, 1]
    Ehot_ratio = Ez_array_H[:, 6] / Ez_array[:, 1]
    Rhot_ratio = Rz_array_H[:, 6] / Rz_array[:, 1]
    Ahot_ratio = Az_array_H[:, 6] / Az_array[:, 1]
    Fhot_ratio = Fz_array_H[:, 6] / Fz_array[:, 1]
    Arthot_ratio = Artz_array_H[:, 6] / Artz_array[:, 1]
    #Plot ratio of cold-gas to DM
    fig = plt.figure()
    plt.ylabel('$\lambda_{cold}$ / $\lambda_{DM}$')
    plt.ylim(0, 10)
    ax1 = fig.add_subplot(111)
    ax1.set_xlabel('Lookback Time [Gyr]')
    ax1.set_xlim(LBT_max, LBT_min)
    ax2 = ax1.twiny()
    ax2.set_xlabel('Redshift')
    ax2.set_xlim(LBT_max, LBT_min)
    ax2.set_xticks(z_tick_locations)
    ax2.set_xticklabels(z_tick_value_labels)
    ax1.plot(E_LBtime, Ez_array[:, 5] / Ez_array[:, 1], linewidth=2, color='k')
    ax1.plot(R_LBtime, Rz_array[:, 5] / Rz_array[:, 1], linewidth=2, color='g')
    ax1.plot(Art_LBtime,
             Artz_array[:, 5] / Artz_array[:, 1],
             linewidth=2,
             color='b')
    ax1.plot(A_LBtime, Az_array[:, 5] / Az_array[:, 1], linewidth=2, color='r')
    ax1.plot(F_LBtime, Fz_array[:, 5] / Fz_array[:, 1], linewidth=2, color='y')
    ax1.plot(E_LBtime,
             Ez_array[:, 6] / Ez_array[:, 1],
             ':',
             linewidth=2,
             color='k')
    ax1.plot(R_LBtime, Rz_array[:, 6] / Rz_array[:, 1], linewidth=2, color='g')
    ax1.plot(Art_LBtime,
             Artz_array[:, 6] / Artz_array[:, 1],
             ':',
             linewidth=2,
             color='b')
    ax1.plot(A_LBtime,
             Az_array[:, 6] / Az_array[:, 1],
             ':',
             linewidth=2,
             color='r')
    ax1.plot(F_LBtime,
             Fz_array[:, 6] / Fz_array[:, 1],
             ':',
             linewidth=2,
             color='y')
    ax1.plot([14, 0], [1.0, 1.0], linewidth=1, color='k')
    ax1.legend(("Enzo", "Ramses", "Art", "Arepo", "Fire"), frameon=False)
    plt.savefig("ALL_spin_ratio_vs_time.png")
    plt.close()

    P.rc('font', family='serif', size=15)
    bins = [
        0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6, 6.5, 7, 7.5, 8, 8.5,
        9
    ]

    P.figure()
    P.xlabel("$j_{\\rm cold}(>0.1R_{\\rm vir})$ / $j_{\\rm DM}$", fontsize=20)
    P.ylabel("Frequency", fontsize=20)
    P.xlim(0, 8)
    n, bins, patches = P.hist(
        [Ecold_ratio, Artcold_ratio, Rcold_ratio, Acold_ratio, Fcold_ratio],
        stacked=True,
        histtype='bar',
        bins=bins,
        normed=1)
    P.legend(["Enzo", "Art", "Ramses", "Arepo", "Fire"], frameon=False)
    P.tight_layout()
    P.savefig("ALL_coldspin_histogram.png")
    P.close()

    P.figure()
    P.xlim(0, 8)
    P.xlabel("$j_{\\rm hot}(>0.1R_{\\rm vir})$ / $j_{\\rm DM}$", fontsize=20)
    P.ylabel("Frequency", fontsize=20)
    n, bins, patches = P.hist(
        [Ehot_ratio, Arthot_ratio, Rhot_ratio, Ahot_ratio, Fhot_ratio],
        stacked=True,
        histtype='bar',
        bins=bins,
        normed=1)
    P.legend(["Enzo", "Art", "Ramses", "Arepo", "Fire"], frameon=False)
    P.tight_layout()
    P.savefig("ALL_hotspin_histogram.png")
    P.close()

    cold = []
    cold.extend(Ecold_ratio)
    cold.extend(Acold_ratio)
    cold.extend(Rcold_ratio)
    cold.extend(Fcold_ratio)
    cold.extend(Artcold_ratio)
    cold.sort()
    cold = np.array(cold)
    print "median, mean, stdev for cold ratios.....", cold[
        cold.shape[0] / 2], cold.mean(), cold.std()
    hot = []
    hot.extend(Ehot_ratio)
    hot.extend(Ahot_ratio)
    hot.extend(Rhot_ratio)
    hot.extend(Fhot_ratio)
    hot.extend(Arthot_ratio)
    hot.sort()
    hot = np.array(hot)
    print "median, mean, stdev for hot ratios......", hot[
        hot.shape[0] / 2], hot.mean(), hot.std()

    #do same kinds of histograms, but just for spin param (not ratio)
    bins = np.array(range(21)) / 50.0
    P.figure()
    P.xlabel("$\lambda_{cold gas}$")
    P.ylabel("Number")
    P.xlim(0, 0.4)
    n, bins, patches = P.hist([
        Ez_array[:, 5], Artz_array[:, 5], Rz_array[:, 5], Az_array[:, 5],
        Fz_array[:, 5]
    ],
                              stacked=True,
                              histtype='bar',
                              bins=bins)
    P.legend(["Enzo", "Art", "Ramses", "Arepo", "Fire"], frameon=False)
    P.savefig("ALL_coldspinparam_histogram.png")
    P.close()

    P.figure()
    P.xlabel("$\lambda_{hot gas}$")
    P.ylabel("Number")
    n, bins, patches = P.hist([
        Ez_array[:, 6], Artz_array[:, 6], Rz_array[:, 6], Az_array[:, 6],
        Fz_array[:, 6]
    ],
                              stacked=True,
                              histtype='bar',
                              bins=bins)
    P.legend(["Enzo", "Art", "Ramses", "Arepo", "Fire"], frameon=False)
    P.savefig("ALL_hotspinparam_histogram.png")
    P.close()
示例#36
0
from pylab import plot, legend, xlabel, ylabel, savefig, show, rc
from scipy.stats import gamma
from numpy import linspace
x = linspace(0, 15, 100)
rc('font', size=15)
rc('text', usetex=False)
plot(x, gamma.pdf(x, 4, 0, 2), 'r*-', label="$\\alpha=4,\\beta=2$")
plot(x, gamma.pdf(x, 4, 0, 1), 'bp-', label="$\\alpha=4,\\beta=1$")
plot(x, gamma.pdf(x, 4, 0, 0.5), '.k-', label="$\\alpha=4,\\beta=0.5$")
plot(x, gamma.pdf(x, 2, 0, 0.5), '>g-', label="$\\alpha=2,\\beta=0.5$")
legend()
xlabel("$x$")
ylabel('$f(x)$')
savefig('figure2_46.png', dpi=500)
show()
示例#37
0
import numpy as np
import networkx as nx
import pandas as pd
import pylab as plt

a = pd.read_excel("Pdata10_14.xlsx", header=None)
b = a.values
b[np.isnan(b)] = 0
c = np.zeros((8, 8))  # 邻接矩阵初始化
c[0:7, 1:8] = b  # 构造图的邻接矩阵
G = nx.Graph(c)
T = nx.minimum_spanning_tree(G)  # 返回可迭代对象
d = nx.to_numpy_matrix(T)  # 返回最小生成树的邻接矩阵
print("邻接矩阵c=\n", d)
W = d.sum() / 2 + 5  # 求油管长度
print("油管长度W=", W)
s = dict(zip(range(8), range(1, 9)))  # 构造用于顶点标注的标号字典
plt.rc('font', size=16)
pos = nx.shell_layout(G)
nx.draw(T, pos, node_size=280, labels=s, node_color='r')
w = nx.get_edge_attributes(T, 'weight')
nx.draw_networkx_edge_labels(T, pos, edge_labels=w)
plt.savefig('figure10_14.png')
plt.show()
示例#38
0
#程序文件Pex4_2.py
from scipy.stats import norm
from pylab import plot, fill_between, show, text, savefig, rc
from numpy import array, linspace, zeros
alpha = array([0.001, 0.005, 0.01, 0.025, 0.05, 0.10])
za = norm.ppf(1 - alpha, 0, 1)  #求上alpha分位数
print("上alpha分位数分别为", za)
x = linspace(-4, 4, 100)
y = norm.pdf(x, 0, 1)
rc('font', size=16)
rc('text', usetex=True)
plot(x, y)  #画标准正态分布密度曲线
x2 = linspace(za[-1], 4, 100)
y2 = norm.pdf(x2)
y1 = [0] * len(x2)
fill_between(x2, y1, y2, color='r')  #y1,y2对应的点之间填充
plot([-4, 4], [0, 0])  #画水平线
text(1.9, 0.07, "$\\leftarrow\\alpha$=0.1")  #标注
savefig("figure4_2.png", dpi=500)
show()
示例#39
0
文件: e2spt_group.py 项目: okwh/eman2
def main():
    print("I have entered main")
    #progname = os.path.basename(sys.argv[0])
    #usage = """Aligns a 3d volume to another by executing e2spt_classaverage.py and then calculates the FSC between them by calling e2proc3d.py . It returns both a number for the resolution based on the FSC0.5
    #criterion(on the screen) and a plot as an image in .png format."""

    progname = os.path.basename(sys.argv[0])
    usage = """Aligns a 3d volume to another by executing e2spt_classaverage.py and then calculates the FSC between them by calling e2proc3d.py . It returns both a number for the resolution based on the FSC0.5 
	criterion(on the screen) and a plot as an image in .png format."""

    parser = EMArgumentParser(usage=usage, version=EMANVERSION)

    parser.add_argument(
        "--averager",
        type=str,
        default="mean.tomo",
        help=
        """Default=mean.tomo. The type of averager used to produce the class average. Default=mean.tomo."""
    )

    parser.add_argument(
        "--cutoff",
        type=float,
        default=None,
        help=
        """Fraction of particles (as a decimal, where 1.0 is the entire set, 0.8 is 80 percent. 0.5 is 50 percent, etc); where to make the cutoff to divide the set into two groups. For example, if you specify --cutoff=0.2, the 20 percent of particles with the highest correlation scores will be bundled into the first group, and the remaining 80 percent into the second group."""
    )

    parser.add_argument(
        "--groups",
        type=int,
        default=None,
        help=
        "Number of groups you want the data to be divided into based on correlation."
    )

    parser.add_argument(
        "--input",
        type=str,
        default='',
        help=
        """Default=None. Stack of particles aligned with e2spt_classaverage.p.y"""
    )

    parser.add_argument(
        "--lowpass",
        type=str,
        default='default',
        help=
        """Filter applied to averages when --groups is used. Default=filter.lowpass.gauss:cutoff_freq=1/F, where F is Nyquist frequency, automatically calculated. To disable type --lowpass=None"""
    )

    parser.add_argument(
        "--nbins",
        type=int,
        default=0,
        help=
        """Used for histogram plot. Default=0 (not used). Number of bins for histogram. If not provided, the optimal bin number will be automatically calculated based on bin-width, computed using Scott's normal reference rule, width = (3.5*std)/cuberoot(n), where 'std' is the standard deviation of the distribution of scores and n is the number of values considered. Then, bins will be nbins = (max(scores) - min(scores)) / width."""
    )
    parser.add_argument(
        "--normalizeplot",
        action="store_true",
        help=
        "Make maximum correlation value on plot equal to 1 and the minimum equal to 0, and scale all other values accordingly.",
        default=False)

    parser.add_argument(
        "--path",
        type=str,
        default='spt_group',
        help=
        "Results directory. If not specified, defaults to a numbered series starting with spt_group_01."
    )
    parser.add_argument(
        "--ppid",
        type=int,
        default=-1,
        help="Set the PID of the parent process, used for cross platform PPID")

    parser.add_argument(
        "--scores",
        type=str,
        default='',
        help=
        """Default=None. Text file containing a list of correlations scores."""
    )
    parser.add_argument(
        "--sigmaprune",
        type=float,
        default=0.0,
        help=
        """Number of standard deviations below the mean to cut off particles; that is, the mean cross correlation coefficient of all particles will be computed, and those that are --sigmaprune=N standard deviations below the mean will not be considered."""
    )

    parser.add_argument(
        "--topn",
        type=int,
        default=None,
        help=
        "Number of particles from best to worst that you want to be written as a substack, averaged, and generate a coordinates .txt file with their coordinates."
    )

    parser.add_argument(
        "--verbose",
        "-v",
        dest="verbose",
        action="store",
        metavar="n",
        type=int,
        default=0,
        help=
        "verbose level [0-9], higner number means higher level of verboseness")

    (options, args) = parser.parse_args()

    options = checkinput(options)

    if options.groups and (options.cutoff or options.topn):
        print(
            "ERROR: you cannot specify --cutoff, --groups and --topn all at the same time. Choose one."
        )
        sys.exit()

    if options.cutoff and (options.groups or options.topn):
        print(
            "ERROR: you cannot specify --cutoff, --groups and --topn all at the same time. Choose one."
        )
        sys.exit()

    if options.topn and (options.cutoff or options.groups):
        print(
            "ERROR: you cannot specify --cutoff, --groups and --topn all at the same time. Choose one."
        )
        sys.exit()

    logger = E2init(sys.argv, options.ppid)

    options = makepath(options, 'sptcoeff')

    print("\nI have read the parameters")

    if options.lowpass:
        if options.lowpass == "default":
            hdr = EMData(options.alistack, 0, True)
            apix = hdr['apix_x']
            nyquist = 2.0 * apix
            nyquistfreq = 1.0 / nyquist
            options.lowpass = '******' + str(
                nyquistfreq) + ':apix=' + str(apix)
            if apix == '1.0':
                print(
                    "\nWARNING: apix is 1.0, most likely wrong (default empty value). You can fix/change it with e2fixheaderparam.py"
                )
        elif 'None' in options.lowpass or 'none' in options.lowpass:
            options.lowpass = None

    if options.averager:
        options.align = parsemodopt(options.averager)
    if options.lowpass:
        options.lowpass = parsemodopt(options.lowpass)

    scores = []
    dataset = {}
    #x=[]

    k = 0
    usenewstack = False
    newstack = options.alistack.replace('.hdf', '_prepruned.hdf')

    if options.alistack:
        n = EMUtil.get_image_count(options.alistack)

        for i in range(n):
            ahdr = EMData(options.alistack, i, True)
            #print "ahdr is", ahdr
            score = None

            if options.verbose:
                print("\nanalyzing header for particle", i)

            if 'spt_score' in ahdr.get_attr_dict():
                score = -1 * ahdr['spt_score']
                print("spt_score is", score)
            elif 'spt_coefficient' in ahdr.get_attr_dict():
                score = ahdr['spt_coefficient'] * -1
                print("spt_coefficient is", score)
            else:
                print(
                    "\nERROR: no score found in header for particle %d. Skipping it! A prepruned stack will be made with all the particles that did have score info in their header"
                    % (i))
                a = EMData(options.alistack, i)
                a.write_image(newstack, k)
                usenewstack = True

            if score:
                scores.append(score)

    elif options.scores and not options.alistack:
        f = open(options.scores, 'r')
        lines = f.readlines()
        f.close()
        scores = [round(float(line.replace('\n', '')), 6) for line in lines]

    elif not options.scores and not options.alistack:
        print(
            "\n(e2spt_coeffplot)(main) ERROR: you need to supply either --alistack or --scores, with the former taking precedence over the latter."
        )
        sys.exit()

    if usenewstack:
        options.alistack = newstack

    n = len(scores)

    nstack = EMUtil.get_image_count(options.alistack)

    if n != nstack:
        print(
            "\n!!!! WARNING: the number of scores %d does not match the number of images %d in the stack %s"
            % (n, nstack, options.alistack))

    if scores and n > 1:
        print("\nThe set has these many particles", len(scores))
    else:
        print(
            "\nERROR: There seems to be no information on particle scores. The number of scores must be larger than one to do any statistics with them."
        )
        sys.exit()

    for i in range(n):
        #dataset.append({'score':float(score), 'particle':a})
        dataset.update({i: scores[i]})
        #x.append(i)

    dataset = sorted(dataset.items(), key=itemgetter(1), reverse=True)

    if options.normalizeplot:
        #for s in scores:
        #val = values[ele]
        minv1 = min(scores)
        #maxv1 = max(scores)
        #print "Min max before normalization was", minv,maxv1
        for k in range(len(scores)):
            scores[k] = scores[k] - minv1

        #minv2 = min(scores)
        maxv2 = max(scores)
        #print "After subtracting min, the are", minv2,maxv
        #print "Max before normalization was", maxv
        for k in range(len(scores)):
            scores[k] = scores[k] / maxv2

    scores.sort()
    scores.reverse()
    #scores=scores[:-2]
    '''
	c:plot the distribution of scores
	'''
    import matplotlib.pyplot as plt
    import pylab
    import matplotlib

    std = np.std(scores)
    mean = np.mean(scores)
    statistics = ['mean=' + str(mean) + ' std=' + str(std) + '\n']

    print("\nthe standard deviation %.6f, mean %.6f" % (std, mean))

    if not std:
        print("\nERROR: std=0, which means all intensity values are the same.")
        sys.exit()

    cuberoot = np.power(len(scores), 1.0 / 3.0)
    width = (3.5 * std) / cuberoot
    print(
        "\naccording to Scott's normal reference rule, width = (3.5*std)/cuberoot(n), the width of the histogram bins will be",
        width)

    calcbins = (max(scores) - min(scores)) / width

    if options.nbins:
        calcbins = options.nbins
        print("\overwriting number of bins to be", options.nbins)

    print(
        "\nand the number of bins n = ( max(scores) - min(scores) ) / width will thus be",
        calcbins)
    calcbins = int(round(calcbins))
    print("rounding to", calcbins)

    statistics.append('bins=' + str(calcbins) + ' , binwidth=' + str(width) +
                      '\n')

    if not calcbins:
        print(
            "WARNING: nbins=0, which means max and min intensity are the same, which probably means all scores are zero. Defaulting nbins to number of partilces."
        )
        calcbins = len(scores)

    datafile = ''
    if options.alistack:
        datafile = os.path.basename(options.alistack)
    elif options.scores:
        datafile = os.path.basename(options.scores)

    f = open(options.path + '/stats.txt', 'w')
    f.writelines(statistics)
    f.close()

    plt.hist(scores, calcbins, alpha=0.30, label=datafile)

    plottitle = os.path.basename(options.alistack).replace(
        '.hdf', '') + ' CC scores distribution histogram'
    plt.title(plottitle)

    matplotlib.rc('xtick', labelsize=16)
    matplotlib.rc('ytick', labelsize=16)

    font = {'weight': 'bold', 'size': 16}
    matplotlib.rc('font', **font)

    pylab.rc("axes", linewidth=2.0)

    pylab.xlabel('CC score (au)', fontsize=16, fontweight='bold')
    pylab.ylabel('Number of particles', fontsize=16, fontweight='bold')

    plt.savefig(options.path + '/scores_histogram.png')
    plt.clf()
    '''
  	c:plot decay in ranked correlation scores
  	'''
    x = [i for i in range(len(scores))]

    plt.plot(x, scores, color='k', linewidth=3)
    plottitle = os.path.basename(options.alistack).replace(
        '.hdf', '') + ' CC scores decay'
    plt.title(plottitle)

    pylab.xlim([min(x), max(x) + 0.1 * max(x)])
    font = {'weight': 'bold', 'size': 16}
    matplotlib.rc('font', **font)

    pylab.xlabel('Particle index', fontsize=16, fontweight='bold')
    pylab.ylabel('CC score (au)', fontsize=16, fontweight='bold')

    plt.savefig(options.path + '/scores_decay.png')
    plt.clf()
    '''
  	c:plot the distance to mean value in # of standard deviations
  	'''
    distancestomean = [(scores[i] - mean) / std for i in range(len(scores))]
    plt.plot(
        x,
        distancestomean,
        color='b',
        linewidth=2,
    )

    plottitle = os.path.basename(options.alistack).replace(
        '.hdf', '') + ' CC scores distance to mean'
    plt.title(plottitle)

    pylab.xlim([min(x), max(x) + 0.1 * max(x)])

    font = {'weight': 'bold', 'size': 16}
    matplotlib.rc('font', **font)

    pylab.xlabel('Particle index', fontsize=16, fontweight='bold')
    pylab.ylabel('Distance from mean (sigmas)', fontsize=16, fontweight='bold')

    plt.savefig(options.path + '/scores_distance2mean.png')
    plt.clf()
    '''
  	c:plot the distance to max value in # of standard deviations
  	'''
    maxi = max(scores)
    distancestomax = [(maxi - scores[i]) / std for i in range(len(scores))]
    plt.plot(
        x,
        distancestomax,
        color='b',
        linewidth=2,
    )

    plottitle = os.path.basename(options.alistack).replace(
        '.hdf', '') + ' CC scores distance to max'
    plt.title(plottitle)

    pylab.xlim([min(x), max(x) + 0.1 * max(x)])

    font = {'weight': 'bold', 'size': 16}
    matplotlib.rc('font', **font)

    pylab.xlabel('Particle index', fontsize=16, fontweight='bold')
    pylab.ylabel('Distance from max (sigmas)', fontsize=16, fontweight='bold')

    plt.savefig(options.path + '/scores_distance2max.png')
    plt.clf()

    print('sorted dataset is', dataset)
    '''
	c:prune and/or divide into groups
	'''
    newscores = []
    if options.sigmaprune:

        #print "Will analyze scores to remove aberrantly low ones"

        #mu=numpy.mean(scores)
        #sigma=numpy.std(scores)

        mu = mean
        sigma = std

        print("\nMean is", mu)
        print("Std is", sigma)
        filter = mu - sigma * (options.sigmaprune)
        print("Therefore, filter is", filter)

        for d in dataset:
            if float(d['score']) < float(filter):
                dataset.remove(d)
                print(
                    "I have removed this aberrant particle from the dataset due to its low score",
                    d['score'])
            else:
                newscores.append(float(d['score']))
                print("This score is high enough to survive", d['score'])

        newscores.sort()
        newscores.reverse()
        x = range(len(newscores))

        plottitle = os.path.basename(options.alistack).replace(
            '.hdf', '_prunedSCORES')
        plt.plot(x, newscores, color='k', linewidth=2)
        pylab.xlim([min(x), max(x) + 0.1 * max(x)])
        #plt.title(plottitle)
        plt.ylabel('CC coefficient')
        plt.xlabel('Particle number')
        #a = plt.gca()
        plotfile = options.path + '/' + plottitle + '.png'
        plt.savefig(plotfile)
        plt.clf()

    newN = len(dataset)

    if options.groups:

        if not options.alistack:
            print("\nERROR: --groups requires --alistack")
            sys.exit()

        halfptclnum = int(round(n / 2.0))
        halfptcl = dataset[halfptclnum][0]
        print("half ptclnum is", halfptclnum)
        print("which happens to be ptcl indx", halfptcl)
        halfscore = dataset[halfptcl][1]
        print("with halfscore being", halfscore)

        subdatasetsSET = []
        N = len(dataset)
        #print "THe type of dataset is", type(dataset)
        print("The len of the dataset is", N)
        subN = N / options.groups
        print("The len of each subset, except the last, should be", subN)
        for g in range(options.groups):
            #subscores = scores[g*subN : (g+1)*subN]
            subdataset = dataset[g * subN:(g + 1) * subN]
            if g == options.groups - 1:
                subdataset = dataset[g * subN:]
            subdatasetsSET.append(subdataset)

        kk = 0
        for subdataset in subdatasetsSET:
            print("The len of subset %d is %d" % (kk, len(subdataset)))
            jj = 0
            groupname = options.path + '/' + os.path.basename(
                options.alistack).replace(
                    '.', '_' + str(kk).zfill(len(str(options.groups))) + '.')
            particleLIST = []
            lines = []
            print("options.averager is", options.averager)
            #avgr = Averagers.get(options.averager[0], options.averager[1])
            avgr = Averagers.get('mean.tomo')

            for element in subdataset:
                #particle = element['particle']

                ptclnum = element[0]
                img = EMData(options.alistack, ptclnum)
                img.write_image(groupname, jj)
                jj += 1
                particleLIST.append(ptclnum)

                avgr.add_image(img)

            averageNAME = groupname.replace('.hdf', '_AVG.hdf')

            average = avgr.finish()

            average['origin_x'] = 0
            average['origin_y'] = 0
            average['origin_z'] = 0

            average.process_inplace('normalize.edgemean')

            if options.lowpass:
                print("(e2spt_coeffplot)(main) --lowpass provided:",
                      options.lowpass)
                average.process_inplace(options.lowpass[0], options.lowpass[1])

            average.write_image(averageNAME, 0)

            cmd = 'cd ' + options.path + ' && e2orthoproject.py --input ' + os.path.basename(
                averageNAME)
            cmd += ' && e2slicer.py --input ' + os.path.basename(averageNAME)

            runcmd(options, cmd)
            #print "\nThe group average has been written to", averageNAME
            kk += 1

    if options.cutoff:

        if not options.alistack:
            print("\nERROR: --cutoff requires --alistack")
            sys.exit()

        threshptclnum = int(round(newN / (1 / options.cutoff)))
        threshptcl = dataset[threshptclnum]
        print("The new threshptcl is", threshptcl)
        threshscore = dataset[threshptclnum][1]

        threshlabel = "%0.2f" % (options.cutoff)
        threshlabel = str(threshlabel).replace('.', 'p')
        group1 = []
        group2 = []
        k1 = 0
        k2 = 0
        g1name = options.path + '/' + os.path.basename(
            options.alistack).replace('.', '_G1.')
        g2name = options.path + '/' + os.path.basename(
            options.alistack).replace('.', '_G2.')
        avgr1 = avgr = Averagers.get('mean.tomo')
        avgr2 = avgr = Averagers.get('mean.tomo')
        for i in dataset:
            img = EMData(options.alistack, i[0])

            if i[1] >= threshscore:
                group1.append(i[0])
                img.write_image(g1name, k1)
                avgr1.add_image(img)
                k1 += 1
            else:
                group2.append(i[0])
                img.write_image(g2name, k2)
                avgr2.add_image(img)
                k2 += 1
                #else:
                #	print "\n\n@@@@ Found a garbage particle, and thus did not consider it!\n\n"

        if group1:
            g1avg = avgr1.finish()
            g1avg.write_image(g1name.replace('.hdf', '_avg.hdf'), 0)

        if group2:
            g2avg = avgr1.finish()
            g2avg.write_image(g2name.replace('.hdf', '_avg.hdf'), 0)

    if options.topn:

        if not options.alistack:
            print("\nERROR: --topn requires --alistack")
            sys.exit()

        topndataset = dataset[0:options.topn]
        bottomdataset = dataset[options.topn:]

        outnamestack = options.path + '/' + os.path.basename(
            options.alistack).replace('.', 'top' + str(options.topn) + '.')

        coordsname = options.path + '/' + os.path.basename(outnamestack).split(
            '.')[0] + '_coords.txt'

        indxsname = options.path + '/' + os.path.basename(coordsname).replace(
            'coords', 'indxs')

        k = 0
        linescoords = []
        linesindxs = []
        topptcls = []

        avgr = Averagers.get('mean.tomo')
        for ptcl in topndataset:
            p = ptcl[0]
            img = EMData(options.alistack, p)
            img.write_image(outnamestack, k)
            avgr.add_imag(img)
            topptcls.append(p)
            linescoords.append(str(p['ptcl_source_coord']) + '\n')
            linesindxs.append(str(p['source_n']) + '\n')
            k += 1

        avg = avgr.finish()
        avgname = options.path + '/' + os.path.basename(outnamestack).replace(
            '.', '_avg.')

        avg.write_image(avgname, 0)
        f = open(coordsname, 'w')
        f.writelines(linescoords)
        f.close()

        f = open(indxsname, 'w')
        f.writelines(linesindxs)
        f.close()

    #x=range(len(scores))

    #plottitle = os.path.basename(options.alistack).replace('.hdf', '_prunedSCORES')
    #plt.plot(x, scores, marker='o', color='r', linewidth=2)
    #plt.title(plottitle)
    #plt.ylabel('score')
    #plt.xlabel('n ptcl')
    #a = plt.gca()

    #plotfile = options.path + '/' + plottitle + '.png'
    #plt.savefig(plotfile)
    #plt.clf()

    E2end(logger)

    return
示例#40
0
#-*- coding: utf-8 -*-

import pylab
import numpy as np
import math
from numpy import arctan

pylab.rc('text', usetex=True)
pylab.rc('font', family='serif')

omega = np.logspace(0, 7, num=4000)

C = 5e-8
R = 13000
O = omega * R * C

# phi=abs((1-4*O**2)/np.sqrt((1-4*O**2)**2+64*O**2))
phi = arctan(8 * O / (1 - 4 * O**2))
# fi = np.loadtxt('data/chem6.tsv', skiprows=1, delimiter='\t', usecols=(0, 6))
# print(fi)

# Результаты эксперимента
# om=fi.T[0]*2*np.pi
# fi=fi.T[1]

pylab.semilogx(omega, phi, "r-")
# pylab.semilogx(om, fi, "bo", markersize=5)

pylab.xlabel(r"$\omega$")
pylab.ylabel(r"$\phi$")
示例#41
0
    def __init__(self):
        self.prediction = []
        self.true_value = []
        self.score = []


data = Data()

data.prediction = np.array(data_frame[:, 0])
data.true_value = np.array(data_frame[:, 1])

data.error = data.prediction - data.true_value

font = {'size': 18}

pylab.rc('font', **font)

pylab.figure(1)
pylab.hist(data.error, bins=1000)

var = np.var(data.error)
print "Var: ", var
data.error = [n / (var**(0.5)) for n in data.error]

pylab.savefig(filename + "_prediction_error_hist.pdf", box_inches='tight')

pylab.figure(2)
stats.probplot(data.error, dist="norm", plot=pylab)
pylab.savefig(filename + "_prediction_error_hist.pdf", box_inches='tight')

from scipy import stats
plt.rcParams['xtick.major.width'] = 1

plt.rcParams['xtick.minor.size'] = 5

plt.rcParams['xtick.minor.width'] = 1

plt.rcParams['ytick.major.size'] = 9

plt.rcParams['ytick.major.width'] = 1

plt.rcParams['ytick.minor.size'] = 5

plt.rcParams['ytick.minor.width'] = 1

font = {'family': 'serif', 'weight': 'normal', 'size': 15}
plt.rc('font', **font)

#===============FIRST PLOT++++++++++++++++++++++++++++++++++++++++++++++

#Load Data==========================================================
data = np.loadtxt('../TimeSeries.dat', comments='#')
t = data[:, 0]
Re = data[:, 1]
Nu = data[:, 2]
Div = data[:, 3]
dt = data[:, 4]

#Define Figure and subplots=========================================
fig = plt.figure(1)
f_ax1 = fig.add_subplot(2, 2, 1)
f_ax2 = fig.add_subplot(2, 2, 2)
示例#43
0
def main():

    matlab_path = '/Applications/MATLAB_R2020b.app/bin/matlab'

    ## THE FOLLOWING FLAGS TO TRUE/FALSE CONTROL WHICH TESTS ARE DONE
    do_ibp_tests = True
    do_maaipm_tests = True
    do_colgen_tests = True
    do_comparison_plots = True

    # Control which data set to use: 'sparsesquare', 'sparsedisc', 'noisygrid', 'translatedgrid'
    test_type = 'sparsesquare'
    k_vals = [10]
    n_vals = [10]

    # Control parameters for IBP vs. MAAIPM method.
    ibp_eps_vals = [0.1, 0.01] # Support size gridding for IBP.
    ibp_filter_sizes = [1] # the regularization parameter is eta = (1/eps)^2 / (2 * filter_size^2)
    maaipm_eps_inv_vals = [10] # eps_inv x eps_inv grid for MAAIPM.

    # Plot parameters
    y_limits = (1e-10 - 1e-11, 10.0)
    x_limits = (0.009,100)


    for k in k_vals:

        for n in n_vals:

            np.random.seed(19238412)
            random.seed(12834981)

            data_identifier = test_type + '_n' + str(n) + 'k' + str(k)

            ##########################################################################
            ## A) Generate the sparse test data
            if test_type == 'sparsesquare':
                sparse_data = get_sparsesquare_test(k=k,n=n)
            elif test_type == 'sparsedisc':
                sparse_data = get_sparsedisc_test(k=k,n=n)
            elif test_type == 'noisygrid':
                sparse_data = get_noisygrid_test(k=k,n=n)
            elif test_type == 'translatedgrid':
                sparse_data = get_translatedgrid_test(k=k,n=n)
            else:
                assert(0)
#            show_sparse_data(sparse_data)

            # And save it for use by IBP and MAAIPM
            data_filename = 'comparison_test_files/experiment_data/' + data_identifier

            # Save it as gridded images (for IBP):
            eps_vals = ibp_eps_vals
            for i, eps_val in enumerate(eps_vals):
                dense_data = get_dense_data_representation(sparse_data, eps=eps_val, bounding_box=((-1,-1),(1,1)))
                eps_desc = str(eps_val).split('.')[1]
                dense_data_filename = data_filename + 'eps' + eps_desc
                save_dense_data_representation(dense_data, dense_data_filename)

            # Save it as a list of points (for MAAIPM):
            save_sparse_data_representation(sparse_data, data_filename)

            ##########################################################################
            # B) Run our column generation method, collecting an error plot.
            if do_colgen_tests:
                filename_colgen = 'comparison_test_files/experiment_results/colgen_results/' + data_identifier + '.txt';
                if os.path.exists(filename_colgen):
                    print('ALREADY EXISTS: ' + filename_colgen)
                else:
                    bary_prob = BarycenterProblem(sparse_data, method='powerdiagram', log_file=filename_colgen)
                    bary_prob.solve()

            ########################################################################
            ## C) Run IBP method, gridding the space.

            ## 1) Run the IBP code (MATLAB) computing regularized barycenters (different regularizations and epsilons).
            if do_ibp_tests:
                eps_vals = ibp_eps_vals
                filter_sizes = ibp_filter_sizes # the regularization parameter is eta = (1/eps)^2 / (2 * filter_size^2)
                for i, eps_val in enumerate(eps_vals):
                    eps_desc = str(eps_val).split('.')[1]
                    for filter_size in filter_sizes:
                        ibp_res_prefix = 'comparison_test_files/experiment_results/ibp_results/' + data_identifier + 'eps' + eps_desc + 'f' + str(filter_size);
                        ibp_res_file = ibp_res_prefix + '.txt'
                        if os.path.exists(ibp_res_file):
                            print('ALREADY EXISTS: ' + ibp_res_file)
                            continue
                        time.sleep(0.05)
                        matlab_command = matlab_path + ' -nodisplay -r "cd(\'comparison_test_files/IBP_code\'); test_barycenters_ibp(' + str(n) + ', ' + str(k) + ',\'' + eps_desc + '\',\'' + test_type + '\',' + str(filter_size) + ',{imgortime:d});exit"';

                        ## i) Assign scores to the IBP barycenters w.r.t. actual point cloud.
                        ## Use the Lemon solver to obtain the exact optimal transport distance between pairs of points.
                        costs_filename = ibp_res_prefix + '_costs.txt'
                        costs_lemon = []
                        if not os.path.exists(costs_filename):
                            print(matlab_command)
                            os.system(matlab_command.format(imgortime=1)) # Write the barycenter at each iteration to the disk.
                            t = 1
                            while True:
                                curr_filename = ibp_res_prefix + '/b_' + str(t) + '.png'
                                if not os.path.exists(curr_filename):
                                    break
                                if t % 40 == 1 or (t < 80 and t % 10 == 1):
                                    f1 = pylab.imread(curr_filename)
                                    print(f1)
                                    f1 = f1 / np.sum(f1)
                                    sparsedatum_f1 = get_sparse_data_representation([f1], bounding_box=((-1,-1),(1,1)))[0]

                                    print(t)
                                    curr_lemon = 0
                                    for i in range(k):
                                        print(t,i)
                                        curr_lemon += exact_cost_lemon(sparse_data[i], sparsedatum_f1, lemon_solver_location='../lemon_solver/LemonNetworkSimplex') / k
                                    costs_lemon.append(curr_lemon)
                                else:
                                    costs_lemon.append(-1)
                                t += 1

                            costs_file = open(costs_filename, 'w')
                            for i in range(len(costs_lemon)):
                                costs_file.write('{v:.9f}\n'.format(v=costs_lemon[i]))
                            costs_file.close()
                        else:
                            print('USING PREVIOUSLY-COMPUTED COSTS FILE: ' + costs_filename)
                            costs_file = open(costs_filename, 'r')
                            costs_lemon = costs_file.readlines()
                            costs_lemon = [float(i) for i in costs_lemon]
                            costs_file.close()

                        # ii) Separately re-run the IBP code to get the timing information.
                        timings_filename = ibp_res_prefix + "_timing.txt";
                        if not os.path.exists(timings_filename):
                            os.system(matlab_command.format(imgortime=2)) # Write the cumulative time to each iteration to the disk.
                        else:
                            print('USING PREVIOUSLY-COMPUTED TIMINGS FILE: ' + timings_filename)
                        timings_file = open(timings_filename, 'r')
                        times = timings_file.readlines()
                        times = [float(i) for i in times]
                        timings_file.close()

                        res_file = open(ibp_res_file, 'w')
                        assert(len(times) == len(costs_lemon))
                        for i in range(len(times)):
                            res_file.write('{v:.9f} {t:.9f}\n'.format(v=costs_lemon[i], t=times[i]));
                        res_file.close()

            ##########################################################################
            ## D) Run MAAIPM method with fixed-support assumption.

            if do_maaipm_tests:
                for eps_inv in maaipm_eps_inv_vals: # eps_inv x eps_inv-size grid
                    maaipm_res_file = 'comparison_test_files/experiment_results/ipm_results/' + data_identifier + 'epsinv' + str(eps_inv) + '.txt'
                    if os.path.exists(maaipm_res_file):
                        print('ALREADY EXISTS: ' + maaipm_res_file)
                        continue
                    time.sleep(0.05)
                    matlab_command = matlab_path + ' -nodisplay -r "cd(\'comparison_test_files/MAAIPM_code\'); test_barycenters_maaipm_grid_support(' + str(n) + ', ' + str(k) + ',' + str(eps_inv) + ',\'' + test_type + '\');exit"';

                    os.system(matlab_command)
                    os.system('mv comparison_test_files/experiment_results/ipm_results/latest_maaipm_results.txt ' + maaipm_res_file)



    ##############################################################################
    ## E) Create the comparison plots between the algorithms
    if do_comparison_plots:
        print('Comparison plots here')
        markers = ['x', 'o', 'v', '^', '.']*100
        best_val = 10;
        last_time = 0;
        title_text = '';
        legend_names = None;


        # Which data to plot.
        # Example comparison plot: n = 5, k = 5, sparsesquare.
        series = ['colgen_results/sparsesquare_n5k5.txt', 'ipm_results/sparsesquare_n5k5epsinv10.txt', 'ibp_results/sparsesquare_n5k5eps1f1.txt']
        legend_names = ['Proposed algorithm', 'MAAIPM 10x10 grid', 'IBP 10 x 10 grid, filter-size 1']

        assert(len(k_vals) == 1)
        assert(len(n_vals) == 1)
        k = k_vals[0]
        n = n_vals[0]
        test_prefix = test_type + '_n' + str(n) + 'k' + str(k);
        title_text = test_type + ', n = ' + str(n) + ', k = ' + str(k)

        series = []
        legend_names = []
        if do_colgen_tests:
            series.append('colgen_results/' + test_prefix + '.txt')
            legend_names.append('Proposed algorithm')

        if do_ibp_tests:
            for eps_val in ibp_eps_vals:
                eps_desc = str(eps_val).split('.')[1]
                for filter_size in ibp_filter_sizes:
                    series.append('ibp_results/' + test_prefix + 'eps' + eps_desc + 'f' + str(filter_size) + '.txt')
                    legend_names.append('IBP eps=' + str(eps_val) + ' filter-size=' + str(filter_size))

        if do_maaipm_tests:
            for eps_inv in maaipm_eps_inv_vals:
                series.append('ipm_results/' + test_prefix + 'epsinv' + str(eps_inv) + '.txt')
                legend_names.append('IPM epsinv=' + str(eps_inv))

#        series = ['colgen_results/sparsesquare_n25k10.txt', 'ibp_results/sparsesquare_n25k10eps1f1.txt', 'ibp_results/sparsesquare_n25k10eps1f2.txt', 'ibp_results/sparsesquare_n25k10eps05f1.txt', 'ibp_results/sparsesquare_n25k10eps05f2.txt']
#        series = ['colgen_results/sparsesquare_n25k10.txt', 'ipm_results/sparsesquare_n25k10epsinv10.txt', 'ipm_results/sparsesquare_n25k10epsinv30.txt', 'ipm_results/sparsesquare_n25k10epsinv70.txt']

##        # IPM plot: n = 20, k = 20, noisygrid.
##        series = ['colgen_results/noisygrid_n20k10.txt', 'ipm_results/noisygrid_n20k10epsinv10.txt', 'ipm_results/noisygrid_n20k10epsinv30.txt', 'ipm_results/noisygrid_n20k10epsinv50.txt']

##        # IBP plot: n = 20, k = 20, sparsesquare.
##        series = ['colgen_results/sparsesquare_n20k10.txt', 'ibp_results/sparsesquare_n20k10eps04f1.06.txt', 'ibp_results/sparsesquare_n20k10eps01f7.txt', 'ibp_results/sparsesquare_n20k10eps004f12.txt']
##        legend_names = ['Proposed algorithm', 'IBP 25x25 grid, $\eta=100$', 'IBP 100x100 grid, $\eta=100$', 'IBP 250x250 grid, $\eta=200$']
##        title_text = 'Comparison with IBP'

#        # IPM plot: n = 20, k = 20, sparsesquare.
#        series = ['colgen_results/sparsesquare_n20k10.txt', 'ipm_results/sparsesquare_n20k10epsinv10.txt', 'ipm_results/sparsesquare_n20k10epsinv40.txt', 'ipm_results/sparsesquare_n20k10epsinv70.txt']
#        legend_names = ['Proposed algorithm', 'MAAIPM 10x10 grid', 'MAAIPM 40x40 grid', 'MAAIPM 70x70 grid']
#        title_text = 'Comparison with MAAIPM'

        # # Comparison plot: n = 5, k = 5, sparsesquare.
        # series = ['colgen_results/sparsesquare_n5k5.txt', 'ipm_results/sparsesquare_n5k5epsinv10.txt', 'ibp_results/sparsesquare_n5k5eps1f1.txt']
        # legend_names = ['Proposed algorithm', 'MAAIPM 10x10 grid', 'IBP 10 x 10 grid, filter-size 1']
        # title_text = 'Example comparison with MAAIPM and IBP'


        if legend_names is None:
            legend_names = series

        val_data = []
        time_data = []

        # Sanitize data (remove places where cost was not computed.)
        for i in range(len(series)):
            temp_vals, temp_times = read_val_time_file('comparison_test_files/experiment_results/' + series[i])
            vals = []
            times = []
            for j in range(len(temp_vals)):
                if temp_vals[j] >= 0:
                    vals.append(temp_vals[j])
                    times.append(temp_times[j])
            val_data.append(vals)
            time_data.append(times)

        for i, serie in enumerate(series):
            vals = val_data[i]
            times = time_data[i]
            best_val = min(best_val, np.min(vals)) # Provided that column generation is one of the methods run, best_val will be the true optimum for the problem.
            last_time = max(last_time, np.max(times))

        pylab.figure(figsize=(12,8))
        for i, serie in enumerate(series):
            vals = val_data[i]
            times = time_data[i]
            vals.append(vals[-1])
            times.append(last_time)
            pylab.plot(times, vals-best_val + 1e-18, marker=markers[i], label=legend_names[i], linewidth=3.0)
        pylab.ylim(y_limits)
        pylab.xlim(x_limits)
        pylab.yscale('log')
        pylab.xscale('log')

        font = {'family' : 'sans-serif',
                'size'   : 30}
        pylab.rc('font', **font)
        pylab.rcParams['text.usetex'] = True

        ax = pylab.gca();
        ax.set_ylabel('Suboptimality gap')
        ax.set_xlabel('Time (seconds)')
        ax.set_title(title_text)
        for item in ([ax.xaxis.label, ax.yaxis.label] +
                     ax.get_xticklabels() + ax.get_yticklabels()):
            item.set_fontsize(30)
            item.set_usetex(True)
        ax.title.set_fontsize(40)
        ax.title.set_usetex(True)

        pylab.legend()
        pylab.show()
# Floor, Boston, MA 02110-1301, USA.
#
#

# Code:

from collections import defaultdict
import numpy as np
import pylab as plt
from util import makepath
from traubdata import TraubData
from trbhist import get_spiketime_hist
from util import makepath, smooth_gaussian
from config import cellcolor
from plotutil import plot_spike_raster

plt.rc('font', size=12)
plt.rc('figure', figsize=(3, 4))

data_filename = 'data_20140526_110240_20695.h5'  #'data_20140525_130513_20265.h5'  #'data_20140825_113047_105368_compute-0-2.local.h5'

if __name__ == '__main__':
    figfilename = 'figures/Figure_5B_spikeraster_80DB.png'
    trange = (5, 8)
    fig, ax = plot_spike_raster(makepath(data_filename), trange)
    plt.savefig(figfilename, transparent=True)
    plt.show()

#
# fig_5_b_spikeraster_30DB.py ends here
示例#45
0
#!/usr/bin/env python
import pandas
import pylab as pl
import numpy as np
import seaborn as sns
from argparse import ArgumentParser
from arsenal import colors
from arsenal.math.pareto import show_frontier
from ldp.viz.cone import lambda_cone, arrow

sns.set(font_scale=2.1)
pl.rc('text', usetex=True)
pl.rc('font', family="Times New Roman")

# Light colors for trajectory and cone.
c_baseline = '#a1d76a'
c_lols = '#9e4c79'

# darker color for vector and distinguished point
c_vec_lols = '#862058'
c_vec_baseline = '#558524'

# TODO: use consistent color for each method.
c_cp = '#6a6bd7'
c_dp = '#d76ad7'


def main():

    p = ArgumentParser()
    p.add_argument('filename', help='Path to csv file containing the results.')
示例#46
0
import pylab
import numpy
from scipy.optimize import curve_fit
import matplotlib
import math

n, V, dV = pylab.loadtxt(
    'C:\\Users\\Lisa\\Desktop\\Lab3\\Lock-In\\dati2marco.txt', unpack=True)

y = V
dy = dV

pylab.figure(1)

pylab.rc('font', size=13)

pylab.title('Assorbimento', fontsize="16")

pylab.xlabel('numero lastrine', size="14")

pylab.ylabel('$V_{out}$ [$V$]', size="14")

pylab.xlim(-0.5, 7.5)
pylab.grid(color="gray")
pylab.plot(n, y, '.', label='data', color='black')
pylab.errorbar(n, y, dy, linestyle='', marker='+', color='black')


def exponential(x, v0, n0):
    return v0 * pylab.exp(-x / n0)
outbase = './balff_data/dataarraySim_pdist'+args.probdist+\
          '_Ntot'+str(args.Ntotal)+\
          '_k'+str(args.kval).replace('.','p')+\
          '_Lstar'+str(args.Lstar).replace('.','p')+\
          '_Llim'+str(args.Llim).replace('.','p')+\
          '_Nobj'+str(Nobj)
if args.nochoice: outbase = outbase + ncstring
outputfile = outbase + '.fits'
#-------------------------------------------------------------------------------------------------------------
plotsamples = 1
if args.nochoice: plotsamples = 0  # ignore plotting when nochoice is set
if plotsamples == 1:
    plotname = outbase + '.pdf'
    import pylab as plt
    Fsize = 10
    plt.rc('text', usetex=True)  # enabling LaTex rendering of text
    plt.rc('font', family='serif', size=Fsize)  # setting text font
    plt.rc('xtick', labelsize=Fsize)
    plt.rc('ytick', labelsize=Fsize)
    hist = plt.hist(np.log10(Ldraw_total),
                    bins=100,
                    color='0.3',
                    label='Total sample drawn from dist: k=' + str(args.kval) +
                    ', L*/[1e44erg/s]=' + str(args.Lstar))
    plt.hist(np.log10(Ldraw_toterr),
             bins=hist[1],
             color='b',
             alpha=0.5,
             label='Total sample added measurement errors')
    plt.hist(np.log10(Ldraw),
             bins=hist[1],
示例#48
0
from __future__ import print_function
import pylab as pl
import os
import json
import sys
try:
    import urllib2 as urllib
except ImportError:
    import urllib.request as urllib

pl.rc('font', size=15)

#MTA_KEY = "d3ccd72f-edb3-433f-8935-1ec3de863290"

url = 'http://bustime.mta.info/api/siri/vehicle-monitoring.json?key='\
+sys.argv[1]+'&VehicleMonitoringDetailLevel=calls&LineRef='+sys.argv[2]

#url="http://bustime.mta.info/api/siri/vehicle-monitoring.json?key=" + MTAAPIKEY + \
#"VehicleMonitoringDetailLevel=calls&LineRef=B52"
#print (url)
response = urllib.urlopen(url)
data = response.read().decode("utf-8")
data = json.loads(data)

busx = data['Siri']['ServiceDelivery']['VehicleMonitoringDelivery'][0][
    'VehicleActivity']
s = "Latitude,Longitude,Stop Name,Stop Status\n"
for i in busx:
    #print(type(i))
    i = i['MonitoredVehicleJourney']
    #print('Onward Calls', len(i['OnwardCalls']))
示例#49
0
import pylab as P
import emcee
import time
import os
import matplotlib.image as mpimg
from astropy.cosmology import Planck15
from scipy.stats import kde
from scipy.interpolate import RegularGridInterpolator
from scipy.interpolate import interp2d
from itertools import product
import sys
from emcee.autocorr import AutocorrError
from scipy.interpolate import interp2d

font = {'family': 'serif', 'size': 16}
P.rc('font', **font)
P.rc('xtick', labelsize='medium')
P.rc('ytick', labelsize='medium')
P.rc('axes', labelsize='medium')

pad_zmet = np.array([
    0.0002, 0.0003, 0.0004, 0.0005, 0.0006, 0.0008, 0.001, 0.0012, 0.0016,
    0.0020, 0.0025, 0.0031, 0.0039, 0.0049, 0.0061, 0.0077, 0.0096, 0.012,
    0.015, 0.019, 0.024, 0.03
])
pad_zmetsol = 0.019

pad_solmet = pad_zmet / pad_zmetsol
zmets = (np.linspace(0, 10, 11) * 2 + 1).astype(int)
zsolmets = pad_solmet[(zmets - 1).astype(int)]
示例#50
0
文件: Pex18_6.py 项目: sduzjp/Python
#程序文件Pex18_6.py
import pandas as pd
from statsmodels.graphics.tsaplots import plot_acf
import pylab as plt
from statsmodels.tsa.arima_model import ARIMA

plt.rc('axes', unicode_minus=False)
plt.rc('font', size=16)
plt.rc('font', family='SimHei')
df = pd.read_csv('austa.csv')
plt.subplot(121)
plt.plot(df.value.diff())
plt.title('一次差分')
ax2 = plt.subplot(122)
plot_acf(df.value.diff().dropna(), ax=ax2, title='自相关')

md = ARIMA(df.value, order=(2, 1, 0))
mdf = md.fit(disp=0)
print(mdf.summary())

residuals = pd.DataFrame(mdf.resid)
fig, ax = plt.subplots(1, 2)
residuals.plot(title="残差", ax=ax[0])
residuals.plot(kind='kde', title='密度', ax=ax[1])
plt.legend('')
plt.ylabel('')

mdf.plot_predict()  #原始数据与预测值对比图
plt.show()
示例#51
0
#程序文件Pex19_2.py
import numpy as np
import pylab as plt
from sklearn.svm import SVR

np.random.seed(123)
x = np.arange(200).reshape(-1, 1)
y = (np.sin(x) + 3 + np.random.uniform(-1, 1, (200, 1))).ravel()

model = SVR(gamma='auto')
print(model)
model.fit(x, y)
pred_y = model.predict(x)
print("原始数据与预测值前15个值对比:")
for i in range(15):
    print(y[i], pred_y[i])

plt.rc('font', family='SimHei')
plt.rc('font', size=15)
plt.scatter(x, y, s=5, color="blue", label="原始数据")
plt.plot(x, pred_y, '-r*', lw=1.5, label="预测值")
plt.legend(loc=1)

score = model.score(x, y)
print("score:", score)
ss = ((y - pred_y)**2).sum()  #计算残差平方和
print("残差平方和:", ss)
plt.show()
示例#52
0
import pylab

# Load the data from the file.
t, s, ds = pylab.loadtxt('data/scatter_plot.txt', unpack=True)

# Format the plot.
pylab.rc('font', size=18)
pylab.title('Law of motion', y=1.02)
pylab.xlabel('t [s]')
pylab.ylabel('s [m]', labelpad=25)
pylab.xlim(0, 10)
pylab.ylim(0, 18)
pylab.grid(color='gray')

# Create the scatter plot.
pylab.errorbar(t, s, ds, linestyle='', color='black', marker='o')

# Save the plot to a pdf file for later use (maybe in a writeup?).
pylab.savefig('scatter_plot_fancier.pdf')

# Finally: show the plot on the screen.
pylab.show()
示例#53
0
import matplotlib as mpl
import pylab as plt
from pylab import rc

rc('axes', linewidth=1.2)
mpl.rcParams.update(mpl.rcParamsDefault)
mpl.rcParams['font.size'] = 26.
mpl.rcParams['font.family'] = 'serif'
#mpl.rcParams['font.family'] = 'serif'
mpl.rcParams['font.serif'] = [
    'Times New Roman', 'Times', 'Palatino', 'Charter', 'serif'
]
mpl.rcParams['font.sans-serif'] = ['Helvetica']
mpl.rcParams['axes.labelsize'] = 24
mpl.rcParams['xtick.labelsize'] = 22.
mpl.rcParams['ytick.labelsize'] = 22.
mpl.rcParams['xtick.major.size'] = 15.
mpl.rcParams['xtick.minor.size'] = 10.
mpl.rcParams['ytick.major.size'] = 15.
mpl.rcParams['ytick.minor.size'] = 10.
#mpl.rcParams['figure.autolayout']= True

#fontsize=26
#mpl.rc('axes',  titlesize=fontsize)
#mpl.rc('axes',  labelsize=fontsize)
#mpl.rc('xtick', labelsize=fontsize)
#mpl.rc('ytick', labelsize=fontsize)
#mpl.rc('font', size=fontsize, family='serif', serif='Utopia',
#              style='normal', variant='normal',
#              stretch='normal', weight='normal')
#mpl.rc('font',**{'family':'serif','serif':[ 'Times New Roman', 'Times', 'serif'],
import aplpy as ap
import numpy as np
import pylab as pl
import coords as co

mom0_map = '../moment_maps/spt0348_C+_dirty_contsub_briggs_robust05.image.mom0.fits'
mom1_map = '../moment_maps/spt0348_C+_dirty_contsub_briggs_robust05.image.mom1.fits'
mom2_map = '../moment_maps/spt0348_C+_dirty_contsub_briggs_robust05.image.mom2.fits'

############
#MOMENT MAPS
############

#set up figure
fig = pl.figure()
pl.rc('font', size=30)
pl.rc('mathtext', default='regular')

RA_c = co.convHMS('03:48:42.271')
DEC_c = co.convDMS('-62:20:50.85')

#moment-0 map
mom0 = ap.FITSFigure(mom0_map, figure=fig, subplot=[0, 0, 0.75, 1])
mom0.tick_labels.set_xformat('hh:mm:ss')
mom0.tick_labels.set_yformat('dd:mm:ss')
mom0.hide_xaxis_label()
mom0.hide_xtick_labels()
mom0.hide_yaxis_label()
mom0.hide_ytick_labels()
mom0.recenter(RA_c, DEC_c, width=5. / 3600, height=5. / 3600)
mom0.show_colorscale(cmap='jet', vmax=12, vmin=0.0, interpolation='nearest')
def test_with_nested_CV(folder='model',
                        folds=5,
                        plot=True,
                        steps=['hashing', 'tfidf']):
    '''
    
    Evaluates the classifer by doing nested CV 
    i.e. keeping 1/folds of the data out of the training and doing training 
    (including model selection for regularizer) on the training set and testing
    on the held-out data
    
    Also prints some stats and figures
    
    INPUT
    folder  folder with model files
    folds   number of folds

    '''
    # start timer
    import time
    t0 = time.time()
    # create bag of words representations
    vv = Vectorizer(steps=steps)

    # load data
    vec = Vectorizer(folder=folder)
    data = get_speech_text(folder=folder)
    for key in data.keys():
        data[key] = vec.transform(data[key])
    # create numerical labels
    Y = hstack(
        map((lambda x: ones(data[data.keys()[x]].shape[0]) * x),
            range(len(data))))
    # create data matrix
    X = vstack(data.values())
    # permute data
    fsize = len(Y) / folds
    randidx = permutation(len(Y))
    Y = Y[randidx]
    X = X[randidx, :]
    idx = reshape(arange(fsize * folds), (folds, fsize))
    Y = Y[:fsize * folds]
    # allocate matrices for predictions
    predicted = zeros(fsize * folds)
    predicted_prob = zeros((fsize * folds, len(data)))

    # the regularization parameters to choose from
    parameters = {'C': (10.**arange(-4, 4, 1.)).tolist()}

    # do nested CV
    for ifold in range(folds):
        testidx = idx[ifold, :]
        trainidx = idx[setdiff1d(arange(folds), ifold), :].flatten()
        text_clf = LogisticRegression(class_weight='auto', dual=True)
        # for nested CV, do folds-1 CV for parameter optimization
        # within inner CV loop and use the outer testfold as held-out data
        # for model validation
        gs_clf = GridSearchCV(text_clf, parameters, n_jobs=-1, cv=(folds - 1))
        gs_clf.fit(X[trainidx, :], Y[trainidx])
        predicted[testidx] = gs_clf.predict(X[testidx, :])
        predicted_prob[testidx, :] = gs_clf.predict_proba(X[testidx, :])
        print '************ Fold %d *************' % (ifold + 1)
        print metrics.classification_report(Y[testidx],
                                            predicted[testidx],
                                            target_names=data.keys())

    t1 = time.time()
    total_time = t1 - t0
    timestr = 'Wallclock time: %f sec\n' % total_time
    dimstr = 'Vocabulary size: %d\n' % X.shape[-1]
    report = timestr + dimstr
    # extract some metrics
    print '********************************'
    print '************ Total *************'
    print '********************************'
    report += metrics.classification_report(Y,
                                            predicted,
                                            target_names=data.keys())
    # dump metrics to file
    open(folder + '/report_%s.txt' % '_'.join(sorted(steps)),
         'wb').write(report)
    print(report)
    conf_mat = metrics.confusion_matrix(Y, predicted)
    open(folder + '/conf_mat_%s.txt' % '_'.join(sorted(steps)),
         'wb').write(json.dumps(conf_mat.tolist()))
    print(conf_mat)

    if plot:
        # print confusion matrix
        import pylab
        pylab.figure(figsize=(16, 16))
        pylab.imshow(metrics.confusion_matrix(Y, predicted),
                     interpolation='nearest')
        pylab.colorbar()
        pylab.xticks(arange(4), [x.decode('utf-8') for x in data.keys()])
        pylab.yticks(arange(4), [x.decode('utf-8') for x in data.keys()])
        pylab.xlabel('Predicted')
        pylab.ylabel('True')
        font = {'family': 'normal', 'size': 30}
        pylab.rc('font', **font)
        pylab.savefig(folder + '/conf_mat.pdf', bbox_inches='tight')
示例#56
0
        # Second Normalisation (mean norm)
        min_val, max_val = curve.min().min(
        ), curve.max().max() + fill.max().max() / 2
        curve = (curve - min_val) / (max_val - min_val)
    elif VAR_ == 'ratio':
        # Fluorescence correction
        delta_val = 1 - curve[0].min()
        if delta_val < 0: curve = curve - abs(delta_val)
    ## Curve labelling
    gf_lbl = df.groupby([LVL_ORDER[1]])
    lbl_list = gf_lbl[LABEL].first().values.astype('str')  # normally same name

    # Figure
    fig = plt.figure(figsize=(W, H))

    plt.rc('font', size=S)
    plt.rc('axes', titlesize=S)

    ax = fig.add_subplot()
    ax.set_title(CURVE_FOLDER + ' ' + label, fontsize=L)
    ax.set_ylabel(NAME_VAR + ' ' + VAR_, fontsize=L)
    ax.set_xlabel('time (h)', fontsize=L)
    #curve.T.plot(ax=ax) # Automatic legends, otherwise : #name = curve.index.values
    i = 0
    if not (np.any(EXP_IDX != None)):
        EXP_IDX = np.arange(lbl_list.size)
    for stack in np.dstack((curve.values, fill, time))[EXP_IDX]:
        name = lbl_list[EXP_IDX[i]]
        i += 1
        z = stack.T
        ax.plot(z[-1], z[0], label=name)
示例#57
0
params = {
    'text.usetex': True,
    'axes.labelsize': fontsize,
    'font.size': fontsize,
    'legend.fontsize': legendfontsize,
    'xtick.labelsize': fontsize,
    'ytick.labelsize': fontsize,
    'figure.figsize': fig_size,
    'font.weight': 'normal'
}

import pylab
pylab.rcParams.update(params)
pylab.rcParams['axes.linewidth'] = 1
pylab.rc('axes', linewidth=1)


def touchbox(ax):
    ax.minorticks_on()
    ax.tick_params('both', length=5, width=1, which='major')
    ax.tick_params('both', length=3.5, width=1, which='minor')
    ax.spines['top'].set_linewidth(1)
    ax.spines['bottom'].set_linewidth(1)
    ax.spines['right'].set_linewidth(1)
    ax.spines['left'].set_linewidth(1)
    return


# plt.style.use('seaborn-darkgrid')
def animate_interactive(data, t = [], dimOrder = (0,1,2),
                        fps = 10.0, title = '', xlabel = 'x', ylabel = 'y',
                        fontsize = 24, cBar = 0, sloppy = True,
                        rangeMin = [], rangeMax = [], extent = [-1,1,-1,1],
                        shade = False, azdeg = 0, altdeg = 65,
                        arrowsX = np.array(0), arrowsY = np.array(0), arrowsRes = 10,
                        arrowsPivot = 'mid', arrowsWidth = 0.002, arrowsScale = 5,
                        arrowsColor = 'black', plotArrowsGrid = False,
                        movieFile = '', bitrate = 1800, keepImages = False,
                        figsize = (8, 7), dpi = None,
                        **kwimshow):
    """
    Assemble a 2D animation from a 3D array.

    call signature::
    
      animate_interactive(data, t = [], dimOrder = (0,1,2),
                        fps = 10.0, title = '', xlabel = 'x', ylabel = 'y',
                        fontsize = 24, cBar = 0, sloppy = True,
                        rangeMin = [], rangeMax = [], extent = [-1,1,-1,1],
                        shade = False, azdeg = 0, altdeg = 65,
                        arrowsX = np.array(0), arrowsY = np.array(0), arrowsRes = 10,
                        arrowsPivot = 'mid', arrowsWidth = 0.002, arrowsScale = 5,
                        arrowsColor = 'black', plotArrowsGrid = False,
                        movieFile = '', bitrate = 1800, keepImages = False,
                        figsize = (8, 7), dpi = None,
                        **kwimshow)
    
    Assemble a 2D animation from a 3D array. *data* has to be a 3D array who's
    time index has the same dimension as *t*. The time index of *data* as well
    as its x and y indices can be changed via *dimOrder*.
    
    Keyword arguments:
    
      *dimOrder*: [ (i,j,k) ]
        Ordering of the dimensions in the data array (t,x,y).
        
     *fps*:
       Frames per second of the animation.
       
     *title*:
       Title of the plot.
       
     *xlabel*:
       Label of the x-axis.
       
     *ylabel*:
       Label of the y-axis.
       
     *fontsize*:
       Font size of the title, x and y label.
       The size of the x- and y-ticks is 0.7*fontsize and the colorbar ticks's
       font size is 0.5*fontsize.
       
     *cBar*: [ 0 | 1 | 2 ]
       Determines how the colorbar changes:
       (0 - no cahnge; 1 - keep extreme values constant; 2 - change extreme values).
     
     *sloppy*: [ True | False ]
       If True the update of the plot lags one frame behind. This speeds up the
       plotting.
     
     *rangeMin*, *rangeMax*:
       Range of the colortable.
       
     *extent*: [ None | scalars (left, right, bottom, top) ]
       Data limits for the axes. The default assigns zero-based row,
       column indices to the *x*, *y* centers of the pixels.
       
     *shade*: [ False | True ]
       If True plot a shaded relief plot instead of the usual colormap.
       Note that with this option cmap has to be specified like
       cmap = plt.cm.hot instead of cmap = 'hot'. Shading cannot
       be used with the cBar = 0 option.
     
     *azdeg*, *altdeg*:
       Azimuth and altitude of the light source for the shading.
       
     *arrowsX*:
       Data containing the x-component of the arrows.
       
     *arrowsy*:
       Data containing the y-component of the arrows.
       
     *arrowsRes*:
       Plot every arrowRes arrow.
       
     *arrowsPivot*: [ 'tail' | 'middle' | 'tip' ]
       The part of the arrow that is at the grid point; the arrow rotates
       about this point.
       
     *arrowsWidth*:
       Width of the arrows.
       
     *arrowsScale*:
       Scaling of the arrows.
       
     *arrowsColor*:
       Color of the arrows.
       
     *plotArrowsGrid*: [ False | True ]
       If 'True' the grid where the arrows are aligned to is shown.
     
     *movieFile*: [ None | string ]
       The movie file where the animation should be saved to.
       If 'None' no movie file is written. Requires 'mencoder' to be installed.
     
     *bitrate*:
       Bitrate of the movie file. Set to higher value for higher quality.
       
     *keepImages*: [ False | True ]
       If 'True' the images for the movie creation are not deleted.
     
     *figsize*:
       Size of the figure in inches.
      
     *dpi*:
       Dots per inch of the frame.
     
     **kwimshow:
       Remaining arguments are identical to those of pylab.imshow. Refer to that help.
    """

    import pylab as plt
    import time
    import os # for making the movie
    try:
        import thread # for GUI
    except:
        import _thread as thread
    from matplotlib.colors import LightSource

    global tStep, sliderTime, pause
    
    
    # plot the current frame
    def plotFrame():
        global tStep, sliderTime
        
        if movieFile:
            ax.set_title(title+r'$\quad$'+r'$t={0}$'.format(t[tStep]), fontsize = fontsize)
        
        if shade == False:
            image.set_data(data[tStep,:,:])           
        else:                
            image.set_data(rgb[tStep,:,:,:])   
            
        if (cBar == 0):
            pass
        if (cBar == 1):
            colorbar.set_clim(vmin=data[tStep,:,:].min(), vmax=data[tStep,:,:].max())
        if (cBar == 2):
            colorbar.set_clim(vmin=data[tStep,:,:].min(), vmax=data[tStep,:,:].max())
            colorbar.update_bruteforce(data[tStep,:,:])
            
        if plotArrows:
            arrows.set_UVC(U = arrowsX[tStep,::arrowsRes,::arrowsRes], V = arrowsY[tStep,::arrowsRes,::arrowsRes])
        
        if (sloppy == False) or (movieFile):
            manager.canvas.draw()


    # play the movie
    def play(threadName):               
        global tStep, sliderTime, pause
        
        pause = False
        while (tStep < nT) & (pause == False):        
            # write the image files for the movie
            if movieFile:
                plotFrame()
                frameName = movieFile + '%06d.png'%tStep
                fig.savefig(frameName, dpi = dpi)
                movieFiles.append(frameName)
            else:
                start = time.clock()
                # time slider
                sliderTime.set_val(t[tStep])
                # wait for the next frame (fps)
                while (time.clock() - start < 1.0/fps):
                    pass # do nothing                                        
            tStep += 1        
        tStep -= 1
            
    
    # call the play function as a separate thread (for GUI)
    def play_thread(event):
        global pause
        
        if pause == True:
            try:
                thread.start_new_thread(play, ("playThread", ))
            except:
                print("Error: unable to start play thread")


    def pausing(event):               
        global pause
        
        pause = True        


    def reverse(event):
        global tStep, sliderTime
        
        tStep -= 1
        if tStep < 0:
            tStep = 0
        # plot the frame and update the time slider
        sliderTime.set_val(t[tStep])

        
    def forward(event):
        global tStep, sliderTime
        
        tStep += 1
        if tStep > len(t)-1:
            tStep = len(t)-1
        # plot the frame and update the time slider
        sliderTime.set_val(t[tStep])
    
    pause = True
    plotArrows = False
    
    # check if the data has the right dimensions
    if (len(data.shape) != 3 and len(data.shape) != 4):
        print("error: data dimensions are invalid: {0} instead of 3".format(len(data.shape)))
        return -1
        
    # transpose the data according to dimOrder
    unOrdered = data
    data = np.transpose(unOrdered, dimOrder)
    unOrdered = []        
    
    # check if arrows should be plotted
    if len(arrowsX.shape) == 3:
        # transpose the data according to dimOrder
        unOrdered = arrowsX
        arrowsX = np.transpose(unOrdered, dimOrder)
        unOrdered = []
        if len(arrowsY.shape) == 3:
            # transpose the data according to dimOrder
            unOrdered = arrowsY
            arrowsY = np.transpose(unOrdered, dimOrder)
            unOrdered = []
            
            # check if the dimensions of the arrow arrays match each other
            if ((len(arrowsX[:,0,0]) != len(arrowsY[:,0,0])) or (len(arrowsX[0,:,0]) != len(arrowsY[0,:,0])) or (len(arrowsX[0,0,:]) != len(arrowsY[0,0,:]))):
                print("error: dimensions of arrowX do not match with dimensions of arrowY")
                return -1
            else:
                plotArrows = True
    
    # check if time array has the right length
    nT = len(t)
    if (nT != len(data[:,0,0])):
        print("error: length of time array doesn\'t match length of data array")
        return -1
        if plotArrows:
            if (nT != len(arrowsX[:,0,0]) or nT != len(arrowsX[:,0,0])):
                print("error: length of time array doesn\'t match length of arrows array")
                return -1
    
    # check if fps is positive
    if (fps < 0.0):
        print("error: fps is not positive, fps = {0}".format(fps))
        return -1

    # determine the size of the array
    nX = len(data[0,:,0])
    nY = len(data[0,0,:])
    
    # determine the minimum and maximum values of the data set
    if not(rangeMin):
        rangeMin = np.min(data)
    if not(rangeMax):
        rangeMax = np.max(data)
    
    # setup the plot
    if movieFile:
        plt.rc("figure.subplot", bottom=0.15)
        plt.rc("figure.subplot", top=0.95)
        plt.rc("figure.subplot", right=0.95)
        plt.rc("figure.subplot", left=0.15)
        fig = plt.figure(figsize = figsize)
        ax = plt.axes([0.1, 0.1, .90, .85])
    else:
        plt.rc("figure.subplot", bottom=0.05)
        plt.rc("figure.subplot", top=0.95)
        plt.rc("figure.subplot", right=0.95)
        plt.rc("figure.subplot", left=0.15)
        fig = plt.figure(figsize = figsize)
        ax = plt.axes([0.1, 0.25, .85, .70])
    
    ax.set_title(title, fontsize = fontsize)
    ax.set_xlabel(xlabel, fontsize = fontsize)
    ax.set_ylabel(ylabel, fontsize = fontsize)
    plt.xticks(fontsize = 0.7*fontsize)
    plt.yticks(fontsize = 0.7*fontsize)
    if shade:
        plane = np.zeros((nX,nY,3))
    else:
        plane = np.zeros((nX,nY))

    # apply shading if True
    if shade:
        ls = LightSource(azdeg = azdeg, altdeg = altdeg)
        rgb = []
        # shading can be only used with cBar = 1 or cBar = 2 at the moment
        if cBar == 0:
            cBar = 1
        # check if colormap is set, if not set it to 'copper'
        if not 'cmap' in kwimshow.keys():
            kwimshow['cmap'] = plt.cm.copper
        for i in range(len(data[:,0,0])):
            tmp = ls.shade(data[i,:,:], kwimshow['cmap'])
            rgb.append(tmp.tolist())
        rgb = np.array(rgb)
        tmp = []
        
    # calibrate the displayed colors for the data range
    image = ax.imshow(plane, vmin=rangeMin, vmax=rangeMax, origin='lower', extent = extent, **kwimshow)
    colorbar = fig.colorbar(image)
    # change the font size of the colorbar's ytickslabels
    cbytick_obj = plt.getp(colorbar.ax.axes, 'yticklabels')
    plt.setp(cbytick_obj, fontsize = 0.5*fontsize)
    
    # plot the arrows
    # TODO: add some more options
    if plotArrows:
        # prepare the mash grid where the arrows will be drawn
        arrowGridX, arrowGridY = np.meshgrid(np.arange(extent[0], extent[1], float(extent[1]-extent[0])*arrowsRes/len(data[0,:,0])), np.arange(extent[2], extent[3], float(extent[3]-extent[2])*arrowsRes/len(data[0,0,:])))        
        arrows = ax.quiver(arrowGridX, arrowGridY, arrowsX[0,::arrowsRes,::arrowsRes], arrowsY[0,::arrowsRes,::arrowsRes], units = 'width', pivot = arrowsPivot, width = arrowsWidth, scale = arrowsScale, color = arrowsColor)
        # plot the grid for the arrows
        if plotArrowsGrid == True:
            ax.plot(arrowGridX, arrowGridY, 'k.')
        

    # for real-time image display
    if (sloppy == False) or (movieFile):
        manager = plt.get_current_fig_manager()
        manager.show()


    tStep = 0
    if movieFile:
        movieFiles = []
        # start the animation
        play('noThread')

        # write the movie file        
        mencodeCommand = "mencoder 'mf://"+movieFile+"*.png' -mf type=png:fps="+np.str(fps)+" -ovc lavc -lavcopts vcodec=mpeg4:vhq:vbitrate="+np.str(bitrate)+" -ffourcc MP4S -oac copy -o "+movieFile+".mpg"
        os.system(mencodeCommand)
        # clean up the image files
        if (keepImages == False):
            print("cleaning up files")
            for fname in movieFiles:
                os.remove(fname)

    else:
        # set up the gui        
        plt.ion()

        axPlay = plt.axes([0.1, 0.05, 0.15, 0.05], axisbg='lightgoldenrodyellow')
        buttonPlay = plt.Button(axPlay, 'play', color='lightgoldenrodyellow', hovercolor='0.975')
        buttonPlay.on_clicked(play_thread)
        axPause = plt.axes([0.3, 0.05, 0.15, 0.05], axisbg='lightgoldenrodyellow')
        buttonPause = plt.Button(axPause, 'pause', color='lightgoldenrodyellow', hovercolor='0.975')
        buttonPause.on_clicked(pausing)
    
        axReverse = plt.axes([0.5, 0.05, 0.15, 0.05], axisbg='lightgoldenrodyellow')
        buttonReverse = plt.Button(axReverse, 'reverse', color='lightgoldenrodyellow', hovercolor='0.975')
        buttonReverse.on_clicked(reverse)
        axForward = plt.axes([0.7, 0.05, 0.15, 0.05], axisbg='lightgoldenrodyellow')
        buttonForward = plt.Button(axForward, 'forward', color='lightgoldenrodyellow', hovercolor='0.975')
        buttonForward.on_clicked(forward)
        
        # create the time slider
        fig.subplots_adjust(bottom=0.2)
        sliderTimeAxes = plt.axes([0.2, 0.12, 0.6, 0.03], axisbg='lightgoldenrodyellow')
        sliderTime = plt.Slider(sliderTimeAxes, 'time', t[0], t[-1], valinit = 0.0)
        def update(val):
            global tStep
            # find the closest time step to the slider time value            
            for i in range(len(t)):
                if t[i] < sliderTime.val:
                    tStep = i
            if (tStep != len(t)-1):
                if (t[tStep+1] - sliderTime.val) < (sliderTime.val - t[tStep]):
                    tStep += 1
            plotFrame()
        sliderTime.on_changed(update)
    
        plt.show()
        
    print("done")
示例#59
0
def usetexFalse():
    pylab.rc('text', usetex=False)
    pylab.rc('font', size=14)
    pylab.rc('axes', titlesize=16, labelsize=16)
    pylab.rc('xtick', labelsize=14)
    pylab.rc('ytick', labelsize=14)
def inv_convolve(h1, h3, length):
    x = np.random.standard_normal(10000)
    u = signal.lfilter(h1, 1, x)
    d = signal.lfilter(h3, 1, x)
    h = np.zeros(length, np.float64)
    nlms(u, d, h, 0.1)
    return h


h1 = np.fromfile("h1.txt", sep="\n")
h1 /= np.max(h1)
h3 = np.fromfile("h3.txt", sep="\n")
h3 /= np.max(h3)

pl.rc('legend', fontsize=10)
pl.subplot(411)
pl.plot(h3, label="h3")
pl.plot(h1, label="h1")
pl.legend()
pl.gca().set_yticklabels([])
for idx, length in enumerate([128, 256, 512]):
    pl.subplot(412 + idx)
    h2 = inv_convolve(h1, h3, length)
    pl.plot(np.convolve(h1, h2)[:len(h3)], label="h1*h2(%s)" % length)
    pl.legend()
    pl.gca().set_yticklabels([])
    pl.gca().set_xticklabels([])

pl.show()