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