def get_samples_nde(exp_desc, seed):
"""
Generates MCMC samples for a given NDE experiment.
"""
assert isinstance(exp_desc.inf, ed.NDE_Descriptor)
res_file = os.path.join(root, 'results/seed_'+str(seed), exp_desc.get_dir(), 'mmd')
if os.path.exists(res_file + '.pkl'):
samples = util.io.load(res_file)
else:
exp_dir = os.path.join(root, 'experiments/seed_'+str(seed), exp_desc.get_dir(), '0')
if not os.path.exists(exp_dir):
raise misc.NonExistentExperiment(exp_desc)
net = util.io.load(os.path.join(exp_dir, 'model'))
log_posterior = lambda t: net.eval([t, obs_xs]) + prior.eval(t)
sampler = mcmc.SliceSampler(true_ps, log_posterior, thin=thin)
sampler.gen(burnin, rng=rng) # burn in
samples = sampler.gen(n_mcmc_samples, rng=rng)
util.io.save(samples, res_file)
return samples
def get_samples_snl(exp_desc, seed):
"""
Generates MCMC samples for a given SNL experiment.
"""
assert isinstance(exp_desc.inf, ed.SNL_Descriptor)
res_file = os.path.join(root, 'results/seed_'+str(seed), exp_desc.get_dir(), 'mmd')
if os.path.exists(res_file + '.pkl'):
all_samples = util.io.load(res_file)
else:
exp_dir = os.path.join(root, 'experiments/seed_'+str(seed), exp_desc.get_dir(), '0')
if not os.path.exists(exp_dir):
raise misc.NonExistentExperiment(exp_desc)
_, _, all_nets = util.io.load(os.path.join(exp_dir, 'results'))
all_samples = []
for net in all_nets:
net.reset_theano_functions()
log_posterior = lambda t: net.eval([t, obs_xs]) + prior.eval(t)
sampler = mcmc.SliceSampler(true_ps, log_posterior, thin=thin)
sampler.gen(burnin, rng=rng) # burn in
samples = sampler.gen(n_mcmc_samples, rng=rng)
all_samples.append(samples)
util.io.save(all_samples, res_file)
return all_samples
def _view_snl(self, exp_dir):
"""
Shows the results of learning the likelihood with MCMC.
"""
model_id = self.exp_desc.inf.model.get_id(' ')
train_on = self.exp_desc.inf.train_on
true_ps, obs_xs = util.io.load(os.path.join(exp_dir, 'gt'))
model = util.io.load(os.path.join(exp_dir, 'model'))
all_ps, all_xs, _ = util.io.load(os.path.join(exp_dir, 'results'))
# show distances
all_dist = [np.sqrt(np.sum((xs - obs_xs) ** 2, axis=1)) for xs in all_xs]
fig, ax = plt.subplots(1, 1)
ax.boxplot(all_dist)
ax.set_xlabel('round')
ax.set_title('SNL on {0}, {1}, distances'.format(train_on, model_id))
# show proposed parameters
for i, ps in enumerate(all_ps):
fig = util.plot.plot_hist_marginals(ps, lims=self.sim.get_disp_lims(), gt=true_ps)
fig.suptitle('SNL on {0}, {1}, proposed params round {2}'.format(train_on, model_id, i+1))
# show posterior
n_samples = 1000
prior = self.sim.Prior()
log_posterior = lambda t: model.eval([t, obs_xs]) + prior.eval(t)
sampler = mcmc.SliceSampler(true_ps, log_posterior)
sampler.gen(200, logger=None) # burn in
samples = sampler.gen(n_samples, logger=None)
fig = util.plot.plot_hist_marginals(samples, lims=self.sim.get_disp_lims(), gt=true_ps)
fig.suptitle('SNL on {0}, {1}, posterior samples (slice sampling)'.format(train_on, model_id))
def do_mcmc_inference(rng=np.random):
import inference.mcmc as mcmc
true_ps, obs_xs = get_ground_truth()
prior = Prior()
model = Model()
log_posterior = lambda t: model.eval([t, obs_xs]) + prior.eval(t)
sampler = mcmc.SliceSampler(true_ps, log_posterior)
ps = sampler.gen(10000, show_info=True, rng=rng)
util.plot.plot_hist_marginals(ps, lims=get_disp_lims(), gt=true_ps)
plt.show()
def get_samples_snl(exp_desc, trial, sim, prior_kind):
"""
Generates MCMC samples for a given SNL experiment.
"""
assert isinstance(exp_desc.inf, ed.SNL_Descriptor)
if prior_kind == 'original':
folder = exp_desc.get_dir()
prior = sim.Prior()
elif prior_kind == 'near_truth':
folder = os.path.join(exp_desc.sim, 'other', 'prior_near_truth',
exp_desc.inf.get_dir())
prior = sim.PriorNearTruth()
else:
raise ValueError('unknown prior: {0}'.format(prior_kind))
res_file = os.path.join(root, 'results', folder, str(trial), 'samples')
if os.path.exists(res_file + '.pkl'):
samples = util.io.load(res_file)
else:
exp_dir = os.path.join(root, 'experiments', folder, str(trial))
if not os.path.exists(exp_dir):
raise misc.NonExistentExperiment(exp_desc)
net = util.io.load(os.path.join(exp_dir, 'model'))
true_ps, obs_xs = util.io.load(os.path.join(exp_dir, 'gt'))
if sim is simulators.lotka_volterra:
fs_net = get_failed_sims_model_lv()
log_posterior = lambda t: net.eval([t, obs_xs]) + prior.eval(
t) + np.log(fs_net.eval(t)[0])
else:
log_posterior = lambda t: net.eval([t, obs_xs]) + prior.eval(t)
print 'sampling trial {0}'.format(trial)
sampler = mcmc.SliceSampler(true_ps, log_posterior, thin=thin)
sampler.gen(burnin, rng=rng)
samples = sampler.gen(n_samples, rng=rng)
util.io.save(samples, res_file)
return samples
def _run_synth_lik(self, exp_dir, sample_gt, rng):
"""
Runs gaussian synthetic likelihood.
"""
import inference.mcmc as mcmc
from simulators import gaussian_synthetic_likelihood
inf_desc = self.exp_desc.inf
mcmc_desc = inf_desc.mcmc
prior = self.sim.Prior()
model = self.sim.Model()
stats = self.sim.Stats()
sim_model = lambda ps, rng: stats.calc(model.sim(ps, rng=rng))
true_ps, obs_xs = simulators.sim_data(
prior.gen, sim_model,
rng=rng) if sample_gt else self.sim.get_ground_truth()
log_posterior = lambda ps: gaussian_synthetic_likelihood(
[ps, obs_xs
], sim_model, n_sims=inf_desc.n_sims, rng=rng) + prior.eval(ps)
if isinstance(mcmc_desc, ed.GaussianMetropolisDescriptor):
sampler = mcmc.GaussianMetropolis(true_ps, log_posterior,
mcmc_desc.step)
elif isinstance(mcmc_desc, ed.SliceSamplerDescriptor):
sampler = mcmc.SliceSampler(true_ps, log_posterior)
else:
raise TypeError('unknown MCMC algorithm')
with util.io.Logger(os.path.join(exp_dir, 'out.log')) as logger:
samples = sampler.gen(n_samples=mcmc_desc.n_samples,
logger=logger,
rng=rng)
util.io.save((true_ps, obs_xs), os.path.join(exp_dir, 'gt'))
util.io.save((samples, model.n_sims),
os.path.join(exp_dir, 'results'))
util.io.save_txt(self.exp_desc.pprint(),
os.path.join(exp_dir, 'info.txt'))
def _view_nde(self, exp_dir):
"""
Shows the posterior learnt by the model in NDE.
"""
model_desc = self.exp_desc.inf.model
target = self.exp_desc.inf.target
true_ps, obs_xs = self.sim.get_ground_truth()
model = util.io.load(os.path.join(exp_dir, 'model'))
if target == 'posterior':
if isinstance(model_desc, ed.MDN_Descriptor):
levels = [0.68, 0.95, 0.99]
posterior = model.get_mog(obs_xs)
fig = util.plot.plot_pdf_marginals(posterior, lims=self.sim.get_disp_lims(), gt=true_ps, levels=levels)
elif isinstance(model_desc, ed.MAF_Descriptor):
n_samples = 1000
samples = model.gen(obs_xs, n_samples)
fig = util.plot.plot_hist_marginals(samples, lims=self.sim.get_disp_lims(), gt=true_ps)
else:
raise TypeError('unknown model type')
elif target == 'likelihood':
n_samples = 1000
prior = self.sim.Prior()
log_posterior = lambda t: model.eval([t, obs_xs]) + prior.eval(t)
sampler = mcmc.SliceSampler(true_ps, log_posterior)
sampler.gen(200, logger=None) # burn in
samples = sampler.gen(n_samples, logger=None)
fig = util.plot.plot_hist_marginals(samples, lims=self.sim.get_disp_lims(), gt=true_ps)
else:
raise ValueError('unknown target')
fig.suptitle('NDE, ' + target + ', ' + model_desc.get_id(' '))
def get_true_samples(seed):
"""
Generates MCMC samples from the true posterior.
"""
res_file = os.path.join(root, 'results/seed_'+str(seed), 'gauss', 'true_samples')
if os.path.exists(res_file + '.pkl'):
samples = util.io.load(res_file)
else:
log_posterior = lambda t: model.eval([t, obs_xs]) + prior.eval(t)
sampler = mcmc.SliceSampler(true_ps, log_posterior, thin=thin)
sampler.gen(burnin, rng=rng) # burn in
samples = sampler.gen(n_mcmc_samples, rng=rng)
util.io.save(samples, res_file)
return samples
def learn_likelihood(self,
obs_xs,
model,
n_samples,
n_rounds,
train_on_all=True,
thin=10,
save_models=False,
logger=sys.stdout,
rng=np.random):
"""
:param obs_xs: the observed data
:param model: the model to train
:param n_samples: number of simulated samples per round
:param n_rounds: number of rounds
:param train_on_all: whether to train on all simulated samples or just on the latest batch
:param thin: number of samples to thin the chain
:param logger: logs messages
:param rng: random number generator
:return: the trained model
"""
self.all_ps = []
self.all_xs = []
self.all_models = []
log_posterior = lambda t: model.eval([t, obs_xs]) + self.prior.eval(t)
sampler = mcmc.SliceSampler(self.prior.gen(), log_posterior, thin=thin)
for i in xrange(n_rounds):
logger.write('Learning likelihood, round {0}\n'.format(i + 1))
if i == 0:
# sample from prior in first round
proposal = self.prior
else:
# MCMC sample posterior in every other round
logger.write('burning-in MCMC chain...\n')
sampler.gen(max(200 / thin, 1), logger=logger,
rng=rng) # burn in
logger.write('burning-in done...\n')
proposal = sampler
# run new batch of simulations
logger.write('simulating data... ')
ps, xs = simulators.sim_data(proposal.gen,
self.sim_model,
n_samples,
rng=rng)
logger.write('done\n')
self.all_ps.append(ps)
self.all_xs.append(xs)
if train_on_all:
ps = np.concatenate(self.all_ps)
xs = np.concatenate(self.all_xs)
N = ps.shape[0]
monitor_every = min(10**5 / float(N), 1.0)
# retrain likelihood model
logger.write('training model...\n')
learn_conditional_density(model,
ps,
xs,
monitor_every=monitor_every,
logger=logger,
rng=rng)
logger.write('training done\n')
if save_models:
self.all_models.append(deepcopy(model))
return model
