From 58c7441b4e1f6fab93c4283330f573b282da178b Mon Sep 17 00:00:00 2001 From: Daniel Emaasit Date: Tue, 23 Oct 2018 00:06:43 -0400 Subject: [PATCH] added tests for students tp, sparse gp --- README.rst | 6 +- pmlearn/gaussian_process/gpr.py | 61 ++- pmlearn/gaussian_process/tests/test_gpr.py | 492 ++++++++++----------- 3 files changed, 288 insertions(+), 271 deletions(-) diff --git a/README.rst b/README.rst index 821f666..55420eb 100644 --- a/README.rst +++ b/README.rst @@ -262,8 +262,8 @@ project: https://github.com/parsing-science/pymc3_models. .. |Travis| image:: https://travis-ci.com/pymc-learn/pymc-learn.svg?branch=master :target: https://travis-ci.com/pymc-learn/pymc-learn -.. |Coverage| image:: https://coveralls.io/repos/github/pymc-learn/pymc-learn/badge.svg - :target: https://coveralls.io/github/pymc-learn/pymc-learn +.. |Coverage| image:: https://coveralls.io/repos/github/pymc-learn/pymc-learn/badge.svg?branch=master + :target: https://coveralls.io/github/pymc-learn/pymc-learn?branch=master .. |Python27| image:: https://img.shields.io/badge/python-2.7-blue.svg :target: https://badge.fury.io/py/pymc-learn @@ -280,4 +280,4 @@ project: https://github.com/parsing-science/pymc3_models. :target: https://github.com/pymc-learn/pymc-learn/blob/master/LICENSE .. |Pypi| image:: https://badge.fury.io/py/pymc-learn.svg - :target: https://badge.fury.io/py/pymc-learn \ No newline at end of file + :target: https://badge.fury.io/py/pymc-learn diff --git a/pmlearn/gaussian_process/gpr.py b/pmlearn/gaussian_process/gpr.py index 9ba1794..4f41373 100644 --- a/pmlearn/gaussian_process/gpr.py +++ b/pmlearn/gaussian_process/gpr.py @@ -173,7 +173,8 @@ def load(self, file_prefix): self.num_training_samples = params['num_training_samples'] -class StudentsTProcessRegressor(GaussianProcessRegressor): +class StudentsTProcessRegressor(BayesianModel, + GaussianProcessRegressorMixin): """ StudentsT Process Regression built using PyMC3. Fit a StudentsT process model and estimate model parameters using @@ -204,8 +205,15 @@ class StudentsTProcessRegressor(GaussianProcessRegressor): Rasmussen and Williams (2006). Gaussian Processes for Machine Learning. """ - def __init__(self, prior_mean=0.0): - super(StudentsTProcessRegressor, self).__init__(prior_mean=prior_mean) + def __init__(self, prior_mean=None, kernel=None): + self.ppc = None + self.gp = None + self.num_training_samples = None + self.num_pred = None + self.prior_mean = prior_mean + self.kernel = kernel + + super(StudentsTProcessRegressor, self).__init__() def create_model(self): """ Creates and returns the PyMC3 model. @@ -241,13 +249,17 @@ def create_model(self): degrees_of_freedom = pm.Gamma('degrees_of_freedom', alpha=2, beta=0.1, shape=1) - # cov_function = signal_variance**2 * pm.gp.cov.ExpQuad( - # 1, length_scale) - cov_function = signal_variance ** 2 * pm.gp.cov.Matern52( - 1, length_scale) + if self.kernel is None: + cov_function = signal_variance ** 2 * RBF( + input_dim=self.num_pred, + ls=length_scale) + else: + cov_function = self.kernel - # mean_function = pm.gp.mean.Zero() - mean_function = pm.gp.mean.Constant(self.prior_mean) + if self.prior_mean is None: + mean_function = pm.gp.mean.Zero() + else: + mean_function = self.prior_mean self.gp = pm.gp.Latent(mean_func=mean_function, cov_func=cov_function) @@ -277,7 +289,8 @@ def load(self, file_prefix): self.num_training_samples = params['num_training_samples'] -class SparseGaussianProcessRegressor(GaussianProcessRegressor): +class SparseGaussianProcessRegressor(BayesianModel, + GaussianProcessRegressorMixin): """ Sparse Gaussian Process Regression built using PyMC3. Fit a Sparse Gaussian process model and estimate model parameters using @@ -308,9 +321,15 @@ class SparseGaussianProcessRegressor(GaussianProcessRegressor): Rasmussen and Williams (2006). Gaussian Processes for Machine Learning. """ - def __init__(self, prior_mean=0.0): - super(SparseGaussianProcessRegressor, self).__init__( - prior_mean=prior_mean) + def __init__(self, prior_mean=None, kernel=None): + self.ppc = None + self.gp = None + self.num_training_samples = None + self.num_pred = None + self.prior_mean = prior_mean + self.kernel = kernel + + super(SparseGaussianProcessRegressor, self).__init__() def create_model(self): """ Creates and returns the PyMC3 model. @@ -344,13 +363,17 @@ def create_model(self): noise_variance = pm.HalfCauchy('noise_variance', beta=5, shape=1) - # cov_function = signal_variance**2 * pm.gp.cov.ExpQuad( - # 1, length_scale) - cov_function = signal_variance ** 2 * pm.gp.cov.Matern52( - 1, length_scale) + if self.kernel is None: + cov_function = signal_variance ** 2 * RBF( + input_dim=self.num_pred, + ls=length_scale) + else: + cov_function = self.kernel - # mean_function = pm.gp.mean.Zero() - mean_function = pm.gp.mean.Constant(self.prior_mean) + if self.prior_mean is None: + mean_function = pm.gp.mean.Zero() + else: + mean_function = self.prior_mean self.gp = pm.gp.MarginalSparse(mean_func=mean_function, cov_func=cov_function, diff --git a/pmlearn/gaussian_process/tests/test_gpr.py b/pmlearn/gaussian_process/tests/test_gpr.py index 255516b..dfb98ea 100644 --- a/pmlearn/gaussian_process/tests/test_gpr.py +++ b/pmlearn/gaussian_process/tests/test_gpr.py @@ -19,7 +19,9 @@ from pmlearn.exceptions import NotFittedError -from pmlearn.gaussian_process import (GaussianProcessRegressor) +from pmlearn.gaussian_process import (GaussianProcessRegressor, + StudentsTProcessRegressor, + SparseGaussianProcessRegressor) # , # SparseGaussianProcessRegressor, # StudentsTProcessRegressor) @@ -144,251 +146,243 @@ def test_save_and_load_work_correctly(self): npt.assert_almost_equal(score1, score2, 0) -# class StudentsTProcessRegressorTestCase(unittest.TestCase): -# -# def setUp(self): -# self.num_training_samples = 150 -# self.num_pred = 1 -# -# self.length_scale = 2.0 -# self.noise_variance = 1.0 -# self.signal_variance = 1.0 -# self.degrees_of_freedom = 3.0 -# -# X = np.linspace(start=0, stop=10, num=self.num_training_samples)[:, None] -# cov_func = self.signal_variance**2 * pm.gp.cov.ExpQuad(self.num_pred, -# self.length_scale) -# -# mean_func = pm.gp.mean.Zero() -# f_ = np.random.multivariate_normal(mean_func(X).eval(), -# cov_func(X).eval() + 1e-8 * np.eye(self.num_training_samples), -# self.num_pred -# ).flatten() -# -# y = f_ + self.noise_variance * np.random.standard_t(self.degrees_of_freedom, -# size=self.num_training_samples) -# self.X_train, self.X_test, self.y_train, self.y_test = train_test_split( -# X, y, test_size=0.3 -# ) -# -# self.test_STPR = StudentsTProcessRegressor() -# # self.test_nuts_STPR = StudentsTProcessRegressor() -# self.test_dir = tempfile.mkdtemp() -# -# def tearDown(self): -# shutil.rmtree(self.test_dir) -# -# -# class StudentsTProcessRegressorFitTestCase(StudentsTProcessRegressorTestCase): -# def test_advi_fit_returns_correct_model(self): -# # This print statement ensures PyMC3 output won't overwrite the test name -# print('') -# self.test_STPR.fit(self.X_train, self.y_train) -# -# self.assertEqual(self.num_pred, self.test_STPR.num_pred) -# self.assertAlmostEqual(self.signal_variance, -# int(self.test_STPR.summary['mean']['signal_variance__0']), -# 0) -# self.assertAlmostEqual(self.length_scale, -# int(self.test_STPR.summary['mean']['length_scale__0_0']), -# 0) -# self.assertAlmostEqual(self.noise_variance, -# int(self.test_STPR.summary['mean']['noise_variance__0']), -# 0) - - # def test_nuts_fit_returns_correct_model(self): - # # This print statement ensures PyMC3 output won't overwrite the test name - # print('') - # self.test_nuts_STPR.fit(self.X_train, self.y_train, inference_type='nuts') - # - # self.assertEqual(self.num_pred, self.test_nuts_STPR.num_pred) - # self.assertAlmostEqual(self.signal_variance, - # int(self.test_nuts_STPR.summary['mean']['signal_variance__0']), - # 0) - # self.assertAlmostEqual(self.length_scale, - # int(self.test_nuts_STPR.summary['mean']['length_scale__0_0']), - # 0) - # self.assertAlmostEqual(self.noise_variance, - # int(self.test_nuts_STPR.summary['mean']['noise_variance__0']), - # 0) - - -# class StudentsTProcessRegressorPredictTestCase(StudentsTProcessRegressorTestCase): -# def test_predict_returns_predictions(self): -# print('') -# self.test_STPR.fit(self.X_train, self.y_train) -# preds = self.test_STPR.predict(self.X_test) -# self.assertEqual(self.y_test.shape, preds.shape) -# -# def test_predict_returns_mean_predictions_and_std(self): -# print('') -# self.test_STPR.fit(self.X_train, self.y_train) -# preds, stds = self.test_STPR.predict(self.X_test, return_std=True) -# self.assertEqual(self.y_test.shape, preds.shape) -# self.assertEqual(self.y_test.shape, stds.shape) -# -# def test_predict_raises_error_if_not_fit(self): -# print('') -# with self.assertRaises(NotFittedError) as no_fit_error: -# test_STPR = StudentsTProcessRegressor() -# test_STPR.predict(self.X_train) -# -# expected = 'Run fit on the model before predict.' -# self.assertEqual(str(no_fit_error.exception), expected) -# -# -# class StudentsTProcessRegressorScoreTestCase(StudentsTProcessRegressorTestCase): -# def test_score_matches_sklearn_performance(self): -# print('') -# skGPR = skGaussianProcessRegressor() -# skGPR.fit(self.X_train, self.y_train) -# skGPR_score = skGPR.score(self.X_test, self.y_test) -# -# self.test_STPR.fit(self.X_train, self.y_train) -# test_STPR_score = self.test_STPR.score(self.X_test, self.y_test) -# -# self.assertAlmostEqual(skGPR_score, test_STPR_score, 1) -# -# -# class StudentsTProcessRegressorSaveAndLoadTestCase(StudentsTProcessRegressorTestCase): -# def test_save_and_load_work_correctly(self): -# print('') -# self.test_STPR.fit(self.X_train, self.y_train) -# score1 = self.test_STPR.score(self.X_test, self.y_test) -# self.test_STPR.save(self.test_dir) -# -# STPR2 = StudentsTProcessRegressor() -# STPR2.load(self.test_dir) -# -# self.assertEqual(self.test_STPR.inference_type, STPR2.inference_type) -# self.assertEqual(self.test_STPR.num_pred, STPR2.num_pred) -# self.assertEqual(self.test_STPR.num_training_samples, STPR2.num_training_samples) -# pd.testing.assert_frame_equal(summary(self.test_STPR.trace), -# summary(STPR2.trace)) -# -# score2 = STPR2.score(self.X_test, self.y_test) -# self.assertAlmostEqual(score1, score2, 1) -# -# -# class SparseGaussianProcessRegressorTestCase(unittest.TestCase): -# -# def setUp(self): -# self.num_training_samples = 150 -# self.num_pred = 1 -# -# self.length_scale = 1.0 -# self.noise_variance = 2.0 -# self.signal_variance = 3.0 -# -# X = np.linspace(start=0, stop=10, num=self.num_training_samples)[:, None] -# cov_func = self.signal_variance**2 * pm.gp.cov.ExpQuad(self.num_pred, -# self.length_scale) -# -# mean_func = pm.gp.mean.Zero() -# f_ = np.random.multivariate_normal(mean_func(X).eval(), -# cov_func(X).eval() + 1e-8 * np.eye(self.num_training_samples), -# self.num_pred -# ).flatten() -# -# y = f_ + self.noise_variance * np.random.randn(self.num_training_samples) -# self.X_train, self.X_test, self.y_train, self.y_test = train_test_split( -# X, y, test_size=0.3 -# ) -# -# self.test_SGPR = SparseGaussianProcessRegressor() -# # self.test_nuts_SGPR = SparseGaussianProcessRegressor() -# self.test_dir = tempfile.mkdtemp() -# -# def tearDown(self): -# shutil.rmtree(self.test_dir) -# -# -# class SparseGaussianProcessRegressorFitTestCase(SparseGaussianProcessRegressorTestCase): -# def test_advi_fit_returns_correct_model(self): -# # This print statement ensures PyMC3 output won't overwrite the test name -# print('') -# self.test_SGPR.fit(self.X_train, self.y_train) -# -# self.assertEqual(self.num_pred, self.test_SGPR.num_pred) -# self.assertAlmostEqual(self.signal_variance, -# int(self.test_SGPR.summary['mean']['signal_variance__0']), -# 0) -# self.assertAlmostEqual(self.length_scale, -# int(self.test_SGPR.summary['mean']['length_scale__0_0']), -# 0) -# self.assertAlmostEqual(self.noise_variance, -# int(self.test_SGPR.summary['mean']['noise_variance__0']), -# 0) - - # def test_nuts_fit_returns_correct_model(self): - # # This print statement ensures PyMC3 output won't overwrite the test name - # print('') - # self.test_nuts_SGPR.fit(self.X_train, self.y_train, inference_type='nuts') - # - # self.assertEqual(self.num_pred, self.test_nuts_SGPR.num_pred) - # self.assertAlmostEqual(self.signal_variance, - # int(self.test_nuts_SGPR.summary['mean']['signal_variance__0']), - # 0) - # self.assertAlmostEqual(self.length_scale, - # int(self.test_nuts_SGPR.summary['mean']['length_scale__0_0']), - # 0) - # self.assertAlmostEqual(self.noise_variance, - # int(self.test_nuts_SGPR.summary['mean']['noise_variance__0']), - # 0) - - -# class SparseGaussianProcessRegressorPredictTestCase(SparseGaussianProcessRegressorTestCase): -# def test_predict_returns_predictions(self): -# print('') -# self.test_SGPR.fit(self.X_train, self.y_train) -# preds = self.test_SGPR.predict(self.X_test) -# self.assertEqual(self.y_test.shape, preds.shape) -# -# def test_predict_returns_mean_predictions_and_std(self): -# print('') -# self.test_SGPR.fit(self.X_train, self.y_train) -# preds, stds = self.test_SGPR.predict(self.X_test, return_std=True) -# self.assertEqual(self.y_test.shape, preds.shape) -# self.assertEqual(self.y_test.shape, stds.shape) -# -# def test_predict_raises_error_if_not_fit(self): -# print('') -# with self.assertRaises(NotFittedError) as no_fit_error: -# test_SGPR = SparseGaussianProcessRegressor() -# test_SGPR.predict(self.X_train) -# -# expected = 'Run fit on the model before predict.' -# self.assertEqual(str(no_fit_error.exception), expected) -# -# -# class SparseGaussianProcessRegressorScoreTestCase(SparseGaussianProcessRegressorTestCase): -# def test_score_matches_sklearn_performance(self): -# print('') -# skGPR = skGaussianProcessRegressor() -# skGPR.fit(self.X_train, self.y_train) -# skGPR_score = skGPR.score(self.X_test, self.y_test) -# -# self.test_SGPR.fit(self.X_train, self.y_train) -# test_SGPR_score = self.test_SGPR.score(self.X_test, self.y_test) -# -# self.assertAlmostEqual(skGPR_score, test_SGPR_score, 1) -# -# -# class SparseGaussianProcessRegressorSaveAndLoadTestCase(SparseGaussianProcessRegressorTestCase): -# def test_save_and_load_work_correctly(self): -# print('') -# self.test_SGPR.fit(self.X_train, self.y_train) -# score1 = self.test_SGPR.score(self.X_test, self.y_test) -# self.test_SGPR.save(self.test_dir) -# -# SGPR2 = SparseGaussianProcessRegressor() -# SGPR2.load(self.test_dir) -# -# self.assertEqual(self.test_SGPR.inference_type, SGPR2.inference_type) -# self.assertEqual(self.test_SGPR.num_pred, SGPR2.num_pred) -# self.assertEqual(self.test_SGPR.num_training_samples, SGPR2.num_training_samples) -# pd.testing.assert_frame_equal(summary(self.test_SGPR.trace), -# summary(SGPR2.trace)) -# -# score2 = SGPR2.score(self.X_test, self.y_test) -# self.assertAlmostEqual(score1, score2, 1) \ No newline at end of file +class TestStudentsTProcessRegressor(object): + + def setup_method(self): + self.num_pred = 1 + self.num_training_samples = 500 + + self.length_scale = 1.0 + self.signal_variance = 0.1 + self.noise_variance = 0.1 + self.degrees_of_freedom = 1.0 + + X = np.linspace(start=0, stop=10, + num=self.num_training_samples)[:, None] + + cov_func = self.signal_variance ** 2 * pm.gp.cov.ExpQuad( + 1, self.length_scale) + mean_func = pm.gp.mean.Zero() + + f_true = np.random.multivariate_normal( + mean_func(X).eval(), + cov_func(X).eval() + 1e-8 * np.eye(self.num_training_samples), + 1).flatten() + y = f_true + \ + self.noise_variance * \ + np.random.standard_t(self.degrees_of_freedom, + size=self.num_training_samples) + + self.X_train, self.X_test, self.y_train, self.y_test = \ + train_test_split(X, y, test_size=0.3) + + self.advi_stpr = StudentsTProcessRegressor() + + self.test_dir = tempfile.mkdtemp() + + def tearDown(self): + shutil.rmtree(self.test_dir) + + +class TestStudentsTProcessRegressorFit(TestStudentsTProcessRegressor): + def test_advi_fit_returns_correct_model(self): + # This print statement ensures PyMC3 output won't overwrite + # the test name + print('') + self.advi_stpr.fit(self.X_train, self.y_train, + inference_args={"n": 25000}) + + npt.assert_equal(self.num_pred, self.advi_stpr.num_pred) + npt.assert_almost_equal( + self.signal_variance, + self.advi_stpr.summary['mean']['signal_variance__0'], + 0) + npt.assert_almost_equal( + self.length_scale, + self.advi_stpr.summary['mean']['length_scale__0_0'], + 0) + npt.assert_almost_equal( + self.noise_variance, + self.advi_stpr.summary['mean']['noise_variance__0'], + 0) + + +class TestStudentsTProcessRegressorPredict(TestStudentsTProcessRegressor): + def test_predict_returns_predictions(self): + print('') + self.advi_stpr.fit(self.X_train, self.y_train, + inference_args={"n": 25000}) + preds = self.advi_stpr.predict(self.X_test) + npt.assert_equal(self.y_test.shape, preds.shape) + + def test_predict_returns_mean_predictions_and_std(self): + print('') + self.advi_stpr.fit(self.X_train, self.y_train, + inference_args={"n": 25000}) + preds, stds = self.advi_stpr.predict(self.X_test, return_std=True) + npt.assert_equal(self.y_test.shape, preds.shape) + npt.assert_equal(self.y_test.shape, stds.shape) + + def test_predict_raises_error_if_not_fit(self): + print('') + with pytest.raises(NotFittedError): + advi_stpr = StudentsTProcessRegressor() + advi_stpr.predict(self.X_train) + + +class TestStudentsTProcessRegressorScore(TestStudentsTProcessRegressor): + def test_score_matches_sklearn_performance(self): + print('') + sk_gpr = skGaussianProcessRegressor() + sk_gpr.fit(self.X_train, self.y_train) + sk_gpr_score = sk_gpr.score(self.X_test, self.y_test) + + self.advi_stpr.fit(self.X_train, self.y_train, + inference_args={"n": 25000}) + advi_stpr_score = self.advi_stpr.score(self.X_test, self.y_test) + + npt.assert_almost_equal(sk_gpr_score, advi_stpr_score, 0) + + +class TestStudentsTProcessRegressorSaveAndLoad(TestStudentsTProcessRegressor): + def test_save_and_load_work_correctly(self): + print('') + self.advi_stpr.fit(self.X_train, self.y_train, + inference_args={"n": 25000}) + score1 = self.advi_stpr.score(self.X_test, self.y_test) + self.advi_stpr.save(self.test_dir) + + stpr2 = StudentsTProcessRegressor() + stpr2.load(self.test_dir) + + npt.assert_equal(self.advi_stpr.inference_type, stpr2.inference_type) + npt.assert_equal(self.advi_stpr.num_pred, stpr2.num_pred) + npt.assert_equal(self.advi_stpr.num_training_samples, + stpr2.num_training_samples) + pdt.assert_frame_equal(summary(self.advi_stpr.trace), + summary(stpr2.trace)) + + score2 = stpr2.score(self.X_test, self.y_test) + npt.assert_almost_equal(score1, score2, 0) + + +class TestSparseGaussianProcessRegressor(object): + + def setup_method(self): + self.num_pred = 1 + self.num_training_samples = 1000 + + self.length_scale = 1.0 + self.signal_variance = 0.1 + self.noise_variance = 0.1 + + X = np.linspace(start=0, stop=10, + num=self.num_training_samples)[:, None] + + cov_func = self.signal_variance ** 2 * pm.gp.cov.ExpQuad( + 1, self.length_scale) + mean_func = pm.gp.mean.Zero() + + f_true = np.random.multivariate_normal( + mean_func(X).eval(), + cov_func(X).eval() + 1e-8 * np.eye(self.num_training_samples), + 1).flatten() + y = f_true + \ + self.noise_variance * np.random.randn(self.num_training_samples) + + self.X_train, self.X_test, self.y_train, self.y_test = \ + train_test_split(X, y, test_size=0.3) + + self.advi_sgpr = SparseGaussianProcessRegressor() + + self.test_dir = tempfile.mkdtemp() + + def teardown_method(self): + """Tear down + """ + shutil.rmtree(self.test_dir) + + +class TestSparseGaussianProcessRegressorFit(TestSparseGaussianProcessRegressor): + def test_advi_fit_returns_correct_model(self): + # This print statement ensures PyMC3 output won't overwrite + # the test name + print('') + self.advi_sgpr.fit(self.X_train, self.y_train) + + npt.assert_equal(self.num_pred, self.advi_sgpr.num_pred) + npt.assert_almost_equal( + self.signal_variance, + self.advi_sgpr.summary['mean']['signal_variance__0'], + 0) + npt.assert_almost_equal( + self.length_scale, + self.advi_sgpr.summary['mean']['length_scale__0_0'], + 0) + npt.assert_almost_equal( + self.noise_variance, + self.advi_sgpr.summary['mean']['noise_variance__0'], + 0) + + +class TestSparseGaussianProcessRegressorPredict( + TestSparseGaussianProcessRegressor): + + def test_predict_returns_predictions(self): + print('') + self.advi_sgpr.fit(self.X_train, self.y_train, + inference_args={"n": 25000}) + preds = self.advi_sgpr.predict(self.X_test) + npt.assert_equal(self.y_test.shape, preds.shape) + + def test_predict_returns_mean_predictions_and_std(self): + print('') + self.advi_sgpr.fit(self.X_train, self.y_train, + inference_args={"n": 25000}) + preds, stds = self.advi_sgpr.predict(self.X_test, return_std=True) + npt.assert_equal(self.y_test.shape, preds.shape) + npt.assert_equal(self.y_test.shape, stds.shape) + + def test_predict_raises_error_if_not_fit(self): + print('') + with pytest.raises(NotFittedError): + advi_sgpr = SparseGaussianProcessRegressor() + advi_sgpr.predict(self.X_train) + + +class TestSparseGaussianProcessRegressorScore( + TestSparseGaussianProcessRegressor): + + def test_score_matches_sklearn_performance(self): + print('') + sk_gpr = skGaussianProcessRegressor() + sk_gpr.fit(self.X_train, self.y_train) + sk_gpr_score = sk_gpr.score(self.X_test, self.y_test) + + self.advi_sgpr.fit(self.X_train, self.y_train) + advi_sgpr_score = self.advi_sgpr.score(self.X_test, self.y_test) + + npt.assert_almost_equal(sk_gpr_score, advi_sgpr_score, 0) + + +class TestSparseGaussianProcessRegressorSaveAndLoad( + TestSparseGaussianProcessRegressor): + + def test_save_and_load_work_correctly(self): + print('') + self.advi_sgpr.fit(self.X_train, self.y_train) + score1 = self.advi_sgpr.score(self.X_test, self.y_test) + self.advi_sgpr.save(self.test_dir) + + sgpr2 = SparseGaussianProcessRegressor() + sgpr2.load(self.test_dir) + + npt.assert_equal(self.advi_sgpr.inference_type, sgpr2.inference_type) + npt.assert_equal(self.advi_sgpr.num_pred, sgpr2.num_pred) + npt.assert_equal(self.advi_sgpr.num_training_samples, + sgpr2.num_training_samples) + pdt.assert_frame_equal(summary(self.advi_sgpr.trace), + summary(sgpr2.trace)) + + score2 = sgpr2.score(self.X_test, self.y_test) + npt.assert_almost_equal(score1, score2, 0)