Beispiel #1
1
def main():
    SAMPLE_NUM = 10
    degree = 9
    x, y = sin_wgn_sample(SAMPLE_NUM)
    fig = pylab.figure(1)
    pylab.grid(True)
    pylab.xlabel('x')
    pylab.ylabel('y')
    pylab.axis([-0.1,1.1,-1.5,1.5])

    # sin(x) + noise
    # markeredgewidth mew
    # markeredgecolor mec
    # markerfacecolor mfc

    # markersize      ms
    # linewidth       lw
    # linestyle       ls
    pylab.plot(x, y,'bo',mew=2,mec='b',mfc='none',ms=8)

    # sin(x)
    x2 = linspace(0, 1, 1000)
    pylab.plot(x2,sin(2*x2*pi),'#00FF00',lw=2,label='$y = \sin(x)$')

    # polynomial fit
    reg = exp(-18)
    w = curve_poly_fit(x, y, degree,reg) #w = polyfit(x, y, 3)
    po = poly1d(w)      
    xx = linspace(0, 1, 1000)
    pylab.plot(xx, po(xx),'-r',label='$M = 9, \ln\lambda = -18$',lw=2)
    
    pylab.legend()
    pylab.show()
    fig.savefig("poly_fit9_10_reg.pdf")
Beispiel #2
1
def plot_tracks(src, fakewcs, spa=None, **kwargs):
    # NOTE -- MAGIC 61 = monthly; this is ASSUMEd below.
    tt = np.linspace(2010., 2015., 61)
    t0 = TAITime(None, mjd=TAITime.mjd2k + 365.25*10)
    #rd0 = src.getPositionAtTime(t0)
    #print 'rd0:', rd0
    xx,yy = [],[]
    rr,dd = [],[]
    for t in tt:
        #print 'Time', t
        rd = src.getPositionAtTime(t0 + (t - 2010.)*365.25*24.*3600.)
        ra,dec = rd.ra, rd.dec
        rr.append(ra)
        dd.append(dec)
        ok,x,y = fakewcs.radec2pixelxy(ra,dec)
        xx.append(x - 1.)
        yy.append(y - 1.)

    if spa is None:
        spa = [None,None,None]
    for rows,cols,sub in spa:
        if sub is not None:
            plt.subplot(rows,cols,sub)
        ax = plt.axis()
        plt.plot(xx, yy, 'k-', **kwargs)
        plt.axis(ax)

    return rr,dd,tt
Beispiel #3
0
def m2screenshot(mayavi_fig=None, mpl_axes=None, autocrop=True):
    """ Capture a screeshot of the Mayavi figure and display it in the
        matplotlib axes.
    """
    import pylab as pl
    # Late import to avoid triggering wx imports before needed.
    try:
        from mayavi import mlab
    except ImportError:
        # Try out old install of Mayavi, with namespace packages
        from enthought.mayavi import mlab

    if mayavi_fig is None:
        mayavi_fig = mlab.gcf()
    else:
        mlab.figure(mayavi_fig)
    if mpl_axes is not None:
        pl.axes(mpl_axes)

    filename = tempfile.mktemp('.png')
    mlab.savefig(filename, figure=mayavi_fig)
    image3d = pl.imread(filename)
    if autocrop:
        bg_color = mayavi_fig.scene.background
        image3d = autocrop_img(image3d, bg_color)
    pl.imshow(image3d)
    pl.axis('off')
    os.unlink(filename)
def check_vpd_ks2_astrometry():
    """
    Check the VPD and quiver plots for our KS2-extracted, re-transformed astrometry.
    """
    catFile = workDir + '20.KS2_PMA/wd1_catalog.fits'
    tab = atpy.Table(catFile)

    good = (tab.xe_160 < 0.05) & (tab.ye_160 < 0.05) & \
        (tab.xe_814 < 0.05) & (tab.ye_814 < 0.05) & \
        (tab.me_814 < 0.05) & (tab.me_160 < 0.05)

    tab2 = tab.where(good)

    dx = (tab2.x_160 - tab2.x_814) * ast.scale['WFC'] * 1e3
    dy = (tab2.y_160 - tab2.y_814) * ast.scale['WFC'] * 1e3

    py.clf()
    q = py.quiver(tab2.x_814, tab2.y_814, dx, dy, scale=5e2)
    py.quiverkey(q, 0.95, 0.85, 5, '5 mas', color='red', labelcolor='red')
    py.savefig(workDir + '20.KS2_PMA/vec_diffs_ks2_all.png')

    py.clf()
    py.plot(dy, dx, 'k.', ms=2)
    lim = 30
    py.axis([-lim, lim, -lim, lim])
    py.xlabel('Y Proper Motion (mas)')
    py.ylabel('X Proper Motion (mas)')
    py.savefig(workDir + '20.KS2_PMA/vpd_ks2_all.png')

    idx = np.where((np.abs(dx) < 10) & (np.abs(dy) < 10))[0]
    print('Cluster Members (within dx < 10 mas and dy < 10 mas)')
    print(('   dx = {dx:6.2f} +/- {dxe:6.2f} mas'.format(dx=dx[idx].mean(),
                                                        dxe=dx[idx].std())))
    print(('   dy = {dy:6.2f} +/- {dye:6.2f} mas'.format(dy=dy[idx].mean(),
                                                        dye=dy[idx].std())))
Beispiel #5
0
def plotLDDecaySelection3d(ax, sweep=False):
    import pylab as plt; import matplotlib as mpl;mpl.rc('font', **{'family': 'serif', 'serif': ['Computer Modern'], 'size':16}) ;    mpl.rc('text', usetex=True)

    def neutral(ld0, t, d, r=2 * 1e-8):
        if abs(d) <= 5e3:
            d = np.sign(d) * 5e3
        if d == 0:
            d = 5e3
        return ((np.exp(-2 * r * t * abs(d)))) * ld0

    t = np.arange(0, 200 + 1., 2)
    L=1e6+1
    pos=500000
    r=2*1e-8
    ld0 = 0.5
    s = 0.05
    nu0 = 0.1
    positions=np.arange(0,L,1000)
    dist=(positions - pos)
    T, D = np.meshgrid(t, dist)
    if not sweep:
        zs = np.array([neutral(ld0, t, d) for t, d in zip(np.ravel(T), np.ravel(D))])
    else:
        zs = np.array([LD(t, ld0, s, nu0, r, abs(d), 0) for t, d in zip(np.ravel(T), np.ravel(D))])
    Z = zs.reshape(T.shape)
    ax.plot_surface(T, D, Z,cmap=mpl.cm.autumn)
    ax.set_xlabel('Generations')
    ax.set_ylabel('Position')
    plt.yticks(plt.yticks()[0][1:-1],map(lambda x:'{:.0f}K'.format((pos+(x))/1000),plt.yticks()[0][1:-1]))
    plt.ylim([-500000,500000])
    ax.set_zlabel(r"$|\rho_t|$")
    pplt.setSize(plt.gca(), fontsize=6)
    plt.axis('tight');
    def plot_matches(self, name, show_below = True, match_maximum = None):
        """ 対応点を線で結んで画像を表示する
          入力: im1,im2(配列形式の画像)、locs1,locs2(特徴点座標)
             machescores(match()の出力)、
             show_below(対応の下に画像を表示するならTrue)"""
        im1 = self._image_1.get_array_image()
        im2 = self._image_2.get_array_image()
        self.appendimages()
        im3 = self._append_image
        if self._match_score is None:
            self.match()
        locs1 = self._image_1.get_shift_location()
        locs2 = self._image_2.get_shift_location()
        if show_below:
            im3 = numpy.vstack((im3,im3))
        pylab.figure(dpi=160)
        pylab.gray()
        pylab.imshow(im3, aspect = 'auto')

        cols1 = im1.shape[1]
        match_num = 0
        for i,m in enumerate(self._match_score):
            if m > 0 : 
                pylab.plot([locs1[i][0],locs2[m][0]+cols1], [locs1[i][1],locs2[m][1]], 'c')
                match_num = match_num + 1
            if match_maximum is not None and match_num >= match_maximum:
                break
        pylab.axis('off')
        pylab.savefig(name, dpi=160)
def compareAnimals(animals, precision):
    """Assumes animals is a list of animals, precision an int >= 0
       Builds a table of Euclidean distance between each animal"""
    #Get labels for columns and rows
    columnLabels = []
    for a in animals:
        columnLabels.append(a.getName())
    rowLabels = columnLabels[:]
    tableVals = []
    #Get distances between pairs of animals
    #For each row
    for a1 in animals:
        row = []
        #For each column
        for a2 in animals:
            if a1 == a2:
                row.append('--')
            else:
                distance = a1.distance(a2)
                row.append(str(round(distance, precision)))
        tableVals.append(row)
    #Produce table
    table = pylab.table(rowLabels = rowLabels,
                        colLabels = columnLabels,
                        cellText = tableVals,
                        cellLoc = 'center',
                        loc = 'center',
                        colWidths = [0.2]*len(animals))
    table.scale(1, 2.5)
    pylab.axis('off') #Don't display x and y-axes
    pylab.savefig('distances')
def simplegrid():

    nzones = 7

    gr = gpu.grid(nzones, xmin=0, xmax=1)

    gpu.drawGrid(gr, edgeTicks=0)

    # label a few cell-centers
    gpu.labelCenter(gr, nzones/2, r"$i$")
    gpu.labelCenter(gr, nzones/2-1, r"$i-1$")
    gpu.labelCenter(gr, nzones/2+1, r"$i+1$")

    # label a few edges
    gpu.labelEdge(gr, nzones/2, r"$i-1/2$")
    gpu.labelEdge(gr, nzones/2+1, r"$i+1/2$")


    # draw an average quantity
    gpu.drawCellAvg(gr, nzones/2, 0.4, color="r")
    gpu.labelCellAvg(gr, nzones/2, 0.4, r"$\,\langle a \rangle_i$", color="r")

    pylab.axis([gr.xmin-1.5*gr.dx,gr.xmax+1.5*gr.dx, -0.25, 1.5])
    pylab.axis("off")

    pylab.subplots_adjust(left=0.05,right=0.95,bottom=0.05,top=0.95)

    f = pylab.gcf()
    f.set_size_inches(10.0,2.5)


    pylab.savefig("simplegrid2.png")
    pylab.savefig("simplegrid2.eps")
Beispiel #9
0
def makeContourPlot(scores, average, HEIGHT, WIDTH, outputId, maskId, plt_title, outputdir, barcodeId=-1, vmaxVal=100):
    pylab.bone()
    #majorFormatter = FormatStrFormatter('%.f %%')
    #ax = pylab.gca()
    #ax.xaxis.set_major_formatter(majorFormatter)
    
    pylab.figure()
    ax = pylab.gca()
    ax.set_xlabel(str(WIDTH) + ' wells')
    ax.set_ylabel(str(HEIGHT) + ' wells')
    ax.autoscale_view()
    pylab.jet()
    
    pylab.imshow(scores,vmin=0, vmax=vmaxVal, origin='lower')
    pylab.vmin = 0.0
    pylab.vmax = 100.0
    ticksVal = getTicksForMaxVal(vmaxVal)
    pylab.colorbar(format='%.0f %%',ticks=ticksVal)
    print "'%s'" % average
    if(barcodeId!=-1):
        if(barcodeId==0): maskId = "No Barcode Match,"
        else:             maskId = "Barcode Id %d," % barcodeId
    if plt_title != '': maskId = '%s\n%s' % (plt_title,maskId)
    print "Checkpoint A"
    pylab.title('%s Loading Density (Avg ~ %0.f%%)' % (maskId, average))
    pylab.axis('scaled')
    print "Checkpoint B"
    pngFn = outputdir+'/'+outputId+'_density_contour.png'
    print "Try save to", pngFn;
    pylab.savefig(pngFn, bbox_inches='tight')
    print "Plot saved to", pngFn;
Beispiel #10
0
 def __init__(self, baseConfig) :
     self.figsize = baseConfig.get('figsize',None)
     self.axis = baseConfig.get('axis',None)
     self.title = baseConfig.get('title','NoName')
     self.ylabel = baseConfig.get('ylabel','NoName')
     self.grid = baseConfig.get('grid',False)
     self.xaxis_locator = baseConfig.get('xaxis_locator',None)
     self.yaxis_locator = baseConfig.get('yaxis_locator',None)
     self.legend_loc = baseConfig.get('legend_loc',0)
     
     if self.figsize != None :
         pylab.figure(figsize = self.figsize)
     if self.axis != None :
         pylab.axis(self.axis)
     
     pylab.title(self.title)
     pylab.ylabel(self.ylabel)
     ax = pylab.gca()
     pylab.grid(self.grid)
     if self.xaxis_locator != None :
         ax.xaxis.set_major_locator( pylab.MultipleLocator(self.xaxis_locator) )
     if self.yaxis_locator != None :
         ax.yaxis.set_major_locator( pylab.MultipleLocator(self.yaxis_locator) )
     self.lineList = []
     self.id = 1
Beispiel #11
0
def display_image_from_array(nparray,colory='binary',roi=None):
	"""
	Produce a display of the nparray 2D matrix
	@param nparray : image to display
	@type nparray : numpy 2darray
	@param colory : color mapping of the image (see http://www.scipy.org/Cookbook/Matplotlib/Show_colormaps)
	@type colory : string
	"""
	#Set the region of interest to display :
	#  (0,0) is set at lower left corner of the image
	if roi == None:
		roi = ((0,0),nparray.shape)
		nparraydsp = nparray
		print roi
	elif type(roi[0])==tuple and type(roi[1])==tuple: 
		# Case of 2 points definition of the domain : roi = integers index of points ((x1,y1),(x2,y2))
		print roi
		nparraydsp = nparray[roi[0][0]:roi[1][0],roi[0][1]:roi[1][1]]
	elif type(roi[0])==int and type(roi[1])==int:	
		# Case of image centered domain : roi = integers (width,high)
		nparraydsp = nparray[int(nparray.shape[0]/2)-int(roi[0])/2:int(nparray.shape[0]/2)+int(roi[0])/2,int(nparray.shape[1]/2)-int(roi[1])/2:int(nparray.shape[1]/2)+int(roi[1])/2]
	fig = pylab.figure()
    #Display array with grayscale intensity and no pixel smoothing interpolation
	pylab.imshow(nparraydsp,cmap=colory,interpolation='nearest')#,origin='lower')
	pylab.colorbar()
	pylab.axis('off')
def correlation_matrix(data, size=8.0):
    """ Calculates and shows the correlation matrix of the pandas data frame
        'data' as a heat map.
        Only the correlations between numerical variables are calculated!
    """
    # calculate the correlation matrix
    corr = data.corr()
    #print corr
    lc = len(corr.columns)
    # set some settings for plottin'
    pl.pcolor(corr, vmin = -1, vmax = 1, edgecolor = "black")
    pl.colorbar()
    pl.xlim([-5,lc])
    pl.ylim([0,lc+5])
    pl.axis('off')
    # anotate the rows and columns with their corresponding variables
    ax = pl.gca()            
    for i in range(0,lc):
        ax.annotate(corr.columns[i], (-0.5, i+0.5), \
            size='large', horizontalalignment='right', verticalalignment='center')
        ax.annotate(corr.columns[i], (i+0.5, lc+0.5),\
            size='large', rotation='vertical',\
            horizontalalignment='center', verticalalignment='right')
    # change the size of the image
    fig = pl.figure(num=1)    
    fig.set_size_inches(size+(size/4), size)     
    
    pl.show()
