def fit_polynomial_p(self, degree): name = 'p{}'.format(degree) self.stored_data[name] = {} ndim = degree + 2 sampler = PTSampler( self.ntemps, self.nwalkers, ndim, self.logl_polynomial_p, self.logp_polynomial_p, loglargs=[self.x, self.y], betas=self.betas) param_keys = ["b{}".format(j) for j in range(0, degree + 1)] param_keys.append('sigma') p0 = [[[ np.random.uniform(*self.get_unif_prior_lims(key)) for key in param_keys ] for i in range(self.nwalkers)] for j in range(self.ntemps)] if self.nburn0 != 0: out = sampler.run_mcmc(p0, self.nburn0) self.stored_data[name]['chains0'] = sampler.chain[0, :, :, :] p0 = self.get_new_p0(sampler, ndim) sampler.reset() else: self.stored_data[name]['chains0'] = None out = sampler.run_mcmc(p0, self.nburn + self.nprod) self.stored_data[name]['chains'] = sampler.chain[0, :, :, :] self.stored_data[name]['sampler'] = sampler samples = sampler.chain[0, :, self.nburn:, :].reshape((-1, ndim)) self.stored_data[name]['samples'] = samples
#Numnber of iterations (after the burn-in) niter = 1500000 num_files=50 #I trust YOU, user, to make sure niter / num_files is remainderless nperfile=niter/num_files thin=1 #Burn-in for 1/5 of the number of iterations nburn = 50000 if __name__=='__main__': print 'Beginning main function' time.clock() time.sleep(1) startTime = datetime.now() sampler=PTSampler(ntemps, nwalkers, ndim, logl, logp ,loglargs=[eps,x,y,sigx,sigy],logpargs=[eps,x,y,sigx,sigy],threads=32) sampler.run_mcmc(p0,nburn,thin=thin) for index in range(num_files): if index == 0: p = sampler.chain[:,:,-1,:] np.savez_compressed(savename+'_burn_'+str(index),af=sampler.acceptance_fraction[0], chain=sampler.chain[0],lnp=sampler.lnprobability[0],p=sampler.chain[:,:,-1,:]) print 'Burn in complete' #burnchain = sampler.chain #pdb.set_trace() else: p = sampler.chain[:,:,-1,:] sampler.reset() #print 'Burn in complete' sampler.run_mcmc(p,nperfile,thin=thin) #print 'orbit fitting complete'
# Of which burn-in is the first burnin = 500; # Initial spot parameters. # [spotx, spoty, spotradius, spotcontrast] spot = numpy.array([0.204, 0.376, 0.096, 0.524]); # Create 3D matrix for initial state for each temperature and walker. p0 = numpy.repeat(spot[:,numpy.newaxis].T, ntemps*nwalkers, axis=0).reshape(ntemps, nwalkers, ndim); # Randomize the initial states in a small neighborhood. p0 += numpy.random.normal(scale=1e-3, size=p0.shape); # Initialize sampler. sampler = PTSampler(ntemps, nwalkers, ndim, logl, logp); # Run sampler. pos, prob, state = sampler.run_mcmc(p0, niter); # Take a view of the T=0 chain. zerotemp = sampler.chain[0]; # We take iterations at T=0 after burn-in as equilibrium # distribution. With a 100 walkers, this is 1e4 points. eq = zerotemp[:,burnin:,:].reshape([nwalkers*(niter-burnin), ndim]); # Plot distribution of every possible pairs. labels = ["spotx", "spoty", "spotradius", "spotcontrast"]; for ploti in range(ndim-1): for plotj in range(ploti+1,ndim): pyplot.figure() pyplot.plot(eq[:,ploti],eq[:,plotj],"b."); pyplot.xlabel(labels[ploti]);
sampler = emcee.EnsembleSampler(nwalkers, ndim, lnlikeZ, args=(Geom,wl_obs,f_obs,f_err,gauss_width,scaling,shift,nspec),pool=pool) elif parameters==['NH','Vmax','Z','theta']: pos = [[NH[i],V[i],Z[i],TH[i]] for i in range(nwalkers)] sampler = emcee.EnsembleSampler(nwalkers, ndim, lnlikeZTH, args=(Geom,wl_obs,f_obs,f_err,gauss_width,scaling,shift,nspec),pool=pool) elif parameters==['NH','Vmax','theta']: pos = [[NH[i],V[i],TH[i]] for i in range(nwalkers)] sampler = emcee.EnsembleSampler(nwalkers, ndim, lnlikeTH, args=(Geom,wl_obs,f_obs,f_err,gauss_width,scaling,shift,nspec),pool=pool) else: pos = [[NH[i],V[i]] for i in range(nwalkers)] sampler = emcee.EnsembleSampler(nwalkers, ndim, lneqnlike, args=(Geom,wl_obs,f_obs,f_err,scaling,shift,nspec),pool=pool) print 'starting burn-in iterations' sys.stdout.flush() pos0, prob, state = sampler.run_mcmc(pos, 5) print 'done' sys.stdout.flush() sampler.reset() #f = open("chain.dat", "w") #f.close() #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])))
return 0.0 # Training Parameters sigma = 1e-6 ntemp = 10 nruns = 2000 Temp_i = 0 #initialize the chian with a=0, b=0, c=0.5 pos = np.tile((0,0,0.5),5)/10+1e-4*np.random.randn(ntemp,64, 15) ntemps, nwalkers, ndim = pos.shape #first MCMC chain sampler = PTSampler(ntemps,nwalkers, ndim, log_probability,logp, loglargs=(x, JV_exp, sigma)) sampler.run_mcmc(pos, nruns ) samples = sampler.chain #%% #use the values obtained in the first MCMC chain to update the inistal estimate pos_update = samples[:,:,-1,:]+1e-5*np.random.randn(ntemp,64, 15) sampler.reset() #second MCM chain sampler = PTSampler(ntemps,nwalkers, ndim, log_probability,logp, loglargs=(x, JV_exp, sigma)) sampler.run_mcmc(pos_update, nruns); flat_samples = sampler.flatchain zero_flat_samples = flat_samples[Temp_i,:,:] zero_samples = samples[Temp_i,:,:,:] #visulize a1 plt.figure() plt.plot(zero_samples[0,:,0])
args=(Geom, wl_obs, f_obs, f_err, gauss_width, scaling, shift, nspec), pool=pool) else: pos = [[NH[i], V[i]] for i in range(nwalkers)] sampler = emcee.EnsembleSampler(nwalkers, ndim, lneqnlike, args=(Geom, wl_obs, f_obs, f_err, scaling, shift, nspec), pool=pool) print 'starting burn-in iterations' sys.stdout.flush() pos0, prob, state = sampler.run_mcmc(pos, 5) print 'done' sys.stdout.flush() sampler.reset() #f = open("chain.dat", "w") #f.close() #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()
init_pos = np.tile(init_theta,(ntemps,nwalkers,1)) + noise_model priors = [prior_z,prior_vp] #sampler = emcee.PTSampler(nwalkers, ndim, logprob, args=(x,tp, sigma_inv,log_sigma_det,nLayers,priors)) sampler = PTSampler(ntemps,nwalkers,ndim,logl = loglike,logp=logprior, logpargs= (prior_z,prior_vp,nLayers), loglargs = (x,tp, sigma_inv,log_sigma_det,nLayers), threads = 6 ) sampler.run_mcmc(init_pos, 6500) #samples = sampler.chain[:, 50:, :].reshape((-1, ndim)) samples = sampler.chain[0,...].reshape((-1, ndim)) samples_info = [samples,sampler.chain,sampler.betas,sampler.lnlikelihood,sampler.nswap, sampler.nswap_accepted,sampler.acceptance_fraction ] pickle.dump( samples_info, open( "samplerMCMC_PT_emcee.p", "wb" )) import corner fig = corner.corner(samples[5000:,:], labels=["V1", "V2", "V3","Z1","Z2"], truths= [3100,4470,6200,2000,2000])
def run_emcee(logl, logp, p0func, ntemps=0, nwalkers=50, nsamples=2500, thin=1, minlogbeta=None, nupdates=10, threads=1, outfilename=None, saveall=True, **kwargs): if minlogbeta is None: if ntemps == 0: # use cunning ladder betas = np.concatenate( (np.linspace(0, -0.9375, 16), np.linspace(-1, -1.875, 8), np.linspace(-2, -3.75, 8), np.linspace(-4, -7.5, 8), np.linspace(-8, -15, 8), np.linspace(-16, -30, 8), np.linspace(-32, -56, 4))) betas = 10**(np.sort(betas)[::-1]) else: betas = None # use emcee default else: betas = np.logspace(0, minlogbeta, ntemps) if betas is not None: ntemps = len(betas) pos = p0func((ntemps, nwalkers)) if not check_init_pars(logl, logp, pos): return None ndim = pos.shape[-1] if threads > 1: pool = Pool(threads) else: pool = None sampler = PTSampler(ntemps, nwalkers, ndim, logl, logp, betas=betas, pool=pool) if nupdates > 0: start = time.clock() print('Steps:', end='') sys.stdout.flush() nsteps = nsamples // nupdates for i in range(nupdates): pos, lnprob, rstate = sampler.run_mcmc(pos, nsteps, thin=thin) print(' {}'.format((i + 1) * nsteps), end='') sys.stdout.flush() nsteps = nsamples - sampler.chain.shape[-2] if nsteps > 0: pos, lnprob, rstate = sampler.run_mcmc(pos, nsteps, thin=thin) if nupdates > 0: print('\nTime taken = {:.2f} secs'.format(time.clock() - start)) if outfilename is None: outfilename = 'emcee_sampler.npz' try: acor = sampler.acor except autocorr.AutocorrError: acor = None if saveall: np.savez_compressed( outfilename, acceptance_fraction=sampler.acceptance_fraction, acor=acor, beta=sampler.betas, chain=sampler.chain, lnlikelihood=sampler.lnlikelihood, lnprobability=sampler.lnprobability, tswap_acceptance_fraction=sampler.tswap_acceptance_fraction) else: # only save lowest temperature and thin samples by factor of ten np.savez_compressed( outfilename, acceptance_fraction=sampler.acceptance_fraction, acor=acor, beta=sampler.betas, chain=sampler.chain[0, :, ::10], lnlikelihood=sampler.lnlikelihood[0, :, ::10], lnprobability=sampler.lnprobability[0, :, ::10], tswap_acceptance_fraction=sampler.tswap_acceptance_fraction) return sampler