def _get_guess(self):
from gmix_image.priors import CenPrior
if self.ares is None:
self.ares=self._run_admom(self.image, self.ivar,
self.cen_guess, 8.0)
cen=[self.ares['wrow'],self.ares['wcol']]
self.cenprior=CenPrior(cen, [self.cen_width]*2)
Tadmom=self.ares['Irr'] + self.ares['Icc']
guess=numpy.zeros( (self.nwalkers,self.npars) )
guess[:,0]=self.cenprior.cen[0] + 0.01*srandu(self.nwalkers)
guess[:,1]=self.cenprior.cen[1] + 0.01*srandu(self.nwalkers)
g1rand,g2rand=self.gprior.sample2d(self.nwalkers)
guess[:,2] = g1rand
guess[:,3] = g2rand
guess[:,4] = Tadmom*(1 + 0.1*srandu(self.nwalkers))
guess[:,5] = self.counts*(1 + 0.1*srandu(self.nwalkers))
self._guess=guess
return guess
def get_guess(self,pars=None):
from esutil.random import srandu
xstep=self.xvals[1]-self.xvals[0]
if pars is None:
Aguess = self.yvals.sum()*xstep
aguess=1.715
g0guess=0.078
gmax_guess=0.70
gsigma_guess=0.126
pars=array( [Aguess, aguess, g0guess, gmax_guess, gsigma_guess])
print("pars:",pars)
self.Aguess=pars[0]
guess=zeros( (self.nwalkers,self.npars) )
width=0.1
nwalkers=self.nwalkers
guess[:,0] = pars[0]*(1.+width*srandu(nwalkers))
guess[:,1] = pars[1]*(1.+width*srandu(nwalkers))
guess[:,2] = pars[2]*(1.+width*srandu(nwalkers))
guess[:,3] = pars[3]*(1.+width*srandu(nwalkers))
guess[:,4] = pars[4]*(1.+width*srandu(nwalkers))
return guess
def _measure_gals_gmix(self):
import gmix_image
from gmix_image.util import print_pars
from esutil.random import srandu
nbin=self.im_stacks.size
psf_pars=numpy.array( [1.0,
self.psf_ares['wrow'],
self.psf_ares['wcol'],
self.psf_ares['Irr'],
self.psf_ares['Irc'],
self.psf_ares['Icc']] )
gmix_psf=gmix_image.gmix.GMixCoellip(psf_pars)
for i in xrange(nbin):
print '-'*70
print self.im_stacks['s2n_min'][i], self.im_stacks['s2n_max'][i]
im_real=self.im_stacks['images_real'][i,:,:]
im_imag=self.im_stacks['images_imag'][i,:,:]
imc = self._make_complex_image(im_real, im_imag)
im=self._make_cspace_image(imc)
pixerr=numpy.sqrt(self.im_stacks['skyvar'][i])
counts=im.sum()
e1guess=self._admom_shear['e1'][i]
e2guess=self._admom_shear['e2'][i]
Tguess = self._admom_shear['T'][i]*(1. + 0.05*srandu())
if False:
prior=numpy.array( [im.shape[0]/2., im.shape[1]/2.,
e1guess,e2guess,
8.0, 6.0, 4.0,
counts*0.3, counts*0.4, counts*0.3])
elif True:
prior=numpy.array( [im.shape[0]/2.,
im.shape[1]/2.,
e1guess,e2guess,
Tguess*0.7,
Tguess*0.3,
counts*0.6,
counts*0.4])
elif False:
prior=numpy.array( [im.shape[0]/2.,
im.shape[1]/2.,
e1guess+0.05*srandu(),
e2guess+0.05*srandu(),
Tguess,
counts*(1.0+0.05*srandu())] )
width=prior*0 + 1.e6
fitter=gmix_image.gmix_fit.GMixFitCoellip(im, pixerr, prior, width,
psf=gmix_psf)
print_pars(fitter.get_pars())
def _set_full_guess(self):
from esutil.random import srandu
guess0 = self._guess0
npars = len(guess0)
nwalkers = self._nwalkers
guess = zeros((nwalkers, npars))
for i in xrange(npars):
if guess0[i] == 0:
guess[:, i] = guess0[i] + 0.1 * srandu(nwalkers)
else:
guess[:, i] = guess0[i] * (1 + 0.1 * srandu(nwalkers))
self._guess = guess
def _run_admom(self, image, skyvar):
import admom
cen_guess=numpy.array(image.shape,dtype='f8')/2.
n=0
while n < 100:
ares = admom.admom(image,
cen_guess[0]+0.1*srandu(),
cen_guess[1]+0.1*srandu(),
sigsky=sqrt(skyvar),
guess=4.0*(1+0.1*srandu()),
nsub=self.nsub)
if ares['whyflag'] == 0:
break
n += 1
return ares
def _set_guess_stepsize(self):
npars=self._npars
guess=numpy.zeros(npars)
# these for S/N=700
stepsize=numpy.zeros(npars)
for i in xrange(self._nimages):
ii = 2 + 4*i
ai=self._ares_list[i]
if ai['whyflag'] != 0:
raise ValueError("admom with flags != 0")
aT = ai['Irr'] + ai['Icc']
counts=self._image_list[i].sum()
guess[ii+0] = ai['wrow']*(1. + 0.1*srandu())
guess[ii+1] = ai['wcol']*(1. + 0.1*srandu())
guess[ii+2] = aT*(1. + 0.1*srandu())
guess[ii+3] = counts*(1. + 0.1*srandu())
stepsize[ii+0] = 0.1
stepsize[ii+1] = 0.1
# update for s/n
stepsize[ii+2] = 0.1
stepsize[ii+3] = 0.05
if self._draw_gprior:
g1rand,g2rand=self._gprior.sample2d(1)
guess[0] = g1rand[0]
guess[1] = g2rand[0]
else:
#guess[0] = 0.1*srandu()
#guess[1] = 0.1*srandu()
guess[0] = 0.038
guess[1] = -0.005
stepsize[0]=0.1
stepsize[1]=0.1
self._stepsize=stepsize
self._guess=guess
return guess
def _run_admom(self, im, row, col, guess0, skysig):
i = 0
res = None
while i < self["admom_ntry"]:
guess = guess0 * (1.0 + 0.05 * srandu())
row = row + 0.4 * srandu()
col = col + 0.4 * srandu()
tmp = admom.admom(im, row, col, sigsky=skysig, guess=guess)
if tmp["whyflag"] == 0:
res = tmp
break
i += 1
return res
def test_lognormal():
import biggles
import esutil as eu
from esutil.random import LogNormal, srandu
from esutil.stat import histogram
n=1000
nwalkers=100
burnin=100
nstep=100
mean=8
sigma=3
ln=LogNormal(mean,sigma)
vals=ln.sample(n)
binsize=0.5
plt=eu.plotting.bhist(vals, binsize=binsize,show=False)
h=histogram(vals, binsize=binsize,more=True)
herr=sqrt(h['hist'])
herr=herr.clip(1.0, herr.max())
guess=[n*(1. + .1*srandu()),
mean*(1. + .1*srandu()),
sigma*(1. + .1*srandu())]
guess=[n*binsize,mean,sigma]
print 'guess:',guess
nlf=LogNormalFitter(h['center'], h['hist'], guess, nwalkers, burnin, nstep,
yerr=herr)
print nlf
res=nlf.get_result()
model=nlf.get_model()
yvals=model.scaled(h['center'])
plt.add(biggles.Curve(h['center'], yvals, color='blue'))
plt.show()
def sample2d_pj(self, nrand, s1, s2):
"""
Get random g1,g2 values from an approximate
sheared distribution
parameters
----------
nrand: int
Number to generate
"""
from .util import srandu
maxval_2d = self(0.0,0.0)
g1,g2=zeros(nrand),zeros(nrand)
ngood=0
nleft=nrand
while ngood < nrand:
# generate on cube [-1,1,h]
g1rand=srandu(nleft)
g2rand=srandu(nleft)
# a bit of padding since we are modifying the distribution
fac=1.3
h = fac*maxval_2d*random.random(nleft)
pjvals = self.get_pj(g1rand,g2rand,s1,s2)
#wbad,=where(pjvals > fac*maxval_2d)
#if wbad.size > 0:
# raise ValueError("found %d > maxval" % wbad.size)
w,=where(h < pjvals)
if w.size > 0:
g1[ngood:ngood+w.size] = g1rand[w]
g2[ngood:ngood+w.size] = g2rand[w]
ngood += w.size
nleft -= w.size
return g1,g2
def _transform_guess(self, guess):
# s1,s2, se1,se2, T, Amp
nguess=zeros(6)
Irr = guess['shear_cov'][0,0]
Irc = 0.0
Icc = guess['shear_cov'][1,1]
T = Irr + Icc
Flux = self.p.sum()*self.scale1*self.scale2
# guess the middle
nguess[0] = (self.s1vals[-1]-self.s1vals[0])/2.
nguess[1] = (self.s2vals[-1]-self.s2vals[0])/2.
nguess[2] = 0.0 + 0.01*srandu()
nguess[3] = 0.0 + 0.01*srandu()
nguess[4] = T
nguess[5] = Flux
return nguess
def _set_guess(self, guess0):
from esutil.random import srandu
if guess0 is not None:
guess0 = array(guess0, dtype="f8", ndmin=1, copy=True)
self._check_guess(guess0)
else:
guess0 = numpy.polyfit(self.x, self.y, self.order)
self.guess = guess0
npars = len(guess0)
nwalkers = self.nwalkers
guess = zeros((nwalkers, npars))
for i in xrange(npars):
if guess0[i] == 0:
guess[:, i] = guess0[i] + 0.1 * srandu(nwalkers)
else:
guess[:, i] = guess0[i] * (1 + 0.1 * srandu(nwalkers))
self._guess = guess
def _get_guess(self):
nwalkers=self._nwalkers
npars=self._npars
guess=numpy.zeros( (nwalkers,npars) )
for i in xrange(self._nimages):
ii = 2 + 4*i
ai=self._ares_list[i]
if ai['whyflag'] != 0:
raise ValueError("admom with flags != 0")
aT = ai['Irr'] + ai['Icc']
counts=self._image_list[i].sum()
guess[:,ii+0] = ai['wrow']*(1. + 0.1*srandu(nwalkers))
guess[:,ii+1] = ai['wcol']*(1. + 0.1*srandu(nwalkers))
guess[:,ii+2] = aT*(1. + 0.1*srandu(nwalkers))
guess[:,ii+3] = counts*(1. + 0.1*srandu(nwalkers))
if self._draw_gprior:
g1rand,g2rand=self._gprior.sample2d(nwalkers)
guess[:,0] = g1rand
guess[:,1] = g2rand
else:
#guess[:,0] = 0.05*srandu(nwalkers)
#guess[:,1] = 0.05*srandu(nwalkers)
guess[:,0] = 0.08*(1.0 + 0.1*srandu(nwalkers))
guess[:,1] = 0.001*srandu(nwalkers)
self._guess=guess
return guess
def _presample_prior_simple(self,cen_prior,g_prior,T_prior,counts_prior):
from gmix_image import priors
if not hasattr(self,'_prior_samples'):
npre=self.get('n_pre_sample',100000)
print >>stderr,'pre-sampling the prior',npre
npars=6
nwalkers=20
# per walker, 2000
burnin=100
start=numpy.zeros( (nwalkers,npars) )
start[:,0:2] = cen_prior.sample(nwalkers)
start[:,2] = 0.1*srandu(nwalkers)
start[:,3] = 0.1*srandu(nwalkers)
start[:,4] = T_prior.sample(nwalkers)
start[:,5] = counts_prior.sample(nwalkers)
comb=priors.CombinedPriorSimple(cen_prior,
g_prior,
T_prior,
counts_prior)
sampler = comb.sample(start,
npre,
burnin=burnin,
nwalkers=nwalkers,
get_sampler=True)
prand = sampler.flatchain
lnp = sampler.lnprobability
lnp = lnp.reshape(lnp.shape[0]*lnp.shape[1])
probs = numpy.exp(lnp)
self._prior_samples={'samples':prand,
'prob':probs}
return self._prior_samples
def sample2d(self, nrand):
"""
Get random g1,g2 values using 2-d brute
force method
parameters
----------
nrand: int
Number to generate
"""
from .util import srandu
maxval_2d = self(0.0,0.0)
g1,g2=zeros(nrand),zeros(nrand)
ngood=0
nleft=nrand
while ngood < nrand:
# generate on cube [-1,1,h]
g1rand=srandu(nleft)
g2rand=srandu(nleft)
# a bit of padding since we are modifying the distribution
h = maxval_2d*random.random(nleft)
vals = self(g1rand,g2rand)
#wbad,=where(vals > maxval_2d)
#if wbad.size > 0:
# raise ValueError("found %d > maxval" % wbad.size)
w,=where(h < vals)
if w.size > 0:
g1[ngood:ngood+w.size] = g1rand[w]
g2[ngood:ngood+w.size] = g2rand[w]
ngood += w.size
nleft -= w.size
return g1,g2
def get_guess(self):
from esutil.random import srandu
xstep=self.xvals[1]-self.xvals[0]
self.Aguess = self.yvals.sum()*xstep
aguess=1.11
g0guess=0.052
gmax_guess=0.9
pcen=array( [self.Aguess, aguess, g0guess, gmax_guess])
print("pcen:",pcen)
guess=zeros( (self.nwalkers,self.npars) )
width=0.1
nwalkers=self.nwalkers
guess[:,0] = pcen[0]*(1.+width*srandu(nwalkers))
guess[:,1] = pcen[1]*(1.+width*srandu(nwalkers))
guess[:,2] = pcen[2]*(1.+width*srandu(nwalkers))
guess[:,3] = pcen[3]*(1.+width*srandu(nwalkers))
return guess
def _get_guess(self):
return numpy.array([self.sh_guess[0] + 0.01*srandu(),
self.sh_guess[1] + 0.01*srandu(),
0.0+0.01*srandu(),
0.0+0.01*srandu(),
self.Tguess*(1.0+0.01*srandu()),
self.a_guess*(1.0+0.01*srandu())
])
def _get_cmcmc_simple_guess(self, ci, config):
nwalkers=config['nwalkers']
guess=numpy.zeros( (nwalkers, 6) )
# cen uniform within 0.1 pixels of truth
guess[:,0] = ci['cen'][0] + 0.1*srandu(nwalkers)
guess[:,1] = ci['cen'][0] + 0.1*srandu(nwalkers)
g_draw=config['g_draw']
if g_draw=="prior":
g1rand,g2rand=self.gprior.sample2d(nwalkers)
guess[:,2]=g1rand
guess[:,3]=g2rand
elif g_draw=="truth":
sh=lensing.Shear(e1=ci['e1true'],e2=ci['e2true'])
g1=sh.g1
g2=sh.g2
g1rand=numpy.zeros( nwalkers )
g2rand=numpy.zeros( nwalkers )
nleft=nwalkers
ngood=0
while nleft > 0:
g1rand_t = g1 + 0.01*srandu(nleft)
g2rand_t = g2 + 0.01*srandu(nleft)
g2tot=g1rand_t**2 + g2rand_t**2
w,=numpy.where(g2tot < 0.999)
if w.size > 0:
g1rand[ngood:ngood+w.size] = g1rand_t[w]
g2rand[ngood:ngood+w.size] = g2rand_t[w]
ngood += w.size
nleft -= w.size
guess[:,2]=g1rand
guess[:,3]=g2rand
elif g_draw=="maxlike":
raise ValueError("implement getting maxlike as guess")
guess[:,4] = ci['Ttrue']*(1.+0.1*srandu(nwalkers))
guess[:,5] = ci['counts_true']*(1.0 + 0.1*srandu(nwalkers))
return guess
def fit_gprior_m_style(cat_type, version=None,
a=0.25, g0=0.1, gmax=0.87, gmax_min=None, Awidth=1.0,
binsize=0.02, doplot=False):
"""
cat_type should be "galfit" or "ngmix-exp" "ngmix-dev" "ngmix-bdf"
If cat_type=="galfit" then fit to the shapes from the sersic fits.
If cat=="ngmix-exp" use my fits, same for dev. Must send version= as well
This works much better than an lm fitter
for all cosmos galaxies I get
[840.0, 1.05, 0.087, 0.810]
"""
import mcmc
import emcee
import esutil as eu
from esutil.random import srandu
g=get_shapes(cat_type, version=version)
bs=eu.stat.Binner(g)
bs.dohist(binsize=binsize)
bs.calc_stats()
xdata=bs['center']
ydata=bs['hist']
nwalkers=200
burnin=500
nstep=100
print 'fitting exp'
A=ydata.sum()*(xdata[1]-xdata[0])
pcen=[A,a,g0,gmax]
npars=4
guess=numpy.zeros( (nwalkers,npars) )
guess[:,0] = pcen[0]*(1.+0.1*srandu(nwalkers))
guess[:,1] = pcen[1]*(1.+0.1*srandu(nwalkers))
guess[:,2] = pcen[2]*(1.+0.1*srandu(nwalkers))
guess[:,3] = pcen[3]*(1.+0.1*srandu(nwalkers))
ivar = numpy.ones(xdata.size)
w,=numpy.where(ydata > 0)
ivar[w] = 1./ydata[w]
gfitter=GPriorMFitter(xdata, ydata, ivar, Aprior=A, Awidth=Awidth, gmax_min=gmax_min)
print 'pcen:',pcen
sampler = emcee.EnsembleSampler(nwalkers,
npars,
gfitter.get_lnprob,
a=2)
pos, prob, state = sampler.run_mcmc(guess, burnin)
sampler.reset()
pos, prob, state = sampler.run_mcmc(pos, nstep)
trials = sampler.flatchain
pars,pcov=mcmc.extract_stats(trials)
d=numpy.diag(pcov)
perr = numpy.sqrt(d)
res={'A':pars[0],
'A_err':perr[0],
'a':pars[1],
'a_err':perr[1],
'g0':pars[2],
'g0_err':perr[2],
'gmax': pars[3],
'gmax_err':perr[3],
'pars':pars,
'pcov':pcov,
'perr':perr}
fmt="""
A: %(A).6g +/- %(A_err).6g
a: %(a).6g +/- %(a_err).6g
g0: %(g0).6g +/- %(g0_err).6g
gmax: %(gmax).6g +/- %(gmax_err).6g
""".strip()
print fmt % res
if doplot:
import mcmc
import ngmix
mcmc.plot_results(trials,names=['A','a','g0','gmax'],
title=cat_type)
p=ngmix.priors.GPriorM(pars)
gsamp=p.sample1d(g.size)
plt=eu.plotting.bhist(g, binsize=binsize, show=False)
eu.plotting.bhist(gsamp, binsize=binsize,
plt=plt, color='blue',
xlabel='|g|',
xrange=[0.,1.],
title=cat_type)
return res
def test_em(s2n=100., show=False, ngauss=2, offcen=True):
#tol=1.e-6
tol=1.e-6
maxiter=5000
dims=[31,31]
if ngauss==2:
if offcen:
gd = [{'p':0.6,'row':17.1,'col':17.6,'irr':4.0,'irc':0.0,'icc':4.0},
{'p':0.4,'row':14.2,'col':15.4,'irr':3.2,'irc':0.3,'icc':2.0}]
else:
gd = [{'p':0.6,'row':15.1,'col':15.6,'irr':4.0,'irc':0.0,'icc':4.0},
{'p':0.4,'row':15.1,'col':15.6,'irr':3.2,'irc':0.3,'icc':2.0}]
guess=[{'p':0.5+0.02*srandu(),
'row':15+2*srandu(),
'col':15+2*srandu(),
'irr':2.0+0.5*srandu(),
'irc':0.0+0.1*srandu(),
'icc':2.0+0.5*srandu()},
{'p':0.5+0.02*srandu(),
'row':15+2*srandu(),
'col':15+2*srandu(),
'irr':2.0+0.5*srandu(),
'irc':0.0+0.1*srandu(),
'icc':2.0+0.5*srandu()} ]
elif ngauss==1:
gd = [{'p':0.6,'row':17.1,'col':17.6,'irr':4.0,'irc':0.0,'icc':4.0}]
guess=[{'p':0.5+0.02*srandu(),
'row':15+2*srandu(),
'col':15+2*srandu(),
'irr':2.0+0.5*srandu(),
'irc':0.0+0.1*srandu(),
'icc':2.0+0.5*srandu()} ]
else:
raise ValueError("1 or 2 gauss")
counts=1000
im_nonoise = gmix2image_em(gd, dims, counts=counts)
im,skysig=add_noise_matched(im_nonoise,s2n)
# pretend it is poisson
#sky = skysig**2
#im += sky
im_min=im.min()
sky = 0.01 + abs(im_min)
im += sky
verbose=False
gm = gmix_image.GMixEM(im,
guess,
sky=sky,
counts=counts,
maxiter=maxiter,
tol=tol,
verbose=verbose)
gm.write()
print 'truth'
for i,d in enumerate(gd):
print '%i'% i,
for k in ['p','row','col','irr','irc','icc']:
print '%s: %9.6lf' % (k,d[k]),
print
if show and have_images:
model_image=gm.get_model()
msum=model_image.sum()
if msum > 0:
model_image *= counts/msum
images.compare_images(im-sky, model_image,
label1='im', label2='model',
cross_sections=False)
return gm
def fit_gprior_exp_mcmc(xdata, ydata, ivar, a=0.25, g0=0.1, gmax=0.87, gmax_min=None, Awidth=1.0):
"""
This works much better than the lm fitter
Input is the histogram data.
"""
import mcmc
import emcee
nwalkers=200
burnin=100
nstep=100
print 'fitting exp'
A=ydata.sum()*(xdata[1]-xdata[0])
pcen=[A,a,g0,gmax]
npars=4
guess=zeros( (nwalkers,npars) )
guess[:,0] = pcen[0]*(1.+0.1*srandu(nwalkers))
guess[:,1] = pcen[1]*(1.+0.1*srandu(nwalkers))
guess[:,2] = pcen[2]*(1.+0.1*srandu(nwalkers))
guess[:,3] = pcen[3]*(1.+0.1*srandu(nwalkers))
gfitter=GPriorExpFitter(xdata, ydata, ivar, Aprior=A, Awidth=Awidth, gmax_min=gmax_min)
print 'pcen:',pcen
sampler = emcee.EnsembleSampler(nwalkers,
npars,
gfitter.get_lnprob,
a=2)
pos, prob, state = sampler.run_mcmc(guess, burnin)
sampler.reset()
pos, prob, state = sampler.run_mcmc(pos, nstep)
trials = sampler.flatchain
pars,pcov=mcmc.extract_stats(trials)
d=diag(pcov)
perr = sqrt(d)
res={'A':pars[0],
'A_err':perr[0],
'a':pars[1],
'a_err':perr[1],
'g0':pars[2],
'g0_err':perr[2],
'gmax': pars[3],
'gmax_err':perr[3],
'pars':pars,
'pcov':pcov,
'perr':perr}
fmt="""
A: %(A).6g +/- %(A_err).6g
a: %(a).6g +/- %(a_err).6g
g0: %(g0).6g +/- %(g0_err).6g
gmax: %(gmax).6g +/- %(gmax_err).6g
""".strip()
print fmt % res
return res
def _fit_stack_lm(self, image_stack, skyvar, ares, psf=None,
ngauss=1, name=''):
row_guess=ares['wrow']
col_guess=ares['wcol']
e1guess=ares['e1']
e2guess=ares['e2']
Tguess=ares['Irr']+ares['Icc']
counts=image_stack.sum()
while True:
if ngauss==4:
prior=numpy.array( [row_guess+0.01*srandu(),
col_guess+0.01*srandu(),
e1guess+0.05*srandu(),
e2guess+0.05*srandu(),
Tguess*16.0*(1.+0.1*srandu()),
Tguess*8.0*(1.+0.1*srandu()),
Tguess*2.42*(1.+0.1*srandu()),
Tguess*0.20*(1.+0.1*srandu()),
counts*0.10*(1.+0.1*srandu()),
counts*0.20*(1.+0.1*srandu()),
counts*0.25*(1.+0.1*srandu()),
counts*0.31*(1.+0.1*srandu())])
elif ngauss==3:
prior=numpy.array( [row_guess+0.01*srandu(),
col_guess+0.01*srandu(),
e1guess+0.05*srandu(),
e2guess+0.05*srandu(),
Tguess*8.0*(1.+0.1*srandu()),
Tguess*2.42*(1.+0.1*srandu()),
Tguess*0.20*(1.+0.1*srandu()),
counts*0.28*(1.+0.1*srandu()),
counts*0.34*(1.+0.1*srandu()),
counts*0.38*(1.+0.1*srandu())])
elif ngauss==2:
prior=numpy.array( [row_guess+0.01*srandu(),
col_guess+0.01*srandu(),
e1guess+0.05*srandu(),
e2guess+0.05*srandu(),
Tguess*3.0*(1.+0.1*srandu()),
Tguess*0.9*(1.+0.1*srandu()),
counts*0.6*(1.+0.1*srandu()),
counts*0.4*(1.+0.1*srandu())])
elif ngauss==1:
prior=numpy.array( [row_guess+0.01*srandu(),
col_guess+0.01*srandu(),
e1guess+0.05*srandu(),
e2guess+0.05*srandu(),
Tguess*(1.+0.1*srandu()),
counts*(1.+0.1*srandu())] )
else:
raise ValueError("send ngauss 1,2,3")
width=numpy.abs(prior)*1.e6
fitter=gmix_image.gmix_fit.GMixFitCoellip(image_stack, sqrt(skyvar), prior, width,
model='coellip',
nsub=self.nsub, psf=psf, verbose=False)
flags=fitter.get_flags()
if flags==0:
break
else:
print flags
res=fitter.get_result()
print 'numiter:',res['numiter']
if self.verbose:
print_pars(prior,front='prior: ')
print_pars(res['pars'], front='pars: ')
print_pars(res['perr'], front='perr: ')
if False:
import images
model=fitter.get_model()
#images.multiview(im/im.max(), nonlinear=1)
images.compare_images(image_stack/image_stack.max(),
model/model.max(),
nonlinear=1,
title=name)
key=raw_input('hit a key: ')
if key=='q':
stop
return fitter
def test_gaussians(npass=1,
n_near1=5,
n_near2=10,
n1=100000,
n2=10000,
show=False, epsfile=None):
"""
test matching a set of 5-d gaussians to another
"""
from numpy.random import multivariate_normal
from esutil.random import srandu
ndim=5
# we want to weight this set to look like the second
ngauss1=3
npergauss1=n1//ngauss1
ntot1=npergauss1*ngauss1
cen1=[ 1.0+0.1*srandu(ndim),
0.9+0.1*srandu(ndim),
1.1+0.1*srandu(ndim)]
sig1=[ [0.75]*ndim,
[1.5]*ndim,
[2]*ndim ]
data1=zeros( (ntot1, ndim) )
ngauss2=3
npergauss2=n1//ngauss1
ntot2=npergauss2*ngauss2
cen2=[ 1.0+0.1*srandu(ndim),
1.0+0.1*srandu(ndim),
1.0+0.1*srandu(ndim)]
sig2=[ [0.5]*ndim,
[0.75]*ndim,
[1.2]*ndim ]
data2=zeros( (ntot2, ndim) )
for i in xrange(ngauss1):
beg=i*npergauss1
end=(i+1)*npergauss1
c=array(cen1[i])
s2=array(sig1[i])**2
cov=diag(s2)
pts = multivariate_normal( c, cov, npergauss1)
data1[beg:end,:] = pts
for i in xrange(ngauss2):
beg=i*npergauss2
end=(i+1)*npergauss2
c=array(cen2[i])
s2=array(sig2[i])**2
cov=diag(s2)
pts = multivariate_normal( c, cov, npergauss2)
data2[beg:end,:] = pts
if npass==1:
wn=WeightNearest(data1, data2, npass=npass)
wn.go(n_near1)
else:
wn=WeightNearest(data1, data2, npass=npass)
wn.go(n_near1, n_near2)
plist=wn.plot_results(show=show)
return plist
def test_turb(ngauss=2, Tfrac=False):
import pprint
import fimage
import admom
from fimage.transform import rebin
import images
from .gmix_fit import print_pars
counts=1.
fwhm=3.3
dims=array([20,20])
#fwhm=10.
#dims=array([60,60])
s2n_psf=1.e9
print 'making image'
expand_fac=5
psfexp=fimage.pixmodel.ogrid_turb_psf(dims*expand_fac,fwhm*expand_fac,
counts=counts)
psf0=rebin(psfexp, expand_fac)
psf,skysig=fimage.noise.add_noise_admom(psf0, s2n_psf)
psfres = admom.admom(psf,
dims[0]/2.,
dims[1]/2.,
sigsky=skysig,
guess=4.,
nsub=1)
"""
psfpars={'model':'turb','psf_fwhm':fwhm}
objpars={'model':'exp','cov':[2.0,0.0,2.0]}
s2n_obj=200.
ci_nonoise = fimage.convolved.ConvolverTurbulence(objpars,psfpars)
ci=fimage.convolved.NoisyConvolvedImage(ci_nonoise, s2n_obj, s2n_psf,
s2n_method='admom')
print ci['cen_uw']
print ci['cov_uw']
print 'running admom'
counts=ci.psf.sum()
psf=ci.psf, skysig=ci['skysig_psf']
psfres = admom.admom(ci.psf,
ci['cen_uw'][0],
ci['cen_uw'][1],
sigsky=ci['skysig_psf'],
guess=4.,
nsub=1)
"""
pprint.pprint(psfres)
if psfres['whyflag'] != 0:
raise ValueError("found admom error: %s" % admom.wrappers.flagmap[psfres['whyflag']])
print 'making prior/guess'
npars=2*ngauss+4
prior=zeros(npars)
width=zeros(npars) + 1000
prior[0]=psfres['row']
prior[1]=psfres['col']
prior[2]=psfres['e1']
prior[3]=psfres['e2']
Tpsf=psfres['Irr']+psfres['Icc']
if Tfrac:
if ngauss==3:
model='coellip-Tfrac'
Tmax = Tpsf*8.3
Tfrac1 = 1.7/8.3
Tfrac2 = 0.8/8.3
prior[4] = Tmax
prior[5] = Tfrac1
prior[6] = Tfrac2
prior[7] = 0.08*counts
prior[8] = 0.38*counts
prior[9] = 0.53*counts
else:
raise ValueError("Do Tfrac ngauss==2")
else:
model='coellip'
if ngauss==3:
Texamp=array([0.46,5.95,2.52])
pexamp=array([0.1,0.7,0.22])
Tfrac=Texamp/Texamp.sum()
pfrac=pexamp/pexamp.sum()
prior[4:4+3] = Tpsf*Tfrac
prior[7:7+3] = counts*pfrac
else:
prior[4] = Tpsf/3.0
prior[5] = Tpsf/3.0
prior[6] = counts/3.
prior[7] = counts/3.
# randomize
prior[0] += 0.01*srandu()
prior[1] += 0.01*srandu()
e1start=prior[2]
e2start=prior[3]
prior[2:2+2] += 0.02*srandu(2)
prior[4:npars] = prior[4:npars]*(1+0.05*srandu(2*ngauss))
print_pars(prior)
print 'doing fit'
gm = gmix_image.GMixFitCoellip(psf, skysig,
prior,width,
model=model,
Tpositive=True)
print_pars( gm.get_pars() )
gmix=gm.get_gmix()
print 'gmix'
pprint.pprint(gmix)
#print 'Tpsf:',Tpsf
moms=fimage.fmom(psf0)
print 'uw T:',moms['cov'][0]+moms['cov'][2]
#print 'unweighted T:',ci['cov_uw'][0]+ci['cov_uw'][1]
print 'T:',gmix.get_T()
model=gm.get_model()
images.compare_images(psf,model)
def _measure_gals_gmix(self):
import gmix_image
from gmix_image.util import print_pars
from esutil.random import srandu
import esutil as eu
import images
import biggles
biggles.configure('screen','width',1100)
biggles.configure('screen','height',1100)
print '\n\n\n'
nbin=self.im_stacks.size
"""
psf_pars=numpy.array( [1.0,
self.psf_ares['wrow'],
self.psf_ares['wcol'],
self.psf_ares['Irr'],
self.psf_ares['Irc'],
self.psf_ares['Icc']] )
gmix_psf=gmix_image.gmix.GMixCoellip(psf_pars)
"""
psf_pixerr=sqrt(self.psf_skyvar)
psfim =eu.numpy_util.to_native( self.psf_stack )
psf_counts=psfim.sum()
psf_Tguess=self.psf_ares['Irr'] + self.psf_ares['Icc']
while True:
e1guess=0.0
e2guess=0.0
if False:
psf_prior=numpy.array( [psfim.shape[0]/2.*(1.+0.1*srandu()),
psfim.shape[1]/2.*(1.+0.1*srandu()),
e1guess+0.05*srandu(),
e2guess+0.05*srandu(),
psf_Tguess*0.6*(1.+0.1*srandu()),
psf_Tguess*0.4*(1.+0.1*srandu()),
psf_Tguess*0.2*(1.+0.1*srandu()),
psf_counts*0.3*(1.+0.1*srandu()),
psf_counts*0.4*(1.+0.1*srandu()),
psf_counts*0.3*(1.+0.1*srandu())])
elif True:
psf_prior=numpy.array( [psfim.shape[0]/2.*(1.+0.1*srandu()),
psfim.shape[1]/2.*(1.+0.1*srandu()),
e1guess+0.05*srandu(),
e2guess+0.05*srandu(),
psf_Tguess*(1.+0.1*srandu()),
psf_counts*(1.+0.1*srandu())] )
psf_width=numpy.abs(psf_prior)*1.e6
fitter=gmix_image.gmix_fit.GMixFitCoellip(psfim, psf_pixerr, psf_prior, psf_width,
verbose=False)
flags=fitter.get_flags()
if flags==0:
break
psf_pars=fitter.get_pars()
psf_perr=fitter.get_perr()
print_pars(psf_pars, front='psf pars: ')
print_pars(psf_perr, front='psf perr: ')
gmix_psf = fitter.get_gmix()
print gmix_psf
st=zeros(nbin, dtype=[('s2n','f8'),
('e1','f8'),
('e1err','f8'),
('e2','f8'),
('e2err','f8'),
('T','f8'),
('R','f8')])
for i in xrange(nbin):
print '-'*70
s2n_min=self.im_stacks['s2n_min'][i]
s2n_max=self.im_stacks['s2n_max'][i]
print 's2n: [%.2f,%.2f]' % (s2n_min,s2n_max)
im=eu.numpy_util.to_native( self.im_stacks['images'][i,:,:] )
pixerr=numpy.sqrt(self.im_stacks['skyvar'][i])
ivar=1./self.im_stacks['skyvar'][i]
counts=im.sum()
#im /= counts
#im += 0.0001*numpy.random.randn(im.size).reshape(im.shape)
#pixerr=0.0001
#pixerr /= counts
#counts=1.
#import images
#images.multiview(im)
#stop
#print 'counts: %s pixerr: %s' % (counts,pixerr)
#pixerr=sqrt(counts)
#e1guess=self._admom_shear['e1'][i]
#e2guess=self._admom_shear['e2'][i]
e1guess=0.0
e2guess=0.0
#e1guess=0.2
#e2guess=0.2
Tguess = self._admom_shear['T'][i]
row_guess=self._ares_dicts[i]['wrow']
col_guess=self._ares_dicts[i]['wcol']
while True:
if False:
prior=numpy.array( [row_guess,
col_guess,
e1guess+0.05*srandu(),
e2guess+0.05*srandu(),
Tguess*8.0*(1.+0.1*srandu()),
Tguess*2.42*(1.+0.1*srandu()),
Tguess*0.20*(1.+0.1*srandu()),
counts*0.28*(1.+0.1*srandu()),
counts*0.34*(1.+0.1*srandu()),
counts*0.38*(1.+0.1*srandu())])
#88.3129658 , 2.42779593, 0.20018009
#0.28709096, 0.34712239, 0.3875399
#[81.5104 81.4744 0.289612 -0.000497128 13967.1 235.063 19.2695 3.70149e+08 1.75106e+08 2.36254e+08 ]
elif True:
prior=numpy.array( [row_guess,
col_guess,
e1guess+0.05*srandu(),
e2guess+0.05*srandu(),
Tguess*0.5*(1.+0.1*srandu()),
Tguess*0.5*(1.+0.1*srandu()),
counts*0.5*(1.+0.1*srandu()),
counts*0.5*(1.+0.1*srandu())])
elif False:
prior=numpy.array( [row_guess,
col_guess,
e1guess+0.05*srandu(),
e2guess+0.05*srandu(),
Tguess*(1.+0.05*srandu()),
counts*(1.0+0.05*srandu())] )
width=numpy.abs(prior)*1.e6
#width[0] = 0.01
#width[1] = 0.01
#gmix0=gmix_image.GMix(prior, type='coellip')
#gmix0=gmix_image.GMixCoellip(prior)
#images.multiview(gmix_image.gmix2image(gmix0,im.shape))
#gmix=gmix0.convolve(gmix_psf)
#images.multiview(gmix_image.gmix2image(gmix,im.shape))
fitter=gmix_image.gmix_fit.GMixFitCoellip(im, pixerr, prior, width,
psf=gmix_psf, verbose=False)
flags=fitter.get_flags()
#fitter=gmix_image.gmix_fit.GMixFitSimple(im, 1./pixerr**2, gmix_psf, 'gexp',
# self._ares_dicts[i])
res=fitter.get_result()
flags=res['flags']
if flags==0:
break
else:
print flags
res=fitter.get_result()
print_pars(prior,front='prior: ')
print_pars(res['pars'], front='pars: ')
print_pars(res['perr'], front='perr: ')
#model=fitter.get_model()
#images.multiview(im/im.max(), nonlinear=1)
#images.compare_images(im/im.max(), model/model.max(),title=('%s %s' % (s2n_min,s2n_max)),
# nonlinear=1)
pars=res['pars']
perr=res['perr']
e1err2=( 0.32**2 + perr[2]**2)/self.im_stacks['nstack'][i]
e2err2=( 0.32**2 + perr[3]**2)/self.im_stacks['nstack'][i]
e1err=sqrt(e1err2)
e2err=sqrt(e2err2)
st['s2n'][i] = (s2n_min+s2n_max)/2.
st['e1'][i] = pars[2]
st['e1err'][i] = e1err
st['e2'][i] = pars[3]
st['e2err'][i] = e2err
#st['R'][i] = R
st['T'][i] = pars[4]
sh1=0.5*st['e1'][i]/self.Rshear
sh2=0.5*st['e2'][i]/self.Rshear
err=0.16/sqrt(self.im_stacks['nstack'][i])
mess='sh1: %s +/- %s sh2: %s +/- %s'
mess=mess % (sh1,err,sh2,err)
print mess
#stop
#print 'chi2per:',res['chi2per']
self._gmix_shear=st
def T_rat_from_fix_rhalf_rat(sigma_psf=1.414, rhalf_exp=4.0, show=False):
"""
Generate models with r_{1/2}^{dev} = 0.6 r_{1/2}^{exp} and
measure the T ratio
parameters
----------
rhalf: float, optional
Half light radius of the exponential component
dependencies
------------
galsim
"""
import galsim
import ngmix
from numpy.random import randn
from esutil.random import srandu
import pprint
flux=100.0
s2n=1.0e6
shape=(40,40)
size=shape[0]*shape[1]
pixel_scale=1.0
j=ngmix.jacobian.UnitJacobian(0.5*shape[0], 0.5*shape[1])
rhalf_dev = 0.6*rhalf_exp
pix = galsim.Pixel(pixel_scale)
psf0=galsim.Gaussian(flux=1.0, sigma=sigma_psf)
exp0=galsim.Exponential(flux=1.0, half_light_radius=rhalf_exp)
dev0=galsim.DeVaucouleurs(flux=1.0, half_light_radius=rhalf_dev)
gal0 = galsim.Add([exp0, dev0])
gal0.setFlux(flux)
gal = galsim.Convolve([gal0, psf0, pix])
psf = galsim.Convolve([psf0, pix])
galsim_image = galsim.ImageD(shape[0], shape[1])
galsim_psf_image = galsim.ImageD(shape[0], shape[1])
gal.draw(galsim_image, dx=pixel_scale)
psf.draw(galsim_psf_image, dx=pixel_scale)
image_nonoise=galsim_image.array
psf_image=galsim_psf_image.array
skysig2 = (image_nonoise**2).sum()/s2n**2
skysig = numpy.sqrt(skysig2)
image = image_nonoise + skysig*randn(size).reshape(shape)
if show:
import images
images.multiview(psf_image,title='psf')
images.multiview(image,title='image')
imsky,sky=ngmix.em.prep_image(psf_image)
em=ngmix.em.GMixEM(imsky, jacobian=j)
Tpsf_guess=2*sigma_psf**2
psf_guess=ngmix.gmix.GMixModel([0.0, 0.0, 0.0, 0.0, Tpsf_guess, 1.0],'gauss')
em.go(psf_guess, sky)
psf_gmix = em.get_gmix()
nwalkers=1000
guess=numpy.zeros( (nwalkers, 8) )
guess[:,0] = 0.1*srandu(nwalkers)
guess[:,1] = 0.1*srandu(nwalkers)
guess[:,2] = 0.1*srandu(nwalkers)
guess[:,3] = 0.1*srandu(nwalkers)
guess[:,4] = 40*(1.0 + 0.1*srandu(nwalkers))
guess[:,5] = 30*(1.0 + 0.1*srandu(nwalkers))
guess[:,6] = flux*(1.0 + 0.1*srandu(nwalkers))
guess[:,7] = flux*(1.0 + 0.1*srandu(nwalkers))
T_prior = ngmix.priors.FlatPrior(0.001, 200)
counts_prior = ngmix.priors.FlatPrior(0.001, 1000)
wt=0*image + 1.0/skysig2
fitter=ngmix.fitting.MCMCBDC(image, wt, j, 'bdc',
psf=psf_gmix,
full_guess=guess,
T_b_prior=T_prior,
T_d_prior=T_prior,
counts_b_prior=counts_prior,
counts_d_prior=counts_prior,
nwalkers=nwalkers,
burnin=800,
nstep=100,
mca_a=3.0,
min_arate=0.3)
fitter.go()
if show:
fitter.make_plots(show=show)
res=fitter.get_result()
pars=res['pars']
perr=res['pars_err']
Tb = pars[4]
Td = pars[5]
Tb_err = perr[4]
Td_err = perr[5]
Trat = Tb/Td
Trat_err = Trat*numpy.sqrt( (Tb_err/Tb)**2 + (Td_err/Td)**2 )
pprint.pprint(res)
print
print '%s +/- %s' % (Trat, Trat_err)
def fit_gprior_2gauss_cut(xdata, ydata, ivar):
"""
This works much better than the lm fitter
Input is the histogram data.
"""
import mcmc
import emcee
nwalkers=800
burnin=1000
nstep=100
A=ydata.sum()#*(xdata[1]-xdata[0])
A1 = 0.6*A
A2 = 0.4*A
sigma1 = 0.02
sigma2 = 0.3
pcen = numpy.array([A1,sigma1,A2,sigma2])
npars=pcen .size
guess=zeros( (nwalkers,npars) )
guess[:,0] = pcen[0]*(1.+0.2*srandu(nwalkers))
guess[:,1] = pcen[1]*(1.+0.2*srandu(nwalkers))
guess[:,2] = pcen[2]*(1.+0.2*srandu(nwalkers))
guess[:,3] = pcen[3]*(1.+0.2*srandu(nwalkers))
gfitter=GPrior2GaussCutFitter(xdata, ydata, ivar)
print 'pcen:',pcen
sampler = emcee.EnsembleSampler(nwalkers,
npars,
gfitter.get_lnprob,
a=2)
pos, prob, state = sampler.run_mcmc(guess, burnin)
sampler.reset()
pos, prob, state = sampler.run_mcmc(pos, nstep)
arate = sampler.acceptance_fraction.mean()
print 'arate:',arate
trials = sampler.flatchain
mcmc.plot_results(trials, ptypes=['log','linear','log','linear'])
pars,pcov=mcmc.extract_stats(trials)
d=diag(pcov)
perr = sqrt(d)
gprior=GPrior2GaussCut(pars)
res={'A1':pars[0],
'A1_err':perr[0],
'sigma1':pars[1],
'sigma1_err':perr[1],
'A2':pars[2],
'A2_err':perr[2],
'sigma2':pars[3],
'sigma2_err':perr[3],
'pars':pars,
'pcov':pcov,
'perr':perr}
fmt="""
A1: %(A1).6g +/- %(A1_err).6g
sigma1: %(sigma1).6g +/- %(sigma1_err).6g
A2: %(A2).6g +/- %(A2_err).6g
sigma2: %(sigma2).6g +/- %(sigma2_err).6g
""".strip()
print fmt % res
return gprior,res
def _run_fitter(self, ci, fitmodel):
from gmix_image.gmix_em import GMixEMBoot
psf_ivar=1./ci['skysig_psf']**2
gmpsf=GMixEMBoot(ci.psf, self['ngauss_psf'], ci['cen_psf'],
ivar=psf_ivar,
maxiter=self['em_maxiter'],
tol=self['em_tol'])
psf_gmix=gmpsf.get_gmix()
Tguess = ci['Ttrue']*(1. + 0.1*srandu())
ivar=1./ci['skysig']**2
cen_prior=self._get_cen_prior(ci)
counts_prior=self._get_counts_prior(ci)
T_prior=self._get_T_prior(ci)
if 'coellip' in fitmodel:
ngauss=self.get_coellip_ngauss(fitmodel)
self.fitter=MixMCCoellip(ci.image, ivar,
psf_gmix, self.gprior, ngauss,
cen=ci['cen'],
do_pqr=True,
nwalkers=self['nwalkers'],
nstep=self['nstep'],
burnin=self['burnin'],
mca_a=self['mca_a'],
iter=self.get('iter',False),
draw_gprior=self['draw_gprior'])
elif 'bd' in fitmodel:
raise ValueError("fix bd")
self.fitter=MixMCBD(ci.image, ivar,
psf_gmix, self.gprior,
cen=ci['cen'],
do_pqr=True,
nwalkers=self['nwalkers'],
nstep=self['nstep'],
burnin=self['burnin'],
mca_a=self['mca_a'],
iter=self.get('iter',False),
draw_gprior=self['draw_gprior'])
else:
sampler_type=self.get('sampler','mcmc')
T_guess=ci['Ttrue']*(1.+0.3*srandu())
counts_guess=ci['counts_true']*(1.0 + 0.3*srandu())
cen_guess=ci['cen']
if sampler_type=='mcmc':
keys={}
keys.update(self)
keys['do_pqr']=True
keys['make_plots']=self.get('make_plots',False)
keys['cen_prior']=cen_prior
keys['T_prior']=T_prior
keys['counts_prior']=counts_prior
keys['when_prior']=self['when_prior']
keys['nwalkers']=self['nwalkers']
keys['nstep']=self['nstep']
keys['burnin']=self['burnin']
keys['mca_a']=self['mca_a']
keys['iter']=self.get('iter',False),
keys['draw_gprior']=self['draw_gprior']
self.fitter=MixMCSimple(ci.image,
ivar,
psf_gmix,
self.gprior,
T_guess,
counts_guess,
cen_guess,
fitmodel,
**keys)
elif sampler_type=='cmcmc':
config={}
config.update(self)
config['model'] = fitmodel
config['cen1_mean']=ci['cen'][0]
config['cen1_width']=self.simc['cen_width']
config['cen2_mean']=ci['cen'][1]
config['cen2_width']=self.simc['cen_width']
config['g_width']=self.simc['g_width']
config['T_mean']=T_prior.get_mean()
config['T_width']=T_prior.get_sigma()
config['counts_mean']=counts_prior.get_mean()
config['counts_width']=counts_prior.get_sigma()
guess=self._get_cmcmc_simple_guess(ci,config)
self.fitter=gmix_image.gmix_mcmc.MixMCC(ci.image,
ivar,
psf_gmix,
guess,
config,
gprior=self.gprior)
elif sampler=='isample':
keys['nsample']=self['nsample']
g1_guess,g2_guess=self.gprior.sample2d(1)
guess=numpy.zeros(6)
guess[0:2] = cen_guess
guess[2] = g1_guess[0]
guess[3] = g2_guess[0]
guess[4] = T_guess
guess[5] = counts_guess
#prior_samples=self._presample_prior_simple(cen_prior,
# self.gprior,
# T_prior,
# counts_prior)
prior_samples=self._presample_gprior()
self.fitter=gmix_image.gmix_isamp.GMixIsampSimple(ci.image,
ivar,
psf_gmix,
cen_prior,
self.gprior,
T_prior,
counts_prior,
prior_samples,
guess,
fitmodel,
**keys)
