def gen_mxfusion_model(self, dtype, D, Z, noise_var, lengthscale, variance, rand_gen=None): m = Model() m.N = Variable() m.X = Variable(shape=(m.N, 3)) m.Z = Variable(shape=(3, 3), initial_value=mx.nd.array(Z, dtype=dtype)) m.noise_var = Variable(transformation=PositiveTransformation(), initial_value=mx.nd.array(noise_var, dtype=dtype)) kernel = RBF(input_dim=3, ARD=True, variance=mx.nd.array(variance, dtype=dtype), lengthscale=mx.nd.array(lengthscale, dtype=dtype), dtype=dtype) m.Y = SVGPRegression.define_variable(X=m.X, kernel=kernel, noise_var=m.noise_var, inducing_inputs=m.Z, shape=(m.N, D), dtype=dtype) gp = m.Y.factor m.Y.factor.svgp_log_pdf.jitter = 1e-8 return m, gp
def gen_mxfusion_model(self, dtype, D, noise_var, lengthscale, variance, rand_gen=None): m = Model() m.N = Variable() m.X = Variable(shape=(m.N, 3)) m.noise_var = Variable(transformation=PositiveTransformation(), initial_value=mx.nd.array(noise_var, dtype=dtype)) kernel = RBF(input_dim=3, ARD=True, variance=mx.nd.array(variance, dtype=dtype), lengthscale=mx.nd.array(lengthscale, dtype=dtype), dtype=dtype) m.Y = GPRegression.define_variable(X=m.X, kernel=kernel, noise_var=m.noise_var, shape=(m.N, D), dtype=dtype, rand_gen=rand_gen) return m
def test_with_samples(self): from mxfusion.common import config config.DEFAULT_DTYPE = 'float64' dtype = 'float64' D, X, Y, noise_var, lengthscale, variance = self.gen_data() m = Model() m.N = Variable() m.X = Normal.define_variable(mean=0, variance=1, shape=(m.N, 3)) m.noise_var = Variable(transformation=PositiveTransformation(), initial_value=mx.nd.array(noise_var, dtype=dtype)) kernel = RBF(input_dim=3, ARD=True, variance=mx.nd.array(variance, dtype=dtype), lengthscale=mx.nd.array(lengthscale, dtype=dtype), dtype=dtype) m.Y = GPRegression.define_variable(X=m.X, kernel=kernel, noise_var=m.noise_var, shape=(m.N, D)) q = create_Gaussian_meanfield(model=m, observed=[m.Y]) infr = GradBasedInference( inference_algorithm=StochasticVariationalInference( model=m, posterior=q, num_samples=10, observed=[m.Y])) infr.run(Y=mx.nd.array(Y, dtype='float64'), max_iter=2, learning_rate=0.1, verbose=True) infr2 = Inference( ForwardSamplingAlgorithm(model=m, observed=[m.X], num_samples=5)) infr2.run(X=mx.nd.array(X, dtype='float64')) infr_pred = TransferInference(ModulePredictionAlgorithm( model=m, observed=[m.X], target_variables=[m.Y]), infr_params=infr.params) xt = np.random.rand(13, 3) res = infr_pred.run(X=mx.nd.array(xt, dtype=dtype))[0] gp = m.Y.factor gp.attach_prediction_algorithms( targets=gp.output_names, conditionals=gp.input_names, algorithm=GPRegressionSamplingPrediction(gp._module_graph, gp._extra_graphs[0], [gp._module_graph.X]), alg_name='gp_predict') gp.gp_predict.diagonal_variance = False gp.gp_predict.jitter = 1e-6 infr_pred2 = TransferInference(ModulePredictionAlgorithm( model=m, observed=[m.X], target_variables=[m.Y]), infr_params=infr.params) xt = np.random.rand(13, 3) res = infr_pred2.run(X=mx.nd.array(xt, dtype=dtype))[0]
def make_gpregr_model(self): m = Model() m.N = Variable() m.X = Variable(shape=(m.N, 3)) m.noise_var = Variable(transformation=PositiveTransformation(), initial_value=mx.nd.array([1.])) kernel = RBF(input_dim=3, variance=mx.nd.array([1.]), lengthscale=mx.nd.array([1.])) m.Y = GPRegression.define_variable(X=m.X, kernel=kernel, noise_var=m.noise_var, shape=(m.N, 2)) return m
def test_prediction(self): np.random.seed(0) np.random.seed(0) X = np.random.rand(10, 3) Y = np.random.rand(10, 1) Z = np.random.rand(3, 3) qU_mean = np.random.rand(3, 1) qU_cov_W = np.random.rand(3, 3) qU_cov_diag = np.random.rand(3,) noise_var = np.random.rand(1) lengthscale = np.random.rand(3) variance = np.random.rand(1) qU_chol = np.linalg.cholesky(qU_cov_W.dot(qU_cov_W.T)+np.diag(qU_cov_diag))[None,:,:] Xt = np.random.rand(5, 3) m_gpy = GPy.core.SVGP(X=X, Y=Y, Z=Z, kernel=GPy.kern.RBF(3, ARD=True, lengthscale=lengthscale, variance=variance), likelihood=GPy.likelihoods.Gaussian(variance=noise_var)) m_gpy.q_u_mean = qU_mean m_gpy.q_u_chol = GPy.util.choleskies.triang_to_flat(qU_chol) dtype = 'float64' m = Model() m.N = Variable() m.X = Variable(shape=(m.N, 3)) m.Z = Variable(shape=(3, 3), initial_value=mx.nd.array(Z, dtype=dtype)) m.noise_var = Variable(transformation=PositiveTransformation(), initial_value=mx.nd.array(noise_var, dtype=dtype)) kernel = RBF(input_dim=3, ARD=True, variance=mx.nd.array(variance, dtype=dtype), lengthscale=mx.nd.array(lengthscale, dtype=dtype), dtype=dtype) m.Y = SVGPRegression.define_variable(X=m.X, kernel=kernel, noise_var=m.noise_var, inducing_inputs=m.Z, shape=(m.N, 1), dtype=dtype) gp = m.Y.factor observed = [m.X, m.Y] infr = Inference(MAP(model=m, observed=observed), dtype=dtype) infr.initialize(X=X.shape, Y=Y.shape) infr.params[gp._extra_graphs[0].qU_mean] = mx.nd.array(qU_mean, dtype=dtype) infr.params[gp._extra_graphs[0].qU_cov_W] = mx.nd.array(qU_cov_W, dtype=dtype) infr.params[gp._extra_graphs[0].qU_cov_diag] = mx.nd.array(qU_cov_diag, dtype=dtype) loss, _ = infr.run(X=mx.nd.array(X, dtype=dtype), Y=mx.nd.array(Y, dtype=dtype)) # noise_free, diagonal mu_gpy, var_gpy = m_gpy.predict_noiseless(Xt) infr2 = TransferInference(ModulePredictionAlgorithm(m, observed=[m.X], target_variables=[m.Y]), infr_params=infr.params, dtype=np.float64) res = infr2.run(X=mx.nd.array(Xt, dtype=dtype))[0] mu_mf, var_mf = res[0].asnumpy()[0], res[1].asnumpy()[0] assert np.allclose(mu_gpy, mu_mf), (mu_gpy, mu_mf) assert np.allclose(var_gpy[:,0], var_mf), (var_gpy[:,0], var_mf) # noisy, diagonal mu_gpy, var_gpy = m_gpy.predict(Xt) infr2 = TransferInference(ModulePredictionAlgorithm(m, observed=[m.X], target_variables=[m.Y]), infr_params=infr.params, dtype=np.float64) infr2.inference_algorithm.model.Y.factor.svgp_predict.noise_free = False res = infr2.run(X=mx.nd.array(Xt, dtype=dtype))[0] mu_mf, var_mf = res[0].asnumpy()[0], res[1].asnumpy()[0] assert np.allclose(mu_gpy, mu_mf), (mu_gpy, mu_mf) assert np.allclose(var_gpy[:,0], var_mf), (var_gpy[:,0], var_mf)
def test_sampling_prediction(self): np.random.seed(0) X = np.random.rand(10, 3) Xt = np.random.rand(20, 3) Y = np.random.rand(10, 1) noise_var = np.random.rand(1) lengthscale = np.random.rand(3) variance = np.random.rand(1) m_gpy = GPy.models.GPRegression(X=X, Y=Y, kernel=GPy.kern.RBF( 3, ARD=True, lengthscale=lengthscale, variance=variance), noise_var=noise_var) dtype = 'float64' m = Model() m.N = Variable() m.X = Variable(shape=(m.N, 3)) m.noise_var = Variable(transformation=PositiveTransformation(), initial_value=mx.nd.array(noise_var, dtype=dtype)) kernel = RBF(input_dim=3, ARD=True, variance=mx.nd.array(variance, dtype=dtype), lengthscale=mx.nd.array(lengthscale, dtype=dtype), dtype=dtype) m.Y = GPRegression.define_variable(X=m.X, kernel=kernel, noise_var=m.noise_var, shape=(m.N, 1), dtype=dtype) observed = [m.X, m.Y] infr = Inference(MAP(model=m, observed=observed), dtype=dtype) loss, _ = infr.run(X=mx.nd.array(X, dtype=dtype), Y=mx.nd.array(Y, dtype=dtype)) infr_pred = TransferInference(ModulePredictionAlgorithm( model=m, observed=[m.X], target_variables=[m.Y], num_samples=5), infr_params=infr.params) gp = m.Y.factor gp.attach_prediction_algorithms( targets=gp.output_names, conditionals=gp.input_names, algorithm=GPRegressionSamplingPrediction(gp._module_graph, gp._extra_graphs[0], [gp._module_graph.X]), alg_name='gp_predict') gp.gp_predict.diagonal_variance = False gp.gp_predict.jitter = 1e-6 y_samples = infr_pred.run(X=mx.nd.array(Xt, dtype=dtype))[0].asnumpy()
def test_module_clone(self): D, X, Y, Z, noise_var, lengthscale, variance = self.gen_data() dtype = 'float64' m = Model() m.N = Variable() kernel = RBF(input_dim=3, ARD=True, variance=mx.nd.array(variance, dtype=dtype), lengthscale=mx.nd.array(lengthscale, dtype=dtype), dtype=dtype) m.Y = SparseGPRegression.define_variable(X=mx.nd.zeros((2, 3)), kernel=kernel, noise_var=mx.nd.ones((1,)), dtype=dtype) m.clone()
def test_clone_gp(self, dtype, X, X_isSamples, rbf_lengthscale, rbf_lengthscale_isSamples, rbf_variance, rbf_variance_isSamples, rv, rv_isSamples, num_samples): X_mx = prepare_mxnet_array(X, X_isSamples, dtype) rbf_lengthscale_mx = prepare_mxnet_array(rbf_lengthscale, rbf_lengthscale_isSamples, dtype) rbf_variance_mx = prepare_mxnet_array(rbf_variance, rbf_variance_isSamples, dtype) rv_mx = prepare_mxnet_array(rv, rv_isSamples, dtype) rv_shape = rv.shape[1:] if rv_isSamples else rv.shape rbf = RBF(2, True, 1., 1., 'rbf', None, dtype) m = Model() m.X_var = Variable(shape=(5, 2)) m.Y = GaussianProcess.define_variable(X=m.X_var, kernel=rbf, shape=rv_shape, dtype=dtype) gp = m.clone().Y.factor variables = { gp.X.uuid: X_mx, gp.rbf_lengthscale.uuid: rbf_lengthscale_mx, gp.rbf_variance.uuid: rbf_variance_mx, gp.random_variable.uuid: rv_mx } log_pdf_rt = gp.log_pdf(F=mx.nd, variables=variables).asnumpy() log_pdf_np = [] for i in range(num_samples): X_i = X[i] if X_isSamples else X lengthscale_i = rbf_lengthscale[ i] if rbf_lengthscale_isSamples else rbf_lengthscale variance_i = rbf_variance[ i] if rbf_variance_isSamples else rbf_variance rv_i = rv[i] if rv_isSamples else rv rbf_np = GPy.kern.RBF(input_dim=2, ARD=True) rbf_np.lengthscale = lengthscale_i rbf_np.variance = variance_i K_np = rbf_np.K(X_i) log_pdf_np.append( multivariate_normal.logpdf(rv_i[:, 0], mean=None, cov=K_np)) log_pdf_np = np.array(log_pdf_np) isSamples_any = any([ X_isSamples, rbf_lengthscale_isSamples, rbf_variance_isSamples, rv_isSamples ]) assert np.issubdtype(log_pdf_rt.dtype, dtype) assert array_has_samples(mx.nd, log_pdf_rt) == isSamples_any if isSamples_any: assert get_num_samples(mx.nd, log_pdf_rt) == num_samples assert np.allclose(log_pdf_np, log_pdf_rt)
def test_sampling_prediction(self): np.random.seed(0) np.random.seed(0) X = np.random.rand(10, 3) Y = np.random.rand(10, 1) Z = np.random.rand(3, 3) qU_mean = np.random.rand(3, 1) qU_cov_W = np.random.rand(3, 3) qU_cov_diag = np.random.rand(3,) noise_var = np.random.rand(1) lengthscale = np.random.rand(3) variance = np.random.rand(1) qU_chol = np.linalg.cholesky(qU_cov_W.dot(qU_cov_W.T)+np.diag(qU_cov_diag))[None,:,:] Xt = np.random.rand(5, 3) m_gpy = GPy.core.SVGP(X=X, Y=Y, Z=Z, kernel=GPy.kern.RBF(3, ARD=True, lengthscale=lengthscale, variance=variance), likelihood=GPy.likelihoods.Gaussian(variance=noise_var)) m_gpy.q_u_mean = qU_mean m_gpy.q_u_chol = GPy.util.choleskies.triang_to_flat(qU_chol) dtype = 'float64' m = Model() m.N = Variable() m.X = Variable(shape=(m.N, 3)) m.Z = Variable(shape=(3, 3), initial_value=mx.nd.array(Z, dtype=dtype)) m.noise_var = Variable(transformation=PositiveTransformation(), initial_value=mx.nd.array(noise_var, dtype=dtype)) kernel = RBF(input_dim=3, ARD=True, variance=mx.nd.array(variance, dtype=dtype), lengthscale=mx.nd.array(lengthscale, dtype=dtype), dtype=dtype) m.Y = SVGPRegression.define_variable(X=m.X, kernel=kernel, noise_var=m.noise_var, inducing_inputs=m.Z, shape=(m.N, 1), dtype=dtype) gp = m.Y.factor observed = [m.X, m.Y] infr = Inference(MAP(model=m, observed=observed), dtype=dtype) infr.initialize(X=X.shape, Y=Y.shape) infr.params[gp._extra_graphs[0].qU_mean] = mx.nd.array(qU_mean, dtype=dtype) infr.params[gp._extra_graphs[0].qU_cov_W] = mx.nd.array(qU_cov_W, dtype=dtype) infr.params[gp._extra_graphs[0].qU_cov_diag] = mx.nd.array(qU_cov_diag, dtype=dtype) loss, _ = infr.run(X=mx.nd.array(X, dtype=dtype), Y=mx.nd.array(Y, dtype=dtype)) # noise_free, diagonal infr_pred = TransferInference(ModulePredictionAlgorithm(model=m, observed=[m.X], target_variables=[m.Y], num_samples=5), infr_params=infr.params) gp = m.Y.factor gp.attach_prediction_algorithms( targets=gp.output_names, conditionals=gp.input_names, algorithm=SVGPRegressionSamplingPrediction( gp._module_graph, gp._extra_graphs[0], [gp._module_graph.X]), alg_name='svgp_predict') gp.svgp_predict.diagonal_variance = False gp.svgp_predict.jitter = 1e-6 y_samples = infr_pred.run(X=mx.nd.array(Xt, dtype=dtype))[0].asnumpy()
def test_log_pdf(self): np.random.seed(0) D = 2 X = np.random.rand(10, 3) Y = np.random.rand(10, D) noise_var = np.random.rand(1) lengthscale = np.random.rand(3) variance = np.random.rand(1) m_gpy = GPy.models.GPRegression(X=X, Y=Y, kernel=GPy.kern.RBF( 3, ARD=True, lengthscale=lengthscale, variance=variance), noise_var=noise_var) l_gpy = m_gpy.log_likelihood() dtype = 'float64' m = Model() m.N = Variable() m.X = Variable(shape=(m.N, 3)) m.noise_var = Variable(transformation=PositiveTransformation(), initial_value=mx.nd.array(noise_var, dtype=dtype)) kernel = RBF(input_dim=3, ARD=True, variance=mx.nd.array(variance, dtype=dtype), lengthscale=mx.nd.array(lengthscale, dtype=dtype), dtype=dtype) m.Y = GPRegression.define_variable(X=m.X, kernel=kernel, noise_var=m.noise_var, shape=(m.N, D), dtype=dtype) observed = [m.X, m.Y] infr = Inference(MAP(model=m, observed=observed), dtype=dtype) loss, _ = infr.run(X=mx.nd.array(X, dtype=dtype), Y=mx.nd.array(Y, dtype=dtype)) l_mf = -loss assert np.allclose(l_mf.asnumpy(), l_gpy)
def gen_mxfusion_model_w_mean(self, dtype, D, Z, noise_var, lengthscale, variance, rand_gen=None): net = nn.HybridSequential(prefix='nn_') with net.name_scope(): net.add(nn.Dense(D, flatten=False, activation="tanh", in_units=3, dtype=dtype)) net.initialize(mx.init.Xavier(magnitude=3)) m = Model() m.N = Variable() m.X = Variable(shape=(m.N, 3)) m.Z = Variable(shape=(3, 3), initial_value=mx.nd.array(Z, dtype=dtype)) m.noise_var = Variable(transformation=PositiveTransformation(), initial_value=mx.nd.array(noise_var, dtype=dtype)) kernel = RBF(input_dim=3, ARD=True, variance=mx.nd.array(variance, dtype=dtype), lengthscale=mx.nd.array(lengthscale, dtype=dtype), dtype=dtype) m.mean_func = MXFusionGluonFunction(net, num_outputs=1, broadcastable=True) m.Y = SparseGPRegression.define_variable(X=m.X, kernel=kernel, noise_var=m.noise_var, mean=m.mean_func(m.X), inducing_inputs=m.Z, shape=(m.N, D), dtype=dtype) m.Y.factor.sgp_log_pdf.jitter = 1e-8 return m, net
def test_log_pdf_w_samples_of_noise_var(self): D, X, Y, Z, noise_var, lengthscale, variance, qU_mean, \ qU_cov_W, qU_cov_diag, qU_chol = self.gen_data() dtype = 'float64' D = 2 Y = np.random.rand(10, D) qU_mean = np.random.rand(3, D) m = Model() m.N = Variable() m.X = Variable(shape=(m.N, 3)) m.Z = Variable(shape=(3, 3), initial_value=mx.nd.array(Z, dtype=dtype)) m.noise_var = Variable(transformation=PositiveTransformation(), shape=(m.N, D)) kernel = RBF(input_dim=3, ARD=True, variance=mx.nd.array(variance, dtype=dtype), lengthscale=mx.nd.array(lengthscale, dtype=dtype), dtype=dtype) m.Y = SVGPRegression.define_variable(X=m.X, kernel=kernel, noise_var=m.noise_var, inducing_inputs=m.Z, shape=(m.N, D), dtype=dtype) gp = m.Y.factor m.Y.factor.svgp_log_pdf.jitter = 1e-8 observed = [m.X, m.Y] infr = Inference(MAP(model=m, observed=observed), dtype=dtype) infr.initialize(X=X.shape, Y=Y.shape) infr.params[gp._extra_graphs[0].qU_mean] = mx.nd.array(qU_mean, dtype=dtype) infr.params[gp._extra_graphs[0].qU_cov_W] = mx.nd.array(qU_cov_W, dtype=dtype) infr.params[gp._extra_graphs[0].qU_cov_diag] = mx.nd.array(qU_cov_diag, dtype=dtype) loss, _ = infr.run(X=mx.nd.array(X, dtype=dtype), Y=mx.nd.array(Y, dtype=dtype), max_iter=1)
def test_log_pdf(self): np.random.seed(0) D = 2 X = np.random.rand(10, 3) Y = np.random.rand(10, D) Z = np.random.rand(3, 3) qU_mean = np.random.rand(3, D) qU_cov_W = np.random.rand(3, 3) qU_cov_diag = np.random.rand(3,) noise_var = np.random.rand(1) lengthscale = np.random.rand(3) variance = np.random.rand(1) qU_chol = np.linalg.cholesky(qU_cov_W.dot(qU_cov_W.T)+np.diag(qU_cov_diag))[None,:,:] m_gpy = GPy.core.SVGP(X=X, Y=Y, Z=Z, kernel=GPy.kern.RBF(3, ARD=True, lengthscale=lengthscale, variance=variance), likelihood=GPy.likelihoods.Gaussian(variance=noise_var)) m_gpy.q_u_mean = qU_mean m_gpy.q_u_chol = GPy.util.choleskies.triang_to_flat(qU_chol) l_gpy = m_gpy.log_likelihood() dtype = 'float64' m = Model() m.N = Variable() m.X = Variable(shape=(m.N, 3)) m.Z = Variable(shape=(3, 3), initial_value=mx.nd.array(Z, dtype=dtype)) m.noise_var = Variable(transformation=PositiveTransformation(), initial_value=mx.nd.array(noise_var, dtype=dtype)) kernel = RBF(input_dim=3, ARD=True, variance=mx.nd.array(variance, dtype=dtype), lengthscale=mx.nd.array(lengthscale, dtype=dtype), dtype=dtype) m.Y = SVGPRegression.define_variable(X=m.X, kernel=kernel, noise_var=m.noise_var, inducing_inputs=m.Z, shape=(m.N, D), dtype=dtype) gp = m.Y.factor observed = [m.X, m.Y] infr = Inference(MAP(model=m, observed=observed), dtype=dtype) infr.initialize(X=X.shape, Y=Y.shape) infr.params[gp._extra_graphs[0].qU_mean] = mx.nd.array(qU_mean, dtype=dtype) infr.params[gp._extra_graphs[0].qU_cov_W] = mx.nd.array(qU_cov_W, dtype=dtype) infr.params[gp._extra_graphs[0].qU_cov_diag] = mx.nd.array(qU_cov_diag, dtype=dtype) loss, _ = infr.run(X=mx.nd.array(X, dtype=dtype), Y=mx.nd.array(Y, dtype=dtype)) l_mf = -loss assert np.allclose(l_mf.asnumpy(), l_gpy)
def make_gpregr_model(self, lengthscale, variance, noise_var): from mxfusion.models import Model from mxfusion.components.variables import Variable, PositiveTransformation from mxfusion.modules.gp_modules import GPRegression from mxfusion.components.distributions.gp.kernels import RBF dtype = 'float64' m = Model() m.N = Variable() m.X = Variable(shape=(m.N, 3)) m.noise_var = Variable(transformation=PositiveTransformation(), initial_value=mx.nd.array(noise_var, dtype=dtype)) kernel = RBF(input_dim=3, ARD=True, variance=mx.nd.array(variance, dtype=dtype), lengthscale=mx.nd.array(lengthscale, dtype=dtype), dtype=dtype) m.Y = GPRegression.define_variable(X=m.X, kernel=kernel, noise_var=m.noise_var, shape=(m.N, 1), dtype=dtype) return m
def test_draw_samples(self): np.random.seed(0) X = np.random.rand(10, 3) Y = np.random.rand(10, 1) noise_var = np.random.rand(1) lengthscale = np.random.rand(3) variance = np.random.rand(1) dtype = 'float64' rand_gen = MockMXNetRandomGenerator( mx.nd.array(np.random.rand(20), dtype=dtype)) m = Model() m.N = Variable() m.X = Variable(shape=(m.N, 3)) m.noise_var = Variable(transformation=PositiveTransformation(), initial_value=mx.nd.array(noise_var, dtype=dtype)) kernel = RBF(input_dim=3, ARD=True, variance=mx.nd.array(variance, dtype=dtype), lengthscale=mx.nd.array(lengthscale, dtype=dtype), dtype=dtype) m.Y = GPRegression.define_variable(X=m.X, kernel=kernel, noise_var=m.noise_var, shape=(m.N, 1), dtype=dtype, rand_gen=rand_gen) observed = [m.X] infr = Inference(ForwardSamplingAlgorithm(m, observed, num_samples=2, target_variables=[m.Y]), dtype=dtype) samples = infr.run(X=mx.nd.array(X, dtype=dtype), Y=mx.nd.array(Y, dtype=dtype))[0].asnumpy() kern = RBF(3, True, name='rbf', dtype=dtype) + White(3, dtype=dtype) X_var = Variable(shape=(10, 3)) gp = GaussianProcess.define_variable(X=X_var, kernel=kern, shape=(10, 1), dtype=dtype, rand_gen=rand_gen).factor variables = { gp.X.uuid: mx.nd.expand_dims(mx.nd.array(X, dtype=dtype), axis=0), gp.add_rbf_lengthscale.uuid: mx.nd.expand_dims(mx.nd.array(lengthscale, dtype=dtype), axis=0), gp.add_rbf_variance.uuid: mx.nd.expand_dims(mx.nd.array(variance, dtype=dtype), axis=0), gp.add_white_variance.uuid: mx.nd.expand_dims(mx.nd.array(noise_var, dtype=dtype), axis=0) } samples_2 = gp.draw_samples(F=mx.nd, variables=variables, num_samples=2).asnumpy() assert np.allclose(samples, samples_2), (samples, samples_2)
def test_prediction(self): np.random.seed(0) X = np.random.rand(10, 3) Xt = np.random.rand(20, 3) Y = np.random.rand(10, 1) noise_var = np.random.rand(1) lengthscale = np.random.rand(3) variance = np.random.rand(1) m_gpy = GPy.models.GPRegression(X=X, Y=Y, kernel=GPy.kern.RBF( 3, ARD=True, lengthscale=lengthscale, variance=variance), noise_var=noise_var) dtype = 'float64' m = Model() m.N = Variable() m.X = Variable(shape=(m.N, 3)) m.noise_var = Variable(transformation=PositiveTransformation(), initial_value=mx.nd.array(noise_var, dtype=dtype)) kernel = RBF(input_dim=3, ARD=True, variance=mx.nd.array(variance, dtype=dtype), lengthscale=mx.nd.array(lengthscale, dtype=dtype), dtype=dtype) m.Y = GPRegression.define_variable(X=m.X, kernel=kernel, noise_var=m.noise_var, shape=(m.N, 1), dtype=dtype) observed = [m.X, m.Y] infr = Inference(MAP(model=m, observed=observed), dtype=dtype) loss, _ = infr.run(X=mx.nd.array(X, dtype=dtype), Y=mx.nd.array(Y, dtype=dtype)) # noise_free, diagonal mu_gpy, var_gpy = m_gpy.predict_noiseless(Xt) infr2 = TransferInference(ModulePredictionAlgorithm( m, observed=[m.X], target_variables=[m.Y]), infr_params=infr.params, dtype=np.float64) res = infr2.run(X=mx.nd.array(Xt, dtype=dtype))[0] mu_mf, var_mf = res[0].asnumpy()[0], res[1].asnumpy()[0] assert np.allclose(mu_gpy, mu_mf), (mu_gpy, mu_mf) assert np.allclose(var_gpy[:, 0], var_mf), (var_gpy[:, 0], var_mf) # noisy, diagonal mu_gpy, var_gpy = m_gpy.predict(Xt) infr2 = TransferInference(ModulePredictionAlgorithm( m, observed=[m.X], target_variables=[m.Y]), infr_params=infr.params, dtype=np.float64) infr2.inference_algorithm.model.Y.factor.gp_predict.noise_free = False res = infr2.run(X=mx.nd.array(Xt, dtype=dtype))[0] mu_mf, var_mf = res[0].asnumpy()[0], res[1].asnumpy()[0] assert np.allclose(mu_gpy, mu_mf), (mu_gpy, mu_mf) assert np.allclose(var_gpy[:, 0], var_mf), (var_gpy[:, 0], var_mf) # noise_free, full_cov mu_gpy, var_gpy = m_gpy.predict_noiseless(Xt, full_cov=True) infr2 = TransferInference(ModulePredictionAlgorithm( m, observed=[m.X], target_variables=[m.Y]), infr_params=infr.params, dtype=np.float64) infr2.inference_algorithm.model.Y.factor.gp_predict.diagonal_variance = False infr2.inference_algorithm.model.Y.factor.gp_predict.noise_free = True res = infr2.run(X=mx.nd.array(Xt, dtype=dtype))[0] mu_mf, var_mf = res[0].asnumpy()[0], res[1].asnumpy()[0] assert np.allclose(mu_gpy, mu_mf), (mu_gpy, mu_mf) assert np.allclose(var_gpy, var_mf), (var_gpy, var_mf) # noisy, full_cov mu_gpy, var_gpy = m_gpy.predict(Xt, full_cov=True) infr2 = TransferInference(ModulePredictionAlgorithm( m, observed=[m.X], target_variables=[m.Y]), infr_params=infr.params, dtype=np.float64) infr2.inference_algorithm.model.Y.factor.gp_predict.diagonal_variance = False infr2.inference_algorithm.model.Y.factor.gp_predict.noise_free = False res = infr2.run(X=mx.nd.array(Xt, dtype=dtype))[0] mu_mf, var_mf = res[0].asnumpy()[0], res[1].asnumpy()[0] print((var_gpy, var_mf)) assert np.allclose(mu_gpy, mu_mf), (mu_gpy, mu_mf) assert np.allclose(var_gpy, var_mf), (var_gpy, var_mf)
def test_clone_cond_gp(self, dtype, X, X_isSamples, X_cond, X_cond_isSamples, Y_cond, Y_cond_isSamples, rbf_lengthscale, rbf_lengthscale_isSamples, rbf_variance, rbf_variance_isSamples, rv, rv_isSamples, num_samples): from scipy.linalg.lapack import dtrtrs X_mx = prepare_mxnet_array(X, X_isSamples, dtype) X_cond_mx = prepare_mxnet_array(X_cond, X_cond_isSamples, dtype) Y_cond_mx = prepare_mxnet_array(Y_cond, Y_cond_isSamples, dtype) rbf_lengthscale_mx = prepare_mxnet_array(rbf_lengthscale, rbf_lengthscale_isSamples, dtype) rbf_variance_mx = prepare_mxnet_array(rbf_variance, rbf_variance_isSamples, dtype) rv_mx = prepare_mxnet_array(rv, rv_isSamples, dtype) rv_shape = rv.shape[1:] if rv_isSamples else rv.shape rbf = RBF(2, True, 1., 1., 'rbf', None, dtype) m = Model() m.X_var = Variable(shape=(5, 2)) m.X_cond_var = Variable(shape=(8, 2)) m.Y_cond_var = Variable(shape=(8, 1)) m.Y = ConditionalGaussianProcess.define_variable(X=m.X_var, X_cond=m.X_cond_var, Y_cond=m.Y_cond_var, kernel=rbf, shape=rv_shape, dtype=dtype) gp = m.clone().Y.factor variables = { gp.X.uuid: X_mx, gp.X_cond.uuid: X_cond_mx, gp.Y_cond.uuid: Y_cond_mx, gp.rbf_lengthscale.uuid: rbf_lengthscale_mx, gp.rbf_variance.uuid: rbf_variance_mx, gp.random_variable.uuid: rv_mx } log_pdf_rt = gp.log_pdf(F=mx.nd, variables=variables).asnumpy() log_pdf_np = [] for i in range(num_samples): X_i = X[i] if X_isSamples else X X_cond_i = X_cond[i] if X_cond_isSamples else X_cond Y_cond_i = Y_cond[i] if Y_cond_isSamples else Y_cond lengthscale_i = rbf_lengthscale[ i] if rbf_lengthscale_isSamples else rbf_lengthscale variance_i = rbf_variance[ i] if rbf_variance_isSamples else rbf_variance rv_i = rv[i] if rv_isSamples else rv rbf_np = GPy.kern.RBF(input_dim=2, ARD=True) rbf_np.lengthscale = lengthscale_i rbf_np.variance = variance_i K_np = rbf_np.K(X_i) Kc_np = rbf_np.K(X_cond_i, X_i) Kcc_np = rbf_np.K(X_cond_i) L = np.linalg.cholesky(Kcc_np) LInvY = dtrtrs(L, Y_cond_i, lower=1, trans=0)[0] LinvKxt = dtrtrs(L, Kc_np, lower=1, trans=0)[0] mu = LinvKxt.T.dot(LInvY) cov = K_np - LinvKxt.T.dot(LinvKxt) log_pdf_np.append( multivariate_normal.logpdf(rv_i[:, 0], mean=mu[:, 0], cov=cov)) log_pdf_np = np.array(log_pdf_np) isSamples_any = any([ X_isSamples, rbf_lengthscale_isSamples, rbf_variance_isSamples, rv_isSamples ]) assert np.issubdtype(log_pdf_rt.dtype, dtype) assert array_has_samples(mx.nd, log_pdf_rt) == isSamples_any if isSamples_any: assert get_num_samples(mx.nd, log_pdf_rt) == num_samples assert np.allclose(log_pdf_np, log_pdf_rt)