Beispiel #13
0
    def __call__(self, n):
        if len(self.f.shape) == 3:
            # f = f[x,v,t], 2 dim in phase space
            ft = self.f[n,:,:]
            pylab.pcolormesh(self.X, self.V, ft.T, cmap = 'jet')
            pylab.colorbar()
            pylab.clim(0,0.38) # for Landau test case
            pylab.grid()
            pylab.axis([self.xmin, self.xmax, self.ymin, self.ymax])
            pylab.xlabel('$x$', fontsize = 18)
            pylab.ylabel('$v$', fontsize = 18)
            pylab.title('$N_x$ = %d, $N_v$ = %d, $t$ = %2.1f' % (self.x.N, self.v.N, self.it*self.t.width))
            pylab.savefig(self.path + self.filename)
            pylab.clf()
            return None

        if len(self.f.shape) == 2:
            # f = f[x], 1 dim in phase space
            ft = self.f[n,:]
            pylab.plot(self.x.gridvalues,ft,'ob')
            pylab.grid()
            pylab.axis([self.xmin, self.xmax, self.ymin, self.ymax])
            pylab.xlabel('$x$', fontsize = 18)
            pylab.ylabel('$f(x)$', fontsize = 18)
            pylab.savefig(self.path + self.filename)
            return None
def display_head(set_x, set_y, n = 5):
    '''
    show some figures based on gray image matrixs
    
    @type set_x: TensorSharedVariable, 
    @param set_x: gray level value matrix of the
    
    @type set_y: TensorVariable, 
    @param set_y: label of the figures    
    
    @type n: int, 
    @param n: numbers of figure to be display, less than 10, default 5
    '''
    import pylab
    
    if n > 10: n = 10
    img_x = set_x.get_value()[0:n].reshape(n, 28, 28)
    img_y = set_y.eval()[0:n]
    
    for i in range(n): 
        pylab.subplot(1, n, i+1); 
        pylab.axis('off'); 
        pylab.title(' %d' % img_y[i])
        pylab.gray()
        pylab.imshow(img_x[i])
Beispiel #15
0
	def update(self):
		if self.pose != []:
			plt.figure(1)
			clf()
			self.fig1 = plt.figure(num=1, figsize=(self.window_size, \
				self.window_size), dpi=80, facecolor='w', edgecolor='w')
			title (self.title)			
			xlabel('Easting [m]')
			ylabel('Northing [m]')
			axis('equal')
			grid (True)
			poseT = zip(*self.pose)	
			pose_plt = plot(poseT[1],poseT[2],'#ff0000')

			if self.wptnav != []:
				mode = self.wptnav[-1][MODE]

				if not (self.wptnav[-1][B_E] == 0 and self.wptnav[-1][B_N] == 0 and self.wptnav[-1][A_E] == 0 and self.wptnav[-1][A_N] == 0):
					b_dot = plot(self.wptnav[-1][B_E],self.wptnav[-1][B_N],'ro',markersize=8)
					a_dot = plot(self.wptnav[-1][A_E],self.wptnav[-1][A_N],'go',markersize=8)
					ab_line = plot([self.wptnav[-1][B_E],self.wptnav[-1][A_E]],[self.wptnav[-1][B_N],self.wptnav[-1][A_N]],'g')
					target_dot = plot(self.wptnav[-1][TARGET_E],self.wptnav[-1][TARGET_N],'ro',markersize=5)

				if mode == -1:
					pose_dot = plot(self.wptnav[-1][POSE_E],self.wptnav[-1][POSE_N],'b^',markersize=8)
				elif mode == 1:
					pose_dot = plot(self.wptnav[-1][POSE_E],self.wptnav[-1][POSE_N],'bs',markersize=8)
				elif mode == 2:
					pose_dot = plot(self.wptnav[-1][POSE_E],self.wptnav[-1][POSE_N],'bo',markersize=8)

		if self.save_images:
			self.fig1.savefig ('plot_map%05d.jpg' % self.image_count)
			self.image_count += 1
		draw()
Beispiel #16
0
    def _draw_V(self):
        """ draw the V-cycle on our optional visualization """
        xdown = numpy.linspace(0.0, 0.5, self.nlevels)
        xup = numpy.linspace(0.5, 1.0, self.nlevels)

        ydown = numpy.linspace(1.0, 0.0, self.nlevels)
        yup = numpy.linspace(0.0, 1.0, self.nlevels)

        pylab.plot(xdown, ydown, lw=2, color="k")
        pylab.plot(xup, yup, lw=2, color="k")

        pylab.scatter(xdown, ydown, marker="o", color="k", s=40)
        pylab.scatter(xup, yup, marker="o", color="k", s=40)

        if self.up_or_down == "down":
            pylab.scatter(
                xdown[self.nlevels - self.current_level - 1],
                ydown[self.nlevels - self.current_level - 1],
                marker="o",
                color="r",
                zorder=100,
                s=38,
            )

        else:
            pylab.scatter(xup[self.current_level], yup[self.current_level], marker="o", color="r", zorder=100, s=38)

        pylab.text(0.7, 0.1, "V-cycle %d" % (self.current_cycle))
        pylab.axis("off")
Beispiel #17
0
    def plot_density(self, plot_filename="out/density.png"):
        x, y, labels = self.load_data()

        figure(figsize=(self.fig_width, self.fig_height), dpi=80)
        # Perform a kernel density estimator on the coords in data.
        # The following 10 lines can be commented out if density map not needed.
        space_factor = 1.2
        xmin = space_factor * x.min()
        xmax = space_factor * x.max()
        ymin = space_factor * y.min()
        ymax = space_factor * y.max()
        X, Y = mgrid[xmin:xmax:100j, ymin:ymax:100j]
        positions = c_[X.ravel(), Y.ravel()]
        values = c_[x, y]
        kernel = stats.kde.gaussian_kde(values.T)
        Z = reshape(kernel(positions.T).T, X.T.shape)
        imshow(rot90(Z), cmap=cm.gist_earth_r, extent=[xmin, xmax, ymin, ymax])

        # Plot the labels
        num_labels_to_plot = min([len(labels), self.max_labels, len(x), len(y)])
        if self.has_labels:
            for i in range(num_labels_to_plot):
                text(x[i], y[i], labels[i])  # assumes m size and order matches labels
        else:
            plot(x, y, "k.", markersize=1)
        axis("equal")
        axis("off")
        savefig(plot_filename)
        print "wrote %s" % (plot_filename)
Beispiel #18
0
def plot_commerror(name1,logfile1,name2,logfile2):

  file1 = open(str(logfile1),'r').readlines()
  data1 = [float(line.split()[1]) for line in file1]
  iso1 = data1[0::3]
  aniso1 = data1[1::3]
  ml1 = data1[2::3]

  file2 = open(str(logfile2),'r').readlines()
  data2 = [float(line.split()[1]) for line in file2]
  iso2 = data2[0::3]
  aniso2 = data2[1::3]
  ml2 = data2[2::3]

  # x axis
  x=[8,16,32,64,128]
  xlabels=['A','B','C','D','E']
  orderone = [1,.5,.25,.125,.0625]
  ordertwo = [i**2 for i in orderone]
  plot1 = pylab.figure(figsize = (6, 6.5))
  size = 15
  ax = pylab.subplot(111)
  ax.plot(x,iso1, linestyle='solid',color='red',lw=2)
  ax.plot(x,aniso1, linestyle='dashed',color='red',lw=2)
  ax.plot(x,ml1, linestyle='dashdot',color='red',lw=2)
  ax.plot(x,iso2, linestyle='solid',color='blue',lw=2)
  ax.plot(x,aniso2, linestyle='dashed',color='blue',lw=2)
  ax.plot(x,ml2, linestyle='dashdot',color='blue',lw=2)
  #ax.plot(x,orderone, linestyle='solid',color='black',lw=2)
  #ax.plot(x,ordertwo, linestyle='dashed',color='black')
  #pylab.legend((str(name1)+'_iso',str(name1)+'_aniso',str(name2)+'_iso',str(name2)+'_aniso','order 1'),loc="best")
  pylab.legend((str(name1)+'_iso',str(name1)+'_aniso',str(name1)+'_ml',str(name2)+'_iso',str(name2)+'_aniso',str(name2)+'_ml'),loc="best")
  leg = pylab.gca().get_legend()
  ltext = leg.get_texts()
  pylab.setp(ltext, fontsize = size, color = 'black')
  frame=leg.get_frame()
  frame.set_fill(False)
  frame.set_visible(False)

  #ax.grid("True")
  for tick in ax.xaxis.get_major_ticks():
    tick.label1.set_fontsize(size)
  for tick in ax.yaxis.get_major_ticks():
    tick.label1.set_fontsize(size)

  # set axes to logarithmic
  pylab.gca().set_xscale('log',basex=2)
  pylab.gca().set_yscale('log',basex=2)

  pylab.axis([8,128,1.e-4,2])
  ax.set_xticks(x)
  ax.set_xticklabels(xlabels)

  #pylab.axis([1,5,1.e-6,1.])
  ax.set_xlabel('Mesh resolution', ha="center",fontsize=size)
  ax.set_ylabel('commutation error',fontsize=size)
  pylab.savefig('commerrorplot.eps')
  pylab.savefig('commerrorplot.pdf')

  return
Beispiel #19
0
 def savepng(pre, img, title=None, **kwargs):
     fn = '%s-%s.png' % (pre, idstr)
     print 'Saving', fn
     plt.clf()
     plt.imshow(img, **kwargs)
     ax = plt.axis()
     if debug:
         print len(xplotx),len(allobjx)
         for i,(objx,objy,objc) in enumerate(zip(allobjx,allobjy,allobjc)):
             plt.plot(objx,objy,'-',c=objc)
             tempx = []
             tempx.append(xplotx[i])
             tempx.append(objx[0])
             tempy = []
             tempy.append(xploty[i])
             tempy.append(objy[0])
             plt.plot(tempx,tempy,'-',c='purple')
         plt.plot(pointx,pointy,'y.')
         plt.plot(xplotx,xploty,'xg')
     plt.axis(ax)
     if title is not None:
         plt.title(title)
     plt.colorbar()
     plt.gray()
     plt.savefig(fn)
Beispiel #20
0
def plot_features(im, features, num_to_plot=100, colors=["blue"]):

  plt.imshow(im)

  for i in range(min(features.shape[0], num_to_plot)):
    x = features[i,0]
    y = features[i,1]
    scale = features[i,2]
    rot = features[i,3]


    color = colors[i % len(colors)]

    box = patches.Rectangle((-scale/2,-scale/2), scale, scale, 
      edgecolor=color, facecolor="none", lw=1)
    arrow = patches.Arrow(0, -scale/2, 0, scale, 
      width=10, edgecolor=color, facecolor="none")
    t_start = plt.gca().transData
    transform = mpl.transforms.Affine2D().rotate(rot).translate(x,y) + t_start

    box.set_transform(transform)
    arrow.set_transform(transform)
    plt.gca().add_artist(box)
    plt.gca().add_artist(arrow)


  plt.axis('off')
  plt.set_cmap('gray')
  plt.show()
Beispiel #21
0
 def newFigLayer():
     pylab.clf()
     pylab.figure(figsize=(8, 8))
     pylab.axes([0.15, 0.15, 0.8, 0.81])
     pylab.axis([0.6, -0.4, -0.4, 0.6])
     pylab.xlabel(r"$\Delta$\textsf{RA from Sgr A* (arcsec)}")
     pylab.ylabel(r"$\Delta$\textsf{Dec. from Sgr A* (arcsec)}")
Beispiel #22
0
    def plot_margin(X1_train, X2_train, clf):
        def f(x, w, b, c=0):
            # given x, return y such that [x,y] in on the line
            # w.x + b = c
            return (-w[0] * x - b + c) / w[1]

        pl.plot(X1_train[:,0], X1_train[:,1], "ro")
        pl.plot(X2_train[:,0], X2_train[:,1], "bo")
        pl.scatter(clf.sv[:,0], clf.sv[:,1], s=100, c="g")

        # w.x + b = 0
        a0 = -4; a1 = f(a0, clf.w, clf.b)
        b0 = 4; b1 = f(b0, clf.w, clf.b)
        pl.plot([a0,b0], [a1,b1], "k")

        # w.x + b = 1
        a0 = -4; a1 = f(a0, clf.w, clf.b, 1)
        b0 = 4; b1 = f(b0, clf.w, clf.b, 1)
        pl.plot([a0,b0], [a1,b1], "k--")

        # w.x + b = -1
        a0 = -4; a1 = f(a0, clf.w, clf.b, -1)
        b0 = 4; b1 = f(b0, clf.w, clf.b, -1)
        pl.plot([a0,b0], [a1,b1], "k--")

        pl.axis("tight")
        pl.show()
Beispiel #23
0
def hinton(W, maxWeight=None):
    """
    Source: http://wiki.scipy.org/Cookbook/Matplotlib/HintonDiagrams
    Draws a Hinton diagram for visualizing a weight matrix.
    Temporarily disables matplotlib interactive mode if it is on,
    otherwise this takes forever.
    """
    reenable = False
    if pl.isinteractive():
        pl.ioff()
    pl.clf()
    height, width = W.shape
    if not maxWeight:
        maxWeight = 2**np.ceil(np.log(np.max(np.abs(W)))/np.log(2))

    pl.fill(np.array([0,width,width,0]),np.array([0,0,height,height]),'gray')
    pl.axis('off')
    pl.axis('equal')
    for x in xrange(width):
        for y in xrange(height):
            _x = x+1
            _y = y+1
            w = W[y,x]
            if w > 0:
                _blob(_x - 0.5, height - _y + 0.5, min(1,w/maxWeight),'white')
            elif w < 0:
                _blob(_x - 0.5, height - _y + 0.5, min(1,-w/maxWeight),'black')
    if reenable:
        pl.ion()
    pl.show()
Beispiel #24
0
def plot_iris_knn():
    iris = datasets.load_iris()
    X = iris.data[:, :2]  # we only take the first two features. We could
                        # avoid this ugly slicing by using a two-dim dataset
    y = iris.target

    knn = neighbors.KNeighborsClassifier(n_neighbors=3)
    knn.fit(X, y)

    x_min, x_max = X[:, 0].min() - .1, X[:, 0].max() + .1
    y_min, y_max = X[:, 1].min() - .1, X[:, 1].max() + .1
    xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100),
                         np.linspace(y_min, y_max, 100))
    Z = knn.predict(np.c_[xx.ravel(), yy.ravel()])

    # Put the result into a color plot
    Z = Z.reshape(xx.shape)
    pl.figure()
    pl.pcolormesh(xx, yy, Z, cmap=cmap_light)

    # Plot also the training points
    pl.scatter(X[:, 0], X[:, 1], c=y, cmap=cmap_bold)
    pl.xlabel('sepal length (cm)')
    pl.ylabel('sepal width (cm)')
    pl.axis('tight')
