def test_compute_posteriors(): np.random.seed(42) arr_range_1 = np.array([ [0.0, 10.0], [-2.0, 2.0], [-5.0, 5.0], ]) dim_X = arr_range_1.shape[0] num_X = 5 X = np.random.randn(num_X, dim_X) Y = np.random.randn(num_X, 1) model_bo = BO(arr_range_1, str_acq='ei', str_exp=None) hyps = utils_covariance.get_hyps(model_bo.str_cov, dim=dim_X, use_ard=model_bo.use_ard, use_gp=False) cov_X_X, inv_cov_X_X, _ = covariance.get_kernel_inverse( X, hyps, model_bo.str_cov) X_test = model_bo.get_samples('sobol', num_samples=10, seed=111) with pytest.raises(AssertionError) as error: model_bo.compute_posteriors(1, Y, X_test, cov_X_X, inv_cov_X_X, hyps) with pytest.raises(AssertionError) as error: model_bo.compute_posteriors(X, 1, X_test, cov_X_X, inv_cov_X_X, hyps) with pytest.raises(AssertionError) as error: model_bo.compute_posteriors(X, Y, 1, cov_X_X, inv_cov_X_X, hyps) with pytest.raises(AssertionError) as error: model_bo.compute_posteriors(X, Y, X_test, 1, inv_cov_X_X, hyps) with pytest.raises(AssertionError) as error: model_bo.compute_posteriors(X, Y, X_test, cov_X_X, 1, hyps) with pytest.raises(AssertionError) as error: model_bo.compute_posteriors(X, Y, X_test, cov_X_X, inv_cov_X_X, 1) with pytest.raises(AssertionError) as error: model_bo.compute_posteriors(X, Y, X_test, cov_X_X, inv_cov_X_X, 1.0) with pytest.raises(AssertionError) as error: model_bo.compute_posteriors(X, Y, X_test, cov_X_X, inv_cov_X_X, 'abc') pred_mean, pred_std = model_bo.compute_posteriors(X, Y, X_test, cov_X_X, inv_cov_X_X, hyps) assert len(pred_mean.shape) == 1 assert len(pred_std.shape) == 1 assert pred_mean.shape[0] == pred_mean.shape[0] == X_test.shape[0]
def predict_with_hyps(X_train: np.ndarray, Y_train: np.ndarray, X_test: np.ndarray, hyps: dict, str_cov: str=constants.STR_COV, prior_mu: constants.TYPING_UNION_CALLABLE_NONE=None, debug: bool=False ) -> constants.TYPING_TUPLE_THREE_ARRAYS: """ This function returns posterior mean and posterior standard deviation functions over `X_test`, computed by Gaussian process regression with `X_train`, `Y_train`, and `hyps`. :param X_train: inputs. Shape: (n, d) or (n, m, d). :type X_train: numpy.ndarray :param Y_train: outputs. Shape: (n, 1). :type Y_train: numpy.ndarray :param X_test: inputs. Shape: (l, d) or (l, m, d). :type X_test: numpy.ndarray :param hyps: dictionary of hyperparameters for Gaussian process. :type hyps: dict. :param str_cov: the name of covariance function. :type str_cov: str., optional :param prior_mu: None, or prior mean function. :type prior_mu: NoneType, or callable, optional :param debug: flag for printing log messages. :type debug: bool., optional :returns: a tuple of posterior mean function over `X_test`, posterior standard deviation function over `X_test`, and posterior covariance matrix over `X_test`. Shape: ((l, 1), (l, 1), (l, l)). :rtype: tuple of (numpy.ndarray, numpy.ndarray, numpy.ndarray) :raises: AssertionError """ utils_gp.validate_common_args(X_train, Y_train, str_cov, prior_mu, debug, X_test) assert isinstance(hyps, dict) utils_covariance.check_str_cov('predict_with_hyps', str_cov, X_train.shape, shape_X2=X_test.shape) cov_X_X, inv_cov_X_X, _ = covariance.get_kernel_inverse(X_train, hyps, str_cov, debug=debug) mu_Xs, sigma_Xs, Sigma_Xs = predict_with_cov(X_train, Y_train, X_test, cov_X_X, inv_cov_X_X, hyps, str_cov=str_cov, prior_mu=prior_mu, debug=debug) return mu_Xs, sigma_Xs, Sigma_Xs
def test_compute_acquisitions_set(): np.random.seed(42) arr_range_1 = np.array([ [0.0, 10.0], [-2.0, 2.0], [-5.0, 5.0], ]) dim_X = arr_range_1.shape[0] num_X = 5 num_instances = 4 X = np.random.randn(num_X, num_instances, dim_X) Y = np.random.randn(num_X, 1) model_bo = BO(arr_range_1, str_acq='pi', str_cov='set_se', str_exp='test') hyps = utils_covariance.get_hyps(model_bo.str_cov, dim=dim_X, use_ard=model_bo.use_ard, use_gp=False) cov_X_X, inv_cov_X_X, _ = covariance.get_kernel_inverse( X, hyps, model_bo.str_cov) X_test = np.array([ [ [1.0, 0.0, 0.0, 1.0], [2.0, -1.0, 2.0, 1.0], [3.0, -2.0, 4.0, 1.0], ], [ [4.0, 2.0, -3.0, 1.0], [5.0, 0.0, -2.0, 1.0], [6.0, -2.0, -1.0, 1.0], ], ]) with pytest.raises(AssertionError) as error: model_bo.compute_acquisitions(X_test, X, Y, cov_X_X, inv_cov_X_X, hyps)
def optimize( self, X_train: np.ndarray, Y_train: np.ndarray, str_sampling_method: str = constants.STR_SAMPLING_METHOD_AO, num_samples: int = constants.NUM_SAMPLES_AO, str_mlm_method: str = constants.STR_MLM_METHOD, ) -> constants.TYPING_TUPLE_ARRAY_DICT: """ It computes acquired example, candidates of acquired examples, acquisition function values for the candidates, covariance matrix, inverse matrix of the covariance matrix, hyperparameters optimized, and execution times. :param X_train: inputs. Shape: (n, d) or (n, m, d). :type X_train: numpy.ndarray :param Y_train: outputs. Shape: (n, 1). :type Y_train: numpy.ndarray :param str_sampling_method: the name of sampling method for acquisition function optimization. :type str_sampling_method: str., optional :param num_samples: the number of samples. :type num_samples: int., optional :param str_mlm_method: the name of marginal likelihood maximization method for Gaussian process regression. :type str_mlm_method: str., optional :returns: acquired example and dictionary of information. Shape: ((d, ), dict.). :rtype: (numpy.ndarray, dict.) :raises: AssertionError """ assert isinstance(X_train, np.ndarray) assert isinstance(Y_train, np.ndarray) assert isinstance(str_sampling_method, str) assert isinstance(num_samples, int) assert isinstance(str_mlm_method, str) assert len(X_train.shape) == 2 assert len(Y_train.shape) == 2 assert Y_train.shape[1] == 1 assert X_train.shape[0] == Y_train.shape[0] assert X_train.shape[1] == self.num_dim assert num_samples > 0 assert str_sampling_method in constants.ALLOWED_SAMPLING_METHOD assert str_mlm_method in constants.ALLOWED_MLM_METHOD time_start = time.time() Y_train_orig = Y_train if self.normalize_Y and str_mlm_method != 'converged': if self.debug: self.logger.debug('Responses are normalized.') Y_train = utils_bo.normalize_min_max(Y_train) time_start_surrogate = time.time() if str_mlm_method == 'regular': cov_X_X, inv_cov_X_X, hyps = gp_kernel.get_optimized_kernel( X_train, Y_train, self.prior_mu, self.str_cov, str_optimizer_method=self.str_optimizer_method_gp, str_modelselection_method=self.str_modelselection_method, use_ard=self.use_ard, debug=self.debug) elif str_mlm_method == 'combined': from bayeso.gp import gp_likelihood from bayeso.utils import utils_gp from bayeso.utils import utils_covariance prior_mu_train = utils_gp.get_prior_mu(self.prior_mu, X_train) neg_log_ml_best = np.inf cov_X_X_best = None inv_cov_X_X_best = None hyps_best = None for cur_str_optimizer_method in ['BFGS', 'Nelder-Mead']: cov_X_X, inv_cov_X_X, hyps = gp_kernel.get_optimized_kernel( X_train, Y_train, self.prior_mu, self.str_cov, str_optimizer_method=cur_str_optimizer_method, str_modelselection_method=self.str_modelselection_method, use_ard=self.use_ard, debug=self.debug) cur_neg_log_ml_ = gp_likelihood.neg_log_ml( X_train, Y_train, utils_covariance.convert_hyps( self.str_cov, hyps, fix_noise=constants.FIX_GP_NOISE), self.str_cov, prior_mu_train, use_ard=self.use_ard, fix_noise=constants.FIX_GP_NOISE, use_gradient=False, debug=self.debug) if cur_neg_log_ml_ < neg_log_ml_best: neg_log_ml_best = cur_neg_log_ml_ cov_X_X_best = cov_X_X inv_cov_X_X_best = inv_cov_X_X hyps_best = hyps cov_X_X = cov_X_X_best inv_cov_X_X = inv_cov_X_X_best hyps = hyps_best elif str_mlm_method == 'converged': fix_noise = constants.FIX_GP_NOISE if self.is_optimize_hyps: cov_X_X, inv_cov_X_X, hyps = gp_kernel.get_optimized_kernel( X_train, Y_train, self.prior_mu, self.str_cov, str_optimizer_method=self.str_optimizer_method_gp, str_modelselection_method=self.str_modelselection_method, use_ard=self.use_ard, debug=self.debug) self.is_optimize_hyps = not utils_bo.check_hyps_convergence( self.historical_hyps, hyps, self.str_cov, fix_noise) else: # pragma: no cover if self.debug: self.logger.debug('hyps converged.') hyps = self.historical_hyps[-1] cov_X_X, inv_cov_X_X, _ = covariance.get_kernel_inverse( X_train, hyps, self.str_cov, fix_noise=fix_noise, debug=self.debug) else: # pragma: no cover raise ValueError('optimize: missing condition for str_mlm_method.') self.historical_hyps.append(hyps) time_end_surrogate = time.time() time_start_acq = time.time() fun_negative_acquisition = lambda X_test: -1.0 * self.compute_acquisitions( X_test, X_train, Y_train, cov_X_X, inv_cov_X_X, hyps) next_point, next_points = self._optimize( fun_negative_acquisition, str_sampling_method=str_sampling_method, num_samples=num_samples) time_end_acq = time.time() acquisitions = fun_negative_acquisition(next_points) time_end = time.time() dict_info = { 'next_points': next_points, 'acquisitions': acquisitions, 'Y_original': Y_train_orig, 'Y_normalized': Y_train, 'cov_X_X': cov_X_X, 'inv_cov_X_X': inv_cov_X_X, 'hyps': hyps, 'time_surrogate': time_end_surrogate - time_start_surrogate, 'time_acq': time_end_acq - time_start_acq, 'time_overall': time_end - time_start, } if self.debug: self.logger.debug('overall time consumed to acquire: %.4f sec.', time_end - time_start) return next_point, dict_info
def get_optimized_kernel( X_train: np.ndarray, Y_train: np.ndarray, prior_mu: constants.TYPING_UNION_CALLABLE_NONE, str_cov: str, str_optimizer_method: str = constants.STR_OPTIMIZER_METHOD_GP, str_modelselection_method: str = constants.STR_MODELSELECTION_METHOD, use_ard: bool = constants.USE_ARD, fix_noise: bool = constants.FIX_GP_NOISE, debug: bool = False) -> constants.TYPING_TUPLE_TWO_ARRAYS_DICT: """ This function computes the kernel matrix optimized by optimization method specified, its inverse matrix, and the optimized hyperparameters. :param X_train: inputs. Shape: (n, d) or (n, m, d). :type X_train: numpy.ndarray :param Y_train: outputs. Shape: (n, 1). :type Y_train: numpy.ndarray :param prior_mu: prior mean function or None. :type prior_mu: callable or NoneType :param str_cov: the name of covariance function. :type str_cov: str. :param str_optimizer_method: the name of optimization method. :type str_optimizer_method: str., optional :param str_modelselection_method: the name of model selection method. :type str_modelselection_method: str., optional :param use_ard: flag for using automatic relevance determination. :type use_ard: bool., optional :param fix_noise: flag for fixing a noise. :type fix_noise: bool., optional :param debug: flag for printing log messages. :type debug: bool., optional :returns: a tuple of kernel matrix over `X_train`, kernel matrix inverse, and dictionary of hyperparameters. :rtype: tuple of (numpy.ndarray, numpy.ndarray, dict.) :raises: AssertionError, ValueError """ # TODO: check to input same fix_noise to convert_hyps and restore_hyps utils_gp.validate_common_args(X_train, Y_train, str_cov, prior_mu, debug) assert isinstance(str_optimizer_method, str) assert isinstance(str_modelselection_method, str) assert isinstance(use_ard, bool) assert isinstance(fix_noise, bool) utils_covariance.check_str_cov('get_optimized_kernel', str_cov, X_train.shape) assert str_optimizer_method in constants.ALLOWED_OPTIMIZER_METHOD_GP assert str_modelselection_method in constants.ALLOWED_MODELSELECTION_METHOD use_gradient = bool(str_optimizer_method != 'Nelder-Mead') # TODO: Now, use_gradient is fixed as False. # use_gradient = False time_start = time.time() if debug: logger.debug('str_optimizer_method: %s', str_optimizer_method) logger.debug('str_modelselection_method: %s', str_modelselection_method) logger.debug('use_gradient: %s', use_gradient) prior_mu_train = utils_gp.get_prior_mu(prior_mu, X_train) if str_cov in constants.ALLOWED_COV_BASE: num_dim = X_train.shape[1] elif str_cov in constants.ALLOWED_COV_SET: num_dim = X_train.shape[2] use_gradient = False if str_modelselection_method == 'ml': neg_log_ml_ = lambda hyps: gp_likelihood.neg_log_ml( X_train, Y_train, hyps, str_cov, prior_mu_train, use_ard=use_ard, fix_noise=fix_noise, use_gradient=use_gradient, debug=debug) elif str_modelselection_method == 'loocv': # TODO: add use_ard. neg_log_ml_ = lambda hyps: gp_likelihood.neg_log_pseudo_l_loocv( X_train, Y_train, hyps, str_cov, prior_mu_train, fix_noise=fix_noise, debug=debug) use_gradient = False else: # pragma: no cover raise ValueError( 'get_optimized_kernel: missing conditions for str_modelselection_method.' ) hyps_converted = utils_covariance.convert_hyps(str_cov, utils_covariance.get_hyps( str_cov, num_dim, use_ard=use_ard), fix_noise=fix_noise) if str_optimizer_method in ['BFGS', 'SLSQP']: result_optimized = scipy.optimize.minimize(neg_log_ml_, hyps_converted, method=str_optimizer_method, jac=use_gradient, options={'disp': False}) if debug: logger.debug('negative log marginal likelihood: %.6f', result_optimized.fun) logger.debug('scipy message: %s', result_optimized.message) result_optimized = result_optimized.x elif str_optimizer_method in ['L-BFGS-B', 'SLSQP-Bounded']: if str_optimizer_method == 'SLSQP-Bounded': str_optimizer_method = 'SLSQP' bounds = utils_covariance.get_range_hyps(str_cov, num_dim, use_ard=use_ard, fix_noise=fix_noise) result_optimized = scipy.optimize.minimize(neg_log_ml_, hyps_converted, method=str_optimizer_method, bounds=bounds, jac=use_gradient, options={'disp': False}) if debug: logger.debug('negative log marginal likelihood: %.6f', result_optimized.fun) logger.debug('scipy message: %s', result_optimized.message) result_optimized = result_optimized.x elif str_optimizer_method in ['Nelder-Mead']: result_optimized = scipy.optimize.minimize(neg_log_ml_, hyps_converted, method=str_optimizer_method, options={'disp': False}) if debug: logger.debug('negative log marginal likelihood: %.6f', result_optimized.fun) logger.debug('scipy message: %s', result_optimized.message) result_optimized = result_optimized.x else: # pragma: no cover raise ValueError( 'get_optimized_kernel: missing conditions for str_optimizer_method' ) hyps = utils_covariance.restore_hyps(str_cov, result_optimized, use_ard=use_ard, fix_noise=fix_noise) hyps = utils_covariance.validate_hyps_dict(hyps, str_cov, num_dim) cov_X_X, inv_cov_X_X, _ = covariance.get_kernel_inverse( X_train, hyps, str_cov, fix_noise=fix_noise, debug=debug) time_end = time.time() if debug: logger.debug('hyps optimized: %s', utils_logger.get_str_hyps(hyps)) logger.debug('time consumed to construct gpr: %.4f sec.', time_end - time_start) return cov_X_X, inv_cov_X_X, hyps
def test_get_kernel_inverse(): dim_X = 3 X = np.reshape(np.arange(0, 9), (3, dim_X)) hyps = utils_covariance.get_hyps('se', dim_X) with pytest.raises(AssertionError) as error: package_target.get_kernel_inverse(1, hyps, 'se') with pytest.raises(AssertionError) as error: package_target.get_kernel_inverse(np.arange(0, 100), hyps, 'se') with pytest.raises(AssertionError) as error: package_target.get_kernel_inverse(X, 1, 'se') with pytest.raises(AssertionError) as error: package_target.get_kernel_inverse(X, hyps, 1) with pytest.raises(ValueError) as error: package_target.get_kernel_inverse(X, hyps, 'abc') with pytest.raises(AssertionError) as error: package_target.get_kernel_inverse(X, hyps, 'se', debug=1) with pytest.raises(AssertionError) as error: package_target.get_kernel_inverse(X, hyps, 'se', use_gradient='abc') with pytest.raises(AssertionError) as error: package_target.get_kernel_inverse(X, hyps, 'se', fix_noise='abc') cov_X_X, inv_cov_X_X, grad_cov_X_X = package_target.get_kernel_inverse( X, hyps, 'se') print(cov_X_X) print(inv_cov_X_X) truth_cov_X_X = np.array([[1.00011000e+00, 1.37095909e-06, 3.53262857e-24], [1.37095909e-06, 1.00011000e+00, 1.37095909e-06], [3.53262857e-24, 1.37095909e-06, 1.00011000e+00]]) truth_inv_cov_X_X = np.array( [[9.99890012e-01, -1.37065753e-06, 1.87890871e-12], [-1.37065753e-06, 9.99890012e-01, -1.37065753e-06], [1.87890871e-12, -1.37065753e-06, 9.99890012e-01]]) assert (np.abs(cov_X_X - truth_cov_X_X) < TEST_EPSILON).all() assert (np.abs(inv_cov_X_X - truth_inv_cov_X_X) < TEST_EPSILON).all() assert cov_X_X.shape == inv_cov_X_X.shape cov_X_X, inv_cov_X_X, grad_cov_X_X = package_target.get_kernel_inverse( X, hyps, 'se', use_gradient=True, fix_noise=True) print(grad_cov_X_X) print(grad_cov_X_X.shape) truth_grad_cov_X_X = np.array( [[[2.00002000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], [ 2.74191817e-06, 1.233863177745676e-05, 1.233863177745676e-05, 1.233863177745676e-05 ], [ 7.06525714e-24, 1.2717462859922906e-22, 1.2717462859922906e-22, 1.2717462859922906e-22 ]], [[ 2.74191817e-06, 1.233863177745676e-05, 1.233863177745676e-05, 1.233863177745676e-05 ], [2.00002000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], [ 2.74191817e-06, 1.233863177745676e-05, 1.233863177745676e-05, 1.233863177745676e-05 ]], [[ 7.06525714e-24, 1.2717462859922906e-22, 1.2717462859922906e-22, 1.2717462859922906e-22 ], [ 2.74191817e-06, 1.233863177745676e-05, 1.233863177745676e-05, 1.233863177745676e-05 ], [2.00002000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]]]) assert (np.abs(cov_X_X - truth_cov_X_X) < TEST_EPSILON).all() assert (np.abs(inv_cov_X_X - truth_inv_cov_X_X) < TEST_EPSILON).all() assert (np.abs(grad_cov_X_X - truth_grad_cov_X_X) < TEST_EPSILON).all() assert cov_X_X.shape == inv_cov_X_X.shape == grad_cov_X_X.shape[:2]
def test_compute_acquisitions(): np.random.seed(42) arr_range_1 = np.array([ [0.0, 10.0], [-2.0, 2.0], [-5.0, 5.0], ]) dim_X = arr_range_1.shape[0] num_X = 5 X = np.random.randn(num_X, dim_X) Y = np.random.randn(num_X, 1) model_bo = BO(arr_range_1, str_acq='pi', str_exp='test') hyps = utils_covariance.get_hyps(model_bo.str_cov, dim=dim_X, use_ard=model_bo.use_ard) cov_X_X, inv_cov_X_X, _ = covariance.get_kernel_inverse( X, hyps, model_bo.str_cov) X_test = model_bo.get_samples('sobol', num_samples=10, seed=111) truth_X_test = np.array([ [ 3.328958908095956, -1.8729291455820203, 0.2839687094092369, ], [ 8.11741182114929, 0.3799784183502197, -0.05574141861870885, ], [ 6.735238193068653, -0.9264274807646871, 3.631770429201424, ], [ 2.13300823001191, 1.3245289996266365, -3.547573888208717, ], [ 0.6936023756861687, -0.018464308232069016, -2.1043178741820157, ], [ 5.438151848502457, 1.7285785367712379, 2.0298107899725437, ], [ 9.085266247857362, -1.2144776917994022, -4.31197423255071, ], [ 4.468362366314977, 0.5345162367448211, 4.0739051485434175, ], [ 3.9395463559776545, -0.5726078534498811, -4.846788686700165, ], [ 9.92871844675392, 1.1744442842900753, 4.774723623413593, ], ]) for elem_1 in X_test: for elem_2 in elem_1: print(elem_2) assert np.all(np.abs(X_test - truth_X_test) < TEST_EPSILON) with pytest.raises(AssertionError) as error: model_bo.compute_acquisitions(1, X, Y, cov_X_X, inv_cov_X_X, hyps) with pytest.raises(AssertionError) as error: model_bo.compute_acquisitions(X_test, 1, Y, cov_X_X, inv_cov_X_X, hyps) with pytest.raises(AssertionError) as error: model_bo.compute_acquisitions(X_test, X, 1, cov_X_X, inv_cov_X_X, hyps) with pytest.raises(AssertionError) as error: model_bo.compute_acquisitions(X_test, X, Y, 1, inv_cov_X_X, hyps) with pytest.raises(AssertionError) as error: model_bo.compute_acquisitions(X_test, X, Y, cov_X_X, 1, hyps) with pytest.raises(AssertionError) as error: model_bo.compute_acquisitions(X_test, X, Y, cov_X_X, inv_cov_X_X, 1) with pytest.raises(AssertionError) as error: model_bo.compute_acquisitions(X_test, X, Y, cov_X_X, inv_cov_X_X, 'abc') acqs = model_bo.compute_acquisitions(X_test, X, Y, cov_X_X, inv_cov_X_X, hyps) print('acqs') for elem_1 in acqs: print(elem_1) truth_acqs = np.array([ 0.9140836833364618, 0.7893422923284443, 0.7893819649518585, 0.780516205172671, 1.170379060386938, 0.7889956503605072, 0.7893345684226016, 0.789773864915061, 0.7908883762985802, 0.7893339801719917, ]) assert isinstance(acqs, np.ndarray) assert len(acqs.shape) == 1 assert X_test.shape[0] == acqs.shape[0] assert np.all(np.abs(acqs - truth_acqs) < TEST_EPSILON)
def test_compute_posteriors_set(): np.random.seed(42) arr_range_1 = np.array([ [0.0, 10.0], [-2.0, 2.0], [-5.0, 5.0], ]) dim_X = arr_range_1.shape[0] num_X = 5 num_instances = 4 X = np.random.randn(num_X, num_instances, dim_X) Y = np.random.randn(num_X, 1) model_bo = BO(arr_range_1, str_acq='pi', str_cov='set_se', str_exp=None) hyps = utils_covariance.get_hyps(model_bo.str_cov, dim=dim_X, use_ard=model_bo.use_ard) cov_X_X, inv_cov_X_X, _ = covariance.get_kernel_inverse( X, hyps, model_bo.str_cov) X_test = np.array([ [ [1.0, 0.0, 0.0, 1.0], [2.0, -1.0, 2.0, 1.0], [3.0, -2.0, 4.0, 1.0], ], [ [4.0, 2.0, -3.0, 1.0], [5.0, 0.0, -2.0, 1.0], [6.0, -2.0, -1.0, 1.0], ], ]) with pytest.raises(AssertionError) as error: model_bo.compute_posteriors(1, Y, X_test, cov_X_X, inv_cov_X_X, hyps) with pytest.raises(AssertionError) as error: model_bo.compute_posteriors(X, 1, X_test, cov_X_X, inv_cov_X_X, hyps) with pytest.raises(AssertionError) as error: model_bo.compute_posteriors(X, Y, 1, cov_X_X, inv_cov_X_X, hyps) with pytest.raises(AssertionError) as error: model_bo.compute_posteriors(X, Y, X_test, 1, inv_cov_X_X, hyps) with pytest.raises(AssertionError) as error: model_bo.compute_posteriors(X, Y, X_test, cov_X_X, 1, hyps) with pytest.raises(AssertionError) as error: model_bo.compute_posteriors(X, Y, X_test, cov_X_X, inv_cov_X_X, 1) with pytest.raises(AssertionError) as error: model_bo.compute_posteriors(X, Y, X_test, cov_X_X, inv_cov_X_X, 1.0) with pytest.raises(AssertionError) as error: model_bo.compute_posteriors(X, Y, X_test, cov_X_X, inv_cov_X_X, 'abc') with pytest.raises(AssertionError) as error: model_bo.compute_posteriors(X, Y, X_test, cov_X_X, inv_cov_X_X, hyps) pred_mean, pred_std = model_bo.compute_posteriors(X, Y, X_test[:, :, :dim_X], cov_X_X, inv_cov_X_X, hyps) assert len(pred_mean.shape) == 1 assert len(pred_std.shape) == 1 assert pred_mean.shape[0] == pred_mean.shape[0] == X_test.shape[0]
def neg_log_ml(X_train: np.ndarray, Y_train: np.ndarray, hyps: np.ndarray, str_cov: str, prior_mu_train: np.ndarray, use_ard: bool = constants.USE_ARD, fix_noise: bool = constants.FIX_GP_NOISE, use_gradient: bool = True, debug: bool = False) -> constants.TYPING_UNION_FLOAT_FA: """ This function computes a negative log marginal likelihood. :param X_train: inputs. Shape: (n, d) or (n, m, d). :type X_train: numpy.ndarray :param Y_train: outputs. Shape: (n, 1). :type Y_train: numpy.ndarray :param hyps: hyperparameters for Gaussian process. Shape: (h, ). :type hyps: numpy.ndarray :param str_cov: the name of covariance function. :type str_cov: str. :param prior_mu_train: the prior values computed by get_prior_mu(). Shape: (n, 1). :type prior_mu_train: numpy.ndarray :param use_ard: flag for automatic relevance determination. :type use_ard: bool., optional :param fix_noise: flag for fixing a noise. :type fix_noise: bool., optional :param use_gradient: flag for computing and returning gradients of negative log marginal likelihood. :type use_gradient: bool., optional :param debug: flag for printing log messages. :type debug: bool., optional :returns: negative log marginal likelihood, or (negative log marginal likelihood, gradients of the likelihood). :rtype: float, or tuple of (float, np.ndarray) :raises: AssertionError """ utils_gp.validate_common_args(X_train, Y_train, str_cov, None, debug) assert isinstance(hyps, np.ndarray) assert isinstance(prior_mu_train, np.ndarray) assert isinstance(use_ard, bool) assert isinstance(fix_noise, bool) assert isinstance(use_gradient, bool) assert len(prior_mu_train.shape) == 2 assert X_train.shape[0] == Y_train.shape[0] == prior_mu_train.shape[0] utils_covariance.check_str_cov('neg_log_ml', str_cov, X_train.shape) num_X = float(X_train.shape[0]) hyps = utils_covariance.restore_hyps(str_cov, hyps, use_ard=use_ard, fix_noise=fix_noise, use_gp=False) new_Y_train = Y_train - prior_mu_train nu = hyps['dof'] cov_X_X, inv_cov_X_X, grad_cov_X_X = covariance.get_kernel_inverse( X_train, hyps, str_cov, fix_noise=fix_noise, use_gradient=use_gradient, debug=debug) alpha = np.dot(inv_cov_X_X, new_Y_train) beta = np.squeeze(np.dot(np.dot(new_Y_train.T, inv_cov_X_X), new_Y_train)) first_term = -0.5 * num_X * np.log((nu - 2.0) * np.pi) sign_second_term, second_term = np.linalg.slogdet(cov_X_X) # TODO: it should be checked. if sign_second_term <= 0: # pragma: no cover second_term = 0.0 second_term = -0.5 * second_term third_term = np.log( scipy.special.gamma( (nu + num_X) / 2.0) / scipy.special.gamma(nu / 2.0)) fourth_term = -0.5 * (nu + num_X) * np.log(1.0 + beta / (nu - 2.0)) log_ml_ = np.squeeze(first_term + second_term + third_term + fourth_term) log_ml_ /= num_X if use_gradient: assert grad_cov_X_X is not None grad_log_ml_ = np.zeros(grad_cov_X_X.shape[2] + 1) first_term_grad = ((nu + num_X) / (nu + beta - 2.0) * np.dot(alpha, alpha.T) - inv_cov_X_X) nu_grad = -num_X / (2.0 * (nu - 2.0))\ + scipy.special.digamma((nu + num_X) / 2.0)\ - scipy.special.digamma(nu / 2.0)\ - 0.5 * np.log(1.0 + beta / (nu - 2.0))\ + (nu + num_X) * beta / (2.0 * (nu - 2.0)**2 + 2.0 * beta * (nu - 2.0)) if fix_noise: grad_log_ml_[0] = nu_grad else: grad_log_ml_[1] = nu_grad for ind in range(0, grad_cov_X_X.shape[2]): cur_grad = 0.5 * np.trace( np.dot(first_term_grad, grad_cov_X_X[:, :, ind])) if fix_noise: grad_log_ml_[ind + 1] = cur_grad else: if ind == 0: cur_ind = 0 else: cur_ind = ind + 1 grad_log_ml_[cur_ind] = cur_grad if use_gradient: return -1.0 * log_ml_, -1.0 * grad_log_ml_ / num_X return -1.0 * log_ml_
def neg_log_ml(X_train: np.ndarray, Y_train: np.ndarray, hyps: np.ndarray, str_cov: str, prior_mu_train: np.ndarray, use_ard: bool=constants.USE_ARD, fix_noise: bool=constants.FIX_GP_NOISE, use_cholesky: bool=True, use_gradient: bool=True, debug: bool=False ) -> constants.TYPING_UNION_FLOAT_FA: """ This function computes a negative log marginal likelihood. :param X_train: inputs. Shape: (n, d) or (n, m, d). :type X_train: numpy.ndarray :param Y_train: outputs. Shape: (n, 1). :type Y_train: numpy.ndarray :param hyps: hyperparameters for Gaussian process. Shape: (h, ). :type hyps: numpy.ndarray :param str_cov: the name of covariance function. :type str_cov: str. :param prior_mu_train: the prior values computed by get_prior_mu(). Shape: (n, 1). :type prior_mu_train: numpy.ndarray :param use_ard: flag for automatic relevance determination. :type use_ard: bool., optional :param fix_noise: flag for fixing a noise. :type fix_noise: bool., optional :param use_cholesky: flag for using a cholesky decomposition. :type use_cholesky: bool., optional :param use_gradient: flag for computing and returning gradients of negative log marginal likelihood. :type use_gradient: bool., optional :param debug: flag for printing log messages. :type debug: bool., optional :returns: negative log marginal likelihood, or (negative log marginal likelihood, gradients of the likelihood). :rtype: float, or tuple of (float, np.ndarray) :raises: AssertionError """ # TODO: add use_ard. utils_gp.validate_common_args(X_train, Y_train, str_cov, None, debug) assert isinstance(hyps, np.ndarray) assert isinstance(prior_mu_train, np.ndarray) assert isinstance(use_ard, bool) assert isinstance(fix_noise, bool) assert isinstance(use_cholesky, bool) assert isinstance(use_gradient, bool) assert len(prior_mu_train.shape) == 2 assert X_train.shape[0] == Y_train.shape[0] == prior_mu_train.shape[0] utils_covariance.check_str_cov('neg_log_ml', str_cov, X_train.shape) hyps = utils_covariance.restore_hyps(str_cov, hyps, use_ard=use_ard, fix_noise=fix_noise) new_Y_train = Y_train - prior_mu_train if use_cholesky: cov_X_X, lower, grad_cov_X_X = covariance.get_kernel_cholesky(X_train, hyps, str_cov, fix_noise=fix_noise, use_gradient=use_gradient, debug=debug) alpha = scipy.linalg.cho_solve((lower, True), new_Y_train) first_term = -0.5 * np.dot(new_Y_train.T, alpha) second_term = -1.0 * np.sum(np.log(np.diagonal(lower) + constants.JITTER_LOG)) if use_gradient: assert grad_cov_X_X is not None first_term_grad = np.einsum("ik,jk->ijk", alpha, alpha) first_term_grad -= np.expand_dims(scipy.linalg.cho_solve((lower, True), np.eye(cov_X_X.shape[0])), axis=2) grad_log_ml_ = 0.5 * np.einsum("ijl,ijk->kl", first_term_grad, grad_cov_X_X) grad_log_ml_ = np.sum(grad_log_ml_, axis=1) else: # TODO: use_gradient is fixed. use_gradient = False cov_X_X, inv_cov_X_X, grad_cov_X_X = covariance.get_kernel_inverse(X_train, hyps, str_cov, fix_noise=fix_noise, use_gradient=use_gradient, debug=debug) first_term = -0.5 * np.dot(np.dot(new_Y_train.T, inv_cov_X_X), new_Y_train) sign_second_term, second_term = np.linalg.slogdet(cov_X_X) # TODO: It should be checked. if sign_second_term <= 0: # pragma: no cover second_term = 0.0 second_term = -0.5 * second_term third_term = -float(X_train.shape[0]) / 2.0 * np.log(2.0 * np.pi) log_ml_ = np.squeeze(first_term + second_term + third_term) log_ml_ /= X_train.shape[0] if use_gradient: return -1.0 * log_ml_, -1.0 * grad_log_ml_ / X_train.shape[0] return -1.0 * log_ml_
def neg_log_pseudo_l_loocv(X_train: np.ndarray, Y_train: np.ndarray, hyps: np.ndarray, str_cov: str, prior_mu_train: np.ndarray, fix_noise: bool=constants.FIX_GP_NOISE, debug: bool=False ) -> float: """ It computes a negative log pseudo-likelihood using leave-one-out cross-validation. :param X_train: inputs. Shape: (n, d) or (n, m, d). :type X_train: numpy.ndarray :param Y_train: outputs. Shape: (n, 1). :type Y_train: numpy.ndarray :param hyps: hyperparameters for Gaussian process. Shape: (h, ). :type hyps: numpy.ndarray :param str_cov: the name of covariance function. :type str_cov: str. :param prior_mu_train: the prior values computed by get_prior_mu(). Shape: (n, 1). :type prior_mu_train: numpy.ndarray :param fix_noise: flag for fixing a noise. :type fix_noise: bool., optional :param debug: flag for printing log messages. :type debug: bool., optional :returns: negative log pseudo-likelihood. :rtype: float :raises: AssertionError """ # TODO: add use_ard. utils_gp.validate_common_args(X_train, Y_train, str_cov, None, debug) assert isinstance(hyps, np.ndarray) assert isinstance(prior_mu_train, np.ndarray) assert isinstance(fix_noise, bool) assert len(prior_mu_train.shape) == 2 assert X_train.shape[0] == Y_train.shape[0] == prior_mu_train.shape[0] utils_covariance.check_str_cov('neg_log_pseudo_l_loocv', str_cov, X_train.shape) num_data = X_train.shape[0] hyps = utils_covariance.restore_hyps(str_cov, hyps, fix_noise=fix_noise) _, inv_cov_X_X, _ = covariance.get_kernel_inverse(X_train, hyps, str_cov, fix_noise=fix_noise, debug=debug) log_pseudo_l_ = 0.0 for ind_data in range(0, num_data): # TODO: check this. # cur_X_train = np.vstack((X_train[:ind_data], X_train[ind_data+1:])) # cur_Y_train = np.vstack((Y_train[:ind_data], Y_train[ind_data+1:])) # cur_X_test = np.expand_dims(X_train[ind_data], axis=0) cur_Y_test = Y_train[ind_data] cur_mu = np.squeeze(cur_Y_test) \ - np.dot(inv_cov_X_X, Y_train)[ind_data] / inv_cov_X_X[ind_data, ind_data] cur_sigma = np.sqrt(1.0 / (inv_cov_X_X[ind_data, ind_data] + constants.JITTER_COV)) first_term = -0.5 * np.log(cur_sigma**2) second_term = -0.5 * (np.squeeze(cur_Y_test - cur_mu))**2 / (cur_sigma**2) third_term = -0.5 * np.log(2.0 * np.pi) cur_log_pseudo_l_ = first_term + second_term + third_term log_pseudo_l_ += cur_log_pseudo_l_ log_pseudo_l_ /= num_data log_pseudo_l_ *= -1.0 return log_pseudo_l_