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