Beispiel #25
0
def draw_io( type ):
    f = open("data\\io.txt")
    s_list = f.readlines()
    f.close()

    r_list_x = []
    r_list_y = []
    w_list_x = []
    w_list_y = []

    y_min = 0x80000000
    y_max = 0

    for s in s_list:
        pos = s.find('[')
        addr = int( s[pos+1:pos+9], 16 )
        if addr > y_max: y_max = addr
        if addr < y_min: y_min = addr 
        if s.find('|R') != -1:
            r_list_y.append( addr )
            r_list_x.append( int( s.strip('\n').split('#')[1] ) ) #read counter
        if s.find('|W') != -1:
            w_list_y.append( int( addr ) )
            w_list_x.append( int( s.strip('\n').split('#')[1] ) ) #read counter

    if type == 'W': pylab.plot( w_list_x, w_list_y, "ro" )
    if type == 'R': pylab.plot( r_list_x, r_list_y, "ro" )

    pylab.axis( [0, get_trace_count(), y_min - 1000, y_max + 1000] )
    pylab.show()
Beispiel #26
0
def plot_adsorbed_circles(adsorbed_x,adsorbed_y,radius, width, label=""):
    import pylab
    from matplotlib.patches import Circle

    # Plot each run
    fig = pylab.figure()
    ax = fig.add_subplot(111)
    for p in range(len(adsorbed_x)):
        ax.add_patch(Circle((adsorbed_x[p], adsorbed_y[p]), radius))
        # Plot "image" particles to verify that periodic boundary conditions are working
#        if adsorbed_x[p] < radius:
#            ax.add_patch(Circle((adsorbed_x[p] + width,adsorbed_y[p]), radius, facecolor='red'))
#        elif adsorbed_x[p] > (width-radius):
#            ax.add_patch(Circle((adsorbed_x[p] - width,adsorbed_y[p]), radius, facecolor='red'))
#        if adsorbed_y[p] < radius:
#            ax.add_patch(Circle((adsorbed_x[p],adsorbed_y[p] + width), radius, facecolor='red'))
#        elif adsorbed_y[p] > (width-radius):
#            ax.add_patch(Circle((adsorbed_x[p],adsorbed_y[p] - width), radius, facecolor='red'))

    ax.set_aspect(1.0)
    pylab.axhline(y=0, color='k')
    pylab.axhline(y=width, color='k')
    pylab.axvline(x=0, color='k')
    pylab.axvline(x=width, color='k')
    pylab.axis([-0.1*width, width*1.1, -0.1*width, width*1.1])
    pylab.xlabel("non-dimensional x")
    pylab.ylabel("non-dimensional y")
    pylab.title("Adsorbed particles at theta="+label)

    return ax
def show_frequencies(video_filename, bounds=None):
    """Graph the average value of the video as well as the frequency strength"""
    original_video, fps = load_video(video_filename)
    print fps
    averages = []

    if bounds:
        for x in range(1, original_video.shape[0] - 1):
            averages.append(original_video[x, bounds[2]:bounds[3], bounds[0]:bounds[1], :].sum())
    else:
        for x in range(1, original_video.shape[0] - 1):
            averages.append(original_video[x, :, :, :].sum())

    charts_x = 1
    charts_y = 2
    pylab.figure(figsize=(charts_y, charts_x))
    pylab.subplots_adjust(hspace=.7)

    pylab.subplot(charts_y, charts_x, 1)
    pylab.title("Pixel Average")
    pylab.plot(averages)

    frequencies = scipy.fftpack.fftfreq(len(averages), d=1.0 / fps)

    pylab.subplot(charts_y, charts_x, 2)
    pylab.title("FFT")
    pylab.axis([0, 15, -2000000, 5000000])
    pylab.plot(frequencies, scipy.fftpack.fft(averages))

    pylab.show()
Beispiel #28
0
    def __init__(self, baseConfig):
        self.figsize = baseConfig.get("figsize", None)
        self.axis = baseConfig.get("axis", None)
        self.title = baseConfig.get("title", "NoName")
        self.ylabel = baseConfig.get("ylabel", "NoName")
        self.grid = baseConfig.get("grid", False)
        self.xaxis_locator = baseConfig.get("xaxis_locator", None)
        self.yaxis_locator = baseConfig.get("yaxis_locator", None)
        self.legend_loc = baseConfig.get("legend_loc", 0)

        if self.figsize != None:
            pylab.figure(figsize=self.figsize)
        if self.axis != None:
            pylab.axis(self.axis)

        pylab.title(self.title)
        pylab.ylabel(self.ylabel)
        ax = pylab.gca()
        pylab.grid(self.grid)
        if self.xaxis_locator != None:
            ax.xaxis.set_major_locator(pylab.MultipleLocator(self.xaxis_locator))
        if self.yaxis_locator != None:
            ax.yaxis.set_major_locator(pylab.MultipleLocator(self.yaxis_locator))
        self.lineList = []
        self.id = 1
Beispiel #29
0
def plot_polynomial_regression():
    rng = np.random.RandomState(0)
    x = 2*rng.rand(100) - 1
    f = lambda t: 1.2 * t**2 + .1 * t**3 - .4 * t **5 - .5 * t ** 9
    y = f(x) + .4 * rng.normal(size=100)

    x_test = np.linspace(-1, 1, 100)

    pl.figure()
    pl.scatter(x, y, s=4)

    X = np.array([x**i for i in range(5)]).T
    X_test = np.array([x_test**i for i in range(5)]).T
    regr = linear_model.LinearRegression()
    regr.fit(X, y)
    pl.plot(x_test, regr.predict(X_test), label='4th order')

    X = np.array([x**i for i in range(10)]).T
    X_test = np.array([x_test**i for i in range(10)]).T
    regr = linear_model.LinearRegression()
    regr.fit(X, y)
    pl.plot(x_test, regr.predict(X_test), label='9th order')

    pl.legend(loc='best')
    pl.axis('tight')
    pl.title('Fitting a 4th and a 9th order polynomial')

    pl.figure()
    pl.scatter(x, y, s=4)
    pl.plot(x_test, f(x_test), label="truth")
    pl.axis('tight')
    pl.title('Ground truth (9th order polynomial)')
Beispiel #30
0
def plotslice(pos,filename='',boxsize=100.):
    ng = pos.shape[0]
    M.clf()
    M.scatter(pos[ng/4,:,:,1].flatten(),pos[ng/4,:,:,2].flatten(),s=1.,lw=0.)
    M.axis('tight')
    if filename != '':
        M.savefig(filename)
Beispiel #31
0
lda.set_labels(labels)
lda.train(features)

# compute output plot iso-lines
xs = np.array(np.concatenate([x_pos, x_neg]))
ys = np.array(np.concatenate([y_pos, y_neg]))

x1_max = max(1.2 * xs)
x1_min = min(1.2 * xs)
x2_max = max(1.2 * ys)
x2_min = min(1.2 * ys)

x1 = np.linspace(x1_min, x1_max, size)
x2 = np.linspace(x2_min, x2_max, size)

x, y = np.meshgrid(x1, x2)

dense = RealFeatures(np.array((np.ravel(x), np.ravel(y))))
dense_labels = lda.apply(dense).get_labels()

z = dense_labels.reshape((size, size))

pcolor(x, y, z, shading='interp')
contour(x, y, z, linewidths=1, colors='black', hold=True)

axis([x1_min, x1_max, x2_min, x2_max])

connect('key_press_event', util.quit)

show()
Beispiel #32
0
def main():
    parser = OptionParser(usage=usage)
    parser.add_option(
        "-c",
        "--compare",
        action="store_true",
        dest="compare",
        default=False,
        help="compare with default scipy.sparse solver [default: %default]")
    parser.add_option("-p",
                      "--plot",
                      action="store_true",
                      dest="plot",
                      default=False,
                      help="plot time statistics [default: %default]")
    parser.add_option("-d",
                      "--default-url",
                      action="store_true",
                      dest="default_url",
                      default=False,
                      help="use default url [default: %default]")
    parser.add_option("-f",
                      "--format",
                      type=type(''),
                      dest="format",
                      default='triplet',
                      help="matrix format [default: %default]")
    (options, args) = parser.parse_args()

    if (len(args) >= 1):
        matrixNames = args
    else:
        parser.print_help(),
        return

    sizes, nnzs, times, errors = [], [], [], []
    legends = ['umfpack', 'sparse.solve']
    for ii, matrixName in enumerate(matrixNames):

        print('*' * 50)
        mtx = readMatrix(matrixName, options)

        sizes.append(mtx.shape)
        nnzs.append(mtx.nnz)
        tts = np.zeros((2, ), dtype=np.double)
        times.append(tts)
        err = np.zeros((2, 2), dtype=np.double)
        errors.append(err)

        print('size              : %s (%d nnz)' % (mtx.shape, mtx.nnz))

        sol0 = np.ones((mtx.shape[0], ), dtype=np.double)
        rhs = mtx * sol0

        umfpack = um.UmfpackContext()

        tt = time.clock()
        sol = umfpack(um.UMFPACK_A, mtx, rhs, autoTranspose=True)
        tts[0] = time.clock() - tt
        print("umfpack           : %.2f s" % tts[0])

        error = mtx * sol - rhs
        err[0, 0] = nla.norm(error)
        print('||Ax-b||          :', err[0, 0])

        error = sol0 - sol
        err[0, 1] = nla.norm(error)
        print('||x - x_{exact}|| :', err[0, 1])

        if options.compare:
            tt = time.clock()
            sol = sp.solve(mtx, rhs)
            tts[1] = time.clock() - tt
            print("sparse.solve      : %.2f s" % tts[1])

            error = mtx * sol - rhs
            err[1, 0] = nla.norm(error)
            print('||Ax-b||          :', err[1, 0])

            error = sol0 - sol
            err[1, 1] = nla.norm(error)
            print('||x - x_{exact}|| :', err[1, 1])

    if options.plot:
        try:
            import pylab
        except ImportError:
            raise ImportError("could not import pylab")
        times = np.array(times)
        print(times)
        pylab.plot(times[:, 0], 'b-o')
        if options.compare:
            pylab.plot(times[:, 1], 'r-s')
        else:
            del legends[1]

        print(legends)

        ax = pylab.axis()
        y2 = 0.5 * (ax[3] - ax[2])
        xrng = list(range(len(nnzs)))
        for ii in xrng:
            yy = y2 + 0.4 * (ax[3] - ax[2])\
                 * np.sin(ii * 2 * np.pi / (len(xrng) - 1))

            if options.compare:
                pylab.text(
                    ii + 0.02, yy, '%s\n%.2e err_umf\n%.2e err_sp' %
                    (sizes[ii], np.sum(
                        errors[ii][0, :]), np.sum(errors[ii][1, :])))
            else:
                pylab.text(
                    ii + 0.02, yy,
                    '%s\n%.2e err_umf' % (sizes[ii], np.sum(errors[ii][0, :])))
            pylab.plot([ii, ii], [ax[2], ax[3]], 'k:')

        pylab.xticks(xrng, ['%d' % (nnzs[ii]) for ii in xrng])
        pylab.xlabel('nnz')
        pylab.ylabel('time [s]')
        pylab.legend(legends)
        pylab.axis([ax[0] - 0.05, ax[1] + 1, ax[2], ax[3]])
        pylab.show()
Beispiel #33
0
def mctweak(wcs, xy, rd):
    obj = McTweak(wcs, xy, rd)

    # Initial args
    args, sigs = get_sip_args(wcs)

    print('Args:', args)
    print('Sigs:', sigs)
    print('Number of arguments:', len(args))
    print('Logodds:', obj(args))

    ndim, nwalkers = len(args), 100
    p0 = emcee.utils.sample_ball(args, sigs, size=nwalkers)
    print('p0', p0.shape)

    ps = PlotSequence('mctweak')

    W, H = wcs.get_width(), wcs.get_height()
    mywcs = Sip(wcs)

    sampler = emcee.EnsembleSampler(nwalkers, ndim, obj)
    lnp0, rstate = None, None
    pp = []
    for step in range(10000):
        print('Step', step)
        p0, lnp0, rstate = sampler.run_mcmc(p0,
                                            1,
                                            lnprob0=lnp0,
                                            rstate0=rstate)
        print('Best logprob:', np.max(lnp0))
        i = np.argmax(lnp0)
        print('Best args:', p0[i, :])

        pp.extend(sampler.flatchain)
        sampler.reset()

        if step % 100 != 0:
            continue

        plt.clf()
        plt.plot(obj.testxy[:, 0], obj.testxy[:, 1], 'r.')
        for args in p0[np.random.permutation(nwalkers)[:10], :]:
            set_sip_args(mywcs, args)
            sip_compute_inverse_polynomials(mywcs, 20, 20, 1, W, 1, H)
            ok, x, y = mywcs.radec2pixelxy(obj.refra, obj.refdec)
            plt.plot(x, y, 'bo', mec='b', mfc='none', alpha=0.25)

            ex = 10.
            ngridx = ngridy = 10
            stepx = stepy = 100
            xgrid = np.linspace(0, W, ngridx)
            ygrid = np.linspace(0, H, ngridy)
            X = np.linspace(0, W, int(np.ceil(W / stepx)))
            Y = np.linspace(0, H, int(np.ceil(H / stepy)))
            for x in xgrid:
                DX, DY = [], []
                xx, yy = [], []
                for y in Y:
                    dx, dy = mywcs.get_distortion(x, y)
                    xx.append(x)
                    yy.append(y)
                    DX.append(dx)
                    DY.append(dy)
                DX = np.array(DX)
                DY = np.array(DY)
                xx = np.array(xx)
                yy = np.array(yy)
                EX = DX + ex * (DX - xx)
                EY = DY + ex * (DY - yy)
                #plot(xx, yy, 'k-', alpha=0.5)
                plt.plot(EX, EY, 'b-', alpha=0.1)

            for y in ygrid:
                DX, DY = [], []
                xx, yy = [], []
                for x in X:
                    dx, dy = mywcs.get_distortion(x, y)
                    DX.append(dx)
                    DY.append(dy)
                    xx.append(x)
                    yy.append(y)
                DX = np.array(DX)
                DY = np.array(DY)
                xx = np.array(xx)
                yy = np.array(yy)
                EX = DX + ex * (DX - xx)
                EY = DY + ex * (DY - yy)
                #plot(xx, yy, 'k-', alpha=0.5)
                plt.plot(EX, EY, 'b-', alpha=0.1)

        for x in xgrid:
            plt.plot(x + np.zeros_like(Y), Y, 'k-', alpha=0.5)
        for y in ygrid:
            plt.plot(X, y + np.zeros_like(X), 'k-', alpha=0.5)

        plt.axis([1, W, 1, H])
        plt.axis('scaled')
        ps.savefig()

        pp = np.vstack(pp)
        print('pp', pp.shape)

        # plt.clf()
        # triangle.corner(pp, plot_contours=False)
        # ps.savefig()

        pp = []
