def select_sigma_grid(Z, num_folds=5, num_repetitions=1, log2_sigma_min=-3, log2_sigma_max=10, resolution_sigma=25, lmbda=1., plot_surface=False): sigmas = 2**np.linspace(log2_sigma_min, log2_sigma_max, resolution_sigma) Js = np.zeros(len(sigmas)) for i, sigma in enumerate(sigmas): K = gaussian_kernel(Z, sigma=sigma) folds = xvalidate(Z, num_folds, sigma, lmbda, K) Js[i] = np.mean(folds) logger.info("sigma trial %d/%d, sigma: %.2f, lambda: %.2f, J=%.2f" % \ (i + 1, len(sigmas), sigma, lmbda, Js[i])) if plot_surface: plt.figure() plt.plot(np.log2(sigmas), Js) best_sigma_idx = Js.argmin() best_sigma = sigmas[best_sigma_idx] logger.info("Best sigma: %.2f with J=%.2f" % (best_sigma, Js[best_sigma_idx])) return best_sigma
def set_up(self): logger.info("Generating dataset") old = np.random.get_state() np.random.seed(0) self.data = skew_normal_simulator(self.theta_true) np.random.set_state(old)
def select_sigma_lambda_cma(Z, num_folds=5, num_repetitions=1, sigma0=1.1, lmbda0=1.1, cma_opts={}, disp=False): import cma start = np.log2(np.array([sigma0, lmbda0])) es = cma.CMAEvolutionStrategy(start, 1., cma_opts) while not es.stop(): if disp: es.disp() solutions = es.ask() values = np.zeros(len(solutions)) for i, (log2_sigma, log2_lmbda) in enumerate(solutions): sigma = 2**log2_sigma lmbda = 2**log2_lmbda K = gaussian_kernel(Z, sigma=sigma) folds = xvalidate(Z, num_folds, sigma, lmbda, K) values[i] = np.mean(folds) logger.info("particle %d/%d, sigma: %.2f, lambda: %.2f, J=%.4f" % \ (i + 1, len(solutions), sigma, lmbda, values[i])) es.tell(solutions, values) return es
def update_density_estimate(self): # load or learn parameters if self.learn_parameters: sigma, lmbda = self.determine_sigma_lmbda() else: sigma = self.sigma0 lmbda = self.lmbda0 logger.info("Using sigma: %.2f, lmbda=%.6f" % (sigma, lmbda)) D = self.Z.shape[1] gamma = 0.5 / (sigma**2) omega, u = sample_basis(D, self.m, gamma) logger.info("Estimate density in RKHS, N=%d, m=%d" % (self.N, self.m)) theta = score_matching_sym(self.Z, lmbda, omega, u) # logger.info("Computing objective function") # J = _objective_sym(Z, sigma, lmbda, a, K, b, C) # J_xval = np.mean(xvalidate(Z, 5, sigma, self.lmbda, K)) # logger.info("N=%d, sigma: %.2f, lambda: %.2f, J(a)=%.2f, XJ(a)=%.2f" % \ # (self.N, sigma, self.lmbda, J, J_xval)) dlogq_est = lambda x: log_pdf_estimate_grad( feature_map_grad_single(x, omega, u), theta) return dlogq_est
def select_sigma_scipy(Z, m, num_folds=5, tol=0.2, num_repetitions=3, lmbda=0.0001): D = Z.shape[1] def objective(log2_sigma): sigma = 2**log2_sigma folds = np.zeros(num_repetitions) for i in range(num_repetitions): gamma = 0.5 * (sigma**2) omega, u = sample_basis(D, m, gamma) folds[i] = np.mean( xvalidate(Z, lmbda, omega, u, num_folds, num_repetitions=1)) result = np.mean(folds) logger.info("xvalidation, sigma: %.2f, lambda: %.6f, J=%.3f" % \ (sigma, lmbda, result)) return result result = sp.optimize.minimize_scalar(objective, tol=tol) logger.info("Best sigma: %.2f with value of J=%.3f after %d iterations in %d evaluations" \ % (2 ** result['x'], result['fun'], result['nit'], result['nfev'])) return 2**result['x']
def plot_trajectory_result_necessary_data(fname, accs_at_least=[0.5]): results = result_dict_from_file(fname) fun = lambda x: np.mean(x[:, 1]) Ds, Ns, avg_accept_est = gen_sparse_2d_array_from_dict(results, fun) plt.figure() for acc_at_least in accs_at_least: N_at_least = np.zeros(len(Ds)) for i, D in enumerate(Ds): w = np.where(avg_accept_est[i, :] > acc_at_least)[0] if len(w) > 0: N_at_least[i] = np.min(Ns[w]) logger.info("%.2f acc. for D=%d at N=%d" % (acc_at_least, D, N_at_least[i])) else: logger.info("Did not reach %.2f acc. for D=%d" % (acc_at_least, D)) plt.plot(Ds, N_at_least) plt.yscale('log') # plt.xscale('log') plt.legend(["%.2f acc." % acc_at_least for acc_at_least in accs_at_least], loc="lower right") plt.grid(True) fname_base = fname.split(".")[-2] plt.savefig(fname_base + "_data_needs_kmc.eps", axis_inches='tight')
def set_up(self): # place a gamma on the Eigenvalues of a Gaussian covariance EVs = np.random.gamma(shape=1, size=self.D) # random orthogonal matrix to rotate Q = qmult(np.eye(self.D)) Sigma = Q.T.dot(np.diag(EVs)).dot(Q) # Cholesky of random covariance L = np.linalg.cholesky(Sigma) # target density self.dlogq = lambda x: log_gaussian_pdf( x, Sigma=L, is_cholesky=True, compute_grad=True) self.logq = lambda x: log_gaussian_pdf( x, Sigma=L, is_cholesky=True, compute_grad=False) # starting state self.q_sample = lambda: sample_gaussian( N=1, mu=np.zeros(self.D), Sigma=L, is_cholesky=True)[0] logger.info("N=%d, D=%d" % (self.N, self.D)) self.Z = sample_gaussian(self.N, mu=np.zeros(self.D), Sigma=L, is_cholesky=True)
def store_fire_and_forget_result(self, folder, job_name): fname = folder + os.sep + self.result.job_name + "_" + job_name + ".csv" logger.info("Storing fire and forget result in %s" % fname) with open(fname, 'w+') as f: for s in self.fire_and_forget_result_strings(): f.write(s + " ")
def determine_sigma_lmbda(self): parameter_dir = project_path + os.sep + "xvalidation_parameters" fname = parameter_dir + os.sep + self.get_parameter_fname_suffix( ) + ".npy" # upper bound for doing x-validation if len(self.Z) > self.upper_bound_N: fname.replace("N=%d" % self.D, "N=%d" % self.upper_bound_N) if not os.path.exists(fname) or self.force_relearn_parameters: logger.info("Learning sigma and lmbda") cma_opts = {'tolfun': 0.3, 'maxiter': 10, 'verb_disp': 1} num_threads = 1 if self.force_relearn_parameters else 6 sigma, lmbda = select_sigma_lambda_cma(self.Z, len(self.Z), sigma0=self.sigma, lmbda0=self.lmbda, cma_opts=cma_opts, num_threads=num_threads) if not os.path.exists(parameter_dir): os.makedirs(parameter_dir) with open(fname, 'w+') as f: np.savez_compressed(f, sigma=sigma, lmbda=lmbda) else: logger.info("Loading sigma and lmbda from %s" % fname) with open(fname, 'r') as f: pars = np.load(f) sigma = pars['sigma'] lmbda = pars['lmbda'] return sigma, lmbda
def determine_sigma_lmbda(self): parameter_dir = project_path + os.sep + "xvalidation_parameters" fname = parameter_dir + os.sep + self.get_parameter_fname_suffix( ) + ".npy" if not os.path.exists(fname): logger.info("Learning sigma and lmbda") cma_opts = {'tolfun': 0.3, 'maxiter': 10, 'verb_disp': 1} sigma, lmbda = select_sigma_lambda_cma(self.Z, self.m, sigma0=self.sigma0, lmbda0=self.lmbda0, cma_opts=cma_opts) if not os.path.exists(parameter_dir): os.makedirs(parameter_dir) with open(fname, 'w+') as f: np.savez_compressed(f, sigma=sigma, lmbda=lmbda) else: logger.info("Loading sigma and lmbda from %s" % fname) with open(fname, 'r') as f: pars = np.load(f) sigma = pars['sigma'] lmbda = pars['lmbda'] return sigma, lmbda
def set_up(self): # target density, rough centred laplace distribution, isotropic self.dlogq = lambda x: log_student_pdf(x, self.nu_q, True) self.logq = lambda x: log_student_pdf(x, self.nu_q, False) # starting state self.q_sample = lambda: np.random.standard_t(df=self.nu_q, size=self.D) logger.info("N=%d, D=%d" % (self.N, self.D)) self.Z = np.random.standard_t(df=self.nu_q, size=(self.N, self.D))
def set_up(self): # momentum is fixed so sample all of them here logger.info("Using momentum seed: %d" % self.momentum_seed) np.random.seed(self.momentum_seed) self.hmc_rnd_state = np.random.get_state() # standard leapfrog integrator self.integrator = leapfrog_no_storing MCMCJob.set_up(self)
def set_up(self): # target density self.logq = lambda x: log_banana_pdf(x, self.bananicity, self.V) self.dlogq = lambda x: log_banana_pdf( x, self.bananicity, self.V, compute_grad=True) # starting state self.q_sample = lambda: sample_banana(1, self.D, self.bananicity, self. V)[0] logger.info("N=%d, D=%d" % (self.N, self.D)) self.Z = sample_banana(self.N, self.D, self.bananicity, self.V)
def sigma_objective(log2_sigma, lmbda): sigma = 2**log2_sigma folds = np.zeros(num_repetitions) for i in range(num_repetitions): gamma = 0.5 * (sigma**2) omega, u = sample_basis(D, m, gamma) folds[i] = np.mean( xvalidate(Z, lmbda, omega, u, num_folds, num_repetitions=1)) result = np.mean(folds) logger.info("xvalidation, sigma: %.2f, lambda: %.2f, J=%.3f" % \ (sigma, lmbda, result)) return result
def compute(self): logger.debug("Entering") random_start_state = np.random.get_state() acc_mean, acc_est_mean, log_det, log_det_est, steps_taken, random_start_state = \ self.compute_trajectory(random_start_state) logger.info("Submitting results to aggregator") result = TrajectoryJobResult(self.D, self.N, acc_mean, acc_est_mean, log_det, log_det_est, steps_taken, random_start_state) self.aggregator.submit_result(result) logger.debug("Leaving")
def store_fire_and_forget_result(self, folder, job_name): uni = unicode(uuid.uuid4()) fname = "%s_ground_truth_iterations=%d_%s.pkl" % \ (self.result.job_name, self.result.num_iterations, uni) full_fname = self.path_to_store + fname try: os.makedirs(self.path_to_store) except Exception: pass with open(full_fname, 'w+') as f: logger.info("Storing result under %s" % full_fname) pickle.dump(self.result, f)
def kmc_generator(num_warmup, thin_step): D = 10 step_size_min = 0.01 step_size_max = .1 num_steps_min = 50 num_steps_max = 50 sigma_p = 1. momentum_seed = np.random.randint(time.time()) momentum = IsotropicZeroMeanGaussian(sigma=sigma_p, D=D) abc_target = ABCSkewNormalPosterior(theta_true=np.ones(D) * 10) start = abc_target.theta_true Z = np.load("../ground_truth/benchmark_samples.arr")[:1000] learn_parameters = False force_relearn_parameters = False lmbda = 1. sigma = 2**4 if False and True: sigma = select_sigma_grid(Z) select_sigma_lambda_cma(Z, num_folds=5, num_repetitions=1, sigma0=0.31, lmbda0=1.) exit() logger.info("Using sigma=%.6f" % sigma) job = KMCLiteJob(Z, sigma, lmbda, abc_target, momentum, num_iterations, start, num_steps_min, num_steps_max, step_size_min, step_size_max, momentum_seed, learn_parameters, force_relearn_parameters, statistics, num_warmup, thin_step) # marginal sampler job.recompute_log_pdf = True job.walltime = 60 * 60 # store results in home dir straight away d = os.sep.join(os.path.abspath(__file__).split(os.sep)[:-1]) + os.sep job.aggregator = MCMCJobResultAggregatorStoreHome(d) return job
def lmbda_objective(log2_lmbda, sigma): lmbda = 2**log2_lmbda gamma = 0.5 * (sigma**2) omega, u = sample_basis(D, m, gamma) folds = xvalidate(Z, lmbda, omega, u, num_folds, num_repetitions=num_repetitions) result = np.mean(folds) logger.info("xvalidation, sigma: %.2f, lambda: %.2f, J=%.3f" % \ (sigma, lmbda, result)) return result
def set_up(self): if self.learn_parameters or self.force_relearn_parameters: self.sigma, self.lmbda = self.determine_sigma_lmbda() logger.info("Using sigma=%.2f, lmbda=%.6f" % (self.sigma, self.lmbda)) logger.info("Estimating density in RKHS, N=%d,D=%d" % (len(self.Z), self.D)) alpha = score_matching_sym(self.Z, self.sigma, self.lmbda) # replace target by kernel estimator to simulate trajectories on # but keep original target for computing acceptance probability self.orig_target = self.target self.target = LiteEstimatorGaussian(alpha, self.Z, self.sigma) HMCJob.set_up(self)
def multicore_fun(log2_sigma, log2_lmbda, num_repetitions, num_folds, Z, m): D = Z.shape[1] lmbda = 2**log2_lmbda sigma = 2**log2_sigma gamma = 0.5 * (sigma**2) folds = np.zeros(num_repetitions) for j in range(num_repetitions): logger.debug("xvalidation repetition %d/%d" % (j + 1, num_repetitions)) omega, u = sample_basis(D, m, gamma) folds[j] = np.mean( xvalidate(Z, lmbda, omega, u, num_folds, num_repetitions=1)) result = np.mean(folds) logger.info("cma particle, sigma: %.2f, lambda: %.6f, J=%.4f" % \ (sigma, lmbda, result)) return result
def set_up(self): # load data using kameleon-mcmc code logger.info("Loading data") X, y = GPData.get_glass_data() # normalise and whiten dataset, as done in kameleon-mcmc code logger.info("Whitening data") X -= np.mean(X, 0) L = np.linalg.cholesky(np.cov(X.T)) X = sp.linalg.solve_triangular(L, X.T, lower=True).T # build target, as in kameleon-mcmc code self.gp_posterior = PseudoMarginalHyperparameters(X, y, self.n_importance, self.prior, self.ridge, num_shogun_threads=1)
def set_up(self): L = np.linalg.cholesky(np.eye(self.D) * self.sigma_q) # target density self.dlogq = lambda x: log_gaussian_pdf( x, Sigma=L, is_cholesky=True, compute_grad=True) self.logq = lambda x: log_gaussian_pdf( x, Sigma=L, is_cholesky=True, compute_grad=False) # starting state self.q_sample = lambda: sample_gaussian( N=1, mu=np.zeros(self.D), Sigma=L, is_cholesky=True)[0] logger.info("N=%d, D=%d" % (self.N, self.D)) self.Z = sample_gaussian(self.N, mu=np.zeros(self.D), Sigma=L, is_cholesky=True)
def select_sigma_grid(Z, m, num_folds=5, num_repetitions=3, log2_sigma_min=-3, log2_sigma_max=10, resolution_sigma=25, lmbda=0.0001, plot_surface=False): D = Z.shape[1] sigmas = 2**np.linspace(log2_sigma_min, log2_sigma_max, resolution_sigma) Js = np.zeros(len(sigmas)) for i, sigma in enumerate(sigmas): gamma = 0.5 * (sigma**2) folds = np.zeros(num_repetitions) for j in range(num_repetitions): # re-sample basis every repetition omega, u = sample_basis(D, m, gamma) folds[j] = xvalidate(Z, lmbda, omega, u, n_folds=num_folds, num_repetitions=1) Js[i] = np.mean(folds) logger.info("fold %d/%d, sigma: %.2f, lambda: %.2f, J=%.3f" % \ (i + 1, len(sigmas), sigma, lmbda, Js[i])) # if plot_surface: # plt.figure() # plt.plot(np.log2(sigmas), Js) return sigmas[Js.argmin()]
def kameleon_generator(num_warmup, thin_step): start = np.random.randn(9) * 0 # this is tuned via median heuristic Z = np.load("../ground_truth/benchmark_samples.arr")[:1000] sigma = GaussianKernel.get_sigma_median_heuristic(Z) sigma = 23. # kameleon-mcmc code logger.info("Using sigma=%.6f" % sigma) gamma2 = 0.2 nu2 = .02 target = GlassPosterior() job = KameleonJob(Z, sigma, nu2, gamma2, target, num_iterations, start, statistics, num_warmup, thin_step) job.walltime = 60 * 60 # store results in home dir straight away d = os.sep.join(os.path.abspath(__file__).split(os.sep)[:-1]) + os.sep job.aggregator = MCMCJobResultAggregatorStoreHome(d) return job
def set_up(self): if self.learn_parameters or self.force_relearn_parameters: self.sigma, self.lmbda = self.determine_sigma_lmbda() logger.info("Using sigma=%.2f, lmbda=%.6f" % (self.sigma, self.lmbda)) gamma = 0.5 * (self.sigma**2) logger.info("Sampling random basis") omega, u = sample_basis(self.D, self.m, gamma) logger.info("Estimating density in RKHS, N=%d, m=%d, D=%d" % (len(self.Z), self.m, self.D)) theta = score_matching_sym(self.Z, self.lmbda, omega, u) # replace target by kernel estimator to simulate trajectories on # but keep original target for computing acceptance probability self.orig_target = self.target self.target = RandomFeatsEstimator(theta, omega, u) HMCJob.set_up(self) # plot density estimate if self.plot: import matplotlib.pyplot as plt from scripts.tools.plotting import evaluate_density_grid, evaluate_gradient_grid, plot_array Xs = np.linspace(-15, 15) Ys = np.linspace(-7, 3) Xs_grad = np.linspace(-40, 40, 40) Ys_grad = np.linspace(-15, 25, 40) G = evaluate_density_grid(Xs, Ys, self.target.log_pdf) G_norm, quiver_U, quiver_V, _, _ = evaluate_gradient_grid( Xs_grad, Ys_grad, self.target.grad) plt.subplot(211) plt.plot(self.Z[:, 0], self.Z[:, 1], 'bx') plot_array(Xs, Ys, np.exp(G), plot_contour=True) plt.subplot(212) plot_array(Xs_grad, Ys_grad, G_norm, plot_contour=True) plt.quiver(Xs_grad, Ys_grad, quiver_U, quiver_V, color='m') plt.ioff() plt.show()
def compute_trajectory(self, random_start_state=None): logger.debug("Entering") if random_start_state is not None: np.random.set_state(random_start_state) else: random_start_state = np.random.get_state() # momentum L_p = np.linalg.cholesky(np.eye(self.D) * self.sigma_p) self.logp = lambda x: log_gaussian_pdf( x, Sigma=L_p, compute_grad=False, is_cholesky=True) self.dlogp = lambda x: log_gaussian_pdf( x, Sigma=L_p, compute_grad=True, is_cholesky=True) self.p_sample = lambda: sample_gaussian( N=1, mu=np.zeros(self.D), Sigma=L_p, is_cholesky=True)[0] self.p_sample = lambda: sample_gaussian( N=1, mu=np.zeros(self.D), Sigma=L_p, is_cholesky=True)[0] # set up target and momentum densities and gradients self.set_up() logger.info("Learning kernel bandwidth") sigma = select_sigma_grid(self.Z, lmbda=self.lmbda, log2_sigma_max=15) logger.info("Using lmbda=%.2f, sigma: %.2f" % (self.lmbda, sigma)) logger.info("Computing kernel matrix") K = gaussian_kernel(self.Z, sigma=sigma) logger.info("Estimate density in RKHS") b = _compute_b_sym(self.Z, K, sigma) C = _compute_C_sym(self.Z, K, sigma) a = score_matching_sym(self.Z, sigma, self.lmbda, K, b, C) # logger.info("Computing objective function") # J = _objective_sym(Z, sigma, self.lmbda, a, K, b, C) # J_xval = np.mean(xvalidate(Z, 5, sigma, self.lmbda, K)) # logger.info("N=%d, sigma: %.2f, lambda: %.2f, J(a)=%.2f, XJ(a)=%.2f" % \ # (self.N, sigma, self.lmbda, J, J_xval)) kernel_grad = lambda x, X=None: gaussian_kernel_grad(x, X, sigma) dlogq_est = lambda x: log_pdf_estimate_grad(x, a, self.Z, kernel_grad) logger.info("Simulating trajectory for L=%d steps of size %.2f" % \ (self.num_steps, self.step_size)) # starting state p0 = self.p_sample() q0 = self.q_sample() Qs, Ps = leapfrog(q0, self.dlogq, p0, self.dlogp, self.step_size, self.num_steps, self.max_steps) # run second integrator for same amount of steps steps_taken = len(Qs) logger.info("%d steps taken" % steps_taken) Qs_est, Ps_est = leapfrog(q0, dlogq_est, p0, self.dlogp, self.step_size, steps_taken) logger.info("Computing average acceptance probabilities") log_acc = compute_log_accept_pr(q0, p0, Qs, Ps, self.logq, self.logp) log_acc_est = compute_log_accept_pr(q0, p0, Qs_est, Ps_est, self.logq, self.logp) acc_mean = np.mean(np.exp(log_acc)) acc_est_mean = np.mean(np.exp(log_acc_est)) logger.info("Computing average volumes") log_det = compute_log_det_trajectory(Qs, Ps) log_det_est = compute_log_det_trajectory(Qs_est, Ps_est) logger.info("Average acceptance prob: %.2f, %.2f" % (acc_mean, acc_est_mean)) logger.info("Log-determinant: %.2f, %.2f" % (log_det, log_det_est)) logger.debug("Leaving") return acc_mean, acc_est_mean, log_det, log_det_est, steps_taken, random_start_state
folder = os.sep + os.sep.join(["nfs", "data3", "ucabhst", modulename]) batch_parameters = BatchClusterParameters( foldername=folder, resubmit_on_timeout=False, parameter_prefix=johns_slurm_hack) engine = SlurmComputationEngine(batch_parameters, check_interval=1, do_clean_up=True) engine.max_jobs_in_queue = 1000 engine.store_fire_and_forget = True aggs = [] for i in range(num_repetitions): job = rw_generator_isotropic(num_warmup, thin_step) logger.info("Repetition %d/%d, %s" % (i + 1, num_repetitions, job.get_parameter_fname_suffix())) aggs += [engine.submit_job(job)] engine.wait_for_all() for i, agg in enumerate(aggs): agg.finalize() result = agg.get_final_result() agg.clean_up() if isinstance(engine, SerialComputationEngine): plot_mcmc_result(result, D1=0, D2=1) agg.store_fire_and_forget_result(folder="", job_name="") # print some summary stats accepted = result.accepted
nu = 1. # degrees of freedom dlogq = lambda x: log_student_pdf(x, nu, True) logq = lambda x: log_student_pdf(x, nu, False) # estimate density in rkhs N = 800 mu = np.zeros(D) Z = np.random.standard_t(df=nu, size=(N, D)) lmbda = 0.0001 sigma = 0.5 gamma = 0.5 * (sigma**2) m = N omega = gamma * np.random.randn(D, m) u = np.random.uniform(0, 2 * np.pi, m) logger.info("Estimating density") theta = score_matching_sym(Z, lmbda, omega, u) logq_est = lambda x: log_pdf_estimate(feature_map(x, omega, u), theta) dlogq_est = lambda x: log_pdf_estimate_grad( feature_map_grad_single(x, omega, u), theta) # momentum Sigma_p = np.eye(D) L_p = np.linalg.cholesky(Sigma_p) logp = lambda x: log_gaussian_pdf( x, Sigma=L_p, compute_grad=False, is_cholesky=True) dlogp = lambda x: log_gaussian_pdf( x, Sigma=L_p, compute_grad=True, is_cholesky=True) p_sample = lambda: sample_gaussian( N=1, mu=np.zeros(D), Sigma=L_p, is_cholesky=True)[0]
import matplotlib.pyplot as plt import numpy as np from scripts.experiments.mcmc.independent_job_classes.debug import plot_mcmc_result if __name__ == "__main__": logger.setLevel(10) thin = 300 warmup = 1000 samples = [] fnames = glob('RW_D=10_ground_truth_iterations=3000_*.pkl') for fname in fnames: logger.info("%s" % fname) with open(fname) as f: result = pickle.load(f) # print some summary stats accepted = result.accepted avg_ess = result.posterior_statistics["avg_ess"] min_ess = result.posterior_statistics["min_ess"] time = result.time_taken_sampling time_set_up = result.time_taken_set_up logger.info("Average acceptance probability: %.2f" % np.mean(accepted)) logger.info("Average ESS: %.2f" % avg_ess) logger.info("Minimum ESS: %.2f" % min_ess) logger.info("Total time: %.2f" % (time + time_set_up)) logger.info("Average ESS/s: %.2f" % (avg_ess / (time + time_set_up)))
def compute_trajectory(self, random_start_state=None): logger.debug("Entering") if random_start_state is not None: np.random.set_state(random_start_state) else: random_start_state = np.random.get_state() # momentum L_p = np.linalg.cholesky(np.eye(self.D) * self.sigma_p) self.logp = lambda x: log_gaussian_pdf( x, Sigma=L_p, compute_grad=False, is_cholesky=True) self.dlogp = lambda x: log_gaussian_pdf( x, Sigma=L_p, compute_grad=True, is_cholesky=True) self.p_sample = lambda: sample_gaussian( N=1, mu=np.zeros(self.D), Sigma=L_p, is_cholesky=True)[0] # set up target and momentum densities and gradients self.set_up() dlogq_est = self.update_density_estimate() # random number of steps? if self.max_steps is not None: steps = np.random.randint(self.num_steps, self.max_steps + 1) else: steps = self.num_steps logger.info("Simulating trajectory for at least L=%d steps of size %.2f" % \ (self.num_steps, self.step_size)) # starting state p0 = self.p_sample() q0 = self.q_sample() Qs, Ps = leapfrog(q0, self.dlogq, p0, self.dlogp, self.step_size, steps) # run second integrator for same amount of steps steps_taken = len(Qs) Qs_est, Ps_est = leapfrog(q0, dlogq_est, p0, self.dlogp, self.step_size, steps_taken) logger.info("%d steps taken" % steps_taken) logger.info("Computing average acceptance probabilities") log_acc = compute_log_accept_pr(q0, p0, Qs, Ps, self.logq, self.logp) log_acc_est = compute_log_accept_pr(q0, p0, Qs_est, Ps_est, self.logq, self.logp) acc_mean = np.mean(np.exp(log_acc)) acc_est_mean = np.mean(np.exp(log_acc_est)) idx09 = int(len(log_acc) * 0.9) acc_mean10 = np.mean(np.exp(log_acc[idx09:])) acc_est_mean10 = np.mean(np.exp(log_acc_est[idx09:])) logger.info("Computing average volumes") log_det = compute_log_det_trajectory(Qs, Ps) log_det_est = compute_log_det_trajectory(Qs_est, Ps_est) logger.info("Average acceptance prob: %.2f, %.2f" % (acc_mean, acc_est_mean)) logger.info("Average acceptance prob (last 10 percent): %.2f, %.2f" % (acc_mean10, acc_est_mean10)) logger.info("Log-determinant: %.2f, %.2f" % (log_det, log_det_est)) logger.debug("Leaving") return acc_mean, acc_est_mean, log_det, log_det_est, steps_taken, random_start_state