def photoobj_to_celestepy_src(photoobj_row): """Conversion between tractor source object and our source object....""" u = photoobj_row[['ra', 'dec']].values # brightnesses are stored in mags (gotta convert to nanomaggies) mags = photoobj_row[['psfMag_%s' % b for b in ['u', 'g', 'r', 'i', 'z']]].values fluxes = [mags2nanomaggies(m) for m in mags] # photoobj type 3 are gals, type 6 are stars if photoobj_row.type == 6: return SrcParams(u, a=0, fluxes=fluxes) else: # compute frac dev/exp prob_dev = np.mean(photoobj_row[['fracDeV_%s' % b for b in BANDS]]) # galaxy A/B estimate, angle, and radius devAB = np.mean(photoobj_row[['deVAB_%s' % b for b in BANDS]]) devRad = np.mean(photoobj_row[['deVRad_%s' % b for b in BANDS]]) devPhi = np.mean(photoobj_row[['deVPhi_%s' % b for b in BANDS]]) expAB = np.mean(photoobj_row[['expAB_%s' % b for b in BANDS]]) expRad = np.mean(photoobj_row[['expRad_%s' % b for b in BANDS]]) expPhi = np.mean(photoobj_row[['expPhi_%s' % b for b in BANDS]]) #estimate - mix over frac dev/exp AB = prob_dev * devAB + (1. - prob_dev) * expAB Rad = prob_dev * devRad + (1. - prob_dev) * expRad Phi = prob_dev * devPhi + (1. - prob_dev) * expPhi ## galaxy flux esimates devFlux = np.array([ mags2nanomaggies(m) for m in photoobj_row[['deVMag_%s' % b for b in BANDS]] ]) expFlux = np.array([ mags2nanomaggies(m) for m in photoobj_row[['expMag_%s' % b for b in BANDS]] ]) fluxes = prob_dev * devFlux + (1. - prob_dev) * expFlux #theta : exponential mixture weight. (1 - theta = devac mixture weight) #sigma : radius of galaxy object (in arcsc > 0) #rho : axis ratio, dimensionless, in [0,1] #phi : radians, "E of N" 0=direction of increasing Dec, 90=direction of increasting RAab return SrcParams( u, a=1, v=u, theta=1.0 - prob_dev, phi=-1. * Phi, #(Phi * np.pi / 180.), # + np.pi / 2) % np.pi, sigma=Rad, rho=AB, fluxes=fluxes)
def propose_from_gal_prior(star, fluxes_prior, shape_prior, test=False): re_prior, ab_prior, phi_prior = shape_prior fluxes = fluxes_prior.sample()[0] # do reverse transformation re = re_prior.sample()[0,0] ab = ab_prior.sample()[0,0] phi = phi_prior.sample()[0,0] # propose star-like shape parameters if test: phi = 0.01 rho = 0.01 sigma = 0.01 else: sigma = np.exp(re) rho = np.exp(ab) / (1 + np.exp(ab)) phi = np.pi * np.exp(phi) / (1 + np.exp(phi)) return SrcParams(star.params.u, a = 1, v = star.params.u, theta = 0.5, phi = phi, sigma = sigma, rho = rho, fluxes = np.exp(fluxes))
def prior_sample(self, src_type, u=None): params = SrcParams(u=u) if src_type == 'star': # TODO SET a with atoken params.a = 0 color = self.star_flux_prior.rvs(size=1)[0] logprob = self.star_flux_prior.logpdf(color) params.fluxes = np.exp(self.star_flux_prior.to_fluxes(color)) return params, logprob elif src_type == 'galaxy': params.a = 1 color = self.galaxy_flux_prior.rvs(size=1)[0] logprob = self.galaxy_flux_prior.logpdf(color) params.fluxes = np.exp(self.galaxy_flux_prior.to_fluxes(color)) sample_ab = self.galaxy_ab_prior.rvs(size=1)[0,0] sample_ab = np.exp(sample_ab) / (1.+np.exp(sample_ab)) params.shape = np.array([np.random.random(), np.exp(self.galaxy_re_prior.rvs(size=1)[0,0]), np.random.random() * np.pi, sample_ab]) logprob_re = self.galaxy_re_prior.logpdf(params.sigma) logprob_ab = self.galaxy_ab_prior.logpdf(params.rho) logprob_shape = -np.log(np.pi) + logprob_re + logprob_ab return params, logprob
def tractor_src_to_celestepy_src(tsrc): """Conversion between tractor source object and our source object....""" pos = tsrc.getPosition() u = np.array([p for p in pos]) # brightnesses are stored in mags (gotta convert to nanomaggies) def mags2nanomaggies(mags): return np.power(10., (mags - 22.5) / -2.5) fluxes = tsrc.getBrightnesses()[0] fluxes = [mags2nanomaggies(flux) for flux in fluxes] if type(tsrc) == PointSource: return SrcParams(u, a=0, fluxes=fluxes) else: if type(tsrc) == ExpGalaxy: shape = tsrc.getShape() theta = 1. elif type(tsrc) == DevGalaxy: shape = tsrc.getShape() theta = 0. elif type(tsrc) == CompositeGalaxy: shape = tsrc.shapeExp theta = 0.5 else: pass return SrcParams( u, a=1, v=u, theta=theta, phi=shape[ 2], #-1*(shape[2]-90), # * np.pi / 180., #(shape[2] + 180) * np.pi / 180, sigma=shape[0], rho=shape[1], fluxes=fluxes)
def linear_propose_other_type(self): """ based on linear regression of fluxes and conditional distribution of galaxy shapes, propose parameters of the other type and report the log probability of generating that proposal Returns: - proposal params - log prob of proposal - log prob of implied reverse proposal - log determinant of the transformation |d(x',u')/d(x,u)| """ params = SrcParams(u=self.params.u) if self.is_star(): params.a = 1 # fluxes residual = mvn.rvs(cov=star_mag_proposal.res_covariance) ll_prop_fluxes = mvn.logpdf(residual, mean=None, cov=star_mag_proposal.res_covariance) gal_mag = star_mag_proposal.predict(self.params.mags.reshape((1,-1))) + residual params.fluxes = du.mags2nanomaggies(gal_mag).flatten() # compute reverse ll res = gal_mag_proposal.predict(gal_mag) - self.params.mags llrev = mvn.logpdf(res, mean=None, cov=gal_mag_proposal.res_covariance) # shape sample_re = star_rad_proposal.rvs(size=1)[0] ll_shape = star_rad_proposal.logpdf(sample_re) params.shape = np.array([np.random.rand(), np.exp(sample_re), np.random.rand() * np.pi, np.random.rand()]) _, logdet = np.linalg.slogdet(star_mag_proposal.coef_) return params, ll_prop_fluxes + ll_shape, llrev, logdet elif self.is_galaxy(): params.a = 0 # fluxes residual = mvn.rvs(cov=gal_mag_proposal.res_covariance) llprob = mvn.logpdf(residual, mean=None, cov=gal_mag_proposal.res_covariance) star_mag = gal_mag_proposal.predict(self.params.mags.reshape((1, -1))) + residual params.fluxes = du.mags2nanomaggies(star_mag).flatten() res = star_mag_proposal.predict(star_mag) - self.params.mags llrev = mvn.logpdf(res, mean=None, cov=star_mag_proposal.res_covariance) ll_re = star_rad_proposal.logpdf(np.log(self.params.sigma)) _, logdet = np.linalg.slogdet(gal_mag_proposal.coef_) return params, llprob, llrev + ll_re, logdet
def propose_from_star_prior(gal, prior, test=False): fluxes = prior.sample()[0] return SrcParams(gal.params.u, a = 0, fluxes = np.exp(fluxes))
def star_arg_squared_loss(fluxes, galaxy_src, images): star = SrcParams(src.u, a=0, fluxes=np.exp(fluxes)) return squared_loss(galaxy_src, star, images)
# medium 1 def star_arg_squared_loss_single_im(fluxes, galaxy_src, image): star = SrcParams(src.u, a=0, fluxes=np.exp(fluxes)) return squared_loss_single_im(galaxy_src, star, image) def star_arg_squared_loss(fluxes, galaxy_src, images): star = SrcParams(src.u, a=0, fluxes=np.exp(fluxes)) return squared_loss(galaxy_src, star, images) # do gradient descent for src in [srcs[10]]: if src.a == 0: continue star = SrcParams(src.u, a=0, fluxes=src.fluxes) print "loss, galaxy with itself:", squared_loss(src, src, imgs) print "loss, galaxy with star:", squared_loss(src, star, imgs) final_fluxes = np.zeros(len(BANDS)) for bi,b in enumerate(BANDS): res = minimize(star_arg_squared_loss_single_im, np.log(src.fluxes), args=(src, imgs[bi]), method='Nelder-Mead', options={'maxiter':10}) print "original result:", squared_loss_single_im(src, star, imgs[bi]) print "opt result for band", bi, ":", res final_fluxes[bi] = np.exp(res.x[bi])