def test_sample_ball(): p0 = np.ones(10) std = np.ones(10) sample = sampling_util.sample_ball(p0, std, size=10000, dist='normal') mean = np.mean(sample, axis=0) npt.assert_almost_equal(mean, p0, decimal=1) sigma = np.std(sample, axis=0) npt.assert_almost_equal(sigma, std, decimal=1) sample = sampling_util.sample_ball(p0, std, size=10000, dist='uniform') mean = np.mean(sample, axis=0) npt.assert_almost_equal(mean, p0, decimal=1) sigma = np.std(sample, axis=0) npt.assert_almost_equal(sigma, std*0.607, decimal=1)
def mcmc_emcee(self, n_walkers, n_run, n_burn, mean_start, sigma_start, mpi=False, progress=False, threadCount=1): numParam, _ = self.chain.param.num_param() p0 = sampling_util.sample_ball(mean_start, sigma_start, n_walkers) time_start = time.time() if mpi is True: pool = MPIPool() if not pool.is_master(): pool.wait() sys.exit(0) is_master_pool = pool.is_master() sampler = emcee.EnsembleSampler(n_walkers, numParam, self.chain.logL, pool=pool) else: is_master_pool = True if threadCount > 1 : pool = Pool(processes=threadCount) else : pool = None sampler = emcee.EnsembleSampler(n_walkers, numParam, self.chain.likelihood, pool=pool) sampler.run_mcmc(p0, n_burn + n_run, progress=progress) flat_samples = sampler.get_chain(discard=n_burn, thin=1, flat=True) dist = sampler.get_log_prob(flat=True, discard=n_burn, thin=1) if is_master_pool: print('Computing the MCMC...') print('Number of walkers = ', n_walkers) print('Burn-in iterations: ', n_burn) print('Sampling iterations:', n_run) time_end = time.time() print(time_end - time_start, 'time taken for MCMC sampling') return flat_samples, dist
def mcmc_emcee(self, n_walkers, n_run, n_burn, mean_start, sigma_start, mpi=False, progress=False, threadCount=1): """ Run MCMC with emcee. For details, please have a look at the documentation of the emcee packager. :param n_walkers: number of walkers in the emcee process :type n_walkers: integer :param n_run: number of sampling (after burn-in) of the emcee :type n_run: integer :param n_burn: number of burn-in iterations (those will not be saved in the output sample) :type n_burn: integer :param mean_start: mean of the parameter position of the initialising sample :type mean_start: numpy array of length the number of parameters :param sigma_start: spread of the parameter values (uncorrelated in each dimension) of the initialising sample :type sigma_start: numpy array of length the number of parameters :param mpi: if True, initializes an MPIPool to allow for MPI execution of the sampler :type mpi: bool :param progress: if True, prints the progress bar :type progress: bool :param threadCount: number of threats in multi-processing (not applicable for MPI) :type threadCount: integer :return: samples, ln likelihood value of samples :rtype: numpy 2d array, numpy 1d array """ num_param, _ = self.chain.param.num_param() p0 = sampling_util.sample_ball(mean_start, sigma_start, n_walkers) time_start = time.time() pool, is_master = choose_pool(mpi=mpi, processes=threadCount, use_dill=True) sampler = emcee.EnsembleSampler(n_walkers, num_param, self.chain.logL, pool=pool) sampler.run_mcmc(p0, n_burn + n_run, progress=progress) flat_samples = sampler.get_chain(discard=n_burn, thin=1, flat=True) dist = sampler.get_log_prob(flat=True, discard=n_burn, thin=1) if is_master: print('Computing the MCMC...') print('Number of walkers = ', n_walkers) print('Burn-in iterations: ', n_burn) print('Sampling iterations:', n_run) time_end = time.time() print(time_end - time_start, 'time taken for MCMC sampling') return flat_samples, dist
def mcmc_emcee(self, n_walkers, n_burn, n_run, kwargs_mean_start, kwargs_sigma_start, continue_from_backend=False, **kwargs_emcee): """ runs the EMCEE MCMC sampling :param n_walkers: number of walkers :param n_burn: number of iteration of burn in (not stored in the output sample :param n_run: number of iterations (after burn in) to be sampled :param kwargs_mean_start: keyword arguments of the mean starting position :param kwargs_sigma_start: keyword arguments of the spread in the initial particles per parameter :param continue_from_backend: bool, if True and 'backend' in kwargs_emcee, will continue a chain sampling from backend :param kwargs_emcee: keyword argument for the emcee (e.g. to specify backend) :return: samples of the EMCEE run """ num_param = self.param.num_param sampler = emcee.EnsembleSampler(n_walkers, num_param, self.chain.likelihood, args=(), **kwargs_emcee) mean_start = self.param.kwargs2args(**kwargs_mean_start) sigma_start = self.param.kwargs2args(**kwargs_sigma_start) p0 = sampling_util.sample_ball(mean_start, sigma_start, n_walkers) backend = kwargs_emcee.get('backend', None) if backend is not None: if continue_from_backend: p0 = None else: backend.reset(n_walkers, num_param) sampler.run_mcmc(p0, n_burn + n_run, progress=True) flat_samples = sampler.get_chain(discard=n_burn, thin=1, flat=True) log_prob = sampler.get_log_prob(discard=n_burn, thin=1, flat=True) return flat_samples, log_prob
def mcmc_emcee(self, n_walkers, n_run, n_burn, mean_start, sigma_start, mpi=False, progress=False, threadCount=1, initpos=None, backup_filename=None, start_from_backup=False): """ Run MCMC with emcee. For details, please have a look at the documentation of the emcee packager. :param n_walkers: number of walkers in the emcee process :type n_walkers: integer :param n_run: number of sampling (after burn-in) of the emcee :type n_run: integer :param n_burn: number of burn-in iterations (those will not be saved in the output sample) :type n_burn: integer :param mean_start: mean of the parameter position of the initialising sample :type mean_start: numpy array of length the number of parameters :param sigma_start: spread of the parameter values (uncorrelated in each dimension) of the initialising sample :type sigma_start: numpy array of length the number of parameters :param mpi: if True, initializes an MPIPool to allow for MPI execution of the sampler :type mpi: bool :param progress: if True, prints the progress bar :type progress: bool :param threadCount: number of threats in multi-processing (not applicable for MPI) :type threadCount: integer :param initpos: initial walker position to start sampling (optional) :type initpos: numpy array of size num param x num walkser :param backup_filename: name of the HDF5 file where sampling state is saved (through emcee backend engine) :type backup_filename: string :param start_from_backup: if True, start from the state saved in `backup_filename`. Otherwise, create a new backup file with name `backup_filename` (any already existing file is overwritten!). :type start_from_backup: bool :return: samples, ln likelihood value of samples :rtype: numpy 2d array, numpy 1d array """ num_param, _ = self.chain.param.num_param() if initpos is None: initpos = sampling_util.sample_ball(mean_start, sigma_start, n_walkers, dist='normal') pool = choose_pool(mpi=mpi, processes=threadCount, use_dill=True) if backup_filename is not None: backend = emcee.backends.HDFBackend(backup_filename, name="lenstronomy_mcmc_emcee") if pool.is_master(): print("Warning: All samples (including burn-in) will be saved in backup file '{}'.".format(backup_filename)) if start_from_backup: initpos = None n_run_eff = n_run else: n_run_eff = n_burn + n_run backend.reset(n_walkers, num_param) if pool.is_master(): print("Warning: backup file '{}' has been reset!".format(backup_filename)) else: backend = None n_run_eff = n_burn + n_run time_start = time.time() sampler = emcee.EnsembleSampler(n_walkers, num_param, self.chain.logL, pool=pool, backend=backend) sampler.run_mcmc(initpos, n_run_eff, progress=progress) flat_samples = sampler.get_chain(discard=n_burn, thin=1, flat=True) dist = sampler.get_log_prob(flat=True, discard=n_burn, thin=1) if pool.is_master(): print('Computing the MCMC...') print('Number of walkers = ', n_walkers) print('Burn-in iterations: ', n_burn) print('Sampling iterations (in current run):', n_run_eff) time_end = time.time() print(time_end - time_start, 'time taken for MCMC sampling') return flat_samples, dist
def test_raise(self): with self.assertRaises(ValueError): sampling_util.sample_ball(p0=np.ones(10), std=np.ones(10), size=1000, dist='BAD')