def sampler_emcee(D): # nlinks: number of iterations for each walker # please specify as even D['nlinks'] = 100 # nwalkers: number of interacting chains D['nwalkers'] = 200 # ntemps: D['ntemps'] = 5 # ntune: number of initialization steps to discard D['ntune'] = 500 st = time.time() # identify starting positions for chains tmp = start_pos(D['ntemps'] * D['nwalkers'], D) pos0 = tmp.reshape((D['ntemps'], D['nwalkers'], D['dim'])) likelihood = D['likelihood'] # run MCMC for the model of interest sampler = PTSampler(ntemps=D['ntemps'], nwalkers=D['nwalkers'], dim=len(D['pname']), logl=likelihood, logp=prior, loglargs=(D, ), logpargs=(D, )) for pos, lnprob, lnlike in sampler.sample(pos0, iterations=D['ntune']): pass burntrace = sampler.chain sampler.reset() print(burntrace.shape) print("burnin completed") for pos, lnprob, lnlike in sampler.sample(pos, iterations=D['nlinks']): pass finaltrace = sampler.chain print(finaltrace.shape) D['rawtrace'] = np.concatenate((burntrace[0, ...], finaltrace[0, ...]), axis=1) D['sampling_time'] = np.round(time.time() - st, 2) st = time.time() D['lnZ'], D['dlnZ'] = sampler.thermodynamic_integration_log_evidence() elaps = np.round(time.time() - st, 2) msg = "model evidence evaluation: " + str(elaps) + " seconds" WP(msg, D['wrt_file']) return D
# Load in samples from previous mcmc chain, and run any models # that weren't generated. p = np.load(maindir + 'p_frommcmc.npy') ################################################################## ##################### Continue After Burn-in ##################### ################################################################## chainfn = maindir + "chain.dat" tempsfn = maindir + "temps.dat" f = open(chainfn, "w") f.close() g = open(tempsfn, "w") g.close() for p, lnprob, lnlike in sampler.sample(p, iterations=niter, storechain=True): position = p[0] position_temp = p[1] f = open(chainfn, "a") g = open(tempsfn, "a") for k in range(position.shape[0]): f.write("{0:4d} {1:s}\n".format(k, " ".join(str(position[k])))) g.write("{0:4d} {1:s}\n".format(k, " ".join(str(position_temp[k])))) f.close() g.close() position = p np.save('p_mcmc', position) print "MCMC Complete" samples = sampler.chain
w0 = np.random.uniform(73.0,80.0,size=(ntemps,nwalkers)) w1 = np.random.uniform(10,20,size=(ntemps,nwalkers)) w2 = np.random.uniform(0.0001,0.001,size=(ntemps,nwalkers)) w3 = np.random.uniform(100.0,3000.0,size=(ntemps,nwalkers)) w4 = np.random.uniform(-2.0,0.0,size=(ntemps,nwalkers)) w5 = np.random.uniform(1.2,1.4,size=(ntemps,nwalkers)) w6 = np.random.uniform(0.4,0.6,size=(ntemps,nwalkers)) p0 = np.dstack((w0,w1,w2,w3,w4,w5,w6)) niter = 400 nburn = np.int(0.2*niter) for p, lnprob, lnlike in sampler.sample(p0, iterations=nburn): pass sampler.reset() print 'Burn in complete' """ #Parallelize after this step. Look into whether it's better to #vary number of walkers or number of steps across different machines. """ for p, lnprob, lnlike in sampler.sample(p, lnprob0=lnprob, lnlike0=lnlike,
class EMPIRE: def __init__(self, stardat, setup): assert len(stardat) >= 1, 'stardat has to contain at least 1 file ! !' assert len(setup) == 3, 'setup has to be [ntemps, nwalkers, nsteps]' # Setup self.cores = multiprocessing.cpu_count() self.setup = setup self.ntemps, self.nwalkers, self.nsteps = setup self.betas = None self.MOAV = 1 self.burn_out = self.nsteps // 2 self.PM = False # Reading data if len(stardat.shape) > 1: # RV self.rvfiles = stardat[0] rvdat = emplib.read_data(self.rvfiles) self.time, self.rv, self.err, self.ins = rvdat[0] # time, radial velocities, error and instrument flag self.all_data = rvdat[0] self.staract, self.starflag = rvdat[1], rvdat[2] # time, star activity index and flag self.totcornum = rvdat[3] # quantity if star activity indices self.nins = len(self.rvfiles) # number of instruments autodefined self.ndat = len(self.time) # number of datapoints # PM self.pmfiles = stardat[1] pmdat = emplib.read_data(self.pmfiles) self.time_pm, self.rv_pm, self.err_pm, self.ins_pm = pmdat[0] # just the fname its pm rly self.all_data_pm = pmdat[0] self.staract_pm, self.starflag_pm = pmdat[1], pmdat[2] # time, star activity index and flag self.totcornum_pm = pmdat[3] # ? self.nins_pm = len(self.pmfiles) self.ndat_pm = len(self.time_pm) self.MOAV_pm = 1 # for flat model self.fsig = 1 self.f2k = sp.array([0, 0]) self.PM = True self.params_pm = sp.array([1, 2, 3, 4]) self.lenppm = len(self.params_pm) self.PACC_pm = False else: # RV self.rvfiles = stardat rvdat = emplib.read_data(stardat) self.time, self.rv, self.err, self.ins = rvdat[0] # time, radial velocities, error and instrument flag self.all_data = rvdat[0] self.staract, self.starflag = rvdat[1], rvdat[2] # time, star activity index and flag self.totcornum = rvdat[3] # quantity if star activity indices self.nins = len(self.rvfiles) # number of instruments autodefined self.ndat = len(self.time) # number of datapoints # PM self.time_pm, self.rv_pm, self.err_pm, self.ins_pm = 0., 0., 0., 0. self.totcornum_pm = 0. # Statistical Tools self.bayes_factor = sp.log(150) # inside chain comparison (smaller = stricter) self.model_comparison = 5 self.BIC = 5 self.AIC = 5 # Menudencies self.thin = 1 self.PLOT = True self.draw_every_n = 1 self.PNG = True self.PDF = False self.CORNER = True self.HISTOGRAMS = True self.starname = self.rvfiles[0].split('_')[0] self.MUSIC = False self.breakFLAG = False self.STARMASS = False self.HILL = False self.CHECK = False self.RAW = False ''' self.CORNER_MASK = True self.CORNER_K = True self.CORNER_I = ''' # About the search parameters self.PACC = False # parabolic Acceleration self.CONSTRAIN = True self.eccprior = 0.3 self.jittprior = 5.0 self.jittmean = 5.0 self.sampler = 0.0 ######################################## # los IC sirven para los mod_lims? NO! # mod_lims sólo acotan el espacio donde buscar, excepto para periodo pass def mklogfile(self, *args): if args: theta_max, best_post, sample_sizes = args[0], args[1], args[2] sigmas, kplanets, modlims = args[3], args[4], args[5] BIC, AIC, alt_res = args[6], args[7], args[8] START, residuals = args[9], args[10] dayis = dt.date.today() # This is for the folder name def ensure_dir(date='datalogs/'+self.starname+'/'+str(dayis.month)+'.'+str(dayis.day)+'.'+str(dayis.year)[2:]): if not os.path.exists(date): os.makedirs(date) return date else: if len(date.split('_')) == 2: aux = int(date.split('_')[1]) + 1 date = date.split('_')[0]+'_'+str(aux) else: date = date + '_1' return ensure_dir(date) def timer(): timing = chrono.time() - START #insec = sp.array([604800, 86400, 3600, 60]) weeks, rest0 = timing // 604800, timing % 604800 days, rest1 = rest0 // 86400, rest0 % 86400 hours, rest2 = rest1 // 3600, rest1 % 3600 minutes, seconds = rest2 // 60, rest2 % 60 if weeks == 0: if days == 0: if hours == 0: if minutes == 0: return '%i seconds' % seconds else: return '%i minutes and %i seconds' % (minutes, seconds) else: return '%i hours, %i minutes and %i seconds' % (hours, minutes, seconds) else: return '%i days, %i hours, %i minutes and %i seconds' % (days, hours, minutes, seconds) else: return '%i weeks, %i days, %i hours, %i minutes and %i seconds' % (weeks, days, hours, minutes, seconds) def mklogdat(theta, best_post): G = 39.5 days_in_year = 365.242199 sigmas_hen = sigmas logdat = '\nStar Name : '+self.starname for i in range(self.nins): if i==0: logdat += '\nUsed datasets : '+self.rvfiles[i] else: logdat += '\n : '+self.rvfiles[i] logdat += '\n--------------------------------------------------------------------' logdat += '\nThe sample sizes are : ' + str(sample_sizes) logdat += '\nThe maximum posterior is : ' + str(best_post) logdat += '\nThe BIC is : ' + str(BIC) logdat += '\nThe AIC is : ' + str(AIC) logdat += '\nThe RMS is : ' + str(sp.sum(residuals**2)) logdat += '\nThe most probable chain values are as follows...' for i in range(kplanets): #MP = sp.sqrt(1 - theta[i*5+4] ** 2) * theta[i*5] * theta[i*5+1] ** (1/3.) * STARMASS ** (2/3.) / 203. #SMA = (((theta[i*5+1]/365.242199) ** 2) * G * STARMASS0 / (4 * sp.pi ** 2)) ** (1/3.) if self.STARMASS: SMA = (((theta[i*5]*24.*3600.)**2.0) / ( (4.0*sp.pi**2.0) / (6.67e-11 * self.STARMASS * 1.99e30) ))**(1./3) / 1.49598e11 MP = theta[i*5+1] / ( (28.4/sp.sqrt(1. - theta[i*5+4]**2.)) * (self.STARMASS**(-0.5)) * (SMA**(-0.5)) ) * 317.8 logdat += '\n--------------------------------------------------------------------' logdat += '\nPeriod '+str(i+1)+'[days] : ' + str(theta[i*5]) + ' +- ' + str(sigmas_hen[i*5]) logdat += '\nAmplitude '+str(i+1)+'[m/s]: ' + str(theta[i*5+1]) + ' +- ' + str(sigmas_hen[i*5+1]) logdat += '\nPhase '+str(i+1)+' : ' + str(theta[i*5+2]) + ' +- ' + str(sigmas_hen[i*5+2]) logdat += '\nLongitude '+str(i+1)+' : ' + str(theta[i*5+3]) + ' +- ' + str(sigmas_hen[i*5+3]) logdat += '\nEccentricity '+str(i+1)+' : ' + str(theta[i*5+4]) + ' +- ' + str(sigmas_hen[i*5+4]) if self.STARMASS: logdat += '\nMinimum Mass '+str(i+1)+' : ' + str(MP) logdat += '\nSemiMajor Axis '+str(i+1)+' : ' + str(SMA) logdat += '\n--------------------------------------------------------------------' logdat += '\nAcceleration [m/s/(year)]:'+str(theta[5*kplanets]/(days_in_year*24*60*60)) + ' +- ' + str(sigmas_hen[5*kplanets]/(days_in_year*24*60*60)) if self.PACC: logdat += '\nQuadratic Acceleration [m/s/(year)]:'+str(theta[5*kplanets + self.PACC]/(days_in_year*24*60*60)) + ' +- ' + str(sigmas_hen[5*kplanets + self.PACC]/(days_in_year*24*60*60)) for i in range(self.nins): logdat += '\n--------------------------------------------------------------------' logdat += '\nJitter '+str(i+1)+' [m/s]: ' + str(theta[5*kplanets + i*2*(self.MOAV+1) + self.PACC + 1]) + ' +- ' + str(sigmas_hen[5*kplanets + i*2*(self.MOAV+1) + self.PACC + 1]) logdat += '\nOffset '+str(i+1)+' [m/s]: ' + str(theta[5*kplanets + i*2*(self.MOAV+1) + self.PACC + 2]) + ' +- ' + str(sigmas_hen[5*kplanets + i*2*(self.MOAV+1) + self.PACC + 2]) for j in range(self.MOAV): logdat += '\nMA coef '+str(i+1)+'_'+str(j+1)+' : ' + str(theta[5*kplanets + i*2*(self.MOAV+1) + 2*(j+1) + 1 + self.PACC]) + ' +- ' + str(sigmas_hen[5*kplanets + i*2*(self.MOAV+1) + 2*(j+1) + 1 + self.PACC]) logdat += '\nTimescale '+str(i+1)+'_'+str(j+1)+'[days]: ' + str(theta[5*kplanets + i*2*(self.MOAV+1) + 2*(j+1) + 2 + self.PACC]) + ' +- ' + str(sigmas_hen[5*kplanets + i*2*(self.MOAV+1) + 2*(j+1) + 2 + self.PACC]) for h in range(self.totcornum): logdat += '\n--------------------------------------------------------------------' logdat += '\nStellar Activity'+str(h+1)+': ' + str(theta[5*kplanets + self.nins*2*(self.MOAV+1) + self.PACC + 1 + h]) + ' +- ' + str(sigmas_hen[5*kplanets + self.nins*2*(self.MOAV+1) + self.PACC + 1 + h]) if self.PM: if kplanets > 0: for i in range(self.fsig): ndim_rv = 5*kplanets + self.nins*2*(self.MOAV+1) + self.PACC + 1 + self.totcornum logdat += '\n--------------------------------------------------------------------' for ii in range(self.lenppm): # BATMAN PARAMS logdat += '\nParam_pm'+str(i+1)+str(ii+1)+'[m/s]: ' + str(theta[ndim_rv + i*self.lenppm + ii]) + ' +- ' + str(sigmas_hen[ndim_rv + i*self.lenppm + ii]) logdat += '\n--------------------------------------------------------------------' fdim = ndim_rv + self.lenppm*self.fsig ''' else: logdat += '\nAcceleration [m/s/(year)]:'+str(theta[ndim_rv]/(days_in_year*24*60*60)) + ' +- ' + str(sigmas_hen[ndim_rv]/(days_in_year*24*60*60)) for i in range(self.nins_pm): logdat += '\n--------------------------------------------------------------------' logdat += '\nJitter_pm '+str(i+1)+' [m/s]: ' + str(theta[ndim_rv + i*2*(self.MOAV_pm+1) + self.PACC_pm + 1]) + ' +- ' + str(sigmas_hen[ndim_rv + i*2*(self.MOAV_pm+1) + self.PACC_pm + 1]) logdat += '\nOffset_pm '+str(i+1)+' [m/s]: ' + str(theta[ndim_rv + i*2*(self.MOAV_pm+1) + self.PACC_pm + 2]) + ' +- ' + str(sigmas_hen[ndim_rv + i*2*(self.MOAV_pm+1) + self.PACC_pm + 2]) for j in range(self.MOAV_pm): logdat += '\nMA coef '+str(i+1)+'_'+str(j+1)+' : ' + str(theta[ndim_rv + i*2*(self.MOAV_pm+1) + 2*(j+1) + 1 + self.PACC_pm]) + ' +- ' + str(sigmas_hen[ndim_rv + i*2*(self.MOAV_pm+1) + 2*(j+1) + 1 + self.PACC_pm]) logdat += '\nTimescale '+str(i+1)+'_'+str(j+1)+'[days]: ' + str(theta[ndim_rv + i*2*(self.MOAV_pm+1) + 2*(j+1) + 2 + self.PACC_pm]) + ' +- ' + str(sigmas_hen[ndim_rv + i*2*(self.MOAV_pm+1) + 2*(j+1) + 2 + self.PACC_pm]) ''' logdat += '\n------------------------------ RV DATA ------------------------------' logdat += '\nTemperatures, Walkers, Steps : '+str((self.ntemps, self.nwalkers, self.nsteps)) logdat += '\nN Instruments, K planets, N data : '+str((self.nins, kplanets, self.ndat)) logdat += '\nNumber of Dimensions : '+str(5 * kplanets + self.nins*2*(self.MOAV+1) + self.totcornum + self.PACC + 1) logdat += '\nN Moving Average : '+str(self.MOAV) logdat += '\nBeta Detail : '+str(self.betas) logdat += '\n--------------------------------------------------------------------' if self.PM: logdat += '\n------------------------------ PM DATA ------------------------------' logdat += '\nN Instruments, N signals, N data : '+str((self.nins_pm, self.fsig, self.ndat_pm)) if kplanets > 0: ndim_rv = 5*kplanets + self.nins*2*(self.MOAV+1) + self.PACC + 1 + self.totcornum logdat += '\nNumber of Dimensions : '+str(ndim_rv + self.fsig*self.lenppm) else: pass #logdat += '\nN Moving Average : '+str(self.MOAV_pm) #logdat += '\nBeta Detail : '+str(self.betas) logdat += '\n--------------------------------------------------------------------' logdat += '\nRunning Time : '+timer() print(logdat) logdat += '\n -------------------------- ADVANCED --------------------------' logdat += '\n raw fit' logdat += '\n'+str(theta) logdat += '\n raw boundaries' logdat += '\n '+ str(modlims) logdat += '\n alt_res' logdat += '\n '+ str(alt_res) return logdat name = str(ensure_dir()) logdat = mklogdat(theta_max, best_post) sp.savetxt(name+'/log.dat', sp.array([logdat]), fmt='%100s') sp.savetxt(name+'/residuals.dat', sp.c_[self.time, residuals]) return name def instigator(self, chain, post, saveplace, kplanets): ''' Automatically saves chains and posteriors. ''' def mk_header(kplanets): h = [] kepler = ['Period ', 'Amplitude ', 'Phase ', 'Longitude ', 'Eccentricity ', 'Minimum Mass ', 'SemiMajor Axis '] telesc = ['Jitter ', 'Offset '] mov_ave = ['MA Coef ', 'Timescale '] photo = ['param'] for i in range(kplanets): for item in kepler: h.append(item) if self.PACC: h.append('Linear Acceleration ') h.append('Quadratic Acceleration ') else: h.append('Acceleration ') for j in range(self.nins): for item in telesc: h.append(item) for c in range(self.MOAV): h.append(mov_ave[0]+str(c)+' ') h.append(mov_ave[1]+str(c)+' ') for jj in range(self.totcornum): h.append('Stellar Activity'+str(jj)) if self.PM: for k in range(self.nins_pm): for kk in range(self.lenppm): h.append('Photometry Parameter '+str(k)+'_'+str(kk)) h = ' '.join(h) return h def savechain(chain): for i in range(self.ntemps): sp.savetxt(saveplace + '/chain_'+str(i)+'.dat', chain[i], header=mk_header(kplanets)) pass def savepost(post): for i in range(self.ntemps): sp.savetxt(saveplace + '/posterior_'+str(i)+'.dat', post[i], header=mk_header(kplanets)) pass savechain(chain) savepost(post) pass def alt_results(self, samples, kplanets): titles = sp.array(["Period","Amplitude","Longitude", "Phase","Eccentricity", 'Acceleration', 'Jitter', 'Offset', 'MACoefficient', 'MATimescale', 'Stellar Activity']) namen = sp.array([]) ndim = kplanets * 5 + self.nins*2*(self.MOAV+1) + self.totcornum + 1 + self.PACC RESU = sp.zeros((ndim, 5)) for k in range(kplanets): namen = sp.append(namen, [titles[i] + '_'+str(k) for i in range(5)]) namen = sp.append(namen, titles[5]) # for acc if self.PACC: namen = sp.append(namen, 'Parabolic Acceleration') for i in range(self.nins): namen = sp.append(namen, [titles[ii] + '_'+str(i+1) for ii in sp.arange(2)+6]) for c in range(self.MOAV): namen = sp.append(namen, [titles[ii] + '_'+str(i+1) + '_'+str(c+1) for ii in sp.arange(2)+8]) for h in range(self.totcornum): namen = sp.append(namen, titles[-1]+'_'+str(h+1)) if self.PM: for g in range(self.nins_pm): for gg in range(self.lenppm): namen = sp.append(namen, 'Photometry param'+str(g)+'_'+str(gg+1)) alt_res = list(map(lambda v: (v[2], v[3]-v[2], v[2]-v[1], v[4]-v[2], v[2]-v[0]), zip(*np.percentile(samples, [2, 16, 50, 84, 98], axis=0)))) logdat = '\nAlternative results with uncertainties based on the 2nd, 16th, 50th, 84th and 98th percentiles of the samples in the marginalized distributions' logdat = '\nFormat is like median +- 1-sigma, +- 2-sigma' for res in range(ndim): logdat += '\n'+namen[res]+' : '+str(alt_res[res][0])+' +- '+str(alt_res[res][1:3]) +' 2% +- '+str(alt_res[res][3:5]) RESU[res] = sp.percentile(samples, [2, 16, 50, 84, 98], axis=0)[:, res] print(logdat) return RESU def MCMC(self, *args): if args: #kplan, mod_lims, ins_lims, acc_lims, sigmas_raw, pos0, logl, logp kplanets, boundaries, inslims = args[0], args[1], args[2] acc_lims, sigmas_raw, pos0 = args[3], args[4], args[5] logl, logp = args[6], args[7] ndim = 1 + 5 * kplanets + self.nins*2*(self.MOAV+1) + self.totcornum + self.PACC print(str(self.PM)), 'self.pm!!' # PMPMPM if kplanets > 0: if self.PM: pm_lims = args[8] ndim += self.lenppm*self.fsig print('checkpoint 1') # PMPMPM ndat = len(self.time) def starinfo(): colors = ['red', 'green', 'blue', 'yellow', 'grey', 'magenta', 'cyan', 'white'] c = sp.random.randint(0,7) print(colored('\n ###############################################', colors[c])) print(colored(' # #', colors[c])) print(colored(' # #', colors[c])) print(colored(' # E M P E R 0 R #', colors[c])) print(colored(' # #', colors[c])) print(colored(' # #', colors[c])) print(colored(' ###############################################', colors[c])) print(colored('Exoplanet Mcmc Parallel tEmpering Radial vel0city fitteR', colors[sp.random.randint(0,7)])) logdat = '\n\nStar Name : '+self.starname logdat += '\nTemperatures, Walkers, Steps : '+str((self.ntemps, self.nwalkers, self.nsteps)) logdat += '\nN Instruments, K planets, N data : '+str((self.nins, kplanets, self.ndat)) if self.PM: logdat += '\nN of data for Photometry : '+str(self.ndat_pm) logdat += '\nN Number of Dimensions : '+str(ndim) logdat += '\nN Moving Average : '+str(self.MOAV) logdat += '\nBeta Detail : '+str(self.betas) logdat += '\n-----------------------------------------------------' print(logdat) pass starinfo() #''' #from emperors_library import logp_rv print(str(self.PM), ndim, 'self.pm y ndim') # PMPMPM if self.PM: if kplanets > 0: logp_params = sp.array([sp.array([self.time, kplanets, self.nins, self.MOAV, self.totcornum, boundaries, inslims, acc_lims, sigmas_raw, self.eccprior, self.jittprior, self.jittmean, self.STARMASS, self.HILL, self.PACC, self.CHECK]), sp.array([self.time_pm, self.fsig, self.lenppm, self.nins_pm, self.MOAV_pm, self.totcornum_pm, boundaries, sigmas_raw, self.PACC_pm])]) logl_params = sp.array([sp.array([self.time, self.rv, self.err, self.ins, self.staract, self.starflag, kplanets, self.nins, self.MOAV, self.totcornum, self.PACC]), sp.array([self.time_pm, self.rv_pm, self.err_pm, self.ins_pm, self.staract_pm, self.starflag_pm, self.fsig, self.f2k, self.nins_pm, self.MOAV_pm, self.totcornum_pm, self.PACC_pm, kplanets])]) self.sampler = PTSampler(self.ntemps, self.nwalkers, ndim, logl, logp, loglargs=[empmir.logl_rvpm, logl_params], logpargs=[empmir.logp_rvpm, logp_params], threads=self.cores, betas=self.betas) #raise ImportError('xd dale al debug mejor') else: logp_params = sp.array([self.time, kplanets, self.nins, self.MOAV, self.totcornum, boundaries, inslims, acc_lims, sigmas_raw, self.eccprior, self.jittprior, self.jittmean, self.STARMASS, self.HILL, self.PACC, self.CHECK]) logl_params = sp.array([self.time, self.rv, self.err, self.ins, self.staract, self.starflag, kplanets, self.nins, self.MOAV, self.totcornum, self.PACC]) self.sampler = PTSampler(self.ntemps, self.nwalkers, ndim, logl, logp, loglargs=[empmir.logl_rv, logl_params], logpargs=[empmir.logp_rv, logp_params], threads=self.cores, betas=self.betas) # raise ImportError else: logp_params = sp.array([self.time, kplanets, self.nins, self.MOAV, self.totcornum, boundaries, inslims, acc_lims, sigmas_raw, self.eccprior, self.jittprior, self.jittmean, self.STARMASS, self.HILL, self.PACC, self.CHECK]) logl_params = sp.array([self.time, self.rv, self.err, self.ins, self.staract, self.starflag, kplanets, self.nins, self.MOAV, self.totcornum, self.PACC]) self.sampler = PTSampler(self.ntemps, self.nwalkers, ndim, logl, logp, loglargs=[empmir.logl_rv, logl_params], logpargs=[empmir.logp_rv, logp_params], threads=self.cores, betas=self.betas) # RVPM THINGY s0 = chrono.time() for _ in range(10000): empmir.logp_rv(pos0[0][0], logp_params) print('________', chrono.time()-s0) print('\n --------------------- BURN IN --------------------- \n') pbar = tqdm(total=self.burn_out) for p, lnprob, lnlike in self.sampler.sample(pos0, iterations=self.burn_out): pbar.update(1) pass pbar.close() p0, lnprob0, lnlike0 = p, lnprob, lnlike print("\nMean acceptance fraction: {0:.3f}".format(sp.mean(self.sampler.acceptance_fraction))) assert sp.mean(self.sampler.acceptance_fraction) != 0, 'Mean acceptance fraction = 0 ! ! !' self.sampler.reset() print('\n ---------------------- CHAIN ---------------------- \n') pbar = tqdm(total=self.nsteps) for p, lnprob, lnlike in self.sampler.sample(p0, lnprob0=lnprob0, lnlike0=lnlike0, iterations=self.nsteps, thin=self.thin): pbar.update(1) pass pbar.close() #''' assert self.sampler.chain.shape == (self.ntemps, self.nwalkers, self.nsteps/self.thin, ndim), 'something really weird happened' print("\nMean acceptance fraction: {0:.3f}".format(sp.mean(self.sampler.acceptance_fraction))) ln_post = self.sampler.lnprobability posteriors = sp.array([ln_post[i].reshape(-1) for i in range(self.ntemps)]) chains = self.sampler.flatchain best_post = posteriors[0] == np.max(posteriors[0]) #raise ImportError thetas_raw = sp.array([chains[i] for i in range(self.ntemps)]) thetas_hen = sp.array([empmir.henshin(chains[i], kplanets) for i in sp.arange(self.ntemps)]) ajuste_hen = thetas_hen[0][best_post][0] ajuste_raw = thetas_raw[0][best_post][0] interesting_loc = sp.array([max(posteriors[temp]) - posteriors[temp] < self.bayes_factor for temp in sp.arange(self.ntemps)]) interesting_thetas = sp.array([thetas_hen[temp][interesting_loc[temp]] for temp in sp.arange(self.ntemps)]) thetas_hen = sp.array([thetas_hen[temp] for temp in sp.arange(self.ntemps)]) interesting_thetas_raw = sp.array([thetas_raw[temp][interesting_loc[temp]] for temp in sp.arange(self.ntemps)]) interesting_posts = sp.array([posteriors[temp][interesting_loc[temp]] for temp in range(self.ntemps)]) sigmas = sp.array([ sp.std(interesting_thetas[0][:, i]) for i in range(ndim) ]) sigmas_raw = sp.array([ sp.std(interesting_thetas_raw[0][:, i]) for i in range(ndim) ]) #print('sigmas', sigmas) # for testing #print('sigmas_raw', sigmas_raw) #print('mod_lims', boundaries) print('ALL RIGHT ALL RIGHT ALL RIGHT ALL RIGHT ALL RIGHT ALL RIGHT ALL RIGHT ALL RIGHT ') return thetas_raw, ajuste_raw, thetas_hen, ajuste_hen, p, lnprob, lnlike, posteriors, self.sampler.betas, interesting_thetas, interesting_posts, sigmas, sigmas_raw def conquer(self, from_k, to_k, logl=logl, logp=logp, BOUND=sp.array([])): burn_out = self.burn_out assert self.cores >= 1, 'Cores is set to 0 ! !' assert self.thin * self.draw_every_n < self.nsteps, 'You are thining way too hard ! !' if self.betas is not None: assert len(self.betas) == self.ntemps, 'Betas array and ntemps dont match ! !' if self.MUSIC: mixer.init() s = mixer.Sound('mediafiles/imperial_march.wav') thybiding = mixer.Sound('mediafiles/swvader04.wav') technological_terror = mixer.Sound('mediafiles/technological.wav') s.play() kplan = from_k # for k = 0 mod_lims = sp.array([]) acc_lims = sp.array([-1., 1.]) jitt_limiter = sp.amax(abs(self.rv)) jitt_lim = 3 * jitt_limiter # review this offs_lim = jitt_limiter # review this ins_lims = sp.array([sp.append(sp.array([0.0001, jitt_lim, -offs_lim, offs_lim]), sp.array([sp.array([-1.0, 1.0, 0.1, 10]) for j in range(self.MOAV)])) for i in range(self.nins)]).reshape(-1) sqrta, sqrte = jitt_lim, 1. sqrta, sqrte = sqrta ** 0.5, sqrte ** 0.5 ndim = kplan * 5 + self.nins*2*(self.MOAV+1) + self.totcornum + 1 + self.PACC free_lims = sp.array([sp.log(0.1), sp.log(3 * max(self.time)), -sqrta, sqrta, -sqrta, sqrta, -sqrte, sqrte, -sqrte, sqrte]) sigmas, sigmas_raw = sp.zeros(ndim), sp.zeros(ndim) pos0 = 0. thetas_hen, ajuste_hen = 0., 0. ajuste_raw = sp.array([0]) oldlogpost = -999999999. interesting_thetas, interesting_posts = sp.array([]), sp.array([]) thetas_raw = sp.array([]) ##################################################### #if self.PM: # pm_lims = sp.array([min(self.time_pm), max(self.time_pm), 0.0, 1.0, min(self.rv_pm), max(self.rv_pm), 0.1, 10]) # t0min t0max ratiomin ratiomax kamin ka_max kr_min kr_max ##################################################### START = chrono.time() while kplan <= to_k: mod_lims = sp.array([free_lims for i in range(kplan)]).reshape(-1) ins_lims = sp.array([sp.append(sp.array([0.0001, jitt_lim, -offs_lim, offs_lim]), sp.array([sp.array([-1.0, 1.0, 0.1, 10]) for j in range(self.MOAV)])) for i in range(self.nins)]).reshape(-1) #if LIL_JITT: # ins_lims = ins_lims = sp.array([sp.append(sp.array([0.0001, 10.0, -offs_lim, offs_lim]), sp.array([sp.array([-1.0, 1.0, 0.1, 10]) for j in range(self.MOAV)])) for i in range(self.nins)]).reshape(-1) if kplan > 0: if self.PM: ndim += self.fsig*self.lenppm t0min, t0max = min(self.time_pm), max(self.time_pm) pm_lims = sp.array([t0min, t0max, 0.0, 1.0, min(self.rv_pm), max(self.rv_pm), -10, 10]) # makes sense???? # t0min t0max ratiomin ratiomax kamin ka_max kr_min kr_max print(pm_lims, pm_lims.shape, 'pm_lims and shape\n\n') # PMPMPM print(self.fsig*self.lenppm, 'ndim en pm\n\n') # PMPMPM if self.CONSTRAIN and ajuste_raw[0]: constrained = sp.array([]) for k in range(kplan - 1): amp = 2.0 Pk, Ask, Ack, Sk, Ck = ajuste_raw[k*5:(k+1)*5] Pk_std, Ask_std, Ack_std, Sk_std, Ck_std = sigmas_raw[5*k:5*(k+1)] Ask_std, Ack_std, Sk_std, Ck_std = amp * sp.array([Ask_std, Ack_std, Sk_std, Ck_std]) aux = sp.array([Pk-Pk_std, Pk+Pk_std, Ask - Ask_std, Ask + Ask_std, Ack - Ack_std, Ack + Ack_std, Sk - Sk_std, Sk + Sk_std, Ck - Ck_std, Ck + Ck_std]) constrained = sp.append(constrained, aux) for nin in range(self.nins): # only constrains ins_lims[0 + nin*4*(self.MOAV+1)] = 0.0001 ins_lims[1 + nin*4*(self.MOAV+1)] = ajuste_raw[(kplan - 1) * 5 + nin*2*(self.MOAV+1) + 1 + self.PACC] mod_lims = sp.append(constrained, free_lims) # only planets limits if len(BOUND) != 0: nn = len(BOUND) for j in range(len(BOUND[:kplan].reshape(-1))): if BOUND[:kplan].reshape(-1)[j] != -sp.inf: mod_lims[j] = BOUND[:kplan].reshape(-1)[j] if nn <= kplan: BOUND = sp.array([]) #print('ins_lims', ins_lims) # testing purposes #print('mod_lims', mod_lims) #print('ajuste_raw', ajuste_raw) if self.breakFLAG==True: break if self.PM: if kplan > 0: pos0 = emplib.pt_pos_rvpm(self.setup, kplan, self.nins, mod_lims, ins_lims, acc_lims, self.MOAV, self.totcornum, self.PACC, self.fsig, self.lenppm, self.nins_pm, pm_lims) print(pos0, pos0.shape, 'pos0 y shape\n\n') # PMPMPM thetas_raw, ajuste_raw, thetas_hen, ajuste_hen, p, lnprob, lnlike, posteriors, betas, interesting_thetas, interesting_posts, sigmas, sigmas_raw = self.MCMC(kplan, mod_lims, ins_lims, acc_lims, sigmas_raw, pos0, logl, logp, pm_lims) else: pos0 = emplib.pt_pos(self.setup, kplan, self.nins, mod_lims, ins_lims, acc_lims, self.MOAV, self.totcornum, self.PACC) thetas_raw, ajuste_raw, thetas_hen, ajuste_hen, p, lnprob, lnlike, posteriors, betas, interesting_thetas, interesting_posts, sigmas, sigmas_raw = self.MCMC(kplan, mod_lims, ins_lims, acc_lims, sigmas_raw, pos0, logl, logp) else: pos0 = emplib.pt_pos(self.setup, kplan, self.nins, mod_lims, ins_lims, acc_lims, self.MOAV, self.totcornum, self.PACC) thetas_raw, ajuste_raw, thetas_hen, ajuste_hen, p, lnprob, lnlike, posteriors, betas, interesting_thetas, interesting_posts, sigmas, sigmas_raw = self.MCMC(kplan, mod_lims, ins_lims, acc_lims, sigmas_raw, pos0, logl, logp) chain = thetas_hen fit = ajuste_hen sample_sizes = sp.array([len(interesting_thetas[i]) for i in range((len(interesting_thetas)))]) bestlogpost = max(posteriors[0]) # BIC NEW_BIC = sp.log(self.ndat) * ndim - 2 * bestlogpost OLD_BIC = sp.log(self.ndat) * ndim - 2 * oldlogpost NEW_AIC = 2 * ndim - 2 * bestlogpost OLD_AIC = 2 * ndim - 2 * oldlogpost # theta, time, kplanets, ins, staract, starflag, kplanets, nins, MOAV, totcornum, PACC residuals = empmir.RV_residuals(ajuste_raw, self.rv, self.time, self.ins, self.staract, self.starflag, kplan, self.nins, self.MOAV, self.totcornum, self.PACC) alt_res = self.alt_results(interesting_thetas[0], kplan) saveplace = self.mklogfile(fit, bestlogpost, sample_sizes, sigmas, kplan, mod_lims, NEW_BIC, NEW_AIC, alt_res, START, residuals) self.instigator(interesting_thetas, interesting_posts, saveplace, kplan) if self.MUSIC: thybiding.play() if self.PLOT: from emperors_canvas import plot1, plot2 plug = sp.array([self.setup, kplan, self.nins, self.totcornum, saveplace, self.MOAV, self.PACC]) plot2(self.all_data, plug, fit, self.starflag, self.staract, self.ndat) plug2 = sp.array([self.HISTOGRAMS, self.CORNER, self.STARMASS, self.PNG, self.PDF, self.thin, self.draw_every_n]) plot1(interesting_thetas, interesting_posts, plug, plug2, '0') if self.RAW: rawplace = str(saveplace)+'/RAW' os.makedirs(rawplace) self.instigator(thetas_hen, posteriors, rawplace, kplan) plug[4] = rawplace plot1(thetas_hen, posteriors, plug, plug2, '0') if OLD_BIC - NEW_BIC < self.BIC: print('\nBayes Information Criteria of %.2f requirement not met ! !' % self.BIC) if OLD_AIC - NEW_AIC < self.AIC: print('\nAkaike Information Criteria of %.2f requirement not met ! !' % self.AIC) print(OLD_AIC, NEW_AIC, OLD_AIC - NEW_AIC) print('New logpost vs. Old logpost', bestlogpost, oldlogpost, bestlogpost - oldlogpost) print('Old BIC vs New BIC', OLD_BIC, NEW_BIC, OLD_BIC - NEW_BIC) print('Old AIC vs New AIC', OLD_AIC, NEW_AIC, OLD_AIC - NEW_AIC) if bestlogpost - oldlogpost < self.model_comparison: print('\nBayes Factor of %.2f requirement not met ! !' % self.model_comparison) break oldlogpost = bestlogpost kplan += 1 if self.MUSIC: technological_terror.play() return pos0, chain, fit, thetas_raw, ajuste_raw, mod_lims, posteriors, bestlogpost, interesting_thetas, interesting_posts, sigmas, sigmas_raw
p0 = np.dstack((w0,w1,w2,w3,w4,w5,w6,w7,w8)) #print p0.shape niter = 2000 nburn = np.int(0.01*niter) diskname='HD141569A' #f = open("burnchain.dat", "w") #f.close() ###################################################### ################## BURN IN STAGE #################### ###################################################### for p, lnprob, lnlike in sampler.sample(p0, iterations=nburn): #samples = sampler.chain[:,:,:].reshape((-1,ndim)) #fig = triangle.corner(samples, labels=["$i$","$Ho$","$M$","$amax$","$alpha$","$beta$","$w$"])#,truths=[i_true,Ho_true,M_true,amax_true,alpha_true,beta_true,w_true]) #fig.savefig("burntriangle.png") pass # for k in range(nwalkers): # for j in range(ntemps): # f.write('{0} \n'.format(sampler.acceptance_fraction[j,k])) #f.close() print 'Burn in complete' #pool.close()
if i == 0: x0,y0 = 0,0 else: x0,y0 = dx,dy image = imgs[i] sigma = sigs[i] psf = PSFs[i] lp += lensModel.lensFit(None,image,sigma,gals,lenses,srcs,xc+x0,yc+y0,OVRS,verbose=False,psf=psf,csub=1) #print lp return lp def logp(X): return 0 sampler=PTSampler(ntemps, nwalkers, ndim, lnprob,logp,threads=4) for p, lnprob, lnlike in sampler.sample(p0, iterations=200): pass sampler.reset() print 'sampled' for p, lnprob, lnlike in sampler.sample(p, lnprob0=lnprob,lnlike0=lnlike,iterations=200): pass assert sampler.chain.shape == (ntemps, nwalkers, 200, ndim) print 'fertig?' ''' outFile = '/data/ljo31/Lens/J1347/test_emcee' f = open(outFile,'wb') cPickle.dump(S.result(),f,2) f.close() result = S.result() lp = result[0]
#for result in sampler.sample(pos_end, iterations=10, storechain=False): # position = result[0] # f = open("chain.dat", "a") # for k in range(position.shape[0]): # f.write("{0:4d} {1:s}\n".format(k, " ".join(position[k]))) # fc.lose() fn = "spec_mcmc_newest_"+str(nspec)+".out" f = open(fn, "w") f.close() print 'now running sampler with '+np.str(niter * nwalkers)+' total steps' sys.stdout.flush() for pos, prob, rstate in sampler.sample(pos0, prob, state, iterations=niter): # Write the current position to a file, one line per walker f = open(fn, "a") f.write("\n".join(["\t".join([str(q) for q in p]) for p in pos])) #f.write("\n".join(["\t".join( pos.tolist()[i] +[prob.tolist()[i]] ) for i in range( len(prob) ) ] ) ) f.write("\n") f.close() #pool.close() print("Mean acceptance fraction: {0:.3f}".format(np.mean(sampler.acceptance_fraction))) #Plotting corner plot that shows the model density over each posible tuples of parameter projections samples = sampler.chain.reshape((-1, ndim)) if parameters==['NH','Vmax']:
#for result in sampler.sample(pos_end, iterations=10, storechain=False): # position = result[0] # f = open("chain.dat", "a") # for k in range(position.shape[0]): # f.write("{0:4d} {1:s}\n".format(k, " ".join(position[k]))) # fc.lose() fn = "spec_mcmc_newest_" + str(nspec) + ".out" f = open(fn, "w") f.close() print 'now running sampler with ' + np.str( niter * nwalkers) + ' total steps' sys.stdout.flush() for pos, prob, rstate in sampler.sample(pos0, prob, state, iterations=niter): # Write the current position to a file, one line per walker f = open(fn, "a") f.write("\n".join(["\t".join([str(q) for q in p]) for p in pos])) #f.write("\n".join(["\t".join( pos.tolist()[i] +[prob.tolist()[i]] ) for i in range( len(prob) ) ] ) ) f.write("\n") f.close() #pool.close() print("Mean acceptance fraction: {0:.3f}".format( np.mean(sampler.acceptance_fraction))) #Plotting corner plot that shows the model density over each posible tuples of parameter projections samples = sampler.chain.reshape((-1, ndim))
def call_mcmc(self): """ Start running the emcee code. """ # Get the data and the intrinsic spin-down values y_measured,y_measured_error = self.params.ACCEL.value,self.params.ACCEL_ERR.value y_measured[self.PBDOT_INDS] = self.params.ACCEL_BINARY[self.PBDOT_INDS].value y_measured_error[self.PBDOT_INDS] = self.params.ACCEL_BINARY_ERR[self.PBDOT_INDS].value y_measured_var = y_measured_error**2 y_measured_var_div = (1/y_measured_error**2) j_measured = (self.params.P2[self.J_INDS].value/self.params.P0[self.J_INDS].value)*const.c.value j_measured_var = ((self.params.P2_ERR[self.J_INDS].value/self.params.P0[self.J_INDS].value)*const.c.value)**2 j_measured_var_div = (1/j_measured_var) P0 = self.params.P0[self.ISO_INDS].value # MCMC setup parameters nwalkers = int(self.options.nwalker) nsteps = int(self.options.nchain) ntemps = int(self.options.ntemp) nthreads = int(self.options.nthread) nburn = int(self.options.nburn) nglide = int(self.options.nglide) nthin = int(self.options.nthin) # Get initial guesses for l l_guesses = self.rough_l_guess(y_measured,(nwalkers,self.rsize)) l_guesses_scale = .1*np.fabs(l_guesses) l_signs = np.sign(l_guesses[0]) # Boundaries for the flat prior lb,ub = self.make_prior_array(l_signs) # Initial guesses for walkers np.random.seed(0) starting_guesses = np.zeros((ntemps,nwalkers,self.ndim)) for ii in range(ntemps): starting_guesses[ii,:,:self.nparam] = np.random.normal(self.theta_init, .1*self.theta_init, (nwalkers,self.nparam)) starting_guesses[ii,:,self.zmin_ind:self.zmax_ind] = np.random.normal(l_guesses, l_guesses_scale, (nwalkers,self.rsize)) starting_guesses[ii,:,self.bmin_ind:self.bmax_ind] = self.bfield_dist(np.log10(self.bmin),np.log10(self.bmax),shape=(nwalkers,self.isosize))*1e8 # Get the initial velocity guesses if needed if self.options.jerkflag: v_inits = np.sqrt(4*np.pi*const.G.value*starting_guesses[ii,:,0]/3.)*starting_guesses[ii,:,1] v_inits = np.repeat(v_inits,self.jsize).reshape(-1,self.jsize) j_signs = np.sign(j_measured) v_inits *= j_signs v_inits = np.random.normal(v_inits,.05*np.fabs(v_inits)) starting_guesses[ii,:,self.vmin_ind:self.vmax_ind] = v_inits # Make the black hole mass spaced evenly in log space if needed if self.options.bhflag: bhmin_log = np.log10(self.options.bhmin) bhmax_log = np.log10(self.options.bhmax) delta_bh = (bhmax_log-bhmin_log) starting_guesses[ii,:,self.nparam-1] = (10**(bhmin_log+delta_bh*np.random.random((nwalkers,))))*const.M_sun.value # Make the argument list to pass to the MCMC handler args = [self.rperp,P0,y_measured,y_measured_var_div,j_measured,j_measured_var_div,self.zmin_ind,self.zmax_ind \ ,self.ISO_INDS,self.PBDOT_INDS,self.rc_grid,self.alpha_grid,self.lookup,l_signs,self.J_INDS \ ,self.vmin_ind,self.vmax_ind,self.options.jerkflag,self.options.bhflag,lb,ub] # Sample the distribution try: sampler = PTSampler(ntemps, nwalkers, self.ndim, mcmcfnc.log_likelihood, mcmcfnc.log_prior, loglargs=[args], logpargs=[args],threads=nthreads) except AssertionError: print "Incorrect number of walkers for the given dimensions. Minimum number of walkers needed: %d." %(2*self.ndim) exit() # Burning in the data print "Beginning the burn-in." for p, lnprob, lnlike in sampler.sample(starting_guesses, iterations=nburn): pass sampler.reset() print "Finished the burn in. Starting the sampling" for p, lnprob, lnlike in sampler.sample(p, lnprob0=lnprob, lnlike0=lnlike, iterations=nsteps, thin=nthin): pass # Save the array np.save(self.options.outfile, sampler.chain) np.save('%schain.p.npy' %(self.outdir),p) np.save('%schain.lbprob.npy' %(self.outdir),lnprob) np.save('%schain.lnlike.npy' %(self.outdir),lnlike)
# Load in samples from previous mcmc chain, and run any models # that weren't generated. p = np.load(maindir+'p_frommcmc.npy') ################################################################## ##################### Continue After Burn-in ##################### ################################################################## chainfn = maindir+"chain.dat" tempsfn = maindir+"temps.dat" f = open(chainfn,"w") f.close() g = open(tempsfn,"w") g.close() for p, lnprob, lnlike in sampler.sample(p, iterations=niter,storechain=True): position = p[0] position_temp = p[1] f = open(chainfn,"a") g = open(tempsfn,"a") for k in range(position.shape[0]): f.write("{0:4d} {1:s}\n".format(k, " ".join(str(position[k])))) g.write("{0:4d} {1:s}\n".format(k, " ".join(str(position_temp[k])))) f.close() g.close() position = p np.save('p_mcmc',position) print "MCMC Complete" samples = sampler.chain
sampler = PTSampler(ntemps, nwalkers, ndim, logl, logp) # Making the sampling multi-threaded is as simple as adding the threads=Nthreads # argument to PTSampler. We could have modified the temperature ladder using the # betas optional argument (which should be an array of beta = 1/T values). The # pool argument also allows to specify our own pool of worker threads if we # wanted fine-grained control over the parallelism. nsteps = 1000 # First, we run the sampler for N/10 burn-in iterations: print "PT burning in for",nsteps/10,"iterations..." p0 = np.random.uniform(low=-1.0, high=1.0, size=(ntemps, nwalkers, ndim)) for p, lnprob, lnlike in sampler.sample(p0, iterations=nsteps/10): pass sampler.reset() # Now we sample for nsteps iterations, recording every 10th sample: print "PT sampling for",nsteps,"iterations..." for p, lnprob, lnlike in sampler.sample(p, lnprob0=lnprob, lnlike0=lnlike, iterations=nsteps, thin=10): pass # The resulting samples (nsteps/thin of them) are stored as the sampler.chain # property: assert sampler.chain.shape == (ntemps, nwalkers, nsteps/10, ndim)
dx2 = x - mu2 return np.logaddexp(-np.dot(dx1, np.dot(sigma1inv, dx1))/2.0, -np.dot(dx2, np.dot(sigma2inv, dx2))/2.0) # Use a flat prior def logp(x): return 0.0 ntemps = 20 nwalkers = 100 ndim = 2 sampler=PTSampler(ntemps, nwalkers, ndim, logl, logp) p0 = np.random.uniform(low=-1.0, high=1.0, size=(ntemps, nwalkers, ndim)) for p, lnprob, lnlike in sampler.sample(p0, iterations=100): pass sampler.reset() for p, lnprob, lnlike in sampler.sample(p, lnprob0=lnprob, lnlike0=lnlike, iterations=1000, thin=10): pass assert sampler.chain.shape == (ntemps, nwalkers, 100, ndim) # Chain has shape (ntemps, nwalkers, nsteps, ndim) # Zero temperature mean: mu0 = np.mean(np.mean(sampler.chain[0,...], axis=0), axis=0) # Longest autocorrelation length (over any temperature)
def MCMC(self, kplanets, boundaries, inslims, acc_lims, sigmas_raw, pos0, logl, logp): ndim = 1 + 4 * kplanets + self.nins * 2 * ( self.MOAV + 1) + self.totcornum + self.PACC ndat = len(self.time) def starinfo(): colors = [ 'red', 'green', 'blue', 'yellow', 'grey', 'magenta', 'cyan', 'white' ] c = sp.random.randint(0, 7) print( colored( '\n ###############################################', colors[c])) print( colored(' # #', colors[c])) print( colored(' # #', colors[c])) print( colored(' # E M P E R 0 R #', colors[c])) print( colored(' # #', colors[c])) print( colored(' # #', colors[c])) print( colored(' ###############################################', colors[c])) print( colored( 'Exoplanet Mcmc Parallel tEmpering Radial vel0city fitteR', colors[sp.random.randint(0, 7)])) logdat = '\n\nStar Name : ' + self.starname logdat += '\nTemperatures, Walkers, Steps : ' + str( (self.ntemps, self.nwalkers, self.nsteps)) logdat += '\nN Instruments, K planets, N data : ' + str( (self.nins, kplanets, self.ndat)) logdat += '\nN Number of Dimensions : ' + str(ndim) logdat += '\nN Moving Average : ' + str(self.MOAV) logdat += '\nBeta Detail : ' + str( self.betas) logdat += '\n-----------------------------------------------------' print(logdat) pass starinfo() #''' sampler = PTSampler(self.ntemps, self.nwalkers, ndim, logl, logp, loglargs=[ self.time, self.rv, self.err, self.ins, self.staract, self.starflag, kplanets, self.nins, self.MOAV, self.totcornum, self.PACC ], logpargs=[ self.time, kplanets, self.nins, self.MOAV, self.totcornum, boundaries, inslims, acc_lims, sigmas_raw, self.eccprior, self.jittprior, self.jittmean, self.STARMASS, self.HILL, self.PACC, self.CHECK ], threads=self.cores, betas=self.betas) print('\n --------------------- BURN IN --------------------- \n') pbar = tqdm(total=self.burn_out) for p, lnprob, lnlike in sampler.sample(pos0, iterations=self.burn_out): pbar.update(1) pass pbar.close() p0, lnprob0, lnlike0 = p, lnprob, lnlike print("\nMean acceptance fraction: {0:.3f}".format( sp.mean(sampler.acceptance_fraction))) assert sp.mean(sampler.acceptance_fraction ) != 0, 'Mean acceptance fraction = 0 ! ! !' sampler.reset() ''' sampler1 = PTSampler(self.ntemps, self.nwalkers, ndim, logl, logp, loglargs=[self.time, self.rv, self.err, self.ins, self.staract, self.starflag, kplanets, self.nins, self.MOAV, self.totcornum, self.PACC], logpargs=[self.time, kplanets, self.nins, self.MOAV, self.totcornum, boundaries, inslims, acc_lims, sigmas_raw, self.eccprior, self.jittprior, self.jittmean, self.STARMASS, self.HILL, self.PACC, self.CHECK], threads=self.cores, betas=self.betas*0.3) print('\n --------------- EXPERIMENTAL BURN IN --------------- \n') pbar = tqdm(total=self.burn_out) for p, lnprob, lnlike in sampler1.sample(pos0, iterations=self.burn_out // 3): pbar.update(1) pass pbar.close() p0, lnprob0, lnlike0 = p, lnprob, lnlike print("\nMean acceptance fraction: {0:.3f}".format(sp.mean(sampler1.acceptance_fraction))) assert sp.mean(sampler1.acceptance_fraction) != 0, 'Mean acceptance fraction = 0 ! ! !' sampler1.reset() print('\n ---------------- EXPERIMENTAL CHAIN ---------------- \n') sampler = PTSampler(self.ntemps, self.nwalkers, ndim, logl, logp, loglargs=[self.time, self.rv, self.err, self.ins, self.staract, self.starflag, kplanets, self.nins, self.MOAV, self.totcornum, self.PACC], logpargs=[self.time, kplanets, self.nins, self.MOAV, self.totcornum, boundaries, inslims, acc_lims, sigmas_raw, self.eccprior, self.jittprior, self.jittmean, self.STARMASS, self.HILL, self.PACC, self.CHECK], threads=self.cores, betas=self.betas) pbar = tqdm(total=self.nsteps) for p, lnprob, lnlike in sampler.sample(p0, lnprob0=lnprob0, lnlike0=lnlike0, iterations=self.nsteps, thin=self.thin): pbar.update(1) pass pbar.close() ''' print('\n ---------------------- CHAIN ---------------------- \n') pbar = tqdm(total=self.nsteps) for p, lnprob, lnlike in sampler.sample(p0, lnprob0=lnprob0, lnlike0=lnlike0, iterations=self.nsteps, thin=self.thin): pbar.update(1) pass pbar.close() #''' assert sampler.chain.shape == (self.ntemps, self.nwalkers, self.nsteps / self.thin, ndim), 'something really weird happened' print("\nMean acceptance fraction: {0:.3f}".format( sp.mean(sampler.acceptance_fraction))) ln_post = sampler.lnprobability posteriors = sp.array( [ln_post[i].reshape(-1) for i in range(self.ntemps)]) chains = sampler.flatchain best_post = posteriors[0] == np.max(posteriors[0]) thetas_raw = sp.array([chains[i] for i in range(self.ntemps)]) thetas_hen = sp.array([ empmir.henshin_PM(chains[i], kplanets) for i in range(self.ntemps) ]) ajuste_hen = thetas_hen[0][best_post][0] ajuste_raw = thetas_raw[0][best_post][0] interesting_loc = sp.array([ max(posteriors[temp]) - posteriors[temp] < self.bayes_factor for temp in sp.arange(self.ntemps) ]) interesting_thetas = sp.array([ thetas_hen[temp][interesting_loc[temp]] for temp in sp.arange(self.ntemps) ]) interesting_thetas_raw = sp.array([ thetas_raw[temp][interesting_loc[temp]] for temp in sp.arange(self.ntemps) ]) interesting_posts = sp.array([ posteriors[temp][interesting_loc[temp]] for temp in range(self.ntemps) ]) sigmas = sp.array( [sp.std(interesting_thetas[0][:, i]) for i in range(ndim)]) sigmas_raw = sp.array( [sp.std(interesting_thetas_raw[0][:, i]) for i in range(ndim)]) #print('sigmas', sigmas) # for testing #print('sigmas_raw', sigmas_raw) #print('mod_lims', boundaries) print ajuste_raw, ajuste_hen return thetas_raw, ajuste_raw, thetas_hen, ajuste_hen, p, lnprob, lnlike, posteriors, sampler.betas, interesting_thetas, interesting_posts, sigmas, sigmas_raw
def mc_main(s_ident, ntemps, nwalkers, niter, nburn, nthin, nthreads, mcdata, mcmod, partemp=True, mc_a=2., init_samples_fn=None, write_model=False, plot=False, save=False): start = time.ctime() time_start_secs = time.time() print("\nSTART TIME: " + start) # TEMP!!! # For now, emcee v3.* offers only an EnsembleSampler, so force that mode # if such a version is detected. if (ntemps > 1) and (emcee_version_major >= 3): ntemps = 1 partemp = False emcee_v3_msg = "WARNING! FORCED to use EnsembleSampler because emcee v3+ detected. Setting ntemps=1 and partemp=False." print("\n" + emcee_v3_msg) print( "To use a PTSampler, try the ptemcee package (NOT currently compatible with diskmc) or using emcee v2.2.1." ) else: emcee_v3_msg = None data = mcdata.data uncerts = mcdata.uncerts data_types = np.array(mcdata.data_types) # need as nd.array for later stars = mcdata.stars model_path = os.path.join( os.path.abspath(os.path.expanduser(mcmod.model_path)), '') log_path = os.path.join( os.path.abspath(os.path.expanduser(mcmod.log_path)), '') lam = mcmod.lam # [microns] unit_conv = mcmod.unit_conv # Sort the parameter names. # NOTE: this must be an array (can't be a list). pkeys_all = np.array(sorted(mcmod.pkeys)) # Create log file. mcmc_log_fn = os.path.join(log_path, '%s_mcmc_log.txt' % s_ident) mcmc_log = open(mcmc_log_fn, 'w') # FIX ME!!! Need to handle this specific case better. # Make phi map specifically for conversion of Stokes to radial Stokes. yy, xx = np.mgrid[:data[0].shape[0], :data[0].shape[1]] phi_stokes = np.arctan2(yy - stars[0][0], xx - stars[0][1]) # Bin data by factors specified in mcdata.bin_facts list. # Do nothing if mcdata.bin_facts is None or its elements are 1. if mcdata.bin_facts is None: mcdata.bin_facts = len(data) * [1] data_orig = [] uncerts_orig = [] stars_orig = [] for ii, bin_fact in enumerate(mcdata.bin_facts): if bin_fact not in [1, None]: # Store the original data as backup. data_orig.append(data[ii].copy()) uncerts_orig.append(uncerts[ii].copy()) # Bin data, uncertainties, and mask by interpolation. datum_binned = zoom(np.nan_to_num(data_orig[ii].data), 1. / bin_fact) * bin_fact uncert_binned = zoom(np.nan_to_num(uncerts_orig[ii]), 1. / bin_fact, order=1) * bin_fact # FIX ME!!! Interpolating the mask may not work perfectly. Linear interpolation (order=1) # is best so far. try: mask_binned = zoom(np.nan_to_num(data_orig[ii].mask), 1. / bin_fact, order=1) except: mask_binned = False stars_orig.append(stars[ii].copy()) star_binned = stars_orig[ii] / int(bin_fact) # radii_binned = make_radii(datum_binned, star_binned) # mask_fit = np.ones(datum_binned.shape).astype(bool) # mask_fit[star_binned[0]-int(hw_y/bin_fact):star_binned[0]+int(hw_y/bin_fact)+1, star_binned[1]-int(hw_x/bin_fact):star_binned[1]+int(hw_x/bin_fact)+1] = False # FIX ME!!! Need to specify this inner region mask or happens automatically? # mask_fit[radii_binned < r_fit/int(bin_fact)] = True data[ii] = np.ma.masked_array(datum_binned, mask=mask_binned) uncerts[ii] = uncert_binned stars[ii] = star_binned #################################### # ------ INITIALIZE WALKERS ------ # # This will be done using a uniform distribution drawn from # plims_lib (first option if not None) or a Gaussian distribution # drawn from pmeans_lib and psigmas_lib (if plims_lib == None). ndim = len(pkeys_all) print( "\nNtemps = %d, Ndim = %d, Nwalkers = %d, Nstep = %d, Nburn = %d, Nthreads = %d" % (ntemps, ndim, nwalkers, niter, nburn, nthreads)) # Sort parameters for walker initialization. if mcmod.plims_lib is not None: plims_sorted = np.array( [val for (key, val) in sorted(mcmod.plims_lib.items())]) init_type = 'uniform' elif mcmod.pmeans_lib is not None: pmeans_sorted = [ val for (key, val) in sorted(mcmod.pmeans_lib.items()) ] psigmas_sorted = [ val for (key, val) in sorted(mcmod.psigmas_lib.items()) ] init_type = 'gaussian' # Make the array of initial walker positions p0. if init_samples_fn is None: if partemp: if init_type == 'uniform': # Uniform initialization between priors. p0 = np.random.uniform(low=plims_sorted[:, 0], high=plims_sorted[:, 1], size=(ntemps, nwalkers, ndim)) elif init_type == 'gaussian': # Gaussian ball initialization. p0 = np.random.normal(loc=pmeans_sorted, scale=psigmas_sorted, size=(ntemps, nwalkers, ndim)) else: if init_type == 'uniform': # Uniform initialization between priors. p0 = np.random.uniform(low=plims_sorted[:, 0], high=plims_sorted[:, 1], size=(nwalkers, ndim)) elif init_type == 'gaussian': # Gaussian ball initialization. p0 = np.random.normal(loc=pmeans_sorted, scale=psigmas_sorted, size=(nwalkers, ndim)) print("Walker initialization = " + init_type) else: init_type == 'sampled' init_step_ind = -1 init_samples = hickle.load(os.path.join(log_path, init_samples_fn)) if partemp: p0 = init_samples['_chain'][:, :, init_step_ind, :] lnprob_init = init_samples['_lnprob'][:, :, init_step_ind] lnlike_init = init_samples['_lnlikelihood'][:, :, init_step_ind] else: p0 = init_samples['_chain'][:, init_step_ind, :] lnprob_init = init_samples['_lnprob'][:, init_step_ind] lnlike_init = init_samples['_lnlikelihood'][:, init_step_ind] print( "\nLoaded init_samples from %s.\nWalkers will start from those final positions." % init_samples_fn) # Try to get the MCFOST version number being used. try: output = subprocess.check_output("mcfost -v", shell=True) mcf_version = output.split('\n')[0].split(' ')[-1] except: mcf_version = 'unknown' print("Running MCFOST version %s" % mcf_version) print("Running diskmc version %s" % __version__) log_preamble = [ '|---MCMC LOG---|\n\n', '%s' % s_ident, '\nLOG DATE: ' + dt.date.isoformat(dt.date.today()), '\nJOB START: ' + start, '\nNPROCESSORS: %d\n' % nthreads, '\ndiskmc version: %s' % __version__, '\nMCFOST version: %s' % mcf_version, '\nMCFOST PARFILE: ', mcmod.parfile, '\n\nMCMC PARAMS: Ndim: %d, Nwalkers: %d, Nburn: %d, Niter: %d, Nthin: %d, Nthreads: %d' % (ndim, nwalkers, nburn, niter, nthin, nthreads), '\nPARALLEL-TEMPERED?: ' + str(partemp), ' , Ntemps: %d' % ntemps, '\nINITIALIZATION: ', init_type, '\na = %.2f' % mc_a, '\nWavelength = %s microns' % str(lam), '\n', ] mcmc_log.writelines(log_preamble) if emcee_v3_msg is not None: mcmc_log.writelines('\n{}\n'.format(emcee_v3_msg)) mcmc_log.close() # Create emcee sampler instances: parallel-tempered or ensemble. if partemp: # Instantiate parallel-tempered sampler. # Pass data_I, uncertainty_I, and parfile as arguments to emcee sampler. sampler = PTSampler( ntemps, nwalkers, ndim, mc_lnlike, mc_lnprior, a=mc_a, loglargs=[ pkeys_all, data, uncerts, data_types, mcmod.mod_bin_factor, phi_stokes, mcmod.parfile, model_path, unit_conv, mcmod.priors, mcmod.scatlight, mcmod.fullimg, mcmod.sed, mcmod.dustprops, lam, partemp, ndim, write_model, s_ident, mcdata.algo_I, mcmod.modfm ], logpargs=[pkeys_all, mcmod.priors], threads=nthreads) #pool=pool) else: # Instantiate ensemble sampler. if emcee_version_major >= 3: # Put backend setup here for some future use. # backend_log_name = os.path.join(log_path, '{}_mcmc_full_sampler.h5'.format(s_ident)) # backend = emcee.backends.HDFBackend(backend_log_name, name='mcmc') # backend.reset(nwalkers, ndim) # # vars(backend)['pkeys_all'] = pkeys_all backend = None from multiprocessing import Pool pool = Pool() sampler = EnsembleSampler( nwalkers, ndim, mc_lnlike, a=mc_a, args=[ pkeys_all, data, uncerts, data_types, mcmod.mod_bin_factor, phi_stokes, mcmod.parfile, model_path, unit_conv, mcmod.priors, mcmod.scatlight, mcmod.fullimg, mcmod.sed, mcmod.dustprops, lam, partemp, ndim, write_model, s_ident, mcdata.algo_I, mcmod.modfm ], pool=pool, backend=backend) # Add some items to sampler that don't exist in emcee >2.2.1. vars(sampler)['_chain'] = np.array([]) vars(sampler)['_lnprob'] = np.array([]) else: sampler = EnsembleSampler( nwalkers, ndim, mc_lnlike, a=mc_a, args=[ pkeys_all, data, uncerts, data_types, mcmod.mod_bin_factor, phi_stokes, mcmod.parfile, model_path, unit_conv, mcmod.priors, mcmod.scatlight, mcmod.fullimg, mcmod.sed, mcmod.dustprops, lam, partemp, ndim, write_model, s_ident, mcdata.algo_I, mcmod.modfm ], threads=nthreads) # Insert pkeys and priors into the sampler dict for later use. # Force '|S' string dtype to avoid unicode (which doesn't hickle well). vars(sampler)['pkeys_all'] = pkeys_all.astype('S') vars(sampler)['priors'] = mcmod.priors.copy() # List of items to delete from the sampler dict that may not hickle well during # logging. Mix of emcee v2 and v3, Ensemble, and PTSampler items. sampler_keys_trim = [ 'pool', 'lnprobfn', 'log_prob_fn', 'runtime_sortingfn', 'logl', 'logp', 'logpkwargs', 'loglkwargs', 'args', 'kwargs', '_random', '_moves', '_previous_state', 'backend' ] ############################### # ------ BURN-IN PHASE ------ # if nburn > 0: print("\nBURN-IN START...\n") for bb, (pburn, lnprob_burn, lnlike_burn) in enumerate(sampler.sample(p0, iterations=nburn)): # Print progress every 25%. if bb in [nburn // 4, nburn // 2, 3 * nburn // 4]: print("PROCESSING ITERATION %d; BURN-IN %.1f%% COMPLETE..." % (bb, 100 * float(bb) / nburn)) pass # Print burn-in autocorrelation time and acceptance fraction. try: max_acl_burn = np.nanmax( sampler.acor) # fails if too few iterations except: max_acl_burn = -1. print("Largest Burn-in Autocorrelation Time = %.1f" % max_acl_burn) if partemp: print("Mean, Median Burn-in Acceptance Fractions: %.2f, %.2f" % (np.mean(sampler.acceptance_fraction[0]), np.median(sampler.acceptance_fraction[0]))) else: print("Mean, Median Burn-in Acceptance Fractions: %.2f, %.2f" % (np.mean(sampler.acceptance_fraction), np.median(sampler.acceptance_fraction))) # Pause interactively between burn-in and main phase. # Comment this out if you don't want the script to pause here. # pdb.set_trace() # Reset the sampler chains and lnprobability after burn-in. sampler.reset() print("BURN-IN COMPLETE!") elif (nburn == 0) & (init_samples_fn is not None): print( "\nWalkers initialized from file and no burn-in samples requested." ) sampler.reset() pburn = p0 lnprob_burn = None #lnprob_init lnlike_burn = None #lnlike_init else: print("\nNo burn-in samples requested.") pburn = p0 lnprob_burn = None lnlike_burn = None ############################ # ------ MAIN PHASE ------ # print("\nMAIN-PHASE MCMC START...\n") if partemp: for nn, (pp, lnprob, lnlike) in enumerate( sampler.sample(pburn, lnprob0=lnprob_burn, lnlike0=lnlike_burn, iterations=niter)): # Print progress every 25%. if nn in [niter // 4, niter // 2, 3 * niter // 4]: print("Processing iteration %d; MCMC %.1f%% complete..." % (nn, 100 * float(nn) / niter)) if emcee_version_major < 3: # Log the full sampler or chain (all temperatures) every so often. log_message = log_sampler(sampler, sampler_keys_trim, log_path, s_ident, nn) else: for nn, (pp, lnprob, lnlike) in enumerate( sampler.sample(pburn, lnprob_burn, iterations=niter)): # Print progress every 25%. if nn in [niter // 4, niter // 2, 3 * niter // 4]: print("Processing iteration %d; MCMC %.1f%% complete..." % (nn, 100 * float(nn) / niter)) # Log the full sampler or chain (all temperatures) every so often. log_message = log_sampler(sampler, sampler_keys_trim, log_path, s_ident, nn) print('\nMCMC RUN COMPLETE!\n') ################################## # ------ RESULTS HANDLING ------ # # Log the sampler output and chains. Also get the max and median likelihood # parameter values and save models for them. # If possible, save the whole sampler to an HDF5 log file (could be large). # If that fails because hickle won't handle something in the sampler, # try to pickle it instead. If that still fails, just log the sampler chains. # if emcee_version_major < 3: log_message = log_sampler(sampler, sampler_keys_trim, log_path, s_ident, 'FINAL') # Chain has shape (ntemps, nwalkers, nsteps/nthin, ndim). if partemp: assert sampler.chain.shape == (ntemps, nwalkers, niter / nthin, ndim) else: assert sampler.chain.shape == (nwalkers, niter / nthin, ndim) # Re-open the text log for additional info. mcmc_log = open(mcmc_log_fn, 'a') mcmc_log.writelines([ '\n' + log_message, '\n\n|--- RESULTS FOR ALL ITERATIONS (NO BURN-IN EXCLUDED) ---|', '\n' ]) # If multiple temperatures, take zero temperature walkers because only they # sample the posterior distribution. # ch has dimensions [nwalkers, nstep, ndim] and excludes burn-in samples. if partemp: ch = sampler.chain[0, :, :, :] # zeroth temperature chain only samples = ch[:, :, :].reshape((-1, ndim)) lnprob_out = sampler.lnprobability[0] # zero-temp chi-squareds # Median acceptance fraction of zero temp walkers. print("\nMean, Median Acceptance Fractions (zeroth temp): %.2f, %.2f" % (np.mean(sampler.acceptance_fraction[0]), np.median(sampler.acceptance_fraction[0]))) mcmc_log.writelines( '\nMean, Median Acceptance Fractions (zeroth temp): %.2f, %.2f' % (np.mean(sampler.acceptance_fraction[0]), np.median(sampler.acceptance_fraction[0]))) else: ch = sampler.chain samples = ch[:, :, :].reshape((-1, ndim)) lnprob_out = sampler.lnprobability # all chi-squareds # Median acceptance fraction of all walkers. print("\nMean, Median Acceptance Fractions: %.2f, %.2f" % (np.mean(sampler.acceptance_fraction), np.median(sampler.acceptance_fraction))) mcmc_log.writelines('\nMean, Median Acceptance Fractions: %.2f, %.2f' % (np.mean(sampler.acceptance_fraction), np.median(sampler.acceptance_fraction))) # Renormalize mass_fraction values so sum to 1.0 (more intuitive). wh_pops = [ind for ind, key in enumerate(pkeys_all) if 'dust_pop' in key] samples_orig = samples.copy() samples[:, wh_pops] /= np.reshape(np.sum(samples_orig[:, wh_pops], axis=1), (samples_orig.shape[0], 1)) # Haven't implemented blobs handling yet. blobs = None # Print zero temp main-phase autocorrelation time and acceptance fraction. try: max_acl = np.nanmax(sampler.acor) if partemp: acor_T0 = sampler.acor[0] else: acor_T0 = sampler.acor except: max_acl = -1. acor_T0 = -1. print("Largest Main Autocorrelation Time = %.1f" % max_acl) # Max likelihood params values. ind_lk_max = np.where(lnprob_out == lnprob_out.max()) lk_max = np.e**lnprob_out.max() params_ml_mcmc = dict(zip(pkeys_all, ch[ind_lk_max][0])) params_ml_mcmc_sorted = [ val for (key, val) in sorted(params_ml_mcmc.items()) ] # Get median values (50th percentile) and 1-sigma (68%) confidence intervals # for each parameter (in order +, -). params_med_mcmc = list( map(lambda vv: (vv[1], vv[2] - vv[1], vv[1] - vv[0]), zip(*np.percentile(samples, [16, 50, 84], axis=0)))) print("\nMax-Likelihood Param Values:") mcmc_log.writelines('\n\nMAX-LIKELIHOOD PARAM VALUES:') for kk, key in enumerate(pkeys_all): print(key + ' = %.3e' % params_ml_mcmc[key]) mcmc_log.writelines('\n%s = %.3e' % (key, params_ml_mcmc[key])) print( "\n50%-Likelihood Param Values (50th percentile +/- 1 sigma (i.e., 34%):" ) mcmc_log.writelines( '\n\n50%-LIKELIHOOD PARAM VALUES (50th percentile +/- 1 sigma (i.e., 34%):' ) for kk, key in enumerate(pkeys_all): print(key + ' = %.3f +/- %.3f/%.3f' % (params_med_mcmc[kk][0], params_med_mcmc[kk][1], params_med_mcmc[kk][2])) mcmc_log.writelines('\n%s = %.3f +/- %.3f/%.3f' % (key, params_med_mcmc[kk][0], params_med_mcmc[kk][1], params_med_mcmc[kk][2])) # Construct max- and med-likelihood models. print("\nConstructing 'best-fit' models...") mod_idents = ['maxlk', 'medlk'] params_50th_mcmc = np.array(params_med_mcmc)[:, 0] for mm, pl in enumerate([params_ml_mcmc_sorted, params_50th_mcmc]): pl_dict = dict() pl_dict.update(zip(pkeys_all, pl)) # Name for model and its directory. try: fnstring = "%s_mcmc_%s_%s%.3e_%s%.3e_%s%.3e" % \ (s_ident, mod_idents[mm], pkeys_all[0], pl_dict[pkeys_all[0]], pkeys_all[1], pl_dict[pkeys_all[1]], pkeys_all[2], pl_dict[pkeys_all[2]]) except: fnstring = "%s_mcmc_%s_%s%.5e" % \ (s_ident, mod_idents[mm], pkeys_all[0], pl_dict[pkeys_all[0]]) # Make the MCFOST model. make_mcfmod(pkeys_all, pl_dict, mcmod.parfile, model_path, s_ident, fnstring, lam=lam, scatlight=mcmod.scatlight, fullimg=mcmod.fullimg) # Calculate Chi2 for images. chi2s = chi2_morph( os.path.join(model_path, fnstring, 'data_%s' % str(lam)), data, uncerts, data_types, mcmod.mod_bin_factor, phi_stokes, unit_conv) # Calculate reduced Chi2 for images. chi2_reds = np.array([ chi2s[ii] / (np.where(np.isfinite(data[ii].filled(np.nan)))[0].size - ndim) for ii in range(len(data)) ]) chi2_red_total = np.sum(chi2_reds) if mm == 0: lk_type = 'Max-Likelihood' # print('\nMax-Likelihood total chi2_red: %.3e | SED Cushing G: %.3e , I chi2_red: %.3f , Qr chi2_red: %.3f' % (chi2_red_total, G_mm, chi2_red_I, chi2_red_Qr)) # mcmc_log.writelines('\n\nMax-Likelihood total chi2_red: %.3e | SED Cushing G: %.3e , I chi2_red: %.3f , Qr chi2_red: %.3f' % (chi2_red_total, G_mm, chi2_red_I, chi2_red_Qr)) elif mm == 1: lk_type = '50%-Likelihood' # print('50%%-Likelihood total chi2_red: %.3e | SED Cushing G: %.3e , I chi2_red: %.3f , Qr chi2_red: %.3f' % (chi2_red_total, G_mm, chi2_red_I, chi2_red_Qr)) # mcmc_log.writelines('\n50%%-Likelihood total chi2_red: %.3e | SED Cushing G: %.3e , I chi2_red: %.3f , Qr chi2_red: %.3f' % (chi2_red_total, G_mm, chi2_red_I, chi2_red_Qr)) # print('%s total chi2_red: %.3e | SED Cushing G: %.3e , I chi2_red: %.3f , Qr chi2_red: %.3f' % (lk_type, chi2_red_total, G_mm, chi2_red_I, chi2_red_Qr)) # mcmc_log.writelines('\n%s total chi2_red: %.3e | SED Cushing G: %.3e , I chi2_red: %.3f , Qr chi2_red: %.3f' % (lk_type, chi2_red_total, G_mm, chi2_red_I, chi2_red_Qr)) print('%s total chi2_red: %.3e' % (lk_type, chi2_red_total)) print("individual chi2_red's: " + len(chi2_reds) * "%.3e | " % tuple(chi2_reds)) mcmc_log.writelines('\n\n%s total chi2_red: %.3e' % (lk_type, chi2_red_total)) mcmc_log.writelines("\nindividual chi2_red's: " + len(chi2_reds) * "%.3e | " % tuple(chi2_reds)) # Make image, sed, and/or dust properties models for maxlk and medlk. try: os.chdir(os.path.join(model_path, fnstring)) # Make the dust properties at proper wavelength. # NOTE: This must come before the image calculation at the same # wavelength, otherwise MCFOST automatically deletes the image directory! subprocess.call('rm -rf data_' + str(lam), shell=True) subprocess.call( 'mcfost ' + fnstring + '.para -dust_prop -op %s >> dustmcfostout.txt' % lam, shell=True) time.sleep(1) # # Delete the (mostly) empty data_[lam] directory after dust_prop step. # subprocess.call('rm -rf data_'+str(lam), shell=True) # Make the SED model. subprocess.call('mcfost ' + fnstring + '.para -rt >> sedmcfostout.txt', shell=True) # Make the image models (thermal + scattered-light) at demanded wavelength. subprocess.call('mcfost ' + fnstring + '.para -img ' + str(lam) + ' -rt2 >> imagemcfostout.txt', shell=True) time.sleep(1) print("Saved image and dust properties models.") except: print("Failed to save image and dust properties models.") # Plot and save maxlk and medlk models. try: # Placeholder for plotting functions. pass print("Max and Median Likelihood models made, plotted, and saved.\n") except: print( "Max and Median Likelihood models made and saved but plotting failed.\n" ) time_end_secs = time.time() time_elapsed_secs = time_end_secs - time_start_secs # [seconds] print("END TIME: " + time.ctime()) print("ELAPSED TIME: %.2f minutes = %.2f hours" % (time_elapsed_secs / 60., time_elapsed_secs / 3600.)) mcmc_log.writelines( ['\n\nSTART TIME - END TIME: ', start, ' - ', time.ctime()]) mcmc_log.writelines([ '\nELAPSED TIME: %.2f minutes = %.2f hours' % (time_elapsed_secs / 60., time_elapsed_secs / 3600.) ]) mcmc_log.writelines('\n\nSUCCESSFUL EXIT') mcmc_log.close() # Close MPI pool. try: pool.close() print("\nPool closed") except: print("\nNo Pool to close.") print("\nmc_main function finished\n") # # Pause interactively before finishing script. # pdb.set_trace() return
def start_sampler(data, recovery_prob, burnin, niter, verbose, contact_daylist, max_recovery_time, nsick_param, diagnosis_lag=False, null_comparison=False, **kwargs3): r"""Sampling performed using emcee """ parameter_estimate=None ############################################################################## G_raw, health_data, node_health, nodelist, true_value, time_min, time_max, seed_date =data ###################################### ### Set number of parameters to estimate ###################################### ndim_base = 2 if recovery_prob: ndim_base += nsick_param ndim = ndim_base+nsick_param ####################### ##Adjust temperature ladder ####################### betas = np.linspace(0, -2, 15) betas = 10**(np.sort(betas)[::-1]) ntemps = 15 ########################################### ###set starting positions for the walker ############################################# nwalkers = max(50, 2*ndim) # number of MCMC walkers starting_guess = np.zeros((ntemps, nwalkers, ndim)) ##starting guess for beta starting_guess[:, :, 0] = np.random.uniform(low = 0, high = 10, size=(ntemps, nwalkers)) ##start epsilon close to zero epsilons = np.random.power(4, size = (ntemps, nwalkers)) starting_guess[:, :, 1] = 1-epsilons if diagnosis_lag: starting_guess[:, :, 2: ] = np.random.uniform(low = 0.001, high = 1,size=(ntemps, nwalkers, ndim-2)) ################################################################################ ##calculating infection date and infection strength outside loglik to speed up # ##computations ################################################################################ if not diagnosis_lag: infection_date = [(node, time1) for node in node_health if node_health[node].has_key(1) for (time1,time2) in node_health[node][1]] infection_date = sorted(infection_date) infected_strength = {network:{node:{time: calculate_infected_strength(node, time, health_data, G_raw[network]) for time in range(time_min, time_max+1)} for node in nodelist} for network in G_raw} pool = None threads = 1 else: infection_date = None infected_strength=None threads = 8 healthy_nodelist = return_healthy_nodelist(node_health) ################################################################################ if threads>1: sampler = PTSampler(ntemps=ntemps, nwalkers=nwalkers, dim=ndim, betas=betas, logl=log_likelihood, logp=log_prior, a = 1.5, loglargs=(data, infection_date, infected_strength, healthy_nodelist, null_comparison, diagnosis_lag, recovery_prob, nsick_param, contact_daylist, max_recovery_time, parameter_estimate), logpargs=(null_comparison, diagnosis_lag, nsick_param, recovery_prob, parameter_estimate), threads=threads) if threads<=1: sampler = PTSampler(ntemps=ntemps, nwalkers=nwalkers, dim=ndim, betas=betas, logl=log_likelihood, logp=log_prior, a = 1.5, loglargs=(data, infection_date, infected_strength, healthy_nodelist, null_comparison, diagnosis_lag, recovery_prob, nsick_param, contact_daylist, max_recovery_time, parameter_estimate), logpargs=(null_comparison, diagnosis_lag, nsick_param, recovery_prob, parameter_estimate)) #Run user-specified burnin print ("burn in......") for i, (p, lnprob, lnlike) in enumerate(sampler.sample(starting_guess, iterations = burnin)): if verbose:print("burnin progress..."), (100 * float(i) / burnin) else: pass sampler.reset() ################################# print ("sampling........") nthin = 5 for i, (p, lnprob, lnlike) in enumerate(sampler.sample(p, lnprob0 = lnprob, lnlike0= lnlike, iterations= niter, thin= nthin)): if verbose:print("sampling progress"), (100 * float(i) / niter) else: pass ############################## #The resulting samples are stored as the sampler.chain property: assert sampler.chain.shape == (ntemps, nwalkers, niter/nthin, ndim) return sampler