Beispiel #34
0
    return cos(x) - 3 * exp( -(x - 0.2) ** 2)

# encontra mínimos de f(x),
# começa de 1.0 e 2.0 respectivamente
minimum1 = fmin(f, 1.0)
print("Busca iniciada em x=1., minimo é", minimum1)
minimum2 = fmin(f, 2.0)
print("Busca iniciada em x=2., minimo é", minimum2)

# plota função
x = arange(-10, 10, 0.1)
y = f(x)
pylab.plot(x, y, label='$\cos(x)-3e^{-(x-0.2)^2}$')
pylab.xlabel('x')
pylab.grid()
pylab.axis([-5, 5, -2.2, 0.5])

# adiciona minimo1 para plot
pylab.plot(minimum1, f(minimum1), 'vr',
           label='minimo 1')
# adiciona ponto de partida 1 para plot
pylab.plot(1.0, f(1.0), 'or', label='partida 1')

# adiciona minimo2 para plot
pylab.plot(minimum2,f(minimum2),'vg',\
           label='minimo 2')

# adiciona ponto de partida 2 para plot
pylab.plot(2.0,f(2.0),'og',label='partida 2')

pylab.legend(loc='lower left')
Beispiel #35
0
def nebtest(MyNEB=NEB, nimages=22):
    import pylab as pl
    from interpolate import InterpolatedPath
    from pygmin.optimize import lbfgs_py
    NEBquenchParams = dict()
    NEBquenchParams["iprint"] = 20
    NEBquenchParams["debug"] = True
    NEBquenchParams["maxErise"] = 0.1

    x = np.arange(.5, 5., .05)
    y = np.arange(.5, 5., .05)
    z = np.zeros([len(x), len(y)])
    potential = test.leps()
    for i in range(0, len(x)):
        for j in range(0, len(y)):
            z[j, i] = potential.getEnergy([x[i], y[j]])
    print "done"
    #z[z>0.] = 0.
    #pl.imshow(z)
    #pl.show()
    initial = np.array([.75, 2.])  #np.random.random(3)
    final = np.array([2., .75])  #np.random.random(3)
    #    from pygmin.optimize import quench
    #    print "quench initial"
    #    ret = quench.lbfgs_py(initial, potential.getEnergyGradient)
    #    initial = ret[0]
    #    print "quench final"
    #    ret = quench.quench(final, potential.getEnergyGradient)
    #    final = ret[0]
    #    print "done with quenching"
    #    print initial, final
    #print "Initial: ", initial
    #print "Final: ", final
    #pl.imshow(z)

    neb = MyNEB(InterpolatedPath(initial, final, nimages),
                potential,
                k=1000,
                dneb=False,
                quenchParams=NEBquenchParams)
    tmp = neb.coords
    energies_interpolate = neb.energies.copy()
    pl.figure()
    pl.subplot(2, 2, 1)
    pl.subplots_adjust(wspace=0.3, left=0.05, right=0.95, bottom=0.14)

    pl.title("path")
    #pl.contourf(x, y, z)
    pl.pcolor(x, y, z, vmax=-0.5, cmap=pl.cm.PuBu)
    pl.colorbar()
    pl.plot(tmp[:, 0], tmp[:, 1], 'ko-')
    print "optimizing NEB"
    neb.optimize()  #quenchRoutine=quench.fire)
    print "done"
    tmp = neb.coords
    pl.plot(tmp[:, 0], tmp[:, 1], 'ro-')
    pl.xlabel("x")
    pl.ylabel("y")
    pl.axis(xmin=0.5, xmax=2.5, ymin=0.5, ymax=2.5)

    pl.subplot(1, 2, 2)
    pl.title("energy")
    pl.plot(energies_interpolate, 'ko-', label="interpolate")
    pl.plot(neb.energies, 'ro-', label="neb")
    pl.xlabel("image")
    pl.ylabel("energy")
    pl.legend(loc='best')

    pl.subplot(1, 2, 2)
    pl.title("energy")
    pl.plot(energies_interpolate, 'ko-', label="interpolate")
    pl.plot(neb.energies, 'ro-', label="neb")
    pl.xlabel("image")
    pl.ylabel("energy")
    pl.legend(loc='best')
    pl.show()
Beispiel #36
0
def my_axis(ymax):
    pl.axis([-5,105,-ymax/10.,ymax])
x_indices = np.arange(x.shape[-1])

###############################################################################
# Univariate feature selection with F-test for feature scoring
# We use the default selection function: the 10% most significant features
selector = SelectPercentile(f_classif, percentile=10)
selector.fit(x, y)
scores = -np.log10(selector._pvalues)
scores /= scores.max()
pl.bar(x_indices - .45,
       scores,
       width=.3,
       label=r'Univariate score ($-Log(p_{value})$)',
       color='g')

###############################################################################
# Compare to the weights of an SVM
clf = svm.SVC(kernel='linear')
clf.fit(x, y)

svm_weights = (clf.coef_**2).sum(axis=0)
svm_weights /= svm_weights.max()
pl.bar(x_indices - .15, svm_weights, width=.3, label='SVM weight', color='r')

pl.title("Comparing feature selection")
pl.xlabel('Feature number')
pl.yticks(())
pl.axis('tight')
pl.legend(loc='upper right')
pl.show()
Beispiel #38
0
import random, math, pylab

alpha = -0.8
nsteps = 1000000
samples_x = []
samples_y = []
x, y = 0.0, 0.0
for step in range(nsteps):
    xnew = random.uniform(-1.0, 1.0)
    ynew = random.uniform(-1.0, 1.0)
    exp_new = -0.5 * (xnew ** 2 + ynew ** 2) - alpha * (xnew ** 4 + ynew ** 4)
    exp_old = -0.5 * (x ** 2 + y ** 2) - alpha * (x ** 4 + y ** 4)
    if random.uniform(0.0, 1.0) < math.exp(exp_new - exp_old):
        x = xnew
        y = ynew

    samples_x.append(x)
    samples_y.append(y)

pylab.hexbin(samples_x, samples_y, gridsize=50, bins=1000)
pylab.axis([-1.0, 1.0, -1.0, 1.0])
cb = pylab.colorbar()
pylab.xlabel('x')
pylab.ylabel('y')
pylab.title('A3_1')
pylab.savefig('plot_A3_1.png')
pylab.show()
import pylab as plt
import numpy as np
import pandas as pd

xvalues = np.arange(0.0, 20.0, 0.1)

df = pd.DataFrame({
    'x': xvalues,
    'sin': np.sin(xvalues),
})

plt.figure()

df.plot('x', 'sin')
plt.xlabel('x')
plt.ylabel('y')
plt.axis([0.0, 20.0, -1.2, 1.2])

plt.title('Sinusfunktion')
plt.savefig('sinusfunktion.png')
Beispiel #40
0
LineWidth = 4.5
p.subplot(223)
#p.title('Turbulence level = %(turb)1.3f ; Death rate = %(death)1.3f'% \
#        {"turb":tubulence, "death":death_rate})
p.bar(ASLD_hist_ranges,
      ASLD_to_hist_mean + ASLD_to_hist_std,
      width=ASLD_hist_ranges_bin_width,
      color=(0.75, 0.75, 0.75, 0.75),
      linewidth=0)
p.bar(ASLD_hist_ranges,
      ASLD_to_hist_mean,
      width=ASLD_hist_ranges_bin_width,
      color='k',
      linewidth=0)
p.axis([
    0,
    ASLD_hist_ranges.max(), 0, (ASLD_to_hist_mean + ASLD_to_hist_std).max()
])
p.xlabel('time passed between reproductions (steps)', fontsize=FontSize)
#p.ylabel('Frequency of occurrence', fontsize=FontSize)
p.ylabel('number of cells', fontsize=FontSize)
p.xticks(size=TickSize)
p.yticks(size=TickSize)
p.grid(True)

#p.figure(2, figsize=(1000,600))
p.subplot(221)
p.title(r'$\delta = %(death)1.3f $    $T = %(turb)1.3f $ ' % {
    "death": death_rate,
    "turb": tubulence
},
        fontsize=FontSize + 2)
Beispiel #41
0
    plt.subplot(2, 2, 2)
    y4 = [y1[i] - y2[i] for i in range(N)]
    pylab.plot(grid, y4, '-', label=r'$\beta = %g$' % beta)
    plt.title(r'$Error$ $Matrix$ $Square$ $with$ $\chi = %g$ $\lambda=%g$' %
              (khi, lambdah))
    plt.legend(prop={'size': 4.})

    z_exa = sum(
        exp(-beta * 0.5 * (khi + lambdah + 2 * i)**2) for i in range(N))

    print zvalues, '           ', z_exa, '              ', beta

E_simulation = -(1.0 / beta) * log(zvalues)
E_exac = 0.5 * (lambdah + khi)**2

print 'E simulation = ', E_simulation
print 'E exact = ', E_exac

#---------------------------------------Plot Potential --------------------------------------#
plt.subplot(2, 2, 3)
y1 = [(v(x)) for x in grid]
pylab.plot(grid, y1, '-', label='$V(x)$')
pylab.axis([0, pi / 2, 10, 1000])
plt.title(r'$Potential$ $with$ $\chi=%0.1f$ $and$ $\lambda= %0.1f$' %
          (khi, lambdah))
plt.legend(loc=1, prop={'size': 8.})
#--------------------------------------------------------------------------------------------#

plt.get_current_fig_manager().resize(780, 660)
plt.tight_layout()
pylab.show()
Beispiel #42
0
import pylab
from PIL import Image

# open random image of dimensions 639x516
img = Image.open('images/3wolfmoon.jpg')
print img
img = numpy.asarray(img, dtype='float64') / 256.
print "Image shape: ", img.shape

# put image in 4D tensor of shape (1, 3, height, width)
img_ = img.swapaxes(0, 2).swapaxes(1, 2).reshape(1, 3, 639, 516)
# print img_ * 256
filtered_img = f(img_)

print "The filtered img shape: ", filtered_img.shape

# plot original image and first and second components of output
pylab.subplot(1, 3, 1)
pylab.axis('off')
pylab.imshow(img)
pylab.gray()
# recall that the convOp output (filtered image) is actually a "minibatch",
# of size 1 here, so we take index 0 in the first dimension:
pylab.subplot(1, 3, 2)
pylab.axis('off')
pylab.imshow(filtered_img[0, 0, :, :])
pylab.subplot(1, 3, 3)
pylab.axis('off')
pylab.imshow(filtered_img[0, 1, :, :])
pylab.show()
Beispiel #43
0
from shelf import PKL
import cross_coil as cc
import scipy as sp
from surface import bernstein
from scipy.interpolate import interp1d
import scipy.optimize as op

import seaborn as sns
rc = {'figure.figsize':[7*12/14,7],'savefig.dpi':110, #*12/16
      'savefig.jpeg_quality':100,'savefig.pad_inches':0.1,
      'lines.linewidth':0.75}
sns.set(context='paper',style='white',font='sans-serif',palette='Set2',
        font_scale=7/8,rc=rc)
color = cycle(sns.color_palette('Set2'))
pl.figure()
pl.axis('equal')
pl.axis('off')


eqdsk = 'vde'
eqdsk = 'SN'

sf = SF(Config(eqdsk))
sf.eq['ncoil'] = 0

if eqdsk == 'vde':
    eq = EQ(sf,dCoil=1,limit=[4.25,8,-4.5,2],n=1e3)
    #eq = EQ(sf,dCoil=1,limit=[3,9,-6,6],n=5e3)
else:
    eq = EQ(sf,dCoil=1,limit=[5,13,-5.5,5],n=5e4)
Beispiel #44
0
Xhr = pylab.linspace(0, 1, 101)
Yhr = pylab.linspace(0, 1, 101)
fhr = exactSol(2, 5, Xhr, Yhr)
vmin, vmax = fhr.min(), fhr.max()

# make plots
f1 = pylab.figure(1)

pylab.subplot(1, 2, 1)
cax = pylab.pcolormesh(Xf,
                       Yf,
                       pylab.transpose(q[:, :, 0]),
                       vmin=vmin,
                       vmax=vmax)
pylab.axis('image')

pylab.subplot(1, 2, 2)
cax = pylab.pcolormesh(Xhr, Yhr, fhr)
pylab.axis('image')

# compute error
fex = exactSol(2, 5, Xf, Yf)
error = numpy.abs(fex - pylab.transpose(q_1)).sum()

fex = exactSol(2, 5, Xf_5, Yf_5)
error = error + numpy.abs(fex - pylab.transpose(q_5)).sum()

fex = exactSol(2, 5, Xf_8, Yf_8)
error = error + numpy.abs(fex - pylab.transpose(q_8)).sum()
def main(argv=None):
    if argv is None:
        argv = sys.argv[1:]

    # Read options and check for errors.
    options = read_command_line(argv)
    if (options == None):
        return

    s = starset.StarSet(options.align_root)

    nEpochs = len(s.stars[0].years)
    nStars = len(s.stars)

    names = np.array(s.getArray('name'))

    if (options.center_star != None):
        idx = np.where(names == options.center_star)[0]

        if (len(idx) > 0):
            options.xcenter = s.stars[idx].x
            options.ycenter = s.stars[idx].y
        else:
            print 'Could not find star to center, %s. Reverting to Sgr A*.' % \
                  (options.center_star)

    # Create a combined error term (quad sum positional and alignment)
    combineErrors(s)
    
    yearsInt = np.floor(s.years)

    # Set up a color scheme
    cnorm = colors.normalize(s.years.min(), s.years.max()+1)
    cmap = cm.gist_ncar

    colorList = []
    for ee in range(nEpochs):
        colorList.append( cmap(cnorm(yearsInt[ee])) )

    py.close(2)
    py.figure(2, figsize=(10,10))

    previousYear = 0.0
    for ee in range(nEpochs):
        x = s.getArrayFromEpoch(ee, 'x')
        y = s.getArrayFromEpoch(ee, 'y')

        xe = s.getArrayFromEpoch(ee, 'xerr')
        ye = s.getArrayFromEpoch(ee, 'yerr')

        mag = s.getArrayFromEpoch(ee, 'mag')

        idx = np.where((x > -1000) & (y > -1000))[0]
        x = x[idx]
        y = y[idx]
        xe = xe[idx]
        ye = ye[idx]
        mag = mag[idx]

        tmpNames = names[idx]
        
        if yearsInt[ee] != previousYear:
            previousYear = yearsInt[ee]
            label = '%d' % yearsInt[ee]
        else:
            label = '_nolegend_'

        (line, foo1, foo2) = py.errorbar(x, y, xerr=xe, yerr=ye,
                                         color=colorList[ee], fmt='k^',
                                         markeredgecolor=colorList[ee],
                                         label=label, picker=4)

        #selector = HighlightSelected(line, )

    class HighlightSelected(lines.VertexSelector):
        def __init__(self, line):
            lines.VertexSelector.__init__(self, line)
            self.markers, = self.axes.plot([], [], 'k^', markerfacecolor='none')

        def process_selected(self, ind, xs, ys):
            self.markers.set_data(xs, ys)
            self.canvas.draw()

    def onpick(event):
        polyCollection = event.artist
        polyCollection.get_xdata()
        polyCollection.get_xdata()
        ind = event.ind
        


    xlo = options.xcenter + (options.range)
    xhi = options.xcenter - (options.range)
    ylo = options.ycenter - (options.range)
    yhi = options.ycenter + (options.range)

    py.axis('equal')
    py.axis([xlo, xhi, ylo, yhi])
    py.legend(numpoints=1, loc='lower left')
    py.show()

    return
