def sampler_speedometer():
""" Tests average sample speed of different samplers in different configurations
:returns: Just prints info
:rtype: None
"""
gaussian = Gaussian()
np.random.seed(2015)
pot = ProductOfT(ndims=36,nbasis=36)
mjhmc_gauss = MarkovJumpHMC(distribution=gaussian)
mjhmc_gauss_nr = MarkovJumpHMC(distribution=gaussian, resample=False)
control_gauss = ControlHMC(distribution=gaussian)
mjhmc_pot = MarkovJumpHMC(distribution=pot)
mjhmc_pot_nr = MarkovJumpHMC(distribution=pot, resample=False)
control_pot = ControlHMC(distribution=pot)
m_g_r_avg = time_per_sample(mjhmc_gauss)
m_g_nr_avg = time_per_sample(mjhmc_gauss_nr)
c_g_avg = time_per_sample(control_gauss)
m_p_r_avg = time_per_sample(mjhmc_pot)
m_p_nr_avg = time_per_sample(mjhmc_pot_nr)
c_p_avg = time_per_sample(control_pot)
print "Average times per samples..."
print "resampled MJHMC numpy gradient: {}".format(m_g_r_avg)
print "not resampled MJHMC numpy gradient: {}".format(m_g_nr_avg)
print "control HMC numpy gradient: {}".format(c_g_avg)
print "resampled MJHMC theano gradient: {}".format(m_p_r_avg)
print "not resampled MJHMC theano gradient: {}".format(m_p_nr_avg)
print "control HMC theano gradient: {}".format(c_p_avg)
def test_hyperparameter_setting(self):
"""
Checks to see that hyperparameters are properly set
"""
beta = np.random.random()
epsilon = np.random.random() * 5
num_leapfrop_steps = np.random.randint(10)
gauss = Gaussian()
sampler = self.sampler_to_test(distribution=gauss,
beta=beta,
epsilon=epsilon,
num_leapfropg_steps=num_leapfrop_steps)
self.assertTrue(sampler.beta == beta)
self.assertTrue(sampler.epsilon == epsilon)
self.assertTrue(sampler.num_leapfropg_steps == num_leapfrop_steps)
def test_autocorrelation_good_init_half_window(self):
""" Tests that the legacy and fast ac implementations produce identical output
when the sampler is not initialized in a biased manner
(meaning we don't have to worry about variance mismatch)
runs on the half window
:returns: None
:rtype: None
"""
gaussian = Gaussian()
sample_df = sample_to_df(MarkovJumpHMC, gaussian, num_steps=1000)
slow_ac_df = slow_autocorrelation(sample_df, half_window=True)
slow_ac = slow_ac_df.autocorrelation.as_matrix()
fast_ac_df = autocorrelation(sample_df, half_window=True)
fast_ac = fast_ac_df.autocorrelation.as_matrix()
self.assertTrue(np.isclose(slow_ac, fast_ac, atol=TOL).all())
def test_ill_conditioned_gaussian(self):
"""
Checks to see that {} can sample from an ill-conditioned gaussian
""".format(self.sampler_to_test.__name__)
n_samples = 100000
ic_gaussian_2d = Gaussian(ndims=2, log_conditioning=1)
target_cov = np.linalg.inv(ic_gaussian_2d.J)
sampler = self.sampler_to_test(ic_gaussian_2d.Xinit, ic_gaussian_2d.E,
ic_gaussian_2d.dEdX)
sampler.burn_in()
samples = sampler.sample(n_samples)
sample_cov = np.cov(samples)
self.assertTrue(
self.approx_equal(sample_cov, target_cov),
msg=(" samples covariance: \n {} is not within tolerance to "
"target cov: \n {}. \n I am {}").format(
sample_cov, target_cov, self.sampler_to_test.__name__))
def ladder_numerical_err_hist(distr=None, n_steps=int(1e5)):
""" Compute a histogram of the numerical integration error
on the state ladder. Implicitly assumes that such a distribution exists
and is shared by all ladders
Args:
distr: distribution object to run on, make sure n_batch is big
Returns:
energies = {E(L^j \zeta) : j \in {0, ..., k}}^{n_batch}
run_lengths: list of observed ladder sizes
"""
distr = distr or Gaussian(nbatch=1)
sampler = ControlHMC(distribution=distr)
# [[ladder_energies]]
energies = []
run_lengths = []
r_counts = [0]
ladder_energies = [np.squeeze(sampler.state.H())]
run_length = 0
for _ in range(n_steps):
if sampler.r_count == r_counts[-1]:
run_length += 1
ladder_energies.append(np.squeeze(sampler.state.H()))
else:
run_lengths.append(run_length)
run_length = 0
energies.append(np.array(ladder_energies))
ladder_energies = [np.squeeze(sampler.state.H())]
r_counts.append(sampler.r_count)
sampler.sampling_iteration()
centered_energies = []
for ladder_energies in energies:
centered_energies += list(ladder_energies - ladder_energies[0])
return centered_energies, run_lengths
def main(job_id, params):
print "job id: {}, params: {}".format(job_id, params)
return obj_func(ControlHMC, Gaussian(ndims=50, nbatch=50, log_conditioning=1.1),
job_id, **params)
def main(job_id, params):
print "job id: {}, params: {}".format(job_id, params)
return obj_func(MarkovJumpHMC, Gaussian(ndims=10, nbatch=200), job_id, **params)