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
