def compute_Power(): from astroML.time_series import generate_power_law from astroML.fourier import PSD_continuous from astroML.plotting import setup_text_plots setup_text_plots(fontsize=8, usetex=False) N = 1024 dt = 0.01 factor = 100 t = dt * np.arange(N) random_state = np.random.RandomState(1) fig = plt.figure(figsize=(5, 3.75)) fig.subplots_adjust(wspace=0.05) for i, beta in enumerate([1.0, 2.0]): # Generate the light curve and compute the PSD x = factor * generate_power_law(N, dt, beta, random_state=random_state) f, PSD = PSD_continuous(t, x) # First axes: plot the time series ax1 = fig.add_subplot(221 + i) ax1.plot(t, x, '-k') ax1.text(0.95, 0.05, r"$P(f) \propto f^{-%i}$" % beta, ha='right', va='bottom', transform=ax1.transAxes) ax1.set_xlim(0, 10.24) ax1.set_ylim(-1.5, 1.5) ax1.set_xlabel(r'$t$') # Second axes: plot the PSD ax2 = fig.add_subplot(223 + i, xscale='log', yscale='log') ax2.plot(f, PSD, '-k') ax2.plot(f[1:], (factor * dt) ** 2 * (2 * np.pi * f[1:]) ** -beta, '--k') ax2.set_xlim(1E-1, 60) ax2.set_ylim(1E-6, 1E1) ax2.set_xlabel(r'$f$') if i == 1: ax1.yaxis.set_major_formatter(plt.NullFormatter()) ax2.yaxis.set_major_formatter(plt.NullFormatter()) else: ax1.set_ylabel(r'${\rm counts}$') ax2.set_ylabel(r'$PSD(f)$') plt.show()
def plot(fname): setup_text_plots(fontsize=10, usetex=True) data = dl.read_dat(fname,',') n = len(data[0]) - 4 f,plots = plt.subplots(int(np.ceil(n/2))+n%2,2, sharex=False,sharey=False) sigmas = [] for sigma in range(0,n): sigmas.append(dl.get_column(data,4+sigma)) for j in range(0,len(sigmas)): sigma = sigmas[j] good_sigmas = [] for i in range(0,len(sigma)): if sigma[i] != 'nan': good_sigmas.append((float(sigma[i]))) good_sigmas = np.sort(good_sigmas) good_sigmas = good_sigmas[0:int(.8*len(good_sigmas))] hist = np.histogram(good_sigmas,bins = 175) plots[np.ceil((j)/2)][(j)%2].bar(hist[1][:-1],hist[0],width=hist[1][1]-hist[1][0]) plots[np.ceil((j)/2)][(j)%2].set_xlabel('$\sigma_{'+str(j+1)+'}$',fontsize=40) plots[np.ceil((j)/2)][(j)%2].set_ylabel('$n$',fontsize=40) plots[np.ceil((j)/2)][(j)%2].text(plots[np.ceil((j)/2)][(j)%2].get_xlim()[1]*0.9,plots[np.ceil((j)/2)][(j)%2].get_ylim()[1]*0.75,'$\sigma_{'+str(j+1)+'}$',fontsize=40) plots[np.ceil((j)/2)][(j)%2].tick_params(axis='both', which='major', labelsize=20) f.set_size_inches(32,20) f.savefig('histograms/sigma_histo_' + fname+'.png', dpi = 300)
def plot_num_density(zbins_list, dist_z_list, err_z_list, titles=None, markers=None): ''' Plots the number density of galaxies for multiple samples. Specifically, rho(z) / [z/0.08]^2 vs z where rho(z) is the number density of galaxies at a given redshift. Reproduces the top right plot of Figure 4.10. Parameters ---------- zbins_list : array-like Tuple of absolute redshift bin centers. dist_z_list : tuple, list Tuple of redshift count distributions. err_z_list : tuple, list Tuple of redshift count errors. titles : tuple, list Tuple of titles for the different distributions. markers : tuple, list Tuple of markers for the different distributions. Returns ------- None ''' from astroML.plotting import setup_text_plots setup_text_plots(fontsize=8, usetex=False) fig = plt.figure(figsize=(8, 8)) ax = fig.add_subplot(1, 1, 1) for i in xrange(len(dist_z_list)): factor = 0.08 ** 2 / (0.5 * (zbins_list[i][1:] + \ zbins_list[i][:-1])) ** 2 ax.errorbar(0.5 * (zbins_list[i][1:] + zbins_list[i][:-1]), factor * dist_z_list[i], factor * err_z_list[i], fmt='-k' + markers[i], ecolor='gray', lw=1, ms=4, label=titles[i]) ax.legend(loc=1) ax.xaxis.set_major_locator(plt.MultipleLocator(0.01)) ax.set_xlabel(r'$z$') ax.set_ylabel(r'$\rho(z) / [z / 0.08]^2$') ax.set_xlim(0.075, 0.125) ax.set_ylim(10, 25) plt.show()
def plot_separation(test_R, sample_R): plt.clf() setup_text_plots(fontsize = 16, usetex = True) fig = plt.figure(figsize = (12,8)) plt.hist(test_R, 50, histtype = 'step', color = 'red', lw = 2, label = 'Test', range = (-2.5,2.5)) plt.hist(sample_R, 50, histtype = 'step', color = 'blue',lw = 2, label = 'Sample', range = (-2.5,2.5)) plt.legend(loc="best") plt.xlabel("$\log(R/R_e)$", fontsize=18) plt.ylabel("Number", fontsize=18) plt.xlim(-2.5, 2.5) plt.show()
def plot_luminosity_function(Mbins_list, dist_M_list, err_M_list, titles=None, markers=None): ''' Plots the normalized luminosity functions Phi(M) vs (M) for multiple samples. Reproduces the bottom right plot of Figure 4.10. Parameters ---------- Mbins_list : array-like Tuple of absolute magnitude bin centers. dist_M_list : tuple, list Tuple of absolute magnitude count distributions. err_M_list : tuple, list Tuple of absolute magnitude count errors. titles : tuple, list Tuple of titles for the different distributions. markers : tuple, list Tuple of markers for the different distributions. Returns ------- None ''' from astroML.plotting import setup_text_plots setup_text_plots(fontsize=8, usetex=False) fig = plt.figure(figsize=(8, 8)) ax = fig.add_subplot(111, yscale='log') # truncate the bins so the plot looks better for i in xrange(len(dist_M_list)): Mbins = Mbins_list[i][3:-1] dist_M = dist_M_list[i][3:-1] err_M = err_M_list[i][3:-1] ax.errorbar(0.5 * (Mbins[1:] + Mbins[:-1]), dist_M, err_M, fmt='-k' + markers[i], ecolor='gray', lw=1, ms=4, label=titles[i]) ax.legend(loc=3) ax.xaxis.set_major_locator(plt.MultipleLocator(1.0)) ax.set_xlabel(r'$M$') ax.set_ylabel(r'$\Phi(M)$') ax.set_xlim(-20, -23.5) ax.set_ylim(1E-5, 2) plt.show()
def plot(fname): setup_text_plots(fontsize=10, usetex=True) data = dl.read_dat(fname,',') print data[0] n = len(data[0]) - 4 print int(np.ceil(n/2))+n%2 f,plots = plt.subplots(int(np.ceil(n/2))+n%2,2, sharex=False,sharey=False) dwarf_flags = dl.get_column(data,1) kepmags = dl.get_column(data,3) Teffs = dl.get_column(data,2) sigmas = [] for sigma in range(0,n): sigmas.append(dl.get_column(data,4+sigma)) length = len(dl.get_column(data,0)) for i in range(0,length): done = [] for seg in range(0,n): done.append(seg) is_dwarf = dwarf_flags[i] if is_dwarf == '1.0' or is_dwarf == '1': symbol = 'd' elif is_dwarf == '0.0' or is_dwarf == '0': symbol = 'o' else: symbol = 'x' x = int(np.ceil((seg)/2)) y = (seg)%2 plots[x][y].set_ylabel('$\log{\sigma_{' + str(seg+1) +'}}$',fontsize=40) plots[x][y].set_xlabel('Kepler band magnitude',fontsize=20) plots[x][y].tick_params(axis='both', which='major', labelsize=20) plots[x][y].grid(True) plots[x][y].set_xlim([8.25,17]) plots[x][y].set_ylim([-4.5,0]) plots[x][y].text(15.25,-0.5,'Segment ' + str(seg+1),fontsize=30) if sigma != 'nan' and kepmags[i] != 'nan' and sigmas[seg][i] != 'nan' and sigmas[seg][i] != '': plots[x][y].scatter(float(kepmags[i]),np.log10(float(sigmas[seg][i])),marker=symbol,color=color_T(Teffs[i])) print fname + ' : ' + str(done) + ' : ' + str((i*100.0)/length) + '%' f.set_size_inches(32,32) f.savefig(fname+'.png', dpi = 300)
def plot(fname): setup_text_plots(fontsize=10, usetex=True) data = dl.read_dat(fname,',') mags = dl.get_column(data,3) for i in range(0,len(mags)): if mags[i] == 'nan': del mags[i] else: mags[i] = float(mags[i]) hist = np.histogram(mags,bins=100) plt.bar(hist[1][:-1],hist[0],width=hist[1][1]-hist[1][0]) plt.xlabel('Kepler band magnitude',fontsize=50) plt.ylabel('$n$',fontsize=50) plt.tick_params(axis='both', which='major', labelsize=40) plt.gcf().set_size_inches(32,20) plt.gcf().savefig(fname.replace('evaluations/','histograms/mag/mag_histo_') +'.png', dpi = 300)
def plot_bic(param_range,bics,lowest_comp): plt.clf() setup_text_plots(fontsize=16, usetex=True) fig = plt.figure(figsize=(12, 6)) plt.plot(param_range,bics,color='blue',lw=2, marker='o') plt.text(lowest_comp, bics.min() * 0.97 + .03 * bics.max(), '*', fontsize=14, ha='center') plt.xticks(param_range) plt.ylim(bics.min() - 0.05 * (bics.max() - bics.min()), bics.max() + 0.05 * (bics.max() - bics.min())) plt.xlim(param_range.min() - 1, param_range.max() + 1) plt.xticks(param_range,fontsize=14) plt.yticks(fontsize=14) plt.xlabel('Number of components',fontsize=18) plt.ylabel('BIC score',fontsize=18) plt.show()
def medians(fname): setup_text_plots(fontsize=10, usetex=True) data = dl.read_dat(fname,',') n = len(data[0]) - 4 sigmas = [] for sigma in range(0,n): sigmas.append(dl.get_column(data,4+sigma)) medians = [] for j in range(0,len(sigmas)): sigma = sigmas[j] good_sigmas = [] for i in range(0,len(sigma)): if sigma[i] != 'nan': good_sigmas.append((float(sigma[i]))) good_sigmas = np.sort(good_sigmas) good_sigmas = good_sigmas[0:int(.8*len(good_sigmas))] medians.append(np.median(good_sigmas)) return medians
def compareSimpleGaia(ngauss=128, quantile=0.05, iter='10th', survey='2MASS', dataFilename='All.npz', contourColor='k'): setup_text_plots(fontsize=16, usetex=True) tgas, twoMass, Apass, bandDictionary, indices = testXD.dataArrays() xdgmm = XDGMM(filename=xdgmmFilename) absmag = 'J' mag1 = 'J' mag2 = 'K' xlabel = '$(J-K)^C$' ylabel = r'$M_J^C$' xlim = [-0.25, 1.25] ylim = [6, -6] ndim = 2 data = np.load(dustFile) dustEBV = data['ebv'] absMagKinda, apparentMagnitude = testXD.absMagKindaArray( absmag, dustEBV, bandDictionary, tgas['parallax']) color = testXD.colorArray(mag1, mag2, dustEBV, bandDictionary) color_err = np.sqrt( bandDictionary[mag1]['array'][bandDictionary[mag1]['err_key']]**2. + bandDictionary[mag2]['array'][bandDictionary[mag2]['err_key']]**2.) postFile = 'posteriorParallax.' + str(ngauss) + 'gauss.dQ' + str( quantile) + '.' + iter + '.' + survey + '.' + dataFilename yim = (-1, 5) for file in ['posteriorSimple.npz', postFile]: data = np.load(file) posterior = data['posterior'] samples = np.zeros(np.shape(posterior)[0]) xparallaxMAS = np.logspace(-2, 2, np.shape(posterior)[1]) for i, p in enumerate(posterior): try: samples[i] = testXD.samples(xparallaxMAS, p, 1, plot=False)[0] except IndexError: samples[i] = -999 mean = data['mean'] var = data['var'] absMag = testXD.absMagKinda2absMag(mean * 10.**(0.2 * apparentMagnitude)) absMagSample = testXD.absMagKinda2absMag( samples * 10.**(0.2 * apparentMagnitude)) neg = tgas['parallax'] < 0 fig, ax = plt.subplots(1, 2) ax[0].plot(data['mean'][~neg], mean[~neg] - tgas['parallax'][~neg], 'ko', markersize=0.5) ax[0].plot(data['mean'][neg], mean[neg] - tgas['parallax'][neg], 'ro', markersize=0.5) ax[0].set_xscale('log') ax[1].plot(data['mean'][~neg], np.log(var[~neg]) - np.log(tgas['parallax_error'][~neg]**2.), 'ko', markersize=0.5) ax[1].plot(data['mean'][neg], np.log(var[neg]) - np.log(tgas['parallax_error'][neg]**2.), 'ro', markersize=0.5) ax[1].set_xscale('log') ax[0].set_xlabel(r'$E[\varpi]$', fontsize=18) ax[1].set_xlabel(r'$E[\varpi]$', fontsize=18) ax[0].set_ylabel(r'$E[\varpi] - \varpi$', fontsize=18) ax[1].set_ylabel( r'$\mathrm{ln} \, \tilde{\sigma}_{\varpi}^2 - \mathrm{ln} \, \sigma_{\varpi}^2$', fontsize=18) plt.tight_layout() #if file == 'posteriorSimple.npz': ax[0].set_ylim(-5, 5) ax[1].set_ylim(-6, 2) ax[0].set_xlim(1e-1, 1e1) ax[1].set_xlim(1e-1, 1e2) fig.savefig(file.split('.')[0] + '_Comparison2Gaia.png') notnans = ~np.isnan(var) & ~np.isnan(tgas['parallax_error']) print 'The median of the differences of the logs: ', np.median( np.log(var[notnans]) - np.log(tgas['parallax_error'][notnans]**2.)) cNorm = plt.matplotlib.colors.Normalize(vmin=-6, vmax=6) fig, ax = plt.subplots(1, 2, figsize=(14, 7)) x = color[notnans] y = np.log(var[notnans]) - np.log(tgas['parallax_error'][notnans]**2.) levels = 1.0 - np.exp(-0.5 * np.arange(1.0, 2.1, 1.0)**2) #(counts, xedges, yedges, Image) = ax[0].hist2d(x, y, bins=100, cmap='Greys', norm=cNorm) #figcount, axcounts = plt.subplots() #nonzero = counts > 0 #axcounts.hist(np.log10(counts[nonzero]), log=True) #axcounts.set_xlabel('log counts') #figcount.savefig('counts.png') norm = plt.matplotlib.colors.Normalize(vmin=-1.5, vmax=1) cmap = 'inferno' ax[0].scatter(x, y, c=y, s=1, lw=0, alpha=0.05, norm=norm, cmap=cmap) corner.hist2d(x, y, bins=200, ax=ax[0], levels=levels, no_fill_contours=True, plot_density=False, plot_data=False, color=contourColor) #ax[0].scatter(color[notnans], np.log(var[notnans]) - np.log(tgas['parallax_error'][notnans]**2.), lw=0, s=1, alpha=0.5, c=tesXD.absMagKinda2absMag(absMagKinda[notnans]), norm=cNorm, cmap='plasma') ax[0].set_xlabel(r'$(J-K)^c$', fontsize=18) ax[0].set_ylim(-6, 2) ax[0].set_xlim(-0.5, 2) ax[0].set_ylabel( r'$\mathrm{ln} \, \tilde{\sigma}_{\varpi}^2 - \mathrm{ln} \, \sigma_{\varpi}^2$', fontsize=18) #ax[0].errorbar(color, np.log(var[notnans]) - np.log(tgas['parallax_error'][notnans]**2.), fmt="none", zorder=0, lw=0.5, mew=0, color='grey') cNorm = plt.matplotlib.colors.Normalize(vmin=0.1, vmax=2) ax[1].scatter(x, absMag[notnans], s=1, lw=0, c=y, alpha=0.05, norm=norm, cmap=cmap) ax[1].set_xlim(xlim) ax[1].set_ylim(ylim) ax[1].set_xlabel(xlabel, fontsize=18) ax[1].set_ylabel(ylabel, fontsize=18) #ax[1].hist(np.log(var[notnans]) - np.log(tgas['parallax_error'][notnans]**2.), bins=100, histtype='step', lw=2, log=True, color='black') #ax[1].set_xlabel(r'$\mathrm{ln} \, \tilde{\sigma}_{\varpi}^2 - \mathrm{ln} \, \sigma_{\varpi}^2$', fontsize=18) #ax[1].set_xlim(-6, 2) #ax[1].set_ylim(1,) fig.savefig('deltaLogVariance_' + file.split('.')[0] + '.png') figVarDiff = plt.figure(figsize=(14, 7)) ax1 = figVarDiff.add_subplot(121) ax2 = figVarDiff.add_subplot(122) ax1.scatter(x, absMag[notnans], s=1, lw=0, c=y, alpha=0.05, norm=norm, cmap=cmap) ax2.scatter(x, absMag[notnans], s=1, lw=0, c=tgas['parallax_error'][notnans]**2., alpha=0.05, cmap=cmap) titles = [ "Colored by change in variance", "Colored by observed variance" ] ax = [ax1, ax2] for i in range(2): ax[i].set_xlim(xlim) ax[i].set_ylim(ylim[0], ylim[1] * 1.1) ax[i].text(0.05, 0.95, titles[i], ha='left', va='top', transform=ax[i].transAxes, fontsize=18) ax[i].set_xlabel(xlabel, fontsize=18) #if i in (1, 3): #ax[i].yaxis.set_major_formatter(plt.NullFormatter()) #else: ax[i].set_ylabel(ylabel, fontsize=18) figVarDiff.savefig('denoisedVariance_' + file.split('.')[0] + '.png') figVarDiff.clf() ax1 = figVarDiff.add_subplot(121) ax2 = figVarDiff.add_subplot(122) ax1.scatter(x, absMag[notnans], s=1, lw=0, c=y, alpha=0.05, norm=norm, cmap=cmap) ax2.scatter(x, absMagSample[notnans], s=1, lw=0, c=tgas['parallax_error'][notnans]**2., alpha=0.05, cmap=cmap) titles = [ "Colored by change in variance", "Colored by observed variance" ] ax = [ax1, ax2] for i in range(2): ax[i].set_xlim(xlim) ax[i].set_ylim(ylim[0], ylim[1] * 1.1) ax[i].text(0.05, 0.95, titles[i], ha='left', va='top', transform=ax[i].transAxes, fontsize=18) ax[i].set_xlabel(xlabel, fontsize=18) #if i in (1, 3): #ax[i].yaxis.set_major_formatter(plt.NullFormatter()) #else: ax[i].set_ylabel(ylabel, fontsize=18) figVarDiff.savefig('denoisedVarianceSamples_' + file.split('.')[0] + '.png')
def priorSample(ngauss=128, quantile=0.5, iter='8th', survey='2MASS', dataFilename='All.npz', Nsamples=1.2e6, xdgmmFilename='xdgmm.fit', xlabel='X', ylabel='Y', contourColor='k'): setup_text_plots(fontsize=16, usetex=True) xdgmm = XDGMM(filename=xdgmmFilename) figPrior = plt.figure(figsize=(12, 5.5)) figPrior.subplots_adjust(left=0.1, right=0.95, bottom=0.15, top=0.95, wspace=0.1, hspace=0.1) sample = xdgmm.sample(Nsamples) negParallax = sample[:, 1] < 0 nNegP = np.sum(negParallax) while nNegP > 0: sampleNew = xdgmm.sample(nNegP) sample[negParallax] = sampleNew negParallax = sample[:, 1] < 0 nNegP = np.sum(negParallax) samplex = sample[:, 0] sampley = testXD.absMagKinda2absMag(sample[:, 1]) ax3 = figPrior.add_subplot(121) alpha = 0.1 xlim = [-0.25, 1.25] ylim = [6, -6] levels = 1.0 - np.exp(-0.5 * np.arange(1.0, 2.1, 1.0)**2) corner.hist2d(samplex, sampley, ax=ax3, levels=levels, bins=200, plot_datapoints=False, no_fill_contours=True, plot_density=False, color=contourColor) ax3.scatter(samplex, sampley, s=1, lw=0, c='k', alpha=alpha) ax4 = figPrior.add_subplot(122) for i in range(xdgmm.n_components): points = drawEllipse.plotvector(xdgmm.mu[i], xdgmm.V[i]) ax4.plot(points[0, :], testXD.absMagKinda2absMag(points[1, :]), 'k-', alpha=xdgmm.weights[i] / np.max(xdgmm.weights)) titles = [ "Extreme Deconvolution\n resampling", "Extreme Deconvolution\n cluster locations" ] ax = [ax3, ax4] for i in range(2): ax[i].set_xlim(xlim) ax[i].set_ylim(ylim[0], ylim[1] * 1.1) ax[i].text(0.05, 0.95, titles[i], ha='left', va='top', transform=ax[i].transAxes, fontsize=18) ax[i].set_xlabel(xlabel, fontsize=18) if i in (1, 3): ax[i].yaxis.set_major_formatter(plt.NullFormatter()) else: ax[i].set_ylabel(ylabel, fontsize=18) figPrior.savefig('prior_ngauss' + str(ngauss) + '.png')
""" Code to generate 2D histograms of embedded spectral data. Authored by OGT 3/15/16 """ import numpy as np import matplotlib.pyplot as plt from matplotlib.colors import LogNorm from astroML.plotting import setup_text_plots import matplotlib as mpl plt.ion() setup_text_plots(fontsize=18) mpl.rc('xtick', labelsize=12) mpl.rc('ytick', labelsize=12) mpl.rc('font', size=18, family='serif', style='normal', variant='normal', stretch='normal', weight='bold') mpl.rc('legend', labelspacing=0.1, handlelength=2, fontsize=12) def get_contours(x, y, bins=(50, 50), ranges=None): if ranges: H, xedges, yedges = np.histogram2d(x, y, bins=bins, range=ranges) else: H, xedges, yedges = np.histogram2d(x, y, bins=bins)
def plot_cont_galaxy(filename, N_bulge, N_disk, bin_no=100): #If you have enough particle resolution, choose 1000 tmp = filename.split('.npy') t = tmp[0].split('galaxy_')[1] galaxy = np.load('%s'%(filename)) x_gal = np.zeros_like(galaxy[0]) y_gal = np.zeros_like(galaxy[1]) z_gal = np.zeros_like(galaxy[2]) cs_gal = galaxy[5] cont = galaxy[4]/np.sum(galaxy[4]) # Bulge (Spherical to Cartesian) r_gal = galaxy[0,:N_bulge] theta_gal = galaxy[1,:N_bulge] phi_gal_sph = galaxy[2,:N_bulge] x_gal[:N_bulge] = r_gal*np.sin(theta_gal)*np.cos(phi_gal_sph) y_gal[:N_bulge] = r_gal*np.sin(theta_gal)*np.sin(phi_gal_sph) z_gal[:N_bulge] = r_gal*np.cos(theta_gal) # Disk (Cylindrical to Cartesian) rho_gal = galaxy[0,N_bulge:N_bulge+N_disk] phi_gal_cyl = galaxy[1,N_bulge:N_bulge+N_disk] z_gal_cyl = galaxy[2,N_bulge:N_bulge+N_disk] x_gal[N_bulge:N_bulge+N_disk] = rho_gal*np.cos(phi_gal_cyl) y_gal[N_bulge:N_bulge+N_disk] = rho_gal*np.sin(phi_gal_cyl) z_gal[N_bulge:N_bulge+N_disk] = z_gal_cyl # Halo (Spherical to Cartesian) r_gal = galaxy[0,N_bulge+N_disk:] theta_gal = galaxy[1,N_bulge+N_disk:] phi_gal_sph = galaxy[2,N_bulge+N_disk:] x_gal[N_bulge+N_disk:] = r_gal*np.sin(theta_gal)*np.cos(phi_gal_sph) y_gal[N_bulge+N_disk:] = r_gal*np.sin(theta_gal)*np.sin(phi_gal_sph) z_gal[N_bulge+N_disk:] = r_gal*np.cos(theta_gal) # Spot the colonizer inds = np.where(cs_gal!=0)[0] x_col = x_gal[inds] y_col = y_gal[inds] z_col = z_gal[inds] colonized_fraction = abs(np.sum(cs_gal)/len(cs_gal)) from astroML.plotting import setup_text_plots setup_text_plots(fontsize=16, usetex=False) from astroML.stats import binned_statistic_2d fig = plt.figure(figsize=(20, 10)) # Face-on axfo = plt.subplot(121) cmap = plt.cm.spectral_r cmap.set_bad('w', 0.) N, xedges, yedges = binned_statistic_2d(x_gal*1e-3, y_gal*1e-3, cont, 'sum', bins=bin_no) plt.imshow((N.T), origin='lower', extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]], aspect='equal', interpolation='nearest', cmap=cmap) plt.xlabel(r'X (kpc)') plt.ylabel(r'Y (kpc)') plt.xlim([-1e1, 1e1]) plt.ylim([-1e1, 1e1]) cb = plt.colorbar(pad=0.2, orientation='horizontal') cb.set_label(r'$\mathrm{log(L/L_{total})}$') clim_min = min(cont) clim_max = max(cont) plt.title("time = %s Myr"%(t)) # plt.clim(clim_min, clim_max) # Edge-on axeo = plt.subplot(122) cmap = plt.cm.spectral_r cmap.set_bad('w', 0.) N, xedges, zedges=binned_statistic_2d(x_gal*1e-3, z_gal*1e-3, cont, 'sum', bins=bin_no) plt.imshow((N.T), origin='lower', extent=[xedges[0], xedges[-1], zedges[0], zedges[-1]], aspect='equal', interpolation='nearest', cmap=cmap) plt.xlabel(r'X (kpc)') plt.ylabel(r'Z (kpc)') plt.xlim([-1e1, 1e1]) plt.ylim([-1e1, 1e1]) cb = plt.colorbar(pad=0.2, orientation='horizontal') cb.set_label(r'$\mathrm{log(L/L_{total})}$') clim_min = min(cont) clim_max = max(cont) # print ("Colonized fraction = %.2f"%(colonized_fraction)) # plt.clim(clim_min, clim_max) # plt.title("Colonized fraction = %.2f"%(abs(colonized_fraction))) plt.savefig("%s.svg"%(filename)) plt.savefig("%s.png"%(filename)) # plt.show() return galaxy
def compute_AF(): from astroML.time_series import lomb_scargle, generate_damped_RW from astroML.time_series import ACF_scargle, ACF_EK #---------------------------------------------------------------------- # This function adjusts matplotlib settings for a uniform feel in the textbook. # Note that with usetex=True, fonts are rendered with LaTeX. This may # result in an error if LaTeX is not installed on your system. In that case, # you can set usetex to False. from astroML.plotting import setup_text_plots setup_text_plots(fontsize=8, usetex=False) #------------------------------------------------------------ # Generate time-series data: # we'll do 1000 days worth of magnitudes t = np.arange(0, 1E3) z = 2.0 tau = 300 tau_obs = tau / (1. + z) np.random.seed(6) y = generate_damped_RW(t, tau=tau, z=z, xmean=20) # randomly sample 100 of these ind = np.arange(len(t)) np.random.shuffle(ind) ind = ind[:100] ind.sort() t = t[ind] y = y[ind] # add errors dy = 0.1 y_obs = np.random.normal(y, dy) #------------------------------------------------------------ # compute ACF via scargle method C_S, t_S = ACF_scargle(t, y_obs, dy, n_omega=2 ** 12, omega_max=np.pi / 5.0) ind = (t_S >= 0) & (t_S <= 500) t_S = t_S[ind] C_S = C_S[ind] #------------------------------------------------------------ # compute ACF via E-K method C_EK, C_EK_err, bins = ACF_EK(t, y_obs, dy, bins=np.linspace(0, 500, 51)) t_EK = 0.5 * (bins[1:] + bins[:-1]) #------------------------------------------------------------ # Plot the results fig = plt.figure(figsize=(5, 5)) # plot the input data ax = fig.add_subplot(211) ax.errorbar(t, y_obs, dy, fmt='.k', lw=1) ax.set_xlabel('t (days)') ax.set_ylabel('observed flux') # plot the ACF ax = fig.add_subplot(212) ax.plot(t_S, C_S, '-', c='gray', lw=1, label='Scargle') ax.errorbar(t_EK, C_EK, C_EK_err, fmt='.k', lw=1, label='Edelson-Krolik') ax.plot(t_S, np.exp(-abs(t_S) / tau_obs), '-k', label='True') ax.legend(loc=3) ax.plot(t_S, 0 * t_S, ':', lw=1, c='gray') ax.set_xlim(0, 500) ax.set_ylim(-1.0, 1.1) ax.set_xlabel('t (days)') ax.set_ylabel('ACF(t)') plt.show()
def compute_Sampling(): from astroML.plotting import setup_text_plots setup_text_plots(fontsize=8, usetex=False) #------------------------------------------------------------ # Generate the data Nbins = 2 ** 15 Nobs = 40 f = lambda t: np.sin(np.pi * t / 3) t = np.linspace(-100, 200, Nbins) dt = t[1] - t[0] y = f(t) # select observations np.random.seed(42) t_obs = 100 * np.random.random(40) D = abs(t_obs[:, np.newaxis] - t) i = np.argmin(D, 1) t_obs = t[i] y_obs = y[i] window = np.zeros(Nbins) window[i] = 1 #------------------------------------------------------------ # Compute PSDs Nfreq = Nbins / 2 dt = t[1] - t[0] df = 1. / (Nbins * dt) f = df * np.arange(Nfreq) PSD_window = abs(np.fft.fft(window)[:Nfreq]) ** 2 PSD_y = abs(np.fft.fft(y)[:Nfreq]) ** 2 PSD_obs = abs(np.fft.fft(y * window)[:Nfreq]) ** 2 # normalize the true PSD so it can be shown in the plot: # in theory it's a delta function, so normalization is # arbitrary # scale PSDs for plotting PSD_window /= 500 PSD_y /= PSD_y.max() PSD_obs /= 500 #------------------------------------------------------------ # Prepare the figures fig = plt.figure(figsize=(5, 2.5)) fig.subplots_adjust(bottom=0.15, hspace=0.2, wspace=0.25, left=0.12, right=0.95) # First panel: data vs time ax = fig.add_subplot(221) ax.plot(t, y, '-', c='gray') ax.plot(t_obs, y_obs, '.k', ms=4) ax.text(0.95, 0.93, "Data", ha='right', va='top', transform=ax.transAxes) ax.set_ylabel('$y(t)$') ax.set_xlim(0, 100) ax.set_ylim(-1.5, 1.8) # Second panel: PSD of data ax = fig.add_subplot(222) ax.fill(f, PSD_y, fc='gray', ec='gray') ax.plot(f, PSD_obs, '-', c='black') ax.text(0.95, 0.93, "Data PSD", ha='right', va='top', transform=ax.transAxes) ax.set_ylabel('$P(f)$') ax.set_xlim(0, 1.0) ax.set_ylim(-0.1, 1.1) # Third panel: window vs time ax = fig.add_subplot(223) ax.plot(t, window, '-', c='black') ax.text(0.95, 0.93, "Window", ha='right', va='top', transform=ax.transAxes) ax.set_xlabel('$t$') ax.set_ylabel('$y(t)$') ax.set_xlim(0, 100) ax.set_ylim(-0.2, 1.5) # Fourth panel: PSD of window ax = fig.add_subplot(224) ax.plot(f, PSD_window, '-', c='black') ax.text(0.95, 0.93, "Window PSD", ha='right', va='top', transform=ax.transAxes) ax.set_xlabel('$f$') ax.set_ylabel('$P(f)$') ax.set_xlim(0, 1.0) ax.set_ylim(-0.1, 1.1) plt.show()
# "Statistics, Data Mining, and Machine Learning in Astronomy" (2013) # For more information, see http://astroML.github.com # To report a bug or issue, use the following forum: # https://groups.google.com/forum/#!forum/astroml-general import numpy as np from matplotlib import pyplot as plt #---------------------------------------------------------------------- # This function adjusts matplotlib settings for a uniform feel in the textbook. # Note that with usetex=True, fonts are rendered with LaTeX. This may # result in an error if LaTeX is not installed on your system. In that case, # you can set usetex to False. if "setup_text_plots" not in globals(): from astroML.plotting import setup_text_plots setup_text_plots(fontsize=8, usetex=True) fig = plt.figure(figsize=(5, 2.5)) fig.subplots_adjust(left=0.05, right=0.95, bottom=0.05, top=0.95) #------------------------------------------------------------ ax = fig.add_subplot(111, xticks=[], yticks=[], aspect='equal') Qx = np.array([[-0.3, -0.5, -0.7, -0.35, -0.58, -0.33], [0.4, 0.36, 0.68, 0.44, 0.77, 0.65]]) Rx = np.array([[0.24, 0.63, 0.7, 0.35, 0.58, 0.33], [0.34, 0.36, 0.68, 0.44, 0.78, 0.65]]) ax.plot([-0.5, 0.5], [0.5, 0.5], 'kx', ms=8)
# "Statistics, Data Mining, and Machine Learning in Astronomy" (2013) # For more information, see http://astroML.github.com # To report a bug or issue, use the following forum: # https://groups.google.com/forum/#!forum/astroml-general from matplotlib import pyplot as plt import numpy as np from sklearn.mixture import GMM import math #---------------------------------------------------------------------- # This function adjusts matplotlib settings for a uniform feel in the textbook. # Note that with usetex=True, fonts are rendered with LaTeX. This may # result in an error if LaTeX is not installed on your system. In that case, # you can set usetex to False. from astroML.plotting import setup_text_plots setup_text_plots(fontsize=8, usetex=False) #------------------------------------------------------------ # Set up the dataset. # We'll use scikit-learn's Gaussian Mixture Model to sample # data from a mixture of Gaussians. The usual way of using # this involves fitting the mixture to data: we'll see that # below. Here we'll set the internal means, covariances, # and weights by-hand. #np.random.seed(1) #gmm = GMM(4, n_iter=1) #gmm.means_ = np.array([[-4], [-1], [4], [1]]) #gmm.covars_ = np.array([[1.5], [0.5], [0.5], [1.0]]) ** 2 #gmm.weights_ = np.array([0.3, 0.3, 0.2, 0.2])
def compute_Convolution(): from scipy.signal import fftconvolve #---------------------------------------------------------------------- # This function adjusts matplotlib settings for a uniform feel in the textbook. # Note that with usetex=True, fonts are rendered with LaTeX. This may # result in an error if LaTeX is not installed on your system. In that case, # you can set usetex to False. from astroML.plotting import setup_text_plots setup_text_plots(fontsize=8, usetex=False) #------------------------------------------------------------ # Generate random x, y with a given covariance length np.random.seed(1) x = np.linspace(0, 1, 500) h = 0.01 C = np.exp(-0.5 * (x - x[:, None]) ** 2 / h ** 2) y = 0.8 + 0.3 * np.random.multivariate_normal(np.zeros(len(x)), C) #------------------------------------------------------------ # Define a normalized top-hat window function w = np.zeros_like(x) w[(x > 0.12) & (x < 0.28)] = 1 #------------------------------------------------------------ # Perform the convolution y_norm = np.convolve(np.ones_like(y), w, mode='full') valid_indices = (y_norm != 0) y_norm = y_norm[valid_indices] y_w = np.convolve(y, w, mode='full')[valid_indices] / y_norm # trick: convolve with x-coordinate to find the center of the window at # each point. x_w = np.convolve(x, w, mode='full')[valid_indices] / y_norm #------------------------------------------------------------ # Compute the Fourier transforms of the signal and window y_fft = np.fft.fft(y) w_fft = np.fft.fft(w) yw_fft = y_fft * w_fft yw_final = np.fft.ifft(yw_fft) #------------------------------------------------------------ # Set up the plots fig = plt.figure(figsize=(5, 5)) fig.subplots_adjust(left=0.09, bottom=0.09, right=0.95, top=0.95, hspace=0.05, wspace=0.05) #---------------------------------------- # plot the data and window function ax = fig.add_subplot(221) ax.plot(x, y, '-k', label=r'data $D(x)$') ax.fill(x, w, color='gray', alpha=0.5, label=r'window $W(x)$') ax.fill(x, w[::-1], color='gray', alpha=0.5) ax.legend() ax.xaxis.set_major_formatter(plt.NullFormatter()) ax.set_ylabel('$D$') ax.set_xlim(0.01, 0.99) ax.set_ylim(0, 2.0) #---------------------------------------- # plot the convolution ax = fig.add_subplot(223) ax.plot(x_w, y_w, '-k') ax.text(0.5, 0.95, "Convolution:\n" + r"$[D \ast W](x)$", ha='center', va='top', transform=ax.transAxes, bbox=dict(fc='w', ec='k', pad=8), zorder=2) ax.text(0.5, 0.05, (r'$[D \ast W](x)$' + r'$= \mathcal{F}^{-1}\{\mathcal{F}[D] \cdot \mathcal{F}[W]\}$'), ha='center', va='bottom', transform=ax.transAxes) for x_loc in (0.2, 0.8): y_loc = y_w[x_w <= x_loc][-1] ax.annotate('', (x_loc, y_loc), (x_loc, 2.0), zorder=1, arrowprops=dict(arrowstyle='->', color='gray', lw=2)) ax.set_xlabel('$x$') ax.set_ylabel('$D_W$') ax.set_xlim(0.01, 0.99) ax.set_ylim(0, 1.99) #---------------------------------------- # plot the Fourier transforms N = len(x) k = - 0.5 * N + np.arange(N) * 1. / N / (x[1] - x[0]) ax = fig.add_subplot(422) ax.plot(k, abs(np.fft.fftshift(y_fft)), '-k') ax.text(0.95, 0.95, r'$\mathcal{F}(D)$', ha='right', va='top', transform=ax.transAxes) ax.set_xlim(-100, 100) ax.set_ylim(-5, 85) ax.xaxis.set_major_formatter(plt.NullFormatter()) ax.yaxis.set_major_formatter(plt.NullFormatter()) ax = fig.add_subplot(424) ax.plot(k, abs(np.fft.fftshift(w_fft)), '-k') ax.text(0.95, 0.95, r'$\mathcal{F}(W)$', ha='right', va='top', transform=ax.transAxes) ax.set_xlim(-100, 100) ax.set_ylim(-5, 85) ax.xaxis.set_major_formatter(plt.NullFormatter()) ax.yaxis.set_major_formatter(plt.NullFormatter()) #---------------------------------------- # plot the product of Fourier transforms ax = fig.add_subplot(224) ax.plot(k, abs(np.fft.fftshift(yw_fft)), '-k') ax.text(0.95, 0.95, ('Pointwise\nproduct:\n' + r'$\mathcal{F}(D) \cdot \mathcal{F}(W)$'), ha='right', va='top', transform=ax.transAxes, bbox=dict(fc='w', ec='k', pad=8), zorder=2) ax.set_xlim(-100, 100) ax.set_ylim(-100, 3500) ax.set_xlabel('$k$') ax.yaxis.set_major_formatter(plt.NullFormatter()) #------------------------------------------------------------ # Plot flow arrows ax = fig.add_axes([0, 0, 1, 1], xticks=[], yticks=[], frameon=False) arrowprops = dict(arrowstyle="simple", color="gray", alpha=0.5, shrinkA=5, shrinkB=5, patchA=None, patchB=None, connectionstyle="arc3,rad=-0.35") ax.annotate('', [0.57, 0.57], [0.47, 0.57], arrowprops=arrowprops, transform=ax.transAxes) ax.annotate('', [0.57, 0.47], [0.57, 0.57], arrowprops=arrowprops, transform=ax.transAxes) ax.annotate('', [0.47, 0.47], [0.57, 0.47], arrowprops=arrowprops, transform=ax.transAxes) plt.show()
def plot_sample(x_true, y_true, x, y, sample, xdgmm): setup_text_plots(fontsize=16, usetex=True) plt.clf() fig = plt.figure(figsize=(12, 9)) fig.subplots_adjust(left=0.1, right=0.95, bottom=0.1, top=0.95, wspace=0.02, hspace=0.02) ax1 = fig.add_subplot(221) ax1.scatter(x_true, y_true, s=4, lw=0, c='k') ax2 = fig.add_subplot(222) ax2.scatter(x, y, s=4, lw=0, c='k') ax3 = fig.add_subplot(223) ax3.scatter(sample[:, 0], sample[:, 1], s=4, lw=0, c='k') ax4 = fig.add_subplot(224) for i in range(xdgmm.n_components): draw_ellipse(xdgmm.mu[i], xdgmm.V[i], scales=[2], ax=ax4, ec='k', fc='gray', alpha=0.2) titles = [ "True Distribution", "Noisy Distribution", "Extreme Deconvolution\n resampling", "Extreme Deconvolution\n cluster locations" ] ax = [ax1, ax2, ax3, ax4] for i in range(4): ax[i].set_xlim(-1, 13) ax[i].set_ylim(-6, 16) ax[i].xaxis.set_major_locator(plt.MultipleLocator(4)) ax[i].yaxis.set_major_locator(plt.MultipleLocator(5)) ax[i].text(0.05, 0.95, titles[i], ha='left', va='top', transform=ax[i].transAxes) if i in (0, 1): ax[i].xaxis.set_major_formatter(plt.NullFormatter()) else: ax[i].set_xlabel('$x$', fontsize=18) if i in (1, 3): ax[i].yaxis.set_major_formatter(plt.NullFormatter()) else: ax[i].set_ylabel('$y$', fontsize=18) plt.show()
def compute_Weiner(): from scipy import optimize, fftpack from astroML.filters import savitzky_golay, wiener_filter #---------------------------------------------------------------------- # This function adjusts matplotlib settings for a uniform feel in the textbook. # Note that with usetex=True, fonts are rendered with LaTeX. This may # result in an error if LaTeX is not installed on your system. In that case, # you can set usetex to False. from astroML.plotting import setup_text_plots setup_text_plots(fontsize=8, usetex=False) #------------------------------------------------------------ # Create the noisy data np.random.seed(5) N = 2000 dt = 0.05 t = dt * np.arange(N) h = np.exp(-0.5 * ((t - 20.) / 1.0) ** 2) hN = h + np.random.normal(0, 0.5, size=h.shape) Df = 1. / N / dt f = fftpack.ifftshift(Df * (np.arange(N) - N / 2)) HN = fftpack.fft(hN) #------------------------------------------------------------ # Set up the Wiener filter: # fit a model to the PSD consisting of the sum of a # gaussian and white noise h_smooth, PSD, P_S, P_N, Phi = wiener_filter(t, hN, return_PSDs=True) #------------------------------------------------------------ # Use the Savitzky-Golay filter to filter the values h_sg = savitzky_golay(hN, window_size=201, order=4, use_fft=False) #------------------------------------------------------------ # Plot the results N = len(t) Df = 1. / N / (t[1] - t[0]) f = fftpack.ifftshift(Df * (np.arange(N) - N / 2)) HN = fftpack.fft(hN) fig = plt.figure(figsize=(5, 3.75)) fig.subplots_adjust(wspace=0.05, hspace=0.25, bottom=0.1, top=0.95, left=0.12, right=0.95) # First plot: noisy signal ax = fig.add_subplot(221) ax.plot(t, hN, '-', c='gray') ax.plot(t, np.zeros_like(t), ':k') ax.text(0.98, 0.95, "Input Signal", ha='right', va='top', transform=ax.transAxes, bbox=dict(fc='w', ec='none')) ax.set_xlim(0, 90) ax.set_ylim(-0.5, 1.5) ax.xaxis.set_major_locator(plt.MultipleLocator(20)) ax.set_xlabel(r'$\lambda$') ax.set_ylabel('flux') # Second plot: filtered signal ax = plt.subplot(222) ax.plot(t, np.zeros_like(t), ':k', lw=1) ax.plot(t, h_smooth, '-k', lw=1.5, label='Wiener') ax.plot(t, h_sg, '-', c='gray', lw=1, label='Savitzky-Golay') ax.text(0.98, 0.95, "Filtered Signal", ha='right', va='top', transform=ax.transAxes) ax.legend(loc='upper right', bbox_to_anchor=(0.98, 0.9), frameon=False) ax.set_xlim(0, 90) ax.set_ylim(-0.5, 1.5) ax.yaxis.set_major_formatter(plt.NullFormatter()) ax.xaxis.set_major_locator(plt.MultipleLocator(20)) ax.set_xlabel(r'$\lambda$') # Third plot: Input PSD ax = fig.add_subplot(223) ax.scatter(f[:N / 2], PSD[:N / 2], s=9, c='k', lw=0) ax.plot(f[:N / 2], P_S[:N / 2], '-k') ax.plot(f[:N / 2], P_N[:N / 2], '-k') ax.text(0.98, 0.95, "Input PSD", ha='right', va='top', transform=ax.transAxes) ax.set_ylim(-100, 3500) ax.set_xlim(0, 0.9) ax.yaxis.set_major_locator(plt.MultipleLocator(1000)) ax.xaxis.set_major_locator(plt.MultipleLocator(0.2)) ax.set_xlabel('$f$') ax.set_ylabel('$PSD(f)$') # Fourth plot: Filtered PSD ax = fig.add_subplot(224) filtered_PSD = (Phi * abs(HN)) ** 2 ax.scatter(f[:N / 2], filtered_PSD[:N / 2], s=9, c='k', lw=0) ax.text(0.98, 0.95, "Filtered PSD", ha='right', va='top', transform=ax.transAxes) ax.set_ylim(-100, 3500) ax.set_xlim(0, 0.9) ax.yaxis.set_major_locator(plt.MultipleLocator(1000)) ax.yaxis.set_major_formatter(plt.NullFormatter()) ax.xaxis.set_major_locator(plt.MultipleLocator(0.2)) ax.set_xlabel('$f$') plt.show()
def compute_Chirp(): from astroML.fourier import FT_continuous, IFT_continuous, wavelet_PSD #---------------------------------------------------------------------- # This function adjusts matplotlib settings for a uniform feel in the textbook. # Note that with usetex=True, fonts are rendered with LaTeX. This may # result in an error if LaTeX is not installed on your system. In that case, # you can set usetex to False. from astroML.plotting import setup_text_plots setup_text_plots(fontsize=8, usetex=False) #------------------------------------------------------------ # Define the chirp signal def chirp(t, T, A, phi, omega, beta): signal = A * np.sin(phi + omega * (t - T) + beta * (t - T) ** 2) signal[t < T] = 0 return signal def background(t, b0, b1, Omega1, Omega2): return b0 + b1 * np.sin(Omega1 * t) * np.sin(Omega2 * t) N = 4096 t = np.linspace(-50, 50, N) h_true = chirp(t, -20, 0.8, 0, 0.2, 0.02) h = h_true + np.random.normal(0, 1, N) #------------------------------------------------------------ # Compute the wavelet PSD f0 = np.linspace(0.04, 0.6, 100) wPSD = wavelet_PSD(t, h, f0, Q=1.0) #------------------------------------------------------------ # Plot the results fig = plt.figure(figsize=(5, 3.75)) fig.subplots_adjust(hspace=0.05, left=0.1, right=0.95, bottom=0.1, top=0.95) # Top: plot the data ax = fig.add_subplot(211) ax.plot(t + 50, h, '-', c='#AAAAAA') ax.plot(t + 50, h_true, '-k') ax.text(0.02, 0.95, "Input Signal: chirp", ha='left', va='top', transform=ax.transAxes, bbox=dict(boxstyle='round', fc='w', ec='k')) ax.set_xlim(0, 100) ax.set_ylim(-2.9, 2.9) ax.xaxis.set_major_formatter(plt.NullFormatter()) ax.set_ylabel('$h(t)$') # Bottom: plot the 2D PSD ax = fig.add_subplot(212) ax.imshow(wPSD, origin='lower', aspect='auto', extent=[t[0] + 50, t[-1] + 50, f0[0], f0[-1]], cmap=plt.cm.binary) ax.text(0.02, 0.95, ("Wavelet PSD"), color='w', ha='left', va='top', transform=ax.transAxes) ax.set_xlim(0, 100) ax.set_ylim(0.04, 0.6001) ax.set_xlabel('$t$') ax.set_ylabel('$f_0$') plt.show()
def compute_FFT(): from scipy.fftpack import fft from scipy.stats import norm from astroML.fourier import PSD_continuous #---------------------------------------------------------------------- # This function adjusts matplotlib settings for a uniform feel in the textbook. # Note that with usetex=True, fonts are rendered with LaTeX. This may # result in an error if LaTeX is not installed on your system. In that case, # you can set usetex to False. from astroML.plotting import setup_text_plots setup_text_plots(fontsize=8, usetex=False) #------------------------------------------------------------ # Draw the data np.random.seed(1) tj = np.linspace(-25, 25, 512) hj = np.sin(tj) hj *= norm(0, 10).pdf(tj) #------------------------------------------------------------ # plot the results fig = plt.figure(figsize=(5, 3.75)) fig.subplots_adjust(hspace=0.25) ax1 = fig.add_subplot(211) ax2 = fig.add_subplot(212) offsets = (0, 0.15) colors = ('black', 'gray') linewidths = (1, 2) errors = (0.005, 0.05) for (offset, color, error, linewidth) in zip(offsets, colors, errors, linewidths): # compute the PSD err = np.random.normal(0, error, size=hj.shape) hj_N = hj + err + offset fk, PSD = PSD_continuous(tj, hj_N) # plot the data and PSD ax1.scatter(tj, hj_N, s=4, c=color, lw=0) ax1.plot(tj, 0 * tj + offset, '-', c=color, lw=1) ax2.plot(fk, PSD, '-', c=color, lw=linewidth) # vertical line marking the expected peak location ax2.plot([0.5 / np.pi, 0.5 / np.pi], [-0.1, 1], ':k', lw=1) ax1.set_xlim(-25, 25) ax1.set_ylim(-0.1, 0.3001) ax1.set_xlabel('$t$') ax1.set_ylabel('$h(t)$') ax1.yaxis.set_major_locator(plt.MultipleLocator(0.1)) ax2.set_xlim(0, 0.8) ax2.set_ylim(-0.101, 0.801) ax2.set_xlabel('$f$') ax2.set_ylabel('$PSD(f)$') plt.show()
def plot_sample(x, y, samplex, sampley, xdgmm, xlabel='x', ylabel='y', xerr=None, yerr=None, ylim=(6, -6), xlim=(0.5, 1.5), errSubsample=1.2e6, thresholdScatter=0.1, binsScatter=200, c='black', norm=None, cmap=None, contourColor='k', posterior=False, ind=None, plot_contours=True, sdss5=False, whatsThatFeature=False, rasterized=False): prng = np.random.RandomState(1234567890) setup_text_plots(fontsize=16, usetex=True) plt.clf() alpha = 0.1 alpha_points = 0.01 figData = plt.figure(figsize=(12, 5.5)) figPrior = plt.figure(figsize=(12, 5.5)) for fig in [figData, figPrior]: fig.subplots_adjust(left=0.1, right=0.95, bottom=0.15, top=0.95, wspace=0.1, hspace=0.1) ax1 = figData.add_subplot(121) levels = 1.0 - np.exp(-0.5 * np.arange(1.0, 2.1, 1.0)**2) cNorm = plt.matplotlib.colors.LogNorm(vmin=3, vmax=1e5) #ax1.hist2d(x, y, bins=100, norm=cNorm, cmap='Greys') if sdss5: plot_contours = False im = corner.hist2d(x, y, ax=ax1, levels=levels, bins=200, no_fill_contours=True, plot_density=False, color=contourColor, rasterized=rasterized, plot_contours=plot_contours) #im = ax1.scatter(x, y, s=1, lw=0, c=c, alpha=alpha, norm=norm, cmap=cmap) ax2 = figData.add_subplot(122) if ind is None: ind = prng.randint(0, len(x), size=errSubsample) #ax2.scatter(x[ind], y[ind], s=1, lw=0, c='black', alpha=alpha_points) ax2.errorbar(x[ind], y[ind], xerr=xerr[ind], yerr=[yerr[0][ind], yerr[1][ind]], fmt="none", zorder=0, mew=0, ecolor='black', alpha=0.5, elinewidth=0.5) ax3 = figPrior.add_subplot(121) #ax3.hist2d(x, y, bins=100, norm=cNorm, cmap='Greys') #kdeDensity(ax3, samplex, sampley, threshold=thresholdScatter, bins=binsScatter, s=1, lw=0, alpha=alpha) corner.hist2d(samplex, sampley, ax=ax3, levels=levels, bins=200, no_fill_contours=True, plot_density=False, color=contourColor, rasterized=rasterized, plot_contours=False) ax3.scatter(samplex, sampley, s=1, lw=0, c='k', alpha=alpha) ax4 = figPrior.add_subplot(122) for i in range(xdgmm.n_components): points = drawEllipse.plotvector(xdgmm.mu[i], xdgmm.V[i]) ax4.plot(points[0, :], absMagKinda2absMag(points[1, :]), 'k-', alpha=xdgmm.weights[i] / np.max(xdgmm.weights)) #draw_ellipse(xdgmm.mu[i], xdgmm.V[i], scales=[2], ax=ax4, # ec='None', fc='gray', alpha=xdgmm.weights[i]/np.max(xdgmm.weights)*0.1) #xlim = ax4.get_xlim() #ylim = ylim #ax3.get_ylim() titles = [ "Observed Distribution", "Obs+Noise Distribution", "Extreme Deconvolution\n resampling", "Extreme Deconvolution\n cluster locations" ] if posterior: titles = [ "De-noised Expectation Values", "Posterior Distributions", "Extreme Deconvolution\n resampling", "Extreme Deconvolution\n cluster locations" ] if sdss5: titles = ['', '', '', ''] ax = [ax1, ax2, ax3, ax4] for i in range(4): ax[i].set_xlim(xlim) ax[i].set_ylim(ylim[0], ylim[1] * 1.1) #ax[i].xaxis.set_major_locator(plt.MultipleLocator([-1, 0, 1])) #ax[i].yaxis.set_major_locator(plt.MultipleLocator([3, 4, 5, 6])) ax[i].text(0.05, 0.95, titles[i], ha='left', va='top', transform=ax[i].transAxes, fontsize=18) #if i in (0, 1): # ax[i].xaxis.set_major_formatter(plt.NullFormatter()) #else: ax[i].set_xlabel(xlabel, fontsize=18) if i in (1, 3): ax[i].yaxis.set_major_formatter(plt.NullFormatter()) else: ax[i].set_ylabel(ylabel, fontsize=18) #ax[3].text(0.05, 0.95, titles[3], # ha='left', va='top', transform=ax[3].transAxes) #ax[3].set_ylabel(r'$\varpi10^{0.2*m_G}$', fontsize=18) #ax[3].set_xlim(-2, 3) #ax[3].set_ylim(3, -1) #ax[3].yaxis.tick_right() #ax[3].yaxis.set_label_position("right") #plt.tight_layout() """ if norm is not None: figData.subplots_adjust(left=0.2, right=0.95) cbar_ax = figData.add_axes([0.01, 0.125, 0.02, 0.75]) cb = figData.colorbar(im, cax=cbar_ax) #cb = plt.colorbar(im, ax=axes[2]) cb.set_label(r'$ln \, \tilde{\sigma}_{\varpi}^2 - ln \, \sigma_{\varpi}^2$', fontsize=20) cb.set_clim(-7, 2) """ figData.savefig('plot_sample.data.pdf', format='pdf') figPrior.savefig('plot_sample.prior.pdf', format='pdf')
def compute_Kernel(): from scipy import optimize, fftpack, interpolate from astroML.fourier import IFT_continuous from astroML.filters import wiener_filter #---------------------------------------------------------------------- # This function adjusts matplotlib settings for a uniform feel in the textbook. # Note that with usetex=True, fonts are rendered with LaTeX. This may # result in an error if LaTeX is not installed on your system. In that case, # you can set usetex to False. from astroML.plotting import setup_text_plots setup_text_plots(fontsize=8, usetex=False) #---------------------------------------------------------------------- # sample the same data as the previous Wiener filter figure np.random.seed(5) t = np.linspace(0, 100, 2001)[:-1] h = np.exp(-0.5 * ((t - 20.) / 1.0) ** 2) hN = h + np.random.normal(0, 0.5, size=h.shape) #---------------------------------------------------------------------- # compute the PSD N = len(t) Df = 1. / N / (t[1] - t[0]) f = fftpack.ifftshift(Df * (np.arange(N) - N / 2)) h_wiener, PSD, P_S, P_N, Phi = wiener_filter(t, hN, return_PSDs=True) #------------------------------------------------------------ # inverse fourier transform Phi to find the effective kernel t_plot, kernel = IFT_continuous(f, Phi) #------------------------------------------------------------ # perform kernel smoothing on the data. This is faster in frequency # space (ie using the standard Wiener filter above) but we will do # it in the slow & simple way here to demonstrate the equivalence # explicitly kernel_func = interpolate.interp1d(t_plot, kernel.real) t_eval = np.linspace(0, 90, 1000) t_KDE = t_eval[:, np.newaxis] - t t_KDE[t_KDE < t_plot[0]] = t_plot[0] t_KDE[t_KDE > t_plot[-1]] = t_plot[-1] F = kernel_func(t_KDE) h_smooth = np.dot(F, hN) / np.sum(F, 1) #------------------------------------------------------------ # Plot the results fig = plt.figure(figsize=(5, 2.2)) fig.subplots_adjust(left=0.1, right=0.95, wspace=0.25, bottom=0.15, top=0.9) # First plot: the equivalent Kernel to the WF ax = fig.add_subplot(121) ax.plot(t_plot, kernel.real, '-k') ax.text(0.95, 0.95, "Effective Wiener\nFilter Kernel", ha='right', va='top', transform=ax.transAxes) ax.set_xlim(-10, 10) ax.set_ylim(-0.05, 0.45) ax.set_xlabel(r'$\lambda$') ax.set_ylabel(r'$K(\lambda)$') # Second axes: Kernel smoothed results ax = fig.add_subplot(122) ax.plot(t_eval, h_smooth, '-k', lw=1) ax.plot(t_eval, 0 * t_eval, '-k', lw=1) ax.text(0.95, 0.95, "Kernel smoothing\nresult", ha='right', va='top', transform=ax.transAxes) ax.set_xlim(0, 90) ax.set_ylim(-0.5, 1.5) ax.set_xlabel('$\lambda$') ax.set_ylabel('flux') plt.show()
""" Code to generate 2D histograms of embedded spectral data. Authored by OGT 3/15/16 """ import numpy as np import matplotlib.pyplot as plt from matplotlib.colors import LogNorm from astroML.plotting import setup_text_plots import matplotlib as mpl plt.ion() setup_text_plots(fontsize=18) mpl.rc('xtick', labelsize=12) mpl.rc('ytick', labelsize=12) mpl.rc('font', size=18, family='serif', style='normal', variant='normal', stretch='normal', weight='bold') mpl.rc('legend', labelspacing=0.1, handlelength=2, fontsize=12) def get_contours(x, y, bins=(50, 50), ranges=None): if ranges: H, xedges, yedges = np.histogram2d(x, y, bins=bins, range=ranges) else: H, xedges, yedges = np.histogram2d(x, y, bins=bins) xmid = (xedges[1:] + xedges[:-1]) / 2.0 ymid = (yedges[1:] + yedges[:-1]) / 2.0 return xmid, ymid, H.T def plot_2Dhist(x, y, xlabel=None, ylabel=None, cblabel=None, ranges=[[-0.007, 0.002],[-0.014, 0.005]], vmin=1, vmax=10**5, normed=False, filename=None, annotate_string=None, annotate_loc=None): xmid, ymid, H = get_contours(x, y, bins=(50, 50), ranges=ranges)
def plot_samples(x, y, xerr, yerr, ind, contourColor='black', rasterized=True, plot_contours=True, dataColor='black', titles=None, xlim=(0, 1), ylim=(0, 1), xlabel=None, ylabel=None, prior=False, xdgmm=None, pdf=False): setup_text_plots(fontsize=16, usetex=True) plt.clf() alpha = 0.1 alpha_points = 0.01 fig = plt.figure(figsize=(12, 5.5)) fig.subplots_adjust(left=0.1, right=0.95, bottom=0.15, top=0.95, wspace=0.1, hspace=0.1) ax1 = fig.add_subplot(121) ax2 = fig.add_subplot(122) levels = 1.0 - np.exp(-0.5 * np.arange(1.0, 2.1, 1.0)**2) im = corner.hist2d(x, y, ax=ax1, levels=levels, bins=200, no_fill_contours=True, plot_density=False, color=contourColor, rasterized=True, plot_contours=plot_contours, plot_datapoints=False) ax1.scatter(x, y, s=1, lw=0, c=dataColor, alpha=alpha, zorder=0, rasterized=True) if prior: plotPrior(xdgmm, ax2, c=dataColor) else: ax2.errorbar(x[ind], y[ind], xerr=xerr[ind], yerr=[yerr[0][ind], yerr[1][ind]], fmt="none", zorder=0, mew=0, ecolor=dataColor, alpha=0.5, elinewidth=0.5) ax = [ax1, ax2] for i, axis in enumerate(ax): axis.set_xlim(xlim) axis.set_ylim(ylim[0], ylim[1] * 1.1) axis.text(0.05, 0.95, titles[i], ha='left', va='top', transform=axis.transAxes, fontsize=18) axis.set_xlabel(xlabel, fontsize=18) if i in [1]: #(1, 3): axis.yaxis.set_major_formatter(plt.NullFormatter()) else: axis.set_ylabel(ylabel, fontsize=18) if pdf: fig.savefig('plot_sample.pdf', dpi=400) fig.savefig('plot_sample.png')
""" Spyder Editor This is a temporary script file. """ import numpy as np from matplotlib import pyplot as plt from sklearn.naive_bayes import GaussianNB from astroML.datasets import fetch_rrlyrae_combined from astroML.utils import split_samples from astroML.utils import completeness_contamination #---------------------------------------------------------------------- from astroML.plotting import setup_text_plots setup_text_plots(fontsize=8, usetex=False) #---------------------------------------------------------------------- # get data and split into training & testing sets X, y = fetch_rrlyrae_combined() X = X[:, [1, 0, 2, 3]] # rearrange columns for better 1-color results (X_train, X_test), (y_train, y_test) = split_samples(X, y, [0.75, 0.25], random_state=0) #total test data N_tot = len(y) #Total assignments of 0 (Classification = true) N_st = np.sum(y == 0) #Total assignments of 1 (Classification = false) N_rr = N_tot - N_st #Number of train labels
def compute_Wavelet(): from astroML.fourier import FT_continuous, IFT_continuous #---------------------------------------------------------------------- # This function adjusts matplotlib settings for a uniform feel in the textbook. # Note that with usetex=True, fonts are rendered with LaTeX. This may # result in an error if LaTeX is not installed on your system. In that case, # you can set usetex to False. from astroML.plotting import setup_text_plots setup_text_plots(fontsize=8, usetex=False) def wavelet(t, t0, f0, Q): return (np.exp(-(f0 / Q * (t - t0)) ** 2) * np.exp(2j * np.pi * f0 * (t - t0))) def wavelet_FT(f, t0, f0, Q): # this is its fourier transform using # H(f) = integral[ h(t) exp(-2pi i f t) dt] return (np.sqrt(np.pi) * Q / f0 * np.exp(-2j * np.pi * f * t0) * np.exp(-(np.pi * (f - f0) * Q / f0) ** 2)) def check_funcs(t0=1, f0=2, Q=3): t = np.linspace(-5, 5, 10000) h = wavelet(t, t0, f0, Q) f, H = FT_continuous(t, h) assert np.allclose(H, wavelet_FT(f, t0, f0, Q)) #------------------------------------------------------------ # Create the simulated dataset np.random.seed(5) t = np.linspace(-40, 40, 2001)[:-1] h = np.exp(-0.5 * ((t - 20.) / 1.0) ** 2) hN = h + np.random.normal(0, 0.5, size=h.shape) #------------------------------------------------------------ # Compute the convolution via the continuous Fourier transform # This is more exact than using the discrete transform, because # we have an analytic expression for the FT of the wavelet. Q = 0.3 f0 = 2 ** np.linspace(-3, -1, 100) f, H = FT_continuous(t, hN) W = np.conj(wavelet_FT(f, 0, f0[:, None], Q)) t, HW = IFT_continuous(f, H * W) #------------------------------------------------------------ # Plot the results fig = plt.figure(figsize=(5, 5)) fig.subplots_adjust(hspace=0.05, left=0.12, right=0.95, bottom=0.08, top=0.95) # First panel: the signal ax = fig.add_subplot(311) ax.plot(t, hN, '-k', lw=1) ax.text(0.02, 0.95, ("Input Signal:\n" "Localized spike plus noise"), ha='left', va='top', transform=ax.transAxes) ax.set_xlim(-40, 40) ax.set_ylim(-1.2, 2.2) ax.xaxis.set_major_formatter(plt.NullFormatter()) ax.set_ylabel('$h(t)$') # Second panel: the wavelet ax = fig.add_subplot(312) W = wavelet(t, 0, 0.125, Q) ax.plot(t, W.real, '-k', label='real part', lw=1) ax.plot(t, W.imag, '--k', label='imag part', lw=1) ax.legend(loc=1) ax.text(0.02, 0.95, ("Example Wavelet\n" "$t_0 = 0$, $f_0=1/8$, $Q=0.3$"), ha='left', va='top', transform=ax.transAxes) ax.text(0.98, 0.05, (r"$w(t; t_0, f_0, Q) = e^{-[f_0 (t - t_0) / Q]^2}" "e^{2 \pi i f_0 (t - t_0)}$"), ha='right', va='bottom', transform=ax.transAxes) ax.set_xlim(-40, 40) ax.set_ylim(-1.4, 1.4) ax.set_ylabel('$w(t; t_0, f_0, Q)$') ax.xaxis.set_major_formatter(plt.NullFormatter()) # Third panel: the spectrogram ax = fig.add_subplot(313) ax.imshow(abs(HW) ** 2, origin='lower', aspect='auto', cmap=plt.cm.binary, extent=[t[0], t[-1], np.log2(f0)[0], np.log2(f0)[-1]]) ax.set_xlim(-40, 40) ax.text(0.02, 0.95, ("Wavelet PSD"), color='w', ha='left', va='top', transform=ax.transAxes) ax.set_ylim(np.log2(f0)[0], np.log2(f0)[-1]) ax.set_xlabel('$t$') ax.set_ylabel('$f_0$') ax.yaxis.set_major_locator(plt.MultipleLocator(1)) ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, *args: ("1/%i" % (2 ** -x)))) plt.show()
# The figure produced by this code is published in the textbook # "Statistics, Data Mining, and Machine Learning in Astronomy" (2013) # For more information, see http://astroML.github.com # To report a bug or issue, use the following forum: # https://groups.google.com/forum/#!forum/astroml-general import numpy as np from matplotlib import pyplot as plt # ---------------------------------------------------------------------- # This function adjusts matplotlib settings for a uniform feel in the textbook. # Note that with usetex=True, fonts are rendered with LaTeX. This may # result in an error if LaTeX is not installed on your system. In that case, # you can set usetex to False. from astroML.plotting import setup_text_plots setup_text_plots(fontsize=8, usetex=True) # ------------------------------------------------------------ # Compute Kernels. x = np.linspace(-5, 5, 10000) dx = x[1] - x[0] gauss = (1.0 / np.sqrt(2 * np.pi)) * np.exp(-0.5 * x ** 2) exp = 0.5 * np.exp(-abs(x)) tophat = 0.5 * np.ones_like(x) tophat[abs(x) > 1] = 0 # ------------------------------------------------------------ # Plot the kernels
def compute_Gaussian(): from astroML.fourier import\ FT_continuous, IFT_continuous, sinegauss, sinegauss_FT, wavelet_PSD #---------------------------------------------------------------------- # This function adjusts matplotlib settings for a uniform feel in the textbook. # Note that with usetex=True, fonts are rendered with LaTeX. This may # result in an error if LaTeX is not installed on your system. In that case, # you can set usetex to False. from astroML.plotting import setup_text_plots setup_text_plots(fontsize=8, usetex=False) #------------------------------------------------------------ # Sample the function: localized noise np.random.seed(0) N = 1024 t = np.linspace(-5, 5, N) x = np.ones(len(t)) h = np.random.normal(0, 1, len(t)) h *= np.exp(-0.5 * (t / 0.5) ** 2) #------------------------------------------------------------ # Compute an example wavelet W = sinegauss(t, 0, 1.5, Q=1.0) #------------------------------------------------------------ # Compute the wavelet PSD f0 = np.linspace(0.5, 7.5, 100) wPSD = wavelet_PSD(t, h, f0, Q=1.0) #------------------------------------------------------------ # Plot the results fig = plt.figure(figsize=(5, 5)) fig.subplots_adjust(hspace=0.05, left=0.12, right=0.95, bottom=0.08, top=0.95) # First panel: the signal ax = fig.add_subplot(311) ax.plot(t, h, '-k', lw=1) ax.text(0.02, 0.95, ("Input Signal:\n" "Localized Gaussian noise"), ha='left', va='top', transform=ax.transAxes) ax.set_xlim(-4, 4) ax.set_ylim(-2.9, 2.9) ax.xaxis.set_major_formatter(plt.NullFormatter()) ax.set_ylabel('$h(t)$') # Second panel: an example wavelet ax = fig.add_subplot(312) ax.plot(t, W.real, '-k', label='real part', lw=1) ax.plot(t, W.imag, '--k', label='imag part', lw=1) ax.text(0.02, 0.95, ("Example Wavelet\n" "$t_0 = 0$, $f_0=1.5$, $Q=1.0$"), ha='left', va='top', transform=ax.transAxes) ax.text(0.98, 0.05, (r"$w(t; t_0, f_0, Q) = e^{-[f_0 (t - t_0) / Q]^2}" "e^{2 \pi i f_0 (t - t_0)}$"), ha='right', va='bottom', transform=ax.transAxes) ax.legend(loc=1) ax.set_xlim(-4, 4) ax.set_ylim(-1.4, 1.4) ax.set_ylabel('$w(t; t_0, f_0, Q)$') ax.xaxis.set_major_formatter(plt.NullFormatter()) # Third panel: the spectrogram ax = plt.subplot(313) ax.imshow(wPSD, origin='lower', aspect='auto', cmap=plt.cm.jet, extent=[t[0], t[-1], f0[0], f0[-1]]) ax.text(0.02, 0.95, ("Wavelet PSD"), color='w', ha='left', va='top', transform=ax.transAxes) ax.set_xlim(-4, 4) ax.set_ylim(0.5, 7.5) ax.set_xlabel('$t$') ax.set_ylabel('$f_0$') plt.show()