Beispiel #46
0
bias = Bias(alpha, X, y)

ym = (y.flatten() < 0).nonzero()[0]
yp = (y.flatten() > 0).nonzero()[0]
ii = inner(wv, X)
bias2 = -0.5 * (max(ii[ym]) + min(ii[yp]))

print('weight vector: %s' % wv)
print('support vectors: %s %s' % (sv1, sv2))
print('bias (from points): %s' % bias)
print('bias (with vectors): %s' % bias2)

# plot data
pylab.plot(c1[:, 0], c1[:, 1], 'bo', markersize=5)
pylab.plot(c2[:, 0], c2[:, 1], 'yo', markersize=5)

# plot hyperplane: wv[0] x + wv[1] y + bias = 0
xmin, xmax, ymin, ymax = pylab.axis()
hx = array([floor(xmin - .1), ceil(xmax + .1)])
hy = -wv[0] / wv[1] * hx - bias / wv[1]
pylab.plot(hx, hy, 'k-')
#pylab.axis([xmin,xmax,ymin,ymax])

# plot the support points
pylab.plot(XX[sv1, 0], XX[sv1, 1], 'bo', markersize=8)
pylab.plot(-XX[sv2, 0], -XX[sv2, 1], 'yo', markersize=8)
#pylab.axis('equal')
pylab.show()

# end of file
Beispiel #47
0
            print mc, ma, av, D
            Ds.append(D)
            Eslist.append(Es)
             
        ED=EDmax_hansen(ka, mu=1., Ns=Ns)
        print    
        print f, ka, sum(Ds)/N_MC, ED
        print
        sys.stdout.flush()
        ecdfD=ECDF(Ds)
        pylab.figure(1)
        pylab.plot(deval,ecdfD(deval), '%s+-'%clr, label="ECDF (Dipoles), $N_{obs}$=%d"%(N_obs_points))
        output_data.append(remove_nan(ecdfD(deval)))
    #pylab.plot(deval, [FD_hertz_one_cut(d) for d in deval], label="Theoretical CDF (a=0 m)")
    #pylab.plot(deval, [FD_hertz_one_cut_costheta(d) for d in deval], label="Theoretical CDF cos(theta)(a=0 m)")
    pylab.axis([deval[0],deval[-1],0,1])
    pylab.grid()
    pylab.legend(loc=4)
    pylab.xlabel("Max. Directivity D")
    pylab.ylabel("CDF")
    pylab.title("$N_{dipoles}=%d$, MC runs=%d, $Frequency=%dGHz$, $R=%dm$"%(N_dipole,N_MC,f/1e9,distance))
    #pylab.show()
    fig = matplotlib.pyplot.gcf()
    fig.set_size_inches(18.5, 10.5)
    pp = PdfPages(r'D:\HIWI\python-script\new_new_results\4.13/result_d.pdf')
    pylab.savefig(pp, format='pdf',dpi=fig1.dpi, bbox_inches='tight')
    pp.close()
    output=zip(*output_data)
    numpy.savetxt(r"D:\HIWI\python-script\new_new_results\4.13/4.13d.dat", output, fmt=['%.6f']*len(output_data))

Beispiel #48
0
        if filtered in corpus:
            continue
        corpus.append(filtered)
    vocab = sorted(list(vocab))
    vocab_index = {}
    for i, w in enumerate(vocab):
        vocab_index[w] = i
    st.subheader("Wordcloud")
    no_of_words = st.slider('How many words do you want?', 1, 50, 20)
    wordcloud = WordCloud(background_color='white',
                          stopwords=stopset,
                          max_words=no_of_words).generate(
                              ' '.join(all_filtered_words))
    plt.figure(figsize=(12, 12))
    plt.imshow(wordcloud, interpolation="bilinear")
    plt.axis("off")
    st.pyplot(plt)

    new_corpus = []
    for doc in corpus:
        new_doc = []
        for word in doc:
            word_idx = vocab_index[word]
            new_doc.append(word_idx)
        new_corpus.append(new_doc)
    st.subheader('Topic Modelling')
    model_type = st.radio(
        "Please choose the topic model",
        ('LDA - Latent Dirichlet Allocation', 'hLDA - hierarchical LDA'))
    if model_type == 'hLDA - hierarchical LDA':  #HLDA模型
        st.subheader("Parameters for hLDA:")
Beispiel #49
0
def plot_subgraph(G,
                  m2m_list,
                  ms1_peakids_to_highlight,
                  motif_idx,
                  colour_map,
                  save_to=None):

    # parameters for the M2M nodes
    motif_node_alpha = 0.75
    motif_node_size = 4000

    # parameters for the ms1_peakids_to_highlight
    highlight_node_colour = 'gray'
    highlight_node_alpha = 0.50
    highlight_node_size = 2000

    # parameters for other nodes
    other_nodes_colour = 'lightgray'
    other_nodes_alpha = 0.50
    other_nodes_size = 1000

    # label parameters
    label_colour = 'black'
    label_background_colour = 'gray'
    label_alpha = 0.75
    label_fontsize = 24

    # other parameters
    fig_width = 15
    fig_height = 15
    edge_alpha = 0.25

    highlight_docs = set()
    other_docs = set()
    motif_nodes = set()
    motif_colours = []
    doc_labels = {}
    motif_labels = {}
    for node_id, node_data in G.nodes(data=True):

        # group == 1 is a doc, 2 is a motif
        if node_data['group'] == 1 and int(
                node_data['peakid']) in ms1_peakids_to_highlight:
            highlight_docs.add(node_id)
            doc_labels[node_id] = node_data['peakid']

        elif node_data['group'] == 2:
            motif_name = node_data['name']
            _, motif_id = motif_name.split('_')
            motif_id = int(motif_id)
            if motif_id in m2m_list:
                motif_nodes.add(node_id)
                neighbours = G.neighbors(node_id)
                other_docs.update(neighbours)
                node_colour = colour_map.to_rgba(motif_idx[motif_id])
                node_colour = rgb2hex(node_colour)
                motif_colours.append(node_colour)
                motif_labels[node_id] = 'M2M_%d' % motif_id

    other_docs = other_docs - highlight_docs
    to_keep = motif_nodes | highlight_docs | other_docs
    SG = nx.Graph(G.subgraph(to_keep))
    for u, v, d in SG.edges(data=True):
        d['weight'] *= 100

    plt.figure(figsize=(fig_width, fig_height), dpi=900)
    plt.axis('off')
    fig = plt.figure(1)

    pos = nx.spring_layout(SG, k=0.25, iterations=50)
    nx.draw_networkx_nodes(SG,
                           pos,
                           nodelist=other_docs,
                           alpha=other_nodes_alpha,
                           node_color=other_nodes_colour,
                           node_size=other_nodes_size)
    nx.draw_networkx_nodes(SG,
                           pos,
                           nodelist=highlight_docs,
                           alpha=highlight_node_alpha,
                           node_color=highlight_node_colour,
                           node_size=highlight_node_size)
    nx.draw_networkx_nodes(SG,
                           pos,
                           nodelist=motif_nodes,
                           alpha=motif_node_alpha,
                           node_color=motif_colours,
                           node_size=motif_node_size)
    nx.draw_networkx_edges(SG, pos, alpha=edge_alpha)
    nx.draw_networkx_labels(SG, pos, doc_labels, font_size=label_fontsize)
    nx.draw_networkx_labels(SG, pos, motif_labels, font_size=label_fontsize)

    #     for node_id in node_labels:
    #         x, y = pos[node_id]
    #         label = node_labels[node_id]
    #         y_offset = -0.3
    #         if node_id in motif_nodes:
    #             y_offset += -0.5
    #         plt.text(x,y+y_offset, s=node_labels[node_id],
    #                  color=label_colour, fontsize=label_fontsize,
    #                  bbox=dict(facecolor=label_background_colour, alpha=label_alpha),
    #                  horizontalalignment='center')

    if save_to is not None:
        print "Figure saved to %s" % save_to
        plt.savefig(save_to, bbox_inches='tight')
    plt.show()

    return SG
Beispiel #50
0
args = parser.parse_args()

raw_image = Image.open('data/empire.jpg')
if args.blackwhite:
    raw_image = raw_image.convert('L')
im = array(raw_image)

if args.blackwhite:
    im2 = filters.gaussian_filter(im, args.sigma)
else:
    im2 = zeros(im.shape)
    for i in range(3):
        im2[:, :, i] = filters.gaussian_filter(im[:, :, i], args.sigma)
        # im2 = uint8(im2)

normalized_image = im / im2

if not args.blackwhite:
    normalized_image = normalized_image.astype('uint8')

figure()

if args.blackwhite:
    gray()

imshow(normalized_image)
axis('equal')
axis('off')

show()
Beispiel #51
0
for het in ['Slightly', 'Moderately', 'Very']:
    model = dismod3.data.fetch_disease_model_if_necessary(30026, 'models/mi/')
    model.keep(areas=['europe_western'], sexes=['male', 'total'], start_year=2000)

    model.parameters['i']['heterogeneity'] = het

    model.vars += dismod3.ism.age_specific_rate(model, 'i')
    dismod3.fit.fit_asr(model, 'i')
    
    m[het] = model

# display uncertainty in age pattern
pl.clf()

for i, het in enumerate(['Slightly', 'Moderately', 'Very']):
    est = m[het].vars['i']['mu_age'].stats()
    #
    x = pl.arange(40,101,10)
    y = est['mean'][x]
    yerr = [y - est['95% HPD interval'][x,0], est['95% HPD interval'][x,1] - y]
    #
    pl.errorbar(x+i-1, y, yerr=yerr, fmt='s-', color=colors[i], mec='w', label=het)

pl.legend(title='Heterogeneity:', fancybox=True, shadow=True, loc='upper left')
pl.xlabel('Age (Years)')
pl.ylabel('Incidence (Per PY)')
pl.title('Parameter Uncertainty of Empirical Prior\n(incidence data for europe_western only)')

dismod3.graphics.plot_data_bars(model.get_data('i'))
pl.axis([35,105,-.001,.11])
Beispiel #52
0
def Main():
    options, _ = MakeOpts().parse_args(sys.argv)
    assert options.species_filename
    assert options.first_col and options.second_col
    print 'Reading species list from', options.species_filename

    filter_cols, filter_vals = [], []
    if options.filter_cols:
        assert options.filter_vals
        filter_cols = map(str.strip, options.filter_cols.split(','))
        filter_vals = map(str.strip, options.filter_vals.split(','))

    # Read and filter species data
    r = csv.DictReader(open(options.species_filename))
    first_col, second_col = options.first_col, options.second_col
    pairmap = {}
    for row in r:
        apply_filter = lambda x, y: x in row and row[x] == y
        or_reduce = lambda x, y: x or y
        passed_filter = reduce(or_reduce,
                               map(apply_filter, filter_cols, filter_vals),
                               True)
        if not passed_filter:
            continue

        a, b = row[first_col].strip(), row[second_col].strip()
        if not a or not b:
            continue
        key = (a, b)
        pairmap.setdefault(key, []).append(row)

    #for key, row_list in pairmap.iteritems():
    #	if len(row_list) < 5:
    #		print key, row_list

    # Find cross-product of column values (all pairs).
    all_a = list(set([x[0] for x in pairmap.keys()]))
    all_b = list(set([x[1] for x in pairmap.keys()]))
    a_to_num = dict((v, i) for i, v in enumerate(all_a))
    b_to_num = dict((v, i) for i, v in enumerate(all_b))
    all_possible_pairs = list(itertools.product(all_a, all_b))

    third_col = options.third_col or 'fake key'
    get_col = lambda x: x.get(third_col, None)
    col_vals = dict((k, map(get_col, v)) for k, v in pairmap.iteritems())
    counts = {}
    totals = []
    all_vals = set()
    for k, v in col_vals.iteritems():
        counter = Counter(v)
        all_vals.update(counter.keys())
        counts[k] = counter
        totals.append(sum(counter.values()))

    x_vals = []
    y_vals = []
    count_array = []
    z_vals = []
    max_val = max(totals)
    for pair in all_possible_pairs:
        a, b = pair
        x_vals.append(a_to_num[a])
        y_vals.append(b_to_num[b])
        z_vals.append(sum(counts.get(pair, {}).values()))
        count_array.append(counts.get(pair, {}))

    # Plot circle scatter.
    axes = pylab.axes()
    axes.grid(color='g', linestyle='--', linewidth=1)

    if options.third_col:
        colormap = ColorMap(all_vals)
        PieScatter(axes, x_vals, y_vals, count_array, max_val, colormap)

        handles, labels = axes.get_legend_handles_labels()
        mapped_labels = dict(zip(labels, handles))
        labels = sorted(mapped_labels.keys())
        handles = [mapped_labels[k] for k in labels]
        pylab.legend(handles, labels)
    else:
        scaled_z_vals = pylab.array(map(float, z_vals))
        max_z = max(scaled_z_vals)
        scaled_z_vals /= (4.0 * max_z)
        scaled_z_vals = pylab.sqrt(scaled_z_vals)

        CircleScatter(axes, x_vals, y_vals, scaled_z_vals)
        for x, y, z in zip(x_vals, y_vals, z_vals):
            pylab.text(x + 0.1, y + 0.1, str(z))

    # Labels, titles and ticks.
    pylab.title('%s vs. %s' % (options.first_col, options.second_col))
    pylab.xlabel(options.first_col)
    pylab.ylabel(options.second_col)
    pylab.figtext(0.70, 0.02, '%d examples total.' % sum(totals))

    size_8 = FontProperties(size=8)
    a_labels = [a or "None given" for a in all_a]
    b_labels = [b or "None given" for b in all_b]
    pylab.xticks(range(0, len(a_labels)), a_labels, fontproperties=size_8)
    pylab.yticks(range(0, len(b_labels)), b_labels, fontproperties=size_8)

    # Scale and show.
    pylab.axis('scaled')
    pylab.axis([-1, len(all_a), -1, len(all_b)])
    pylab.show()
