def __init__(self, sigma, scale):
"""
sigma - kernel width
scale - kernel scalling
"""
Covariance.__init__(self)
self.kernel = GaussianKernel(sigma)
self.scale = scale
def main():
# define the MCMC target distribution
# possible distributions are in kameleon_mcmc.distribution: Banana, Flower, Ring
# distribution = Banana(dimension=2, bananicity=0.03, V=100.0)
distribution = Ring()
# create instance of kameleon sampler that learns the length scale
# can be replaced by any other sampler in kameleon_mcmc.mcmc.samplers
kernel = GaussianKernel(sigma=5)
mcmc_sampler = KameleonWindowLearnScale(distribution, kernel, stop_adapt=inf, nu2=0.05)
# mcmc chain and its parameters
start = asarray([0,-3])
mcmc_params = MCMCParams(start=start, num_iterations=30000)
chain = MCMCChain(mcmc_sampler, mcmc_params)
# plot every iteration and print some statistics
chain.append_mcmc_output(PlottingOutput(distribution, plot_from=2000))
chain.append_mcmc_output(StatisticsOutput())
# run cmcm
chain.run()
# print empirical quantiles
burnin=10000
print distribution.emp_quantiles(chain.samples[burnin:])
Visualise.visualise_distribution(distribution, chain.samples)
def main():
distribution = Banana()
# distribution = Flower(amplitude=6, frequency=6, variance=1, radius=10, dimension=8)
# Visualise.visualise_distribution(distribution)
show()
#
sigma = 5
print "using sigma", sigma
kernel = GaussianKernel(sigma=sigma)
mcmc_sampler = KameleonWindowLearnScale(distribution,
kernel,
stop_adapt=inf)
start = asarray([0, -5.])
mcmc_params = MCMCParams(start=start, num_iterations=30000)
chain = MCMCChain(mcmc_sampler, mcmc_params)
chain.append_mcmc_output(
PlottingOutput(distribution,
plot_from=3000,
colour_by_likelihood=False,
num_samples_plot=0))
chain.append_mcmc_output(StatisticsOutput(plot_times=False))
chain.run()
print distribution.emp_quantiles(chain.samples[10000:])
class SquaredExponentialCovariance(Covariance):
def __init__(self, sigma, scale):
"""
sigma - kernel width
scale - kernel scalling
"""
Covariance.__init__(self)
self.kernel=GaussianKernel(sigma);
self.scale=scale
def compute(self, X, Y=None):
return (self.scale**2)*self.kernel.kernel(X, Y)
@abstractmethod
def gen_num_hyperparameters(self):
return 2
@abstractmethod
def get_hyperparameters(self):
return array([self.sigma, self.scale])
@abstractmethod
def set_hyperparameters(self, theta):
assert(len(shape(theta))==1)
assert(len(theta)==2)
self.kernel.sigma=theta[0]
self.kernel.scale=theta[1]
class SquaredExponentialCovariance(Covariance):
def __init__(self, sigma, scale):
"""
sigma - kernel width
scale - kernel scalling
"""
Covariance.__init__(self)
self.kernel = GaussianKernel(sigma)
self.scale = scale
def compute(self, X, Y=None):
return (self.scale**2) * self.kernel.kernel(X, Y)
@abstractmethod
def gen_num_hyperparameters(self):
return 2
@abstractmethod
def get_hyperparameters(self):
return array([self.sigma, self.scale])
@abstractmethod
def set_hyperparameters(self, theta):
assert (len(shape(theta)) == 1)
assert (len(theta) == 2)
self.kernel.sigma = theta[0]
self.kernel.scale = theta[1]
def __init__(self, sigma, scale):
"""
sigma - kernel width
scale - kernel scalling
"""
Covariance.__init__(self)
self.kernel=GaussianKernel(sigma);
self.scale=scale
def main():
distribution = Banana(dimension=8)
sigma = 5
print "using sigma", sigma
kernel = GaussianKernel(sigma=sigma)
mcmc_sampler = Kameleon(distribution, kernel,
distribution.sample(100).samples)
start = zeros(distribution.dimension)
mcmc_params = MCMCParams(start=start, num_iterations=20000)
chain = MCMCChain(mcmc_sampler, mcmc_params)
chain.append_mcmc_output(StatisticsOutput(plot_times=True))
chain.run()
def main():
distribution = Banana(dimension=8, bananicity=0.1, V=100.0)
sigma = 5
print "using sigma", sigma
kernel = GaussianKernel(sigma=sigma)
mcmc_sampler = KameleonWindow(distribution, kernel)
start = zeros(distribution.dimension)
mcmc_params = MCMCParams(start=start, num_iterations=80000)
chain = MCMCChain(mcmc_sampler, mcmc_params)
# chain.append_mcmc_output(PlottingOutput(distribution, plot_from=3000))
chain.append_mcmc_output(StatisticsOutput(plot_times=True))
chain.run()
print distribution.emp_quantiles(chain.samples)
def all_tests(gaussian1, gaussian2, n=200):
oracle_samples1 = gaussian1.sample(n=n).samples
oracle_samples2 = gaussian2.sample(n=n).samples
distribution1 = GaussianFullConditionals(gaussian1, list(gaussian1.mu))
distribution2 = GaussianFullConditionals(gaussian2, list(gaussian2.mu))
mcmc_sampler1 = Gibbs(distribution1)
mcmc_sampler2 = Gibbs(distribution2)
start = zeros(2)
mcmc_params = MCMCParams(start=start, num_iterations=2000 + n, burnin=2000)
chain1 = MCMCChain(mcmc_sampler1, mcmc_params)
chain1.run()
gibbs_samples1 = chain1.get_samples_after_burnin()
chain2 = MCMCChain(mcmc_sampler2, mcmc_params)
chain2.run()
gibbs_samples2 = chain2.get_samples_after_burnin()
sigma = GaussianKernel.get_sigma_median_heuristic(concatenate((oracle_samples1, oracle_samples2), axis=0))
kernel = GaussianKernel(sigma=sigma)
vanillap = empty((2, 2))
blockp = empty((2, 2))
wildp = empty((2, 2))
vanillap[0, 0] = kernel.TwoSampleTest(oracle_samples1, oracle_samples2, method="vanilla")
vanillap[0, 1] = kernel.TwoSampleTest(oracle_samples1, gibbs_samples2, method="vanilla")
vanillap[1, 0] = kernel.TwoSampleTest(gibbs_samples1, oracle_samples2, method="vanilla")
vanillap[1, 1] = kernel.TwoSampleTest(gibbs_samples1, gibbs_samples2, method="vanilla")
blockp[0, 0] = kernel.TwoSampleTest(oracle_samples1, oracle_samples2, method="block")
blockp[0, 1] = kernel.TwoSampleTest(oracle_samples1, gibbs_samples2, method="block")
blockp[1, 0] = kernel.TwoSampleTest(gibbs_samples1, oracle_samples2, method="block")
blockp[1, 1] = kernel.TwoSampleTest(gibbs_samples1, gibbs_samples2, method="block")
wildp[0, 0] = kernel.TwoSampleTest(oracle_samples1, oracle_samples2, method="wild")
wildp[0, 1] = kernel.TwoSampleTest(oracle_samples1, gibbs_samples2, method="wild")
wildp[1, 0] = kernel.TwoSampleTest(gibbs_samples1, oracle_samples2, method="wild")
wildp[1, 1] = kernel.TwoSampleTest(gibbs_samples1, gibbs_samples2, method="wild")
return vanillap, blockp, wildp
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 __init__(self, distribution, n=200, kernel=GaussianKernel(3), nu2=0.1, \
gamma=0.1, ell=15, nXs=100, nYs=100):
self.kernel = kernel
self.distribution = distribution
self.nu2 = nu2
self.gamma = gamma
self.ell = ell
# fix some samples
self.Z = self.distribution.sample(n).samples
# evaluate and center kernel and scale
self.K = self.kernel.kernel(self.Z, None)
self.K = Kernel.center_kernel_matrix(self.K)
# sample beta
self.rkhs_gaussian = Gaussian(mu=zeros(len(self.Z)), Sigma=self.K, is_cholesky=False, \
ell=self.ell)
self.beta = self.rkhs_gaussian.sample().samples
# plotting resolution
[(xmin, xmax), (ymin, ymax)] = self.distribution.get_plotting_bounds()
self.Xs = linspace(xmin, xmax, nXs)
self.Ys = linspace(ymin, ymax, nYs)
def main():
numTrials = 500
n = 200
Sigma1 = eye(2)
Sigma1[0, 0] = 30.0
Sigma1[1, 1] = 1.0
theta = -pi / 4
U = MatrixTools.rotation_matrix(theta)
Sigma1 = U.T.dot(Sigma1).dot(U)
print Sigma1
gaussian1 = Gaussian(Sigma=Sigma1)
gaussian2 = Gaussian(mu=array([1., 0.]), Sigma=Sigma1)
oracle_samples1 = gaussian1.sample(n=n).samples
oracle_samples2 = gaussian2.sample(n=n).samples
print 'mean1:', mean(oracle_samples1, 0)
print 'mean2:', mean(oracle_samples2, 0)
plot(oracle_samples1[:, 0], oracle_samples1[:, 1], 'b*')
plot(oracle_samples2[:, 0], oracle_samples2[:, 1], 'r*')
show()
distribution1 = GaussianFullConditionals(gaussian1, list(gaussian1.mu))
distribution2 = GaussianFullConditionals(gaussian2, list(gaussian2.mu))
H0_samples = zeros(numTrials)
HA_samples = zeros(numTrials)
mcmc_sampler1 = Gibbs(distribution1)
mcmc_sampler2 = Gibbs(distribution2)
burnin = 9000
thin = 5
start = zeros(2)
mcmc_params = MCMCParams(start=start,
num_iterations=burnin + thin * n,
burnin=burnin)
sigma = GaussianKernel.get_sigma_median_heuristic(
concatenate((oracle_samples1, oracle_samples2), axis=0))
print 'using bandwidth: ', sigma
kernel = GaussianKernel(sigma=sigma)
for ii in arange(numTrials):
start = time.time()
print 'trial:', ii
oracle_samples1 = gaussian1.sample(n=n).samples
oracle_samples1a = gaussian1.sample(n=n).samples
oracle_samples2 = gaussian2.sample(n=n).samples
# chain1 = MCMCChain(mcmc_sampler1, mcmc_params)
# chain1.run()
# gibbs_samples1 = chain1.get_samples_after_burnin()
# gibbs_samples1 = gibbs_samples1[thin*arange(n)]
#
# chain1a = MCMCChain(mcmc_sampler1, mcmc_params)
# chain1a.run()
# gibbs_samples1a = chain1a.get_samples_after_burnin()
# gibbs_samples1a = gibbs_samples1a[thin*arange(n)]
#
# chain2 = MCMCChain(mcmc_sampler2, mcmc_params)
# chain2.run()
# gibbs_samples2 = chain2.get_samples_after_burnin()
# gibbs_samples2 = gibbs_samples2[thin*arange(n)]
# H0_samples[ii]=kernel.estimateMMD(gibbs_samples1,gibbs_samples1a)
# HA_samples[ii]=kernel.estimateMMD(gibbs_samples1,gibbs_samples2)
#
H0_samples[ii] = kernel.estimateMMD(oracle_samples1, oracle_samples1a)
HA_samples[ii] = kernel.estimateMMD(oracle_samples1, oracle_samples2)
end = time.time()
print 'time elapsed: ', end - start
f = open("/home/dino/git/mmdIIDTrueSamples.dat", "w")
dump(H0_samples, f)
dump(HA_samples, f)
dump(gaussian1, f)
dump(gaussian2, f)
f.close()
return None
def main():
numTrials = 500
n=200
Sigma1 = eye(2)
Sigma1[0, 0] = 30.0
Sigma1[1, 1] = 1.0
theta = - pi / 4
U = MatrixTools.rotation_matrix(theta)
Sigma1 = U.T.dot(Sigma1).dot(U)
print Sigma1
gaussian1 = Gaussian(Sigma=Sigma1)
gaussian2 = Gaussian(mu=array([1., 0.]), Sigma=Sigma1)
oracle_samples1 = gaussian1.sample(n=n).samples
oracle_samples2 = gaussian2.sample(n=n).samples
print 'mean1:', mean(oracle_samples1,0)
print 'mean2:', mean(oracle_samples2,0)
plot(oracle_samples1[:,0],oracle_samples1[:,1],'b*')
plot(oracle_samples2[:,0],oracle_samples2[:,1],'r*')
show()
distribution1 = GaussianFullConditionals(gaussian1, list(gaussian1.mu))
distribution2 = GaussianFullConditionals(gaussian2, list(gaussian2.mu))
H0_samples = zeros(numTrials)
HA_samples = zeros(numTrials)
mcmc_sampler1 = Gibbs(distribution1)
mcmc_sampler2 = Gibbs(distribution2)
burnin = 9000
thin = 5
start = zeros(2)
mcmc_params = MCMCParams(start=start, num_iterations=burnin+thin*n, burnin=burnin)
sigma = GaussianKernel.get_sigma_median_heuristic(concatenate((oracle_samples1,oracle_samples2),axis=0))
print 'using bandwidth: ', sigma
kernel = GaussianKernel(sigma=sigma)
for ii in arange(numTrials):
start =time.time()
print 'trial:', ii
oracle_samples1 = gaussian1.sample(n=n).samples
oracle_samples1a = gaussian1.sample(n=n).samples
oracle_samples2 = gaussian2.sample(n=n).samples
# chain1 = MCMCChain(mcmc_sampler1, mcmc_params)
# chain1.run()
# gibbs_samples1 = chain1.get_samples_after_burnin()
# gibbs_samples1 = gibbs_samples1[thin*arange(n)]
#
# chain1a = MCMCChain(mcmc_sampler1, mcmc_params)
# chain1a.run()
# gibbs_samples1a = chain1a.get_samples_after_burnin()
# gibbs_samples1a = gibbs_samples1a[thin*arange(n)]
#
# chain2 = MCMCChain(mcmc_sampler2, mcmc_params)
# chain2.run()
# gibbs_samples2 = chain2.get_samples_after_burnin()
# gibbs_samples2 = gibbs_samples2[thin*arange(n)]
# H0_samples[ii]=kernel.estimateMMD(gibbs_samples1,gibbs_samples1a)
# HA_samples[ii]=kernel.estimateMMD(gibbs_samples1,gibbs_samples2)
#
H0_samples[ii]=kernel.estimateMMD(oracle_samples1,oracle_samples1a)
HA_samples[ii]=kernel.estimateMMD(oracle_samples1,oracle_samples2)
end=time.time()
print 'time elapsed: ', end-start
f = open("/home/dino/git/mmdIIDTrueSamples.dat", "w")
dump(H0_samples, f)
dump(HA_samples, f)
dump(gaussian1, f)
dump(gaussian2, f)
f.close()
return None
AdaptiveMetropolisLearnScale
from kameleon_mcmc.mcmc.samplers.KameleonWindowLearnScale import \
KameleonWindowLearnScale
from kameleon_mcmc.mcmc.samplers.StandardMetropolis import StandardMetropolis
if __name__ == '__main__':
experiment_dir = str(os.path.abspath(sys.argv[0])).split(
os.sep)[-1].split(".")[0] + os.sep
distribution = Flower(amplitude=6,
frequency=6,
variance=1,
radius=10,
dimension=8)
sigma = 5
kernel = GaussianKernel(sigma=sigma)
burnin = 60000
num_iterations = 120000
#mcmc_sampler = KameleonWindowLearnScale(distribution, kernel, stop_adapt=burnin)
mean_est = zeros(distribution.dimension, dtype="float64")
cov_est = 1.0 * eye(distribution.dimension)
#mcmc_sampler = AdaptiveMetropolisLearnScale(distribution, mean_est=mean_est, cov_est=cov_est)
#mcmc_sampler = AdaptiveMetropolis(distribution, mean_est=mean_est, cov_est=cov_est)
mcmc_sampler = StandardMetropolis(distribution)
start = zeros(distribution.dimension, dtype="float64")
mcmc_params = MCMCParams(start=start,
num_iterations=num_iterations,
burnin=burnin)
from kameleon_mcmc.mcmc.MCMCChain import MCMCChain
from kameleon_mcmc.mcmc.MCMCParams import MCMCParams
from kameleon_mcmc.mcmc.output.StatisticsOutput import StatisticsOutput
from kameleon_mcmc.mcmc.samplers.AdaptiveMetropolis import AdaptiveMetropolis
from kameleon_mcmc.mcmc.samplers.AdaptiveMetropolisLearnScale import \
AdaptiveMetropolisLearnScale
from kameleon_mcmc.mcmc.samplers.KameleonWindowLearnScale import \
KameleonWindowLearnScale
from kameleon_mcmc.mcmc.samplers.StandardMetropolis import StandardMetropolis
if __name__ == '__main__':
experiment_dir = str(os.path.abspath(sys.argv[0])).split(os.sep)[-1].split(".")[0] + os.sep
distribution = Banana(dimension=8, bananicity=0.1, V=100)
sigma = GaussianKernel.get_sigma_median_heuristic(distribution.sample(1000).samples)
sigma = 10
print "using sigma", sigma
kernel = GaussianKernel(sigma=sigma)
burnin = 40000
num_iterations = 80000
#mcmc_sampler = KameleonWindowLearnScale(distribution, kernel, stop_adapt=burnin)
mean_est = zeros(distribution.dimension, dtype="float64")
cov_est = 1.0 * eye(distribution.dimension)
cov_est[0, 0] = distribution.V
#mcmc_sampler = AdaptiveMetropolisLearnScale(distribution, mean_est=mean_est, cov_est=cov_est)
#mcmc_sampler = AdaptiveMetropolis(distribution, mean_est=mean_est, cov_est=cov_est)
mcmc_sampler = StandardMetropolis(distribution)
def all_tests(gaussian1,gaussian2,n=200):
oracle_samples1 = gaussian1.sample(n=n).samples
oracle_samples2 = gaussian2.sample(n=n).samples
distribution1 = GaussianFullConditionals(gaussian1, list(gaussian1.mu))
distribution2 = GaussianFullConditionals(gaussian2, list(gaussian2.mu))
mcmc_sampler1 = Gibbs(distribution1)
mcmc_sampler2 = Gibbs(distribution2)
start = zeros(2)
mcmc_params = MCMCParams(start=start, num_iterations=2000+n, burnin=2000)
chain1 = MCMCChain(mcmc_sampler1, mcmc_params)
chain1.run()
gibbs_samples1 = chain1.get_samples_after_burnin()
chain2 = MCMCChain(mcmc_sampler2, mcmc_params)
chain2.run()
gibbs_samples2 = chain2.get_samples_after_burnin()
sigma = GaussianKernel.get_sigma_median_heuristic(concatenate((oracle_samples1,oracle_samples2),axis=0))
kernel = GaussianKernel(sigma=sigma)
vanillap=empty((2,2))
blockp=empty((2,2))
wildp=empty((2,2))
vanillap[0,0]=kernel.TwoSampleTest(oracle_samples1,oracle_samples2,method='vanilla')
vanillap[0,1]=kernel.TwoSampleTest(oracle_samples1,gibbs_samples2,method='vanilla')
vanillap[1,0]=kernel.TwoSampleTest(gibbs_samples1,oracle_samples2,method='vanilla')
vanillap[1,1]=kernel.TwoSampleTest(gibbs_samples1,gibbs_samples2,method='vanilla')
blockp[0,0]=kernel.TwoSampleTest(oracle_samples1,oracle_samples2,method='block')
blockp[0,1]=kernel.TwoSampleTest(oracle_samples1,gibbs_samples2,method='block')
blockp[1,0]=kernel.TwoSampleTest(gibbs_samples1,oracle_samples2,method='block')
blockp[1,1]=kernel.TwoSampleTest(gibbs_samples1,gibbs_samples2,method='block')
wildp[0,0]=kernel.TwoSampleTest(oracle_samples1,oracle_samples2,method='wild')
wildp[0,1]=kernel.TwoSampleTest(oracle_samples1,gibbs_samples2,method='wild')
wildp[1,0]=kernel.TwoSampleTest(gibbs_samples1,oracle_samples2,method='wild')
wildp[1,1]=kernel.TwoSampleTest(gibbs_samples1,gibbs_samples2,method='wild')
return vanillap,blockp,wildp
from numpy import array
from os import makedirs
from kameleon_mcmc.distribution.Banana import Banana
from kameleon_mcmc.distribution.Flower import Flower
from kameleon_mcmc.distribution.Ring import Ring
from kameleon_mcmc.kernel.GaussianKernel import GaussianKernel
from kameleon_mcmc.kernel.MaternKernel import MaternKernel
from kameleon_mcmc.paper_figures.GFunction import GFunction
import latex_plot_init
# global variables that are used by both functions
print "Generating g-functions"
distributions = [Ring(), Banana(), Flower(), Ring(), Banana(), Flower()]
kernels = [GaussianKernel(.5), GaussianKernel(3), GaussianKernel(2), \
MaternKernel(1), MaternKernel(2), MaternKernel(1)]
num_samples = [200, 200, 1000, 200, 200, 1000]
nu2s = [0.01, 0.5, 0.2, 0.01, 0.5, 0.2]
g_functions = [GFunction(distributions[i], n=num_samples[i], kernel=kernels[i], \
nu2=nu2s[i], gamma=0.1, ell=15, nXs=200, nYs=200) \
for i in range(len(distributions))]
ys = [array([2, -3]) , array([2, -3]), array([-2, -8.5]), array([2, -3]) , array([2, -3]), array([-2, -8.5])]
num_proposals = [10, 10, 40, 10, 10, 40]
gradient_scales = [35, 30, 20, 35, 30, 20]
num_betas = [0, 5, 0, 0, 5, 0]
def plot_g_functions():
for i in range(len(distributions)):
for j in range(num_betas[i]):
print distributions[i].__class__.__name__, g_functions[i].kernel.__class__.__name__, j
# normalise and whiten dataset
data -= mean(data, 0)
L = cholesky(cov(data.T))
data = solve_triangular(L, data.T, lower=True).T
dim = shape(data)[1]
# prior on theta and posterior target estimate
theta_prior = Gaussian(mu=0 * ones(dim), Sigma=eye(dim) * 5)
target=PseudoMarginalHyperparameterDistribution(data, labels, \
n_importance=100, prior=theta_prior, \
ridge=1e-3)
# create sampler
burnin = 10000
num_iterations = burnin + 300000
kernel = GaussianKernel(sigma=23.0)
sampler = KameleonWindowLearnScale(target, kernel, stop_adapt=burnin)
# sampler=AdaptiveMetropolisLearnScale(target)
# sampler=StandardMetropolis(target)
# posterior mode derived by initial tests
start = zeros(target.dimension)
params = MCMCParams(start=start,
num_iterations=num_iterations,
burnin=burnin)
# create MCMC chain
chain = MCMCChain(sampler, params)
chain.append_mcmc_output(StatisticsOutput(print_from=0, lag=100))
#chain.append_mcmc_output(PlottingOutput(plot_from=0, lag=500))
from kameleon_mcmc.mcmc.MCMCChain import MCMCChain
from kameleon_mcmc.mcmc.MCMCParams import MCMCParams
from kameleon_mcmc.mcmc.output.StatisticsOutput import StatisticsOutput
from kameleon_mcmc.mcmc.samplers.AdaptiveMetropolis import AdaptiveMetropolis
from kameleon_mcmc.mcmc.samplers.AdaptiveMetropolisLearnScale import \
AdaptiveMetropolisLearnScale
from kameleon_mcmc.mcmc.samplers.KameleonWindowLearnScale import \
KameleonWindowLearnScale
from kameleon_mcmc.mcmc.samplers.StandardMetropolis import StandardMetropolis
if __name__ == '__main__':
experiment_dir = str(os.path.abspath(sys.argv[0])).split(
os.sep)[-1].split(".")[0] + os.sep
distribution = Banana(dimension=8, bananicity=0.03, V=100)
sigma = GaussianKernel.get_sigma_median_heuristic(
distribution.sample(1000).samples)
sigma = 10
print "using sigma", sigma
kernel = GaussianKernel(sigma=sigma)
burnin = 20000
num_iterations = 40000
mcmc_sampler = KameleonWindowLearnScale(distribution,
kernel,
stop_adapt=burnin)
mean_est = zeros(distribution.dimension, dtype="float64")
cov_est = 1.0 * eye(distribution.dimension)
cov_est[0, 0] = distribution.V
#mcmc_sampler = AdaptiveMetropolisLearnScale(distribution, mean_est=mean_est, cov_est=cov_est)
#mcmc_sampler = AdaptiveMetropolis(distribution, mean_est=mean_est, cov_est=cov_est)
# prior on theta and posterior target estimate
theta_prior=Gaussian(mu=0*ones(dim), Sigma=eye(dim)*5)
target=PseudoMarginalHyperparameterDistribution(data, labels, \
n_importance=100, prior=theta_prior, \
ridge=1e-3)
# create sampler
burnin=10000
num_iterations=burnin+300000
kernel = GaussianKernel(sigma=23.0)
sampler=KameleonWindowLearnScale(target, kernel, stop_adapt=burnin)
# sampler=AdaptiveMetropolisLearnScale(target)
# sampler=StandardMetropolis(target)
# posterior mode derived by initial tests
start=zeros(target.dimension)
params = MCMCParams(start=start, num_iterations=num_iterations, burnin=burnin)
# create MCMC chain
chain=MCMCChain(sampler, params)
chain.append_mcmc_output(StatisticsOutput(print_from=0, lag=100))
#chain.append_mcmc_output(PlottingOutput(plot_from=0, lag=500))
# create experiment instance to store results
experiment_dir = str(os.path.abspath(sys.argv[0])).split(os.sep)[-1].split(".")[0] + os.sep
experiment = SingleChainExperiment(chain, experiment_dir)
experiment.run()
sigma=GaussianKernel.get_sigma_median_heuristic(experiment.mcmc_chain.samples.T)
print "median kernel width", sigma
