def main():
d = 5
ps = rand(d)
ps /= norm(ps)
distribution = Bernoulli(ps)
num_history = 100
Z = distribution.sample(num_history).samples
threshold = 0.8
spread = 0.2
gamma = 0.2
kernel = HypercubeKernel(gamma)
mcmc_sampler = DiscreteKameleon(distribution, kernel, Z, threshold, spread)
start = zeros(distribution.dimension, dtype=numpy.bool8)
mcmc_params = MCMCParams(start=start, num_iterations=1000)
chain = MCMCChain(mcmc_sampler, mcmc_params)
chain.append_mcmc_output(StatisticsOutput(plot_times=True))
chain.append_mcmc_output(DiscretePlottingOutput(plot_from=0, lag=100))
chain.run()
print "ps", ps
print "empirical", mean(chain.samples, 0)
def test_sample_dim(self):
n = 3
d = 2
p = asarray(rand(d))
b = Bernoulli(p)
s = b.sample(n)
self.assertEqual(s.samples.shape, (n, d))
def test_log_pdf_array_dimension(self):
d = 3
n = 2
ps = asarray(rand(d))
b = Bernoulli(ps)
X = randint(0, 2, (n, d)).astype(numpy.bool8)
self.assertEqual(b.log_pdf(X).shape, (n, ))
def test_chain_bernoulli(self):
# runs the sampler on a distribution of infdependent bernoulli variables
# and compares the mean
d = 5
ps = rand(d)
ps /= norm(ps)
distribution = Bernoulli(ps)
num_history = 100
Z = distribution.sample(num_history).samples
threshold = 0.8
spread = 0.2
gamma = 0.2
kernel = HypercubeKernel(gamma)
mcmc_sampler = DiscreteKameleon(distribution, kernel, Z, threshold,
spread)
start = zeros(distribution.dimension, dtype=numpy.bool8)
mcmc_params = MCMCParams(start=start, num_iterations=1000)
chain = MCMCChain(mcmc_sampler, mcmc_params)
chain.run()
self.assertAlmostEqual(norm(mean(chain.samples, 0) - ps), 0, delta=0.2)
def main():
d = 5
ps = rand(d)
ps /= norm(ps)
distribution = Bernoulli(ps)
num_history = 100
Z = distribution.sample(num_history).samples
threshold = 0.8
spread = 0.2
gamma = 0.2
kernel = HypercubeKernel(gamma)
mcmc_sampler = DiscreteKameleon(distribution, kernel, Z, threshold, spread)
start = zeros(distribution.dimension, dtype=numpy.bool8)
mcmc_params = MCMCParams(start=start, num_iterations=1000)
chain = MCMCChain(mcmc_sampler, mcmc_params)
chain.append_mcmc_output(StatisticsOutput(plot_times=True))
chain.append_mcmc_output(DiscretePlottingOutput(plot_from=0, lag=100))
chain.run()
print "ps", ps
print "empirical", mean(chain.samples, 0)
def test_sample_mean_values(self):
n = 10000
d = 3
runs = 100
for _ in range(runs):
ps = asarray(rand(d))
b = Bernoulli(ps)
s = b.sample(n)
for i in range(d):
self.assertAlmostEqual(mean(s.samples[:, i]),
ps[i],
delta=0.05)
def test_contructor_wrong_kernel_type(self):
dimension = 3
ps = rand(dimension)
distribution = Bernoulli(ps)
Z = zeros((2, distribution.dimension))
threshold = 0.5
spread = 0.5
self.assertRaises(TypeError, DiscreteKameleon, distribution, None, Z,
threshold, spread)
def test_contructor_wrong_threshold_type(self):
dimension = 3
ps = rand(dimension)
distribution = Bernoulli(ps)
kernel = HypercubeKernel(1.)
Z = zeros((2, distribution.dimension))
spread = 0.5
self.assertRaises(TypeError, DiscreteKameleon, distribution, kernel, Z,
None, spread)
def test_log_pdf_success_multiple(self):
d = 4
n = 3
num_runs = 100
for _ in range(num_runs):
ps = rand(d)
b = Bernoulli(ps)
X = randint(0, 2, (n, d)).astype(numpy.bool8)
# naive computation of log pdf
expected = zeros((n, d))
for i in range(n):
for j in range(d):
expected[i,
j] = log(ps[j]) if X[i,
j] == 1 else log(1 - ps[j])
self.assertTrue(all(sum(expected, 1) == b.log_pdf(X)))
def test_contructor_wrong_Z_array_dimension_too_large(self):
dimension = 3
ps = rand(dimension)
distribution = Bernoulli(ps)
kernel = HypercubeKernel(1.)
Z = zeros((2, distribution.dimension, 3))
threshold = 0.5
spread = 0.5
self.assertRaises(ValueError, DiscreteKameleon, distribution, kernel,
Z, threshold, spread)
def test_contructor(self):
dimension = 3
ps = rand(dimension)
distribution = Bernoulli(ps)
kernel = HypercubeKernel(1.)
Z = zeros((2, distribution.dimension))
threshold = 0.5
spread = 0.5
sampler = DiscreteKameleon(distribution, kernel, Z, threshold, spread)
self.assertEqual(sampler.distribution, distribution)
self.assertEqual(sampler.kernel, kernel)
self.assertTrue(sampler.Z is Z)
self.assertEqual(sampler.threshold, threshold)
self.assertEqual(sampler.spread, spread)
def test_chain_bernoulli(self):
# runs the sampler on a distribution of infdependent bernoulli variables
# and compares the mean
d = 5
ps = rand(d)
ps /= norm(ps)
distribution = Bernoulli(ps)
num_history = 100
Z = distribution.sample(num_history).samples
threshold = 0.8
spread = 0.2
gamma = 0.2
kernel = HypercubeKernel(gamma)
mcmc_sampler = DiscreteKameleon(distribution, kernel, Z, threshold, spread)
start = zeros(distribution.dimension, dtype=numpy.bool8)
mcmc_params = MCMCParams(start=start, num_iterations=1000)
chain = MCMCChain(mcmc_sampler, mcmc_params)
chain.run()
self.assertAlmostEqual(norm(mean(chain.samples, 0) - ps), 0, delta=0.2)
def test_construct_proposal(self):
dimension = 3
num_history = 4
ps = rand(dimension)
distribution = Bernoulli(ps)
kernel = HypercubeKernel(1.)
Z = randint(0, 2, (num_history, dimension)).astype(numpy.bool8)
threshold = 0.5
spread = 0.5
sampler = DiscreteKameleon(distribution, kernel, Z, threshold, spread)
y = randint(0, 2, dimension).astype(dtype=numpy.bool8)
p = sampler.construct_proposal(y)
self.assertTrue(isinstance(p, DiscreteRandomWalkProposal))
self.assertEqual(p.spread, spread)
def main():
d = 5
ps = rand(d)
ps /= norm(ps)
print "ps", ps
full_target = Bernoulli(ps)
current_state = [0. for _ in range(d)]
distribution = BernoulliFullConditionals(full_target, current_state)
mcmc_sampler = Gibbs(distribution)
mcmc_params = MCMCParams(start=asarray(current_state, dtype=numpy.bool8),
num_iterations=10000)
chain = MCMCChain(mcmc_sampler, mcmc_params)
chain.append_mcmc_output(StatisticsOutput(plot_times=True, lag=1000))
chain.append_mcmc_output(DiscretePlottingOutput(plot_from=0, lag=1000))
chain.run()
print "marginals:", ps
print "estimated:", mean(chain.samples, 0)
def test_adapt_does_nothing(self):
dimension = 3
ps = rand(dimension)
distribution = Bernoulli(ps)
kernel = HypercubeKernel(1.)
Z = zeros((2, distribution.dimension))
threshold = 0.5
spread = .5
sampler = DiscreteKameleon(distribution, kernel, Z, threshold, spread)
# serialise, call adapt, load, compare
f = NamedTemporaryFile()
dump(sampler, f)
f.seek(0)
sampler_copy = load(f)
f.close()
sampler.adapt(None, None)
# rough check for equality, dont do a proper one here
self.assertEqual(type(sampler_copy.kernel), type(sampler.kernel))
self.assertEqual(sampler_copy.kernel.gamma, sampler.kernel.gamma)
self.assertEqual(type(sampler_copy.distribution),
type(sampler.distribution))
self.assertEqual(sampler_copy.distribution.dimension,
sampler.distribution.dimension)
self.assertEqual(type(sampler_copy.Z), type(sampler.Z))
self.assertEqual(sampler_copy.Z.shape, sampler.Z.shape)
self.assertAlmostEqual(norm(sampler_copy.Z - sampler.Z), 0)
self.assertEqual(sampler_copy.spread, sampler.spread)
# this is none, so just compare
self.assertEqual(sampler.Q, sampler_copy.Q)
def test_sample_wrong_n_type_float(self):
p = asarray([0.5])
b = Bernoulli(p)
self.assertRaises(TypeError, b.sample, float(1.))
def test_log_pdf_wrong_type_none(self):
p = asarray([0.5])
b = Bernoulli(p)
self.assertRaises(TypeError, b.log_pdf, None)
def test_log_pdf_wrong_type_float(self):
p = asarray([0.5])
b = Bernoulli(p)
self.assertRaises(TypeError, b.log_pdf, float(1.))
def test_log_pdf_wrong_array_dimension_3(self):
p = asarray([0.5])
b = Bernoulli(p)
self.assertRaises(TypeError, b.log_pdf, zeros(3))
def test_log_pdf_wrong_dimension(self):
p = asarray([0.5])
b = Bernoulli(p)
self.assertRaises(ValueError, b.log_pdf, zeros((1, 2)))
def test_log_pdf_type(self):
p = asarray([0.3])
b = Bernoulli(p)
self.assertEqual(type(b.log_pdf(asarray([[1]], dtype=numpy.bool8))),
numpy.ndarray)
def test_contructor_correct_dim(self):
ps = rand(4)
b = Bernoulli(ps)
self.assertEqual(ps.shape, b.ps.shape)
def test_log_pdf_failure_single(self):
d = 1
ps = asarray(rand(d))
b = Bernoulli(ps)
X = asarray([[0]], dtype=numpy.bool8)
self.assertEqual(b.log_pdf(X), log(1 - ps[0]))
def test_contructor_correct_values(self):
ps = rand(4)
b = Bernoulli(ps)
self.assertTrue(all(ps == b.ps))
def test_sample_wrong_n_sameller_zero(self):
p = asarray([0.5])
b = Bernoulli(p)
self.assertRaises(ValueError, b.sample, -1)
def test_sample_samples_dtype(self):
p = asarray([0.5])
b = Bernoulli(p)
self.assertEqual(b.sample(1).samples.dtype, numpy.bool8)
def test_sample_type(self):
p = asarray([0.5])
b = Bernoulli(p)
self.assertTrue(isinstance(b.sample(1), Sample))
def test_sample_wrong_n_type_none(self):
p = asarray([0.5])
b = Bernoulli(p)
self.assertRaises(TypeError, b.sample, None)