Beispiel #53
0
def plot_bipartite(G,
                   min_degree,
                   fig_width=10,
                   fig_height=20,
                   spacing_left=1,
                   spacing_right=2):

    # extract subgraph of docs connected to at least min_degree motifs
    doc_nodes_to_keep = set()
    motif_nodes_to_keep = set()
    nodes = G.nodes(data=True)
    for node_id, node_data in nodes:
        # group == 1 is a doc, 2 is a motif
        if node_data['group'] == 1 and G.degree(node_id) >= min_degree:
            neighbours = G.neighbors(node_id)
            doc_nodes_to_keep.add(node_id)
            motif_nodes_to_keep.update(neighbours)
    to_keep = doc_nodes_to_keep | motif_nodes_to_keep  # set union
    SG = nx.Graph(G.subgraph(to_keep))

    # make bipartite layout, put doc nodes on left, motif nodes on right
    pos = dict()
    pos.update(
        (n, (1, i * spacing_left)) for i, n in enumerate(doc_nodes_to_keep))
    pos.update(
        (n, (2, i * spacing_right)) for i, n in enumerate(motif_nodes_to_keep))

    # for labelling purpose
    motif_singleton = {}
    for n in motif_nodes_to_keep:
        children = G.neighbors(n)  # get the children of this motif
        degree_dict = G.degree(nbunch=children)  # get the degrees of children
        # count how many children have degree == 1
        children_degrees = [degree_dict[c] for c in degree_dict]
        count_singleton = sum(child_deg == 1 for child_deg in children_degrees)
        motif_singleton[n] = count_singleton

    # set the node and edge labels
    doc_labels = {}
    motif_labels = {}
    doc_motifs = {}  # used for the fragmentation spectra plot
    all_motifs = set()
    for node_id, node_data in SG.nodes(data=True):
        if node_data['group'] == 2:  # is a motif
            motif_labels[node_id] = "%s (+%d)" % (node_data['name'],
                                                  motif_singleton[node_id])
        elif node_data['group'] == 1:  # is a doc
            pid = int(node_data['peakid'])
            doc_labels[node_id] = 'pid_%d' % pid
            parent_motifs = set()
            for neighbour_id in SG.neighbors(node_id):
                motif_name = SG.node[neighbour_id]['name']
                _, motif_id = motif_name.split('_')
                parent_motifs.add(int(motif_id))
            doc_motifs[pid] = parent_motifs
            all_motifs.update(parent_motifs)

    # plot the bipartite graph
    plt.figure(figsize=(fig_width, fig_height))
    plt.axis('off')
    fig = plt.figure(1)
    nx.draw_networkx_nodes(SG, pos, alpha=0.25)
    nx.draw_networkx_edges(SG, pos, alpha=0.25)
    _ = nx.draw_networkx_labels(SG, pos, doc_labels, font_size=10)
    _ = nx.draw_networkx_labels(SG, pos, motif_labels, font_size=16)
    ymax = max(
        len(doc_labels) * spacing_left,
        len(motif_labels) * spacing_right)
    _ = plt.ylim([-1, ymax])
    _ = plt.title('MS1 peaks connected to at least %d motifs' % min_degree)

    # assign index to each M2M
    i = 0
    motif_idx = {}
    for key in all_motifs:
        motif_idx[key] = i
        i += 1

    return doc_nodes_to_keep, doc_motifs, motif_idx
Beispiel #54
0
def main():
    import optparse

    parser = optparse.OptionParser('%prog [options]')
    parser.add_option('-o', dest='outfn', help='Output filename (FITS table)')
    parser.add_option('-i', dest='imgfn', help='Image input filename')
    parser.add_option('-f', dest='flagfn', help='Flags input filename')
    parser.add_option('-z',
                      dest='flagzero',
                      help='Flag image: zero = 0',
                      action='store_true')
    parser.add_option('-p', dest='psffn', help='PsfEx input filename')
    #parser.add_option('-s', dest='postxt', help='Source positions input text file')
    parser.add_option(
        '-S',
        dest='statsfn',
        help='Output image statistis filename (FITS table); optional')

    parser.add_option('--sky',
                      dest='fitsky',
                      action='store_true',
                      help='Fit sky level as well as fluxes?')
    parser.add_option(
        '--band',
        '-b',
        dest='band',
        default='r',
        help=
        'Which SDSS band to use for forced photometry profiles: default %default'
    )

    parser.add_option('-g',
                      dest='gaussianpsf',
                      action='store_true',
                      default=False,
                      help='Use multi-Gaussian approximation to PSF?')

    parser.add_option('-P',
                      dest='plotbase',
                      default='scuss',
                      help='Plot base filename (default: %default)')
    parser.add_option('-l',
                      dest='local',
                      action='store_true',
                      default=False,
                      help='Use local SDSS tree?')

    # TESTING
    parser.add_option('--sub',
                      dest='sub',
                      action='store_true',
                      help='Cut to small sub-image for testing')
    parser.add_option('--res',
                      dest='res',
                      action='store_true',
                      help='Just plot results from previous run')

    opt, args = parser.parse_args()

    # Check command-line arguments
    if len(args):
        print('Extra arguments:', args)
        parser.print_help()
        sys.exit(-1)
    for fn, name, exists in [
        (opt.outfn, 'output filename (-o)', False),
        (opt.imgfn, 'image filename (-i)', True),
        (opt.flagfn, 'flag filename (-f)', True),
        (opt.psffn, 'PSF filename (-p)', True),
            #(opt.postxt, 'Source positions filename (-s)', True),
    ]:
        if fn is None:
            print('Must specify', name)
            sys.exit(-1)
        if exists and not os.path.exists(fn):
            print('Input file', fn, 'does not exist')
            sys.exit(-1)

    lvl = logging.DEBUG
    logging.basicConfig(level=lvl, format='%(message)s', stream=sys.stdout)

    if opt.res:
        ps = PlotSequence(opt.plotbase)
        plot_results(opt.outfn, ps)
        sys.exit(0)

    sdss = DR9(basedir='.')  #data/unzip')
    if opt.local:
        sdss.useLocalTree(pobj='photoObjs-new')
        sdss.saveUnzippedFiles('data/unzip')

    # Read inputs
    print('Reading input image', opt.imgfn)
    img, hdr = fitsio.read(opt.imgfn, header=True)
    print('Read img', img.shape, img.dtype)
    H, W = img.shape
    img = img.astype(np.float32)

    sky = hdr['SKYADU']
    print('Sky:', sky)

    cal = hdr['CALIA73']
    print('Zeropoint cal:', cal)
    zpscale = 10.**((2.5 + cal) / 2.5)
    print('Zp scale', zpscale)

    wcs = anwcs(opt.imgfn)
    print('WCS pixel scale:', wcs.pixel_scale())

    print('Reading flags', opt.flagfn)
    flag = fitsio.read(opt.flagfn)
    print('Read flag', flag.shape, flag.dtype)

    imslice = None
    if opt.sub:
        imslice = (slice(0, 800), slice(0, 800))
    if imslice is not None:
        img = img[imslice]
        H, W = img.shape
        flag = flag[imslice]
        wcs.set_width(W)
        wcs.set_height(H)

    print('Reading PSF', opt.psffn)
    psf = PsfEx(opt.psffn, W, H)

    if opt.gaussianpsf:
        picpsffn = opt.psffn + '.pickle'
        if not os.path.exists(picpsffn):
            psf.savesplinedata = True
            print('Fitting PSF model...')
            psf.ensureFit()
            pickle_to_file(psf.splinedata, picpsffn)
            print('Wrote', picpsffn)
        else:
            print('Reading PSF model parameters from', picpsffn)
            data = unpickle_from_file(picpsffn)
            print('Fitting PSF...')
            psf.fitSavedData(*data)

    #
    x = psf.instantiateAt(0., 0.)
    print('PSF', x.shape)
    x = x.shape[0]
    #psf.radius = (x+1)/2.
    psf.radius = 20

    print('Computing image sigma...')
    if opt.flagzero:
        bad = np.flatnonzero((flag == 0))
        good = (flag != 0)
    else:
        bad = np.flatnonzero((flag != 0))
        good = (flag == 0)

    igood = img[good]
    #plo,med,phi = [percentile_f(igood, p) for p in [25, 50, 75]]
    #sky = med
    plo, phi = [percentile_f(igood, p) for p in [25, 75]]
    # Wikipedia says:  IRQ -> sigma:
    sigma = (phi - plo) / (0.6745 * 2)
    print('Sigma:', sigma)
    invvar = np.zeros_like(img) + (1. / sigma**2)
    invvar.flat[bad] = 0.
    del bad
    del good
    del igood

    band = 'u'

    # Get SDSS sources within the image...

    print('Reading SDSS objects...')
    cols = [
        'objid', 'ra', 'dec', 'fracdev', 'objc_type', 'theta_dev',
        'theta_deverr', 'ab_dev', 'ab_deverr', 'phi_dev_deg', 'theta_exp',
        'theta_experr', 'ab_exp', 'ab_experr', 'phi_exp_deg', 'devflux',
        'expflux', 'resolve_status', 'nchild', 'flags', 'objc_flags', 'run',
        'camcol', 'field', 'id', 'psfflux', 'psfflux_ivar', 'cmodelflux',
        'cmodelflux_ivar', 'modelflux', 'modelflux_ivar', 'extinction'
    ]
    T = read_photoobjs_in_wcs(wcs, 1. / 60., sdss=sdss, cols=cols)
    print('Got', len(T), 'SDSS objs')

    T.treated_as_pointsource = treat_as_pointsource(T, band_index(opt.band))

    ok, T.x, T.y = wcs.radec2pixelxy(T.ra, T.dec)

    # We will break the image into cells for speed -- save the
    # original full-size inputs here.
    fullinvvar = invvar
    fullimg = img
    fullpsf = psf
    fullT = T

    # We add a margin around each cell -- we want sources within the
    # cell, we need to include a margin of image pixels touched by
    # those sources, and also an additional margin of sources that
    # touch those pixels.
    margin = 10  # pixels

    # Number of cells to split the image into
    imh, imw = img.shape
    nx = int(np.round(imw / 400.))
    ny = int(np.round(imh / 400.))
    #nx = ny = 20
    #nx = ny = 1

    # cell positions
    XX = np.round(np.linspace(0, W, nx + 1)).astype(int)
    YY = np.round(np.linspace(0, H, ny + 1)).astype(int)

    results = []

    # Image statistics
    imstats = fits_table()
    imstats.xlo = np.zeros(((len(YY) - 1) * (len(XX) - 1)), int)
    imstats.xhi = np.zeros_like(imstats.xlo)
    imstats.ylo = np.zeros_like(imstats.xlo)
    imstats.yhi = np.zeros_like(imstats.xlo)
    imstats.ninbox = np.zeros_like(imstats.xlo)
    imstats.ntotal = np.zeros_like(imstats.xlo)
    imstatkeys = ['imchisq', 'imnpix', 'sky']
    for k in imstatkeys:
        imstats.set(k, np.zeros(len(imstats)))

    # Plots:
    ps = PlotSequence(opt.plotbase)

    # Loop over cells...
    celli = -1
    for yi, (ylo, yhi) in enumerate(zip(YY, YY[1:])):
        for xi, (xlo, xhi) in enumerate(zip(XX, XX[1:])):
            celli += 1
            imstats.xlo[celli] = xlo
            imstats.xhi[celli] = xhi
            imstats.ylo[celli] = ylo
            imstats.yhi[celli] = yhi
            print()
            print('Doing image cell %i: x=[%i,%i), y=[%i,%i)' %
                  (celli, xlo, xhi, ylo, yhi))
            # We will fit for sources in the [xlo,xhi), [ylo,yhi) box.
            # We add a margin in the image around that ROI
            # Beyond that, we add a margin of extra sources

            # image region: [ix0,ix1)
            ix0 = max(0, xlo - margin)
            ix1 = min(W, xhi + margin)
            iy0 = max(0, ylo - margin)
            iy1 = min(H, yhi + margin)
            S = (slice(iy0, iy1), slice(ix0, ix1))

            img = fullimg[S]
            invvar = fullinvvar[S]

            if not opt.gaussianpsf:
                # Instantiate pixelized PSF at this cell center.
                pixpsf = fullpsf.instantiateAt((xlo + xhi) / 2.,
                                               (ylo + yhi) / 2.)
                print('Pixpsf:', pixpsf.shape)
                psf = PixelizedPSF(pixpsf)
            else:
                psf = fullpsf
            psf = ShiftedPsf(fullpsf, ix0, iy0)

            # sources nearby
            x0 = max(0, xlo - margin * 2)
            x1 = min(W, xhi + margin * 2)
            y0 = max(0, ylo - margin * 2)
            y1 = min(H, yhi + margin * 2)

            # FITS pixel indexing, so -1
            J = np.flatnonzero((fullT.x - 1 >= x0) * (fullT.x - 1 < x1) *
                               (fullT.y - 1 >= y0) * (fullT.y - 1 < y1))
            T = fullT[J].copy()
            T.row = J

            # Remember which sources are within the cell (not the margin)
            T.inbounds = ((T.x - 1 >= xlo) * (T.x - 1 < xhi) *
                          (T.y - 1 >= ylo) * (T.y - 1 < yhi))

            # Shift source positions so they are correct for this subimage (cell)
            #T.x -= ix0
            #T.y -= iy0

            imstats.ninbox[celli] = sum(T.inbounds)
            imstats.ntotal[celli] = len(T)

            # print 'Image subregion:', img.shape
            print('Number of sources in ROI:', sum(T.inbounds))
            print('Number of sources in ROI + margin:', len(T))
            #print 'Source positions: x', T.x.min(), T.x.max(), 'y', T.y.min(), T.y.max()

            twcs = WcslibWcs(None, wcs=wcs)
            twcs.setX0Y0(ix0, iy0)

            # Create tractor.Image object
            tim = Image(data=img,
                        invvar=invvar,
                        psf=psf,
                        wcs=twcs,
                        sky=ConstantSky(sky),
                        photocal=LinearPhotoCal(zpscale, band=band),
                        name=opt.imgfn,
                        domask=False)

            # Create tractor catalog objects
            cat, catI = get_tractor_sources_dr9(None,
                                                None,
                                                None,
                                                bandname=opt.band,
                                                sdss=sdss,
                                                objs=T.copy(),
                                                bands=[band],
                                                nanomaggies=True,
                                                fixedComposites=True,
                                                useObjcType=True,
                                                getobjinds=True)
            print('Got', len(cat), 'Tractor sources')

            assert (len(cat) == len(catI))

            # for r,d,src in zip(T.ra[catI], T.dec[catI], cat):
            #     print 'Source', src.getPosition()
            #     print '    vs', r, d

            # Create Tractor object.
            tractor = Tractor([tim], cat)

            # print 'All params:'
            # tractor.printThawedParams()
            t0 = Time()
            tractor.freezeParamsRecursive('*')
            tractor.thawPathsTo(band)
            if opt.fitsky:
                tractor.thawPathsTo('sky')
            # print 'Fitting params:'
            # tractor.printThawedParams()

            minsig = 0.1

            # making plots?
            #if celli <= 10:
            #    mod0 = tractor.getModelImage(0)

            # Forced photometry
            X = tractor.optimize_forced_photometry(
                #minsb=minsig*sigma, mindlnp=1., minFlux=None,
                variance=True,
                fitstats=True,
                shared_params=False,
                sky=opt.fitsky,
                use_ceres=True,
                BW=8,
                BH=8)
            IV = X.IV
            fs = X.fitstats

            print('Forced photometry took', Time() - t0)

            # print 'Fit params:'
            # tractor.printThawedParams()

            # Record results
            X = np.zeros(len(T), np.float32)
            X[catI] = np.array([
                src.getBrightness().getBand(band) for src in cat
            ]).astype(np.float32)
            T.set('tractor_%s_nanomaggies' % band, X)
            X = np.zeros(len(T), np.float32)
            X[catI] = IV.astype(np.float32)
            T.set('tractor_%s_nanomaggies_invvar' % band, X)
            X = np.zeros(len(T), bool)
            X[catI] = True
            T.set('tractor_%s_has_phot' % band, X)

            # DEBUG
            X = np.zeros(len(T), np.float64)
            X[catI] = np.array([src.getPosition().ra for src in cat])
            T.tractor_ra = X
            X = np.zeros(len(T), np.float64)
            X[catI] = np.array([src.getPosition().dec for src in cat])
            T.tractor_dec = X

            T.cell = np.zeros(len(T), int) + celli
            if fs is not None:
                # Per-source stats
                for k in [
                        'prochi2', 'pronpix', 'profracflux', 'proflux', 'npix'
                ]:
                    T.set(k, getattr(fs, k))
                # Per-image stats
                for k in imstatkeys:
                    X = getattr(fs, k)
                    imstats.get(k)[celli] = X[0]

            #T.about()
            # DEBUG
            ## KK = np.flatnonzero(T.tractor_u_nanomaggies[catI] > 3.)
            ## T.cut(catI[KK])
            ## cat = [cat[k] for k in KK]
            ## catI = np.arange(len(cat))
            ## #T.about()
            ## print T.tractor_u_nanomaggies
            ## print T.psfflux[:,0]

            results.append(T.copy())

            # tc = T.copy()
            # print 'tc'
            # print tc.tractor_u_nanomaggies
            # print tc.psfflux[:,0]
            # plot_results(None, ps, tc)
            # mc = merge_tables([x.copy() for x in results])
            # print 'Results:'
            # for x in results:
            #     print x.tractor_u_nanomaggies
            #     print x.psfflux[:,0]
            # print 'Merged'
            # print mc.tractor_u_nanomaggies
            # print mc.psfflux[:,0]
            # plot_results(None, ps, mc)

            # Make plots for the first N cells
            if celli >= 10:
                continue

            mod = tractor.getModelImage(0)
            ima = dict(interpolation='nearest',
                       origin='lower',
                       vmin=sky + -2. * sigma,
                       vmax=sky + 5. * sigma,
                       cmap='gray',
                       extent=[ix0 - 0.5, ix1 - 0.5, iy0 - 0.5, iy1 - 0.5])

            ok, rc, dc = wcs.pixelxy2radec((ix0 + ix1) / 2., (iy0 + iy1) / 2.)

            plt.clf()
            plt.imshow(img, **ima)
            plt.title('Data: ~ (%.3f, %.3f)' % (rc, dc))
            #ps.savefig()

            ax = plt.axis()
            plt.plot(T.x - 1, T.y - 1, 'o', mec='r', mfc='none', ms=10)
            plt.axis(ax)
            plt.title('Data + SDSS sources ~ (%.3f, %.3f)' % (rc, dc))
            ps.savefig()

            flim = 2.5
            I = np.flatnonzero(T.psfflux[catI, 0] > flim)
            for ii in I:
                tind = catI[ii]
                src = cat[ii]
                fluxes = [
                    T.psfflux[tind, 0],
                    src.getBrightness().getBand(band)
                ]
                print('Fluxes', fluxes)
                mags = [-2.5 * (np.log10(flux) - 9) for flux in fluxes]
                print('Mags', mags)

                t = ''
                if type(src) == ExpGalaxy:
                    t = 'E'
                elif type(src) == DevGalaxy:
                    t = 'D'
                elif type(src) == PointSource:
                    t = 'S'
                elif type(src) == FixedCompositeGalaxy:
                    t = 'C'
                else:
                    t = str(type(src))

                plt.text(T.x[tind],
                         T.y[tind] + 3,
                         '%.1f / %.1f %s' % (mags[0], mags[1], t),
                         color='r',
                         va='bottom',
                         bbox=dict(facecolor='k', alpha=0.5))
                plt.plot(T.x[tind] - 1, T.y[tind] - 1, 'rx')

            for i, src in enumerate(cat):
                flux = src.getBrightness().getBand(band)
                if flux < flim:
                    continue
                tind = catI[i]
                fluxes = [T.psfflux[tind, 0], flux]
                print('RA,Dec', T.ra[tind], T.dec[tind])
                print(src.getPosition())
                print('Fluxes', fluxes)
                mags = [-2.5 * (np.log10(flux) - 9) for flux in fluxes]
                print('Mags', mags)
                plt.text(T.x[tind],
                         T.y[tind] - 3,
                         '%.1f / %.1f' % (mags[0], mags[1]),
                         color='g',
                         va='top',
                         bbox=dict(facecolor='k', alpha=0.5))
                plt.plot(T.x[tind] - 1, T.y[tind] - 1, 'g.')

            plt.axis(ax)
            ps.savefig()

            # plt.clf()
            # plt.imshow(mod0, **ima)
            # plt.title('Initial Model')
            # #plt.colorbar()
            # ps.savefig()

            # plt.clf()
            # plt.imshow(mod0, interpolation='nearest', origin='lower',
            #            cmap='gray', extent=[ix0-0.5, ix1-0.5, iy0-0.5, iy1-0.5])
            # plt.title('Initial Model')
            # plt.colorbar()
            # ps.savefig()

            plt.clf()
            plt.imshow(mod, **ima)
            plt.title('Model')
            ps.savefig()

            noise = np.random.normal(scale=sigma, size=img.shape)
            plt.clf()
            plt.imshow(mod + noise, **ima)
            plt.title('Model + noise')
            ps.savefig()

            chi = (img - mod) * tim.getInvError()
            plt.clf()
            plt.imshow(chi,
                       interpolation='nearest',
                       origin='lower',
                       cmap='RdBu',
                       vmin=-5,
                       vmax=5)
            plt.title('Chi')
            ps.savefig()

    # Merge results from the cells
    TT = merge_tables(results)
    # Cut to just the sources within the cells
    TT.cut(TT.inbounds)
    TT.delete_column('inbounds')
    # Sort them back into original order
    TT.cut(np.argsort(TT.row))
    #TT.delete_column('row')
    TT.writeto(opt.outfn)
    print('Wrote results to', opt.outfn)

    if opt.statsfn:
        imstats.writeto(opt.statsfn)
        print('Wrote image statistics to', opt.statsfn)

    plot_results(opt.outfn, ps)
