def run(self, train_iters=200, mcmc_steps=5000, bootstrap_iters=1, bootstrap_mcmc_steps=5000, bootstrap_fileroot='', bootstrap_match='', bootstrap_batch_size=5, alpha=0, single_thin=1, ignore_rows=0.3): if alpha == 0.0: alpha = 1 / self.x_dim**0.5 if self.log: self.logger.info('Alpha [%5.4f]' % (alpha)) for t in range(bootstrap_iters): if t == 0: if bootstrap_fileroot: mc = self._read_samples(bootstrap_fileroot, match=bootstrap_match, ignore_rows=ignore_rows) else: mc = self._init_samples( mcmc_steps=bootstrap_mcmc_steps, mcmc_batch_size=bootstrap_batch_size, ignore_rows=ignore_rows) else: samples, likes, scale, nc = self.trainer.sample( loglike=self.loglike, transform=transform, mcmc_steps=bootstrap_mcmc_steps, alpha=alpha, dynamic=False, show_progress=True) samples = transform(samples) self._chain_stats(samples) loglikes = -np.array(likes) weights = np.ones(loglikes.shape) mc = MCSamples(samples=[samples[0]], weights=[weights[0]], loglikes=[loglikes[0]], ignore_rows=ignore_rows) samples = mc.makeSingleSamples(single_thin=single_thin) samples = samples[:, :self.x_dim] mean = np.mean(samples, axis=0) std = np.std(samples, axis=0) samples = (samples - mean) / std self.trainer.train(samples, max_iters=train_iters, noise=-1) def transform(x): return x * std + mean samples, likes, scale, nc = self.trainer.sample( loglike=self.loglike, transform=transform, mcmc_steps=mcmc_steps, alpha=alpha, dynamic=False, show_progress=True, out_chain=os.path.join(self.logs['chains'], 'chain')) samples = transform(samples) self._chain_stats(samples)
def bootstrap( self, mcmc_steps, num_walkers, iters=1, thin=10, stats_interval=10, output_interval=None, initial_jitter=0.01, final_jitter=0.01, init_samples=None, moves=None): """ Args: num_walkers: mcmc_steps: iters: thin: stats_interval: output_interval: initial_jitter: final_jitter: init_samples: moves: Returns: """ def log_prob(x): logl, der = self.loglike(x) return logl + self.prior(x), der if not os.path.isfile(os.path.join(self.log_dir, 'emcee.h5')) and init_samples is None: if self.sample_prior is not None: init_samples = self.sample_prior(num_walkers) else: raise ValueError('Prior does not have sample method') try: import emcee except: raise ImportError if moves is not None: ensemble_moves = [] for k, v in moves.items(): if k.lower() == 'stretch': ensemble_moves.append((emcee.moves.StretchMove(), v)) elif k.lower() == 'kde': ensemble_moves.append((emcee.moves.KDEMove(), v)) elif k.lower() == 'de': ensemble_moves.append((emcee.moves.DEMove(), v)) elif k.lower() == 'snooker': ensemble_moves.append((emcee.moves.DESnookerMove(), v)) else: ensemble_moves = [(emcee.moves.StretchMove(), 1.0)] self.logger.info('Performing initial emcee run with [%d] walkers' % (num_walkers)) sampler = emcee.EnsembleSampler(num_walkers, self.x_dim, log_prob, moves=ensemble_moves, backend=emcee.backends.HDFBackend(os.path.join(self.log_dir, 'emcee.h5'))) state = sampler.run_mcmc(init_samples, mcmc_steps) self.logger.info('Initial acceptance [%5.4f]' % (np.mean(sampler.acceptance_fraction))) self._chain_stats(np.transpose(sampler.get_chain(), axes=[1, 0, 2])) tau = sampler.get_autocorr_time() training_samples = sampler.get_chain(discard=int(2 * np.max(tau)), flat=True, thin=int(0.5 * np.min(tau))) for it in range(1, iters + 1): if iters > 1: jitter = initial_jitter + (it - 1) * (final_jitter - initial_jitter) / (iters - 1) else: jitter = initial_jitter mean = np.mean(training_samples, axis=0) std = np.std(training_samples, axis=0) # Normalise samples training_samples = (training_samples - mean) / std self.transform = lambda x: x * std + mean self.trainer.train(training_samples, jitter=jitter) init_samples = None init_loglikes = None init_derived = None samples, latent_samples, derived_samples, loglikes, ncall = self._ensemble_sample( mcmc_steps, num_walkers, init_samples=init_samples, init_loglikes=init_loglikes, init_derived=init_derived, stats_interval=stats_interval, output_interval=output_interval) # Remember last position and loglikes # init_samples = samples[:, -1, :] # init_loglikes = loglikes[:, -1] # init_derived = derived_samples[:, -1, :] samples = self.transform(samples) self._chain_stats(samples) mc = MCSamples(samples=[samples[i, :, :].squeeze() for i in range(samples.shape[0])], loglikes=[-loglikes[i, :].squeeze() for i in range(loglikes.shape[0])]) training_samples = mc.makeSingleSamples(single_thin=thin) return training_samples