def fit(self, numLevels, directory="", numPerSave=1000, numParticles=5, new_level_interval=10000): sampler = dnest4.DNest4Sampler(self.model, backend=dnest4.backends.CSVBackend( basedir="./" + directory, sep=" ")) # Set up the sampler. The first argument is max_num_levels gen = sampler.sample(max_num_levels=numLevels, num_steps=200000, new_level_interval=new_level_interval, num_per_step=numPerSave, thread_steps=100, num_particles=numParticles, lam=10, beta=100, seed=1234) # Do the sampling (one iteration here = one particle save) for i, sample in enumerate(gen): print("# Saved {k} particles.".format(k=(i + 1)))
def fit_particle(self, manager_comm, numLevels, directory="", numPerSave=1000, numParticles=5, new_level_interval=10000): """This is a different method to be used in place of fit() for the case where you are fitting with MPI, with a thread for each particle. """ mpi_sampler = dnest4.MPISampler(comm=manager_comm, debug=False) if manager_comm.rank == 0: # Set up the sampler. The first argument is max_num_levels sampler = dnest4.DNest4Sampler(self.model, backend=dnest4.backends.CSVBackend(basedir =directory,#basedir ="./" + directory, sep=" "), MPISampler=mpi_sampler) gen = sampler.sample(max_num_levels=numLevels, num_steps=200000, new_level_interval=new_level_interval, num_per_step=numParticles, thread_steps=100, lam=10, beta=100, seed=1234) # Do the sampling (one iteration here = one particle save) for i, sample in enumerate(gen): # print("# Saved {k} particles.".format(k=(i+1))) if self.debug: meminfo = "Particle {0} memory: {1}\n".format(MPI.COMM_WORLD.Get_rank(), memory_usage_psutil()) with open(self.debug_mem_file, "a") as f: f.write(meminfo) else: mpi_sampler.wait(self.model, max_num_levels=numLevels, num_steps=200000, new_level_interval=new_level_interval, num_per_step=numPerSave, thread_steps=100, lam=10, beta=100, seed=1234) return
def fit(self, numLevels, directory=None, numPerSave=1000,numParticles=5,new_level_interval=10000,debug=False ): if directory is None: directory = "./" if not os.access(directory, os.W_OK): raise OSError("Directory {} either does not exist or is not writeable to the fitter...".format(directory)) # mpi = dnest4.MPISampler() sampler = dnest4.DNest4Sampler(self.model, backend=dnest4.backends.CSVBackend(basedir = directory, sep=" ")) # MPISampler=mpi) # Set up the sampler. The first argument is max_num_levels gen = sampler.sample(max_num_levels=numLevels, num_steps=200000, new_level_interval=new_level_interval, num_per_step=numPerSave, thread_steps=100, num_particles=numParticles, lam=10, beta=100, seed=1234) # Set up the sampler. The first argument is max_num_levels # gen = sampler.sample(model=self.model, # max_num_levels=numLevels, # num_steps=-1, # num_per_step=numPerSave, # new_level_interval=new_level_interval, # thread_steps=1, # lam=10, beta=100, seed=1234) # Do the sampling (one iteration here = one particle save) for i, sample in enumerate(gen): print("# Saved {k} particles.".format(k=(i+1)))
def fit(self, numLevels, directory="",numPerSave=1000,numParticles=5 ): """Called by rank 0 of the fit, directly from the top script where the fit manager is instantiated. In general, this is where the master rank will spend all its time, and it will not leave this method until it is killed. """ mpi_sampler = dnest4.MPISampler(debug=self.debug)#comm=manager_comm, debug=False) print(F"Initializing DNest4Sampler from fm fit in {directory}...") sampler = dnest4.DNest4Sampler( self.model, backend=dnest4.backends.CSVBackend(basedir =directory,sep=" "), #MPISampler=mpi_sampler ) print("Setting up DNest4Sampler generator...") # Set up the sampler. The first argument is max_num_levels gen = sampler.sample(max_num_levels=numLevels, num_steps=200000, new_level_interval=10000, num_per_step=numParticles, thread_steps=100, lam=10, beta=100, seed=1234) # gen = sampler.sample(max_num_levels=numLevels, num_steps=200000, new_level_interval=10000, # num_per_step=numPerSave, thread_steps=100, # num_particles=numParticles, lam=10, beta=100, seed=1234) print("Doing the sampling from generator...") # Do the sampling (one iteration here = one particle save) for i, sample in enumerate(gen): print("# Saved {k} particles.".format(k=(i+1)))
def fit(directory): if reinitializeDetector: initializeDetectorAndWaveforms(det.__getstate__(), wfs, reinit=reinitializeDetector, doInterp=doMaxInterp) else: initializeDetectorAndWaveforms(det, wfs, reinit=reinitializeDetector, doInterp=doMaxInterp) initMultiThreading(numThreads) # Create a model object and a sampler model = Model() sampler = dnest4.DNest4Sampler(model, backend=dnest4.backends.CSVBackend( basedir="./" + directory, sep=" ")) # Set up the sampler. The first argument is max_num_levels gen = sampler.sample(max_num_levels=numLevels, num_steps=100000, new_level_interval=25000, num_per_step=1000, thread_steps=100, num_particles=5, lam=10, beta=100, seed=1234) # Do the sampling (one iteration here = one particle save) for i, sample in enumerate(gen): print("# Saved {k} particles.".format(k=(i + 1)))
def fit(argv): initializeDetector(det, ) initializeWaveform(wf, results[wf_idx]['x']) # Create a model object and a sampler model = Model() sampler = dnest4.DNest4Sampler(model, backend=dnest4.backends.CSVBackend(".", sep=" ")) seed = 1234 np.random.seed(seed) # Set up the sampler. The first argument is max_num_levels gen = sampler.sample(max_num_levels=100, num_steps=1000000, new_level_interval=100000, num_per_step=10000, thread_steps=100, num_particles=5, lam=10, beta=100, seed=seed) # Do the sampling (one iteration here = one particle save) for i, sample in enumerate(gen): print("# Saved {k} particles.".format(k=(i + 1))) # Run the postprocessing dnest4.postprocess()
def run_sampler(self): import dnest4 self._set_dnest4_kwargs() backend = self._set_backend() self._verify_kwargs_against_default_kwargs() self._setup_run_directory() self._check_and_load_sampling_time_file() self.start_time = time.time() self.sampler = dnest4.DNest4Sampler(self._dnest4_model, backend=backend) out = self.sampler.sample(self.max_num_levels, num_particles=self.num_particles, **self.dnest4_kwargs) for i, sample in enumerate(out): if self._verbose and ((i + 1) % 100 == 0): stats = self.sampler.postprocess() logger.info("Iteration: {0} log(Z): {1}".format( i + 1, stats['log_Z'])) self._calculate_and_save_sampling_time() self._clean_up_run_directory() stats = self.sampler.postprocess(resample=1) self.result.log_evidence = stats['log_Z'] self._information = stats['H'] self.result.log_evidence_err = np.sqrt(self._information / self.num_particles) if self._backend == 'memory': self._last_live_sample_info = pd.DataFrame( self.sampler.backend.sample_info[-1]) self.result.log_likelihood_evaluations = self._last_live_sample_info[ 'log_likelihood'] self.result.samples = np.array( self.sampler.backend.posterior_samples) else: sample_info_path = './' + self.kwargs[ "outputfiles_basename"] + '/sample_info.txt' sample_info = np.genfromtxt(sample_info_path, comments='#', names=True) self.result.log_likelihood_evaluations = sample_info[ 'log_likelihood'] self.result.samples = np.array( self.sampler.backend.posterior_samples) self.result.sampler_output = out self.result.outputfiles_basename = self.outputfiles_basename self.result.sampling_time = datetime.timedelta( seconds=self.total_sampling_time) self.calc_likelihood_count() return self.result
def fit(directory): # Create a model object and a sampler model = Model() sampler = dnest4.DNest4Sampler(model, backend=dnest4.backends.CSVBackend(basedir ="./" + directory, sep=" ")) # Set up the sampler. The first argument is max_num_levels gen = sampler.sample(max_num_levels=100, num_steps=10000, new_level_interval=10000, num_per_step=1000, thread_steps=100, num_particles=5, lam=10, beta=100, seed=1234) # Do the sampling (one iteration here = one particle save) for i, sample in enumerate(gen): print("# Saved {k} particles.".format(k=(i+1)))
def run(self, verbose=False): """Initiate the DNest4 Nested Sampling run.""" if self.dnest4_backend == 'csv': # for CSVBackend, which is output data to disk backend = dnest4.backends.CSVBackend("./dnest4_run_", sep=" ") else: # for the MemoryBackend, which is output data to memory backend = dnest4.backends.MemoryBackend() sampler = dnest4.DNest4Sampler(self._dnest4_model, backend=backend) output = sampler.sample(self.n_diffusive_levels, num_particles=self.population_size, **self.dnest4_kwargs) self._output = output for i, sample in enumerate(output): if verbose and ((i + 1) % 100 == 0): stats = sampler.postprocess() print("Iteration: {0} log(Z): {1}".format( i + 1, stats['log_Z'])) stats = sampler.postprocess(resample=1) self._log_evidence = stats['log_Z'] self._information = stats['H'] logZ_err = np.sqrt(self._information / self.population_size) self._logZ_err = logZ_err ev_err = np.exp(logZ_err) self._evidence_error = ev_err self._evidence = np.exp(self._log_evidence) # To compute posterior distributions self._samples = np.array(sampler.backend.posterior_samples) # To compute AIC estimate # print(sampler.backend.sample_info) # print(len(sampler.backend.sample_info)) # print(sampler.backend.sample_info[-1]) # print(len(sampler.backend.sample_info[-1])) # print(pd.DataFrame(sampler.backend.sample_info[-1])) print(len(sampler.backend.samples[-1])) print(len(sampler.backend.weights[-1])) # quit() self._last_live_sample = sampler.backend.samples[-1] self._last_live_sample_weights = sampler.backend.weights[-1] self._last_live_sample_info = pd.DataFrame( sampler.backend.sample_info[-1]) return self.log_evidence, self.log_evidence_error
def run(self): """ Executes the inference """ if self.prepare(): # Set up the inference backend = dnest4.backends.CSVBackend(basedir=self.outputdir, sep=" ") dns = dnest4.DNest4Sampler(DNest4_Model(loglike=self.loglike, perturb=self.perturb, prior=self.prior), backend=backend) # Run it out = dns.sample(max_num_levels=self.nlevel, num_steps=self.niter, new_level_interval=self.nlevelint, num_per_step=self.nperstep, lam=self.lam, beta=self.beta) for i, samp in enumerate(out): if self.verb: print(''.join( ['Iteration: ', str(i + 1), '/', str(self.niter)]), end='\r') print('') # Best-fit parameters ibest = np.argmax(backend.sample_info["log_likelihood"]) self.bestp = backend.samples[ibest] # Resample for posterior stats = dns.postprocess(resample=self.resample) self.outp = backend.posterior_samples.T """ stats = dns.postprocess() # Load the weights to properly estimate the posterior #weights = np.loadtxt(os.path.join(self.outputdir, 'weights.txt')) weights = np.squeeze(backend.weights) wsh = weights.shape[0] # Remove cases w/ 0 weight samps = backend.samples samps = samps [weights!=0] weights = weights[weights!=0] # As in MultiNest, resample to equal weights by considering # int(nsamples*weight) repetitions self.outp = [] for i in range(len(weights)): self.outp.extend([samps[i] for j in range(int(wsh * weights[i]))]) self.outp = np.asarray(self.outp).T """ # Quantiles if self.kll is not None: for i in range(self.outp.shape[-1]): self.kll.update(self.model(self.outp[:, i], fullout=True)) # Save posterior and bestfit params if self.fsavefile is not None: np.save(self.fsavefile, self.outp) if self.fbestp is not None: np.save(self.fbestp, self.bestp) else: if self.verb: print("Sampler is not fully prepared to run. " + \ "Correct the above errors and try again.")
Generate from the heavy-tailed distribution. """ a = np.random.randn() b = np.random.rand() t = a/np.sqrt(-np.log(b)) n = np.random.randn() return 10.0**(1.5 - 3*np.abs(t))*n def wrap(self, x, a, b): assert b > a return (x - a)%(b - a) + a # Create a model object and a sampler model = Model() sampler = dnest4.DNest4Sampler(model, backend=dnest4.backends.CSVBackend(".", sep=" ")) # Set up the sampler. The first argument is max_num_levels gen = sampler.sample(max_num_levels=30, num_steps=1000, new_level_interval=10000, num_per_step=10000, thread_steps=100, num_particles=5, lam=10, beta=100, seed=1234) # Do the sampling (one iteration here = one particle save) for i, sample in enumerate(gen): print("# Saved {k} particles.".format(k=(i+1))) # Run the postprocessing dnest4.postprocess()