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