Beispiel #55
0
def plot_results(outfn, ps, T=None):
    if T is None:
        T = fits_table(outfn)
        print('read', len(T))

    I = np.flatnonzero(T.tractor_u_has_phot)
    print('Plotting', len(I), 'with phot')

    stars = (T.objc_type[I] == 6)
    gals = (T.objc_type[I] == 3)

    # SDSS measurements
    nm = np.zeros(len(I))
    nm[stars] = T.psfflux[I[stars], 0]
    nm[gals] = T.modelflux[I[gals], 0]

    # Tractor measurements
    counts = T.tractor_u_nanomaggies[I]
    dcounts = 1. / np.sqrt(T.tractor_u_nanomaggies_invvar[I])

    # plt.clf()
    # plt.errorbar(nm, counts, yerr=dcounts, fmt='o', ms=5)
    # plt.xlabel('SDSS nanomaggies')
    # plt.ylabel('Tractor counts')
    # plt.title('Tractor forced photometry of SCUSS data')
    # ps.savefig()
    #
    # plt.clf()
    # plt.errorbar(np.maximum(1e-2, nm), np.maximum(1e-3, counts), yerr=dcounts, fmt='o', ms=5, alpha=0.5)
    # plt.xlabel('SDSS nanomaggies')
    # plt.ylabel('Tractor counts')
    # plt.title('Tractor forced photometry of SCUSS data')
    # plt.xscale('log')
    # plt.yscale('log')
    # ps.savefig()

    xx, dc = [], []
    xxmags = []
    for mag in [24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12]:
        tnm = 10.**((mag - 22.5) / -2.5)
        if (mag > 12):
            nmlo = tnm / np.sqrt(2.5)
            nmhi = tnm * np.sqrt(2.5)
            K = np.flatnonzero((counts > nmlo) * (counts < nmhi))
            xx.append(tnm)
            xxmags.append(mag)
            dc.append(np.median(dcounts[K]))
    xx = np.array(xx)
    dc = np.array(dc)

    if False:
        plt.clf()
        plt.loglog(np.maximum(1e-2, nm[stars]),
                   np.maximum(1e-2, counts[stars]),
                   'b.',
                   ms=5,
                   alpha=0.5)
        plt.loglog(np.maximum(1e-2, nm[gals]),
                   np.maximum(1e-2, counts[gals]),
                   'g.',
                   ms=5,
                   alpha=0.5)
        plt.xlabel('SDSS nanomaggies')
        plt.ylabel('Tractor nanomaggies')
        plt.title('Tractor forced photometry of SCUSS data')
        ax = plt.axis()
        plt.axhline(1e-2, color='r', alpha=0.5)
        plt.axvline(1e-2, color='r', alpha=0.5)
        mx = max(ax[1], ax[3])
        plt.plot([1e-2, mx], [1e-2, mx], 'b-', alpha=0.25, lw=2)

        for tnm, mag in zip(xx, xxmags):
            plt.axvline(tnm, color='k', alpha=0.25)
            plt.text(tnm * 1.05,
                     3e4,
                     '%i mag' % mag,
                     ha='left',
                     rotation=90,
                     color='0.5')
        plt.errorbar(xx,
                     xx,
                     yerr=dc,
                     fmt=None,
                     ecolor='r',
                     elinewidth=2,
                     capsize=3)  #, capthick=2)
        plt.plot([xx, xx], [xx - dc, xx + dc], 'r-')

        mm = np.arange(11, 27)
        nn = 10.**((mm - 22.5) / -2.5)
        plt.xticks(nn, ['%i' % i for i in mm])
        plt.yticks(nn, ['%i' % i for i in mm])

        plt.xlim(0.8e-2, ax[1])
        plt.ylim(0.8e-2, ax[3])
        ps.savefig()

    lo, hi = 11, 26
    smag = np.clip(-2.5 * (np.log10(nm) - 9), lo, hi)
    tmag = np.clip(-2.5 * (np.log10(counts) - 9), lo, hi)
    dt = np.abs((-2.5 / np.log(10.)) * dc / xx)
    xxmag = -2.5 * (np.log10(xx) - 9)

    plt.clf()
    p1 = plt.plot(smag[stars], tmag[stars], 'b.', ms=5, alpha=0.5)
    p2 = plt.plot(smag[gals], tmag[gals], 'g.', ms=5, alpha=0.5)
    plt.xlabel('SDSS mag')
    plt.ylabel('Tractor mag')
    plt.title('Tractor forced photometry of SCUSS data')
    plt.plot([lo, hi], [lo, hi], 'b-', alpha=0.25, lw=2)
    plt.axis([hi, lo, hi, lo])
    plt.legend((p1[0], p2[0]), ('Stars', 'Galaxies'), loc='lower right')
    plt.errorbar(xxmag,
                 xxmag,
                 dt,
                 fmt=None,
                 ecolor='r',
                 elinewidth=2,
                 capsize=3)
    plt.plot([xxmag, xxmag], [xxmag - dt, xxmag + dt], 'r-')
    ps.savefig()

    plt.clf()
    p1 = plt.plot(smag[stars],
                  tmag[stars] - smag[stars],
                  'b.',
                  ms=5,
                  alpha=0.5)
    p2 = plt.plot(smag[gals], tmag[gals] - smag[gals], 'g.', ms=5, alpha=0.5)
    plt.xlabel('SDSS mag')
    plt.ylabel('Tractor mag - SDSS mag')
    plt.title('Tractor forced photometry of SCUSS data')
    plt.axhline(0, color='b', alpha=0.25, lw=2)
    plt.axis([hi, lo, -1, 1])
    plt.legend((p1[0], p2[0]), ('Stars', 'Galaxies'), loc='lower right')
    plt.errorbar(xxmag,
                 np.zeros_like(xxmag),
                 dt,
                 fmt=None,
                 ecolor='r',
                 elinewidth=2,
                 capsize=3)
    plt.plot([xxmag, xxmag], [-dt, +dt], 'r-')
    ps.savefig()

    # lo,hi = -2,5
    # plt.clf()
    # loghist(np.clip(np.log10(nm),lo,hi), np.clip(np.log10(counts), lo, hi), 200,
    #         range=((lo-0.1,hi+0.1),(lo-0.1,hi+0.1)))
    # plt.xlabel('SDSS nanomaggies')
    # plt.ylabel('Tractor nanomaggies')
    # plt.title('Tractor forced photometry of SCUSS data')
    # ps.savefig()

    if True:
        # Cut to valid/bright ones
        I = np.flatnonzero((nm > 1e-2) * (counts > 1e-2))
        J = np.flatnonzero((nm > 1) * (counts > 1e-2))
        # Estimate zeropoint
        med = np.median(counts[J] / nm[J])

        plt.clf()
        plt.loglog(nm[I], counts[I] / nm[I], 'b.', ms=5, alpha=0.25)
        plt.xlabel('SDSS nanomaggies')
        plt.ylabel('Tractor nanomaggies / SDSS nanomaggies')
        plt.title('Tractor forced photometry of SCUSS data')
        ax = plt.axis()
        #plt.axhline(med, color='k', alpha=0.5)
        plt.axhline(1, color='k', alpha=0.5)
        plt.axis(ax)
        plt.ylim(0.1, 10.)
        ps.savefig()

    C = fits_table(
        'data/scuss-w1-images/photozCFHTLS-W1_270912.fits',
        columns=['alpha', 'delta', 'u', 'eu', 'g', 'stargal', 'ebv'])
    Cfull = C
    Tfull = T

    if False:
        # Johan's mag vs error plots
        #plt.clf()
        #ha = dict(range=((19,26),(-3,0)))#, doclf=False)
        ha = dict(range=((19, 26), (np.log10(5e-2), np.log10(0.3))))
        #plt.subplot(2,2,1)
        loghist(Cfull.u, np.log10(Cfull.eu), 100, **ha)
        plt.xlabel('u (mag)')
        plt.ylabel('u error (mag)')
        plt.title('CFHT')
        yt = [0.05, 0.06, 0.07, 0.08, 0.09, 0.1, 0.2, 0.3]
        plt.yticks(np.log10(yt), ['%g' % y for y in yt])
        ps.savefig()
        #plt.subplot(2,2,2)
        su = -2.5 * (np.log10(Tfull.modelflux[:, 0]) - 9)
        se = np.abs(
            (-2.5 / np.log(10.)) * (1. / np.sqrt(Tfull.modelflux_ivar[:, 0])) /
            Tfull.modelflux[:, 0])
        loghist(su, np.log10(se), 100, **ha)
        plt.xlabel('u (mag)')
        plt.ylabel('u error (mag)')
        plt.yticks(np.log10(yt), ['%g' % y for y in yt])
        plt.title('SDSS')
        ps.savefig()
        c = Tfull.tractor_u_nanomaggies
        d = 1. / np.sqrt(Tfull.tractor_u_nanomaggies_invvar)
        tu = -2.5 * (np.log10(c) - 9)
        te = np.abs((-2.5 / np.log(10.)) * d / c)
        #plt.subplot(2,2,3)
        loghist(tu, np.log10(te), 100, **ha)
        plt.xlabel('u (mag)')
        plt.ylabel('u error (mag)')
        plt.yticks(np.log10(yt), ['%g' % y for y in yt])
        plt.title('SCUSS')
        ps.savefig()

    # (don't use T.cut(): const T)
    T = T[T.tractor_u_has_phot]

    print('C stargal:', np.unique(C.stargal))

    I, J, d = match_radec(T.ra, T.dec, C.alpha, C.delta, 1. / 3600.)

    C = C[J]
    T = T[I]

    stars = (T.objc_type == 6)
    gals = (T.objc_type == 3)

    #stars = (C.stargal == 1)
    #gals  = (C.stargal == 0)

    counts = T.tractor_u_nanomaggies
    dcounts = 1. / np.sqrt(T.tractor_u_nanomaggies_invvar)

    sdssu = -2.5 * (np.log10(T.modelflux[:, 0]) - 9)
    tmag = -2.5 * (np.log10(counts) - 9)
    dt = np.abs((-2.5 / np.log(10.)) * dcounts / counts)

    #cmag = C.u + 0.241 * (C.u - C.g)

    sdssu = -2.5 * (np.log10(T.psfflux[:, 0]) - 9)
    sdssg = -2.5 * (np.log10(T.psfflux[:, 1]) - 9)

    sdssugal = -2.5 * (np.log10(T.modelflux[:, 0]) - 9)

    #sdssu = -2.5*(np.log10(T.modelflux[:,0])-9)
    #sdssg = -2.5*(np.log10(T.modelflux[:,1])-9)
    #cmag = C.u
    #cmag = C.u + 0.241 * (sdssu - sdssg)
    #cmag += (4.705 * C.ebv)

    def _comp_plot(smag, cmag, tt, xname='SDSS', yname='CFHTLS'):
        plt.clf()
        lo, hi = 13, 26
        # p1 = plt.plot(cmag[stars], smag[stars], 'b.', ms=5, alpha=0.5)
        # p2 = plt.plot(cmag[gals] , smag[gals ], 'g.', ms=5, alpha=0.5)
        # plt.xlabel('CFHTLS u mag')
        # plt.ylabel('SDSS u mag')
        p1 = plt.plot(smag[stars],
                      cmag[stars] - smag[stars],
                      'b.',
                      ms=5,
                      alpha=0.5)
        p2 = plt.plot(smag[gals],
                      cmag[gals] - smag[gals],
                      'g.',
                      ms=5,
                      alpha=0.5)
        plt.xlabel('%s u mag' % xname)
        plt.ylabel('%s u mag - %s u mag' % (yname, xname))
        plt.title(tt)
        #plt.plot([lo,hi],[lo,hi], 'b-', alpha=0.25, lw=2)
        #plt.axis([hi,lo,hi,lo])
        plt.axhline(0, color='b', alpha=0.25, lw=2)
        plt.axis([hi, lo, -2, 2])
        plt.legend((p1[0], p2[0]), ('Stars', 'Galaxies'), loc='lower right')
        ps.savefig()

    smag = sdssu
    cmag = C.u

    eu = 4.705 * C.ebv
    ct = 0.241 * (sdssu - sdssg)

    sboth = np.zeros_like(smag)
    sboth[stars] = sdssu[stars]
    sboth[gals] = sdssugal[gals]

    _comp_plot(smag, cmag, 'CFHTLS vs SDSS -- raw (PSF)')

    _comp_plot(sdssugal, cmag, 'CFHTLS vs SDSS -- raw (model)')

    _comp_plot(sboth, cmag, 'CFHTLS vs SDSS -- raw')

    _comp_plot(sboth, cmag + eu, 'CFHTLS vs SDSS -- un-extincted')

    _comp_plot(sboth, cmag + ct, 'CFHTLS vs SDSS -- color term')

    #_comp_plot(sboth, cmag + ct + eu, 'CFHTLS vs SDSS -- un-extincted, color term')
    #_comp_plot(sboth, cmag - eu, 'CFHTLS vs SDSS -- -un-extincted')
    #_comp_plot(sboth, cmag + ct - eu, 'CFHTLS vs SDSS -- -un-extincted, color term')

    _comp_plot(cmag + ct,
               tmag,
               'CFHTLS+ct vs Tractor(SCUSS)',
               xname='CFHTLS',
               yname='Tractor(SCUSS)')
    _comp_plot(cmag,
               tmag,
               'CFHTLS vs Tractor(SCUSS)',
               xname='CFHTLS',
               yname='Tractor(SCUSS)')
    _comp_plot(sboth,
               tmag,
               'SDSS vs Tractor(SCUSS)',
               xname='SDSS',
               yname='Tractored SCUSS')

    plt.clf()
    keep = ((cmag > 17) * (cmag < 22))
    plt.plot((sdssu - sdssg)[keep * stars], (tmag - cmag)[keep * stars],
             'b.',
             ms=5,
             alpha=0.5)
    plt.plot((sdssu - sdssg)[keep * gals], (tmag - cmag)[keep * gals],
             'g.',
             ms=5,
             alpha=0.5)
    plt.xlabel('SDSS u-g')
    plt.ylabel('Tractor(SCUSS) - CFHTLS')
    plt.axis([-1, 4, -1, 1])
    ps.savefig()

    # I = np.flatnonzero((sboth < 16) * ((cmag + ct - sboth) > 0.25))
    # for r,d in zip(T.ra[I], T.dec[I]):
    #     print 'RA,Dec', r,d
    #     print 'http://skyservice.pha.jhu.edu/DR10/ImgCutout/getjpeg.aspx?ra=%.5f&dec=%.5f&width=100&height=100' % (r,d)

    # ???
    # sdssu -= T.extinction[:,0]
    # sdssg -= T.extinction[:,1]
    # tmag -= T.extinction[:,0]

    xxmag = np.arange(13, 26)
    dx = []
    dc = []
    for xx in xxmag:
        ii = np.flatnonzero((tmag > xx - 0.5) * (tmag < xx + 0.5))
        dx.append(np.median(dt[ii]))
        ii = np.flatnonzero((cmag > xx - 0.5) * (cmag < xx + 0.5))
        dc.append(np.median(C.eu[ii]))
    dc = np.array(dc)
    dx = np.array(dx)

    plt.clf()
    lo, hi = 13, 26
    p1 = plt.plot(cmag[stars], tmag[stars], 'b.', ms=5, alpha=0.5)
    p2 = plt.plot(cmag[gals], tmag[gals], 'g.', ms=5, alpha=0.5)
    plt.xlabel('CFHTLS mag')
    plt.ylabel('Tractor mag')
    plt.title('Tractor forced photometry of SCUSS data')
    plt.plot([lo, hi], [lo, hi], 'b-', alpha=0.25, lw=2)
    plt.axis([hi, lo, hi, lo])
    plt.legend((p1[0], p2[0]), ('Stars', 'Galaxies'), loc='lower right')
    plt.errorbar(xxmag,
                 xxmag,
                 dx,
                 fmt=None,
                 ecolor='r',
                 elinewidth=2,
                 capsize=3)
    plt.plot([xxmag, xxmag], [xxmag - dx, xxmag + dx], 'r-')
    dd = 0.1
    plt.errorbar(xxmag + dd,
                 xxmag,
                 dc,
                 fmt=None,
                 ecolor='m',
                 elinewidth=2,
                 capsize=3)
    plt.plot([xxmag + dd, xxmag + dd], [xxmag - dc, xxmag + dc], 'm-')
    ps.savefig()

    plt.clf()
    p1 = plt.plot(cmag[stars],
                  tmag[stars] - cmag[stars],
                  'b.',
                  ms=5,
                  alpha=0.5)
    p2 = plt.plot(cmag[gals], tmag[gals] - cmag[gals], 'g.', ms=5, alpha=0.5)
    plt.xlabel('CFHTLS mag')
    plt.ylabel('Tractor mag - CFHTLS mag')
    plt.title('Tractor forced photometry of SCUSS data')
    plt.axhline(0, color='b', alpha=0.25, lw=2)
    plt.axis([hi, lo, -1, 1.5])
    plt.legend((p1[0], p2[0]), ('Stars', 'Galaxies'), loc='lower right')
    plt.errorbar(xxmag,
                 np.zeros_like(xxmag),
                 dx,
                 fmt=None,
                 ecolor='r',
                 elinewidth=2,
                 capsize=3)
    plt.plot([xxmag, xxmag], [-dx, +dx], 'r-')
    plt.errorbar(xxmag + dd,
                 np.zeros_like(xxmag),
                 dc,
                 fmt=None,
                 ecolor='m',
                 elinewidth=2,
                 capsize=3)
    plt.plot([xxmag + dd, xxmag + dd], [-dc, +dc], 'm-')
    ps.savefig()
Beispiel #56
0
import numpy as np
import pylab as pl
from sklearn import svm

# we create 20 points
np.random.seed(0)
X = np.r_[np.random.randn(10, 2) + [1, 1], np.random.randn(10, 2)]
Y = [1] * 10 + [-1] * 10
sample_weight = 100 * np.abs(np.random.randn(20))
# and assign a bigger weight to the last 10 samples
sample_weight[:10] *= 10

# # fit the model
clf = svm.SVC()
clf.fit(X, Y, sample_weight=sample_weight)

# plot the decision function
xx, yy = np.meshgrid(np.linspace(-4, 5, 500), np.linspace(-4, 5, 500))

Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

# plot the line, the points, and the nearest vectors to the plane
pl.set_cmap(pl.cm.bone)
pl.contourf(xx, yy, Z, alpha=0.75)
pl.scatter(X[:, 0], X[:, 1], c=Y, s=sample_weight, alpha=0.9)

pl.axis('off')
pl.show()
Beispiel #57
0
def plot_data(evalpts, datapts, style='k.'):
    pylab.plot(evalpts, datapts, '%s' % style)
    pylab.axis([0, 5, 0, 50], 'k-')
    pylab.draw()
    return
Beispiel #58
0
def plot_commerror(name1, logfile1, name2, logfile2):

    file1 = open(str(logfile1), 'r').readlines()
    data1 = [float(line.split()[1]) for line in file1]
    iso1 = data1[0::3]
    aniso1 = data1[1::3]
    ml1 = data1[2::3]

    file2 = open(str(logfile2), 'r').readlines()
    data2 = [float(line.split()[1]) for line in file2]
    iso2 = data2[0::3]
    aniso2 = data2[1::3]
    ml2 = data2[2::3]

    # x axis
    x = [8, 16, 32, 64, 128]
    xlabels = ['A', 'B', 'C', 'D', 'E']
    orderone = [1, .5, .25, .125, .0625]
    ordertwo = [i**2 for i in orderone]
    plot1 = pylab.figure(figsize=(6, 6.5))
    size = 15
    ax = pylab.subplot(111)
    ax.plot(x, iso1, linestyle='solid', color='red', lw=2)
    ax.plot(x, aniso1, linestyle='dashed', color='red', lw=2)
    ax.plot(x, ml1, linestyle='dashdot', color='red', lw=2)
    ax.plot(x, iso2, linestyle='solid', color='blue', lw=2)
    ax.plot(x, aniso2, linestyle='dashed', color='blue', lw=2)
    ax.plot(x, ml2, linestyle='dashdot', color='blue', lw=2)
    #ax.plot(x,orderone, linestyle='solid',color='black',lw=2)
    #ax.plot(x,ordertwo, linestyle='dashed',color='black')
    #pylab.legend((str(name1)+'_iso',str(name1)+'_aniso',str(name2)+'_iso',str(name2)+'_aniso','order 1'),loc="best")
    pylab.legend(
        (str(name1) + '_iso', str(name1) + '_aniso', str(name1) + '_ml',
         str(name2) + '_iso', str(name2) + '_aniso', str(name2) + '_ml'),
        loc="best")
    leg = pylab.gca().get_legend()
    ltext = leg.get_texts()
    pylab.setp(ltext, fontsize=size, color='black')
    frame = leg.get_frame()
    frame.set_fill(False)
    frame.set_visible(False)

    #ax.grid("True")
    for tick in ax.xaxis.get_major_ticks():
        tick.label1.set_fontsize(size)
    for tick in ax.yaxis.get_major_ticks():
        tick.label1.set_fontsize(size)

    # set axes to logarithmic
    pylab.gca().set_xscale('log', basex=2)
    pylab.gca().set_yscale('log', basex=2)

    pylab.axis([8, 128, 1.e-4, 2])
    ax.set_xticks(x)
    ax.set_xticklabels(xlabels)

    #pylab.axis([1,5,1.e-6,1.])
    ax.set_xlabel('Mesh resolution', ha="center", fontsize=size)
    ax.set_ylabel('commutation error', fontsize=size)
    pylab.savefig('commerrorplot.eps')
    pylab.savefig('commerrorplot.pdf')

    return
Beispiel #59
0
##################PLOT THE BAND STRUCTURE#########################

calc.get_potential_energy()
# Create an array of eigenvalue arrays of kpoints
e_kn = np.array([calc.get_eigenvalues(k) for k in range(len(kpts))])

import pylab as plt

# Subtract the fermi level from the eigenvalues
e_kn -= efermi
emin = e_kn.min() - 1.0
emax = e_kn[:, nbands].max() - 1.0

plt.figure(figsize=(5, 6))
for i in range(nbands):
    plt.scatter(x, e_kn[:, i])
for j in X:
    plt.plot([j, j], [emin, emax], 'k-')
plt.plot([0, X[-1]], [0, 0], 'k-')
# Label the kpoint path
#plt.xticks(X, ['$%s$' % n for n in ['L', r'\Gamma', 'X', 'W', 'K', r'\Gamma']])
plt.xticks(X, ['$%s$' % n for n in ['L', r'\Gamma', 'X', 'U', r'\Gamma']])
# x-axis range is range of x-coordinates of special points, y-axis is eigenvalues
plt.axis(xmin=0, xmax=X[-1], ymin=emin, ymax=emax)
plt.xlabel('k-vector')
plt.ylabel('E - E$_F$ (eV)')
plt.title('Band Structure of Diamond')
plt.savefig('Diamond_bands_2.png')
plt.show()