def get_OracleKernelAdaptiveLangevin_instance(D, target_log_pdf): step_size = 1. m = 500 N = 5000 Z = sample_banana(N, D, bananicity, V) surrogate = KernelExpFiniteGaussian(sigma=10, lmbda=.001, m=m, D=D) surrogate.fit(Z) if False: param_bounds = {'sigma': [-2, 3]} bo = BayesOptSearch(surrogate, Z, param_bounds) best_params = bo.optimize() surrogate.set_parameters_from_dict(best_params) if False: sigma = 1. / gamma_median_heuristic(Z) surrogate.set_parameters_from_dict({'sigma': sigma}) logger.info("kernel exp family uses %s" % surrogate.get_parameters()) if False: import matplotlib.pyplot as plt Xs = np.linspace(-30, 30, 50) Ys = np.linspace(-20, 40, 50) visualise_fit_2d(surrogate, Z, Xs, Ys) plt.show() instance = OracleKernelAdaptiveLangevin(D, target_log_pdf, surrogate, step_size) return instance
class KernelExpLiteGaussianLowRankAdaptive(KernelExpLiteGaussianLowRank): def __init__(self, sigma, lmbda, D, N, eta=0.1, cg_tol=1e-3, cg_maxiter=None, num_initial_evaluations=3, num_evaluations=3, minimum_size_learning=100, num_initial_evaluations_relearn=1, num_evaluations_relearn=1, param_bounds={'sigma': [-3, 3]}): KernelExpLiteGaussianLowRank.__init__(self, sigma, lmbda, D, N, eta, cg_tol, cg_maxiter) self.bo = None self.param_bounds = param_bounds self.num_initial_evaluations = num_initial_evaluations self.num_iter = num_evaluations self.minimum_size_learning = minimum_size_learning self.n_initial_relearn = num_initial_evaluations_relearn self.n_iter_relearn = num_evaluations_relearn self.learning_parameters = False def fit(self, X): # avoid infinite recursion from x-validation fit call if not self.learning_parameters and len( X) >= self.minimum_size_learning: self.learning_parameters = True if self.bo is None: logger.info("Bayesian optimisation from scratch.") self.bo = BayesOptSearch( self, X, self.param_bounds, n_initial=self.num_initial_evaluations) best_params = self.bo.optimize(self.num_iter) else: logger.info("Bayesian optimisation using prior model.") self.bo.re_initialise(X, self.n_initial_relearn) best_params = self.bo.optimize(self.n_iter_relearn) self.set_parameters_from_dict(best_params) self.learning_parameters = False logger.info("Learnt %s" % str(self.get_parameters())) # standard fit call from superclass KernelExpLiteGaussianLowRank.fit(self, X)
class KernelExpLiteGaussianLowRankAdaptive(KernelExpLiteGaussianLowRank): def __init__( self, sigma, lmbda, D, N, eta=0.1, cg_tol=1e-3, cg_maxiter=None, num_initial_evaluations=3, num_evaluations=3, minimum_size_learning=100, num_initial_evaluations_relearn=1, num_evaluations_relearn=1, param_bounds={"sigma": [-3, 3]}, ): KernelExpLiteGaussianLowRank.__init__(self, sigma, lmbda, D, N, eta, cg_tol, cg_maxiter) self.bo = None self.param_bounds = param_bounds self.num_initial_evaluations = num_initial_evaluations self.num_iter = num_evaluations self.minimum_size_learning = minimum_size_learning self.n_initial_relearn = num_initial_evaluations_relearn self.n_iter_relearn = num_evaluations_relearn self.learning_parameters = False def fit(self, X): # avoid infinite recursion from x-validation fit call if not self.learning_parameters and len(X) >= self.minimum_size_learning: self.learning_parameters = True if self.bo is None: logger.info("Bayesian optimisation from scratch.") self.bo = BayesOptSearch(self, X, self.param_bounds, n_initial=self.num_initial_evaluations) best_params = self.bo.optimize(self.num_iter) else: logger.info("Bayesian optimisation using prior model.") self.bo.re_initialise(X, self.n_initial_relearn) best_params = self.bo.optimize(self.n_iter_relearn) self.set_parameters_from_dict(best_params) self.learning_parameters = False logger.info("Learnt %s" % str(self.get_parameters())) # standard fit call from superclass KernelExpLiteGaussianLowRank.fit(self, X)
def fit(self, X): # avoid infinite recursion from x-validation fit call if not self.learning_parameters and len(X) >= self.minimum_size_learning: self.learning_parameters = True if self.bo is None: logger.info("Bayesian optimisation from scratch.") self.bo = BayesOptSearch(self, X, self.param_bounds, num_initial_evaluations=self.num_initial_evaluations) best_params = self.bo.optimize(self.num_iter) else: logger.info("Bayesian optimisation using prior model.") self.bo.re_initialise(X, self.n_initial_relearn) best_params = self.bo.optimize(self.n_iter_relearn) self.set_parameters_from_dict(best_params) self.learning_parameters = False logger.info("Learnt %s" % str(self.get_parameters())) # standard fit call from superclass KernelExpStein.fit(self, X)
def fit(self, X): # avoid infinite recursion from x-validation fit call if not self.learning_parameters and len(X) >= self.minimum_size_learning: self.learning_parameters = True if self.bo is None: logger.info("Bayesian optimisation from scratch.") self.bo = BayesOptSearch(self, X, self.param_bounds, n_initial=self.num_initial_evaluations) best_params = self.bo.optimize(self.num_iter) else: logger.info("Bayesian optimisation using prior model.") self.bo.re_initialise(X, self.n_initial_relearn) best_params = self.bo.optimize(self.n_iter_relearn) self.set_parameters_from_dict(best_params) self.learning_parameters = False logger.info("Learnt %s" % str(self.get_parameters())) # standard fit call from superclass KernelExpLiteGaussianLowRank.fit(self, X)
for est in estimators: print(est.__class__.__name__) est.fit(X) # specify bounds of parameters to search for param_bounds = { # 'lmbda': [-5,0], # fixed lmbda, uncomment to include in search 'sigma': [-2, 3], } # oop interface for optimising and using results # objective is not put through log here, if it is, might want to bound away from zero bo = BayesOptSearch(est, X, param_bounds, objective_log=False, objective_log_bound=100, num_initial_evaluations=5) # optimisation starts here, use results and apply to model best_params = bo.optimize(num_iter=5) est.set_parameters_from_dict(best_params) est.fit(X) visualise_fit_2d(est, X) plt.suptitle("Original fit %s\nOptimised over: %s" % (str(est.get_parameters()), str(param_bounds))) if len(param_bounds) == 1: plt.figure() plot_bayesopt_model_1d(bo) plt.title("Objective")
visualise_trace(samples, log_pdf, accepted, log_pdf_density=surrogate, step_sizes=step_sizes) plt.suptitle("KMC lite %s, acceptance rate: %.2f" % \ (surrogate.__class__.__name__, np.mean(accepted))) # now initialise KMC finite with the samples from the surrogate, and run for more # learn parameters before starting thinned = samples[np.random.permutation(len(samples))[:N]] surrogate2 = KernelExpFiniteGaussian(sigma=2, lmbda=0.001, D=D, m=N) surrogate2.set_parameters_from_dict( BayesOptSearch(surrogate2, thinned, { 'sigma': [-3, 3] }).optimize(3)) surrogate2.fit(thinned) # now use conservative schedule, or None at all if confident in oracle samples schedule2 = lambda t: 0.01 if t < 3000 else 0. kmc2 = KMC(surrogate2, target, momentum, kmc.num_steps_min, kmc.num_steps_max, kmc.step_size[0], kmc.step_size[1], schedule2, acc_star) # run MCMC samples2, proposals2, accepted2, acc_prob2, log_pdf2, times2, step_sizes = mini_mcmc( kmc2, start, num_iter, D) visualise_trace(samples2, log_pdf2, accepted2,
] for est in estimators: print(est.__class__.__name__) est.fit(X) # specify bounds of parameters to search for param_bounds = { # 'lmbda': [-5,0], # fixed lmbda, uncomment to include in search 'sigma': [-2,3], } # oop interface for optimising and using results # objective is not put through log here, if it is, might want to bound away from zero bo = BayesOptSearch(est, X, param_bounds, objective_log=False, objective_log_bound=100, num_initial_evaluations=5) # optimisation starts here, use results and apply to model best_params = bo.optimize(num_iter=5) est.set_parameters_from_dict(best_params) est.fit(X) visualise_fit_2d(est, X) plt.suptitle("Original fit %s\nOptimised over: %s" % (str(est.get_parameters()), str(param_bounds))) if len(param_bounds) == 1: plt.figure() plot_bayesopt_model_1d(bo) plt.title("Objective") # now change data, with different length scale