def _make_gluon_function_evaluation_rand_param(self, dtype, broadcastable): class Dot(HybridBlock): def __init__(self, params=None, prefix=None): super(Dot, self).__init__(params=params, prefix=prefix) with self.name_scope(): self.const = self.params.get('const', shape=(1, ), dtype=dtype, init=Zero()) def hybrid_forward(self, F, a, b, const): return F.broadcast_add(F.linalg.gemm2(a, b), const) dot = Dot(prefix='dot_') dot.initialize() dot.hybridize() print(dot.collect_params()) func_wrapper = MXFusionGluonFunction(dot, 1, dtype=dtype, broadcastable=broadcastable) from mxfusion.components.distributions.normal import Normal rand_var = Normal.define_variable(shape=(1, )) out = func_wrapper(Variable(shape=(3, 4)), Variable(shape=(4, 5)), dot_const=rand_var) return out.factor
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 __init__(self): inputs = [('A', Variable(shape=(3, 4))), ('B', Variable(shape=(4, 5)))] outputs = [('output', Variable(shape=(3, 5)))] input_names = ['A', 'B'] output_names = ['output'] super(DotFuncEval, self).__init__(inputs=inputs, outputs=outputs, input_names=input_names, output_names=output_names, broadcastable=broadcastable)
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 _make_gluon_function_evaluation(self, dtype, broadcastable): class Dot(HybridBlock): def hybrid_forward(self, F, a, b): return F.linalg.gemm2(a, b) dot = Dot(prefix='dot') dot.initialize() dot.hybridize() func_wrapper = MXFusionGluonFunction(dot, 1, dtype=dtype, broadcastable=broadcastable) out = func_wrapper(Variable(shape=(3, 4)), Variable(shape=(4, 5))) return out.factor
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_draw_samples(self): np.random.seed(0) samples_1_np = np.random.randn(5) samples_1 = mx.nd.array(samples_1_np) samples_2_np = np.random.randn(50) samples_2 = mx.nd.array(samples_2_np) m = Model() v = Variable(shape=(1,)) m.v2 = Normal.define_variable(mean=v, variance=mx.nd.array([1]), rand_gen=MockMXNetRandomGenerator(samples_1)) m.v3 = Normal.define_variable(mean=m.v2, variance=mx.nd.array([0.1]), shape=(10,), rand_gen=MockMXNetRandomGenerator(samples_2)) np.random.seed(0) v_np =np.random.rand(1) v_mx = mx.nd.array(v_np) v_rt = add_sample_dimension(mx.nd, v_mx) variance = m.v2.factor.variance variance2 = m.v3.factor.variance variance_rt = add_sample_dimension(mx.nd, variance.constant) variance2_rt = add_sample_dimension(mx.nd, variance2.constant) samples = m.draw_samples(F=mx.nd, num_samples=5, targets=[m.v3.uuid], variables={v.uuid: v_rt, variance.uuid: variance_rt, variance2.uuid: variance2_rt})[0] samples_np = v_np + samples_1_np[:, None] + np.sqrt(0.1)*samples_2_np.reshape(5,10) assert array_has_samples(mx.nd, samples) and get_num_samples(mx.nd, samples)==5 assert np.allclose(samples.asnumpy(), samples_np)
def test_compute_log_prob(self): m = Model() v = Variable(shape=(1,)) m.v2 = Normal.define_variable(mean=v, variance=mx.nd.array([1])) m.v3 = Normal.define_variable(mean=m.v2, variance=mx.nd.array([1]), shape=(10,)) np.random.seed(0) v_mx = mx.nd.array(np.random.randn(1)) v2_mx = mx.nd.array(np.random.randn(1)) v3_mx = mx.nd.array(np.random.randn(10)) v_rt = add_sample_dimension(mx.nd, v_mx) v2_rt = add_sample_dimension(mx.nd, v2_mx) v3_rt = add_sample_dimension(mx.nd, v3_mx) variance = m.v2.factor.variance variance2 = m.v3.factor.variance variance_rt = add_sample_dimension(mx.nd, variance.constant) variance2_rt = add_sample_dimension(mx.nd, variance2.constant) log_pdf = m.log_pdf(F=mx.nd, variables={m.v2.uuid: v2_rt, m.v3.uuid:v3_rt, variance.uuid: variance_rt, variance2.uuid: variance2_rt, v.uuid: v_rt}).asscalar() variables = {m.v2.factor.mean.uuid: v_rt, m.v2.factor.variance.uuid: variance_rt, m.v2.factor.random_variable.uuid: v2_rt} log_pdf_1 = mx.nd.sum(m.v2.factor.log_pdf(F=mx.nd, variables=variables)) variables = {m.v3.factor.mean.uuid: v2_rt, m.v3.factor.variance.uuid: variance2_rt, m.v3.factor.random_variable.uuid: v3_rt} log_pdf_2 = mx.nd.sum(m.v3.factor.log_pdf(F=mx.nd, variables=variables)) assert log_pdf == (log_pdf_1 + log_pdf_2).asscalar()
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 test_function_execution(self): f, f_mx = self.instantialize_customize_function() np.random.seed(0) A = mx.nd.array(np.random.rand(1, 3, 2)) B = mx.nd.array(np.random.rand(1, 3, 2)) C = mx.nd.array(np.random.rand(1)) A_mf = Variable(shape=A.shape) B_mf = Variable(shape=B.shape) outs = f(A_mf, B_mf) assert len(outs) == 2 eval = f(A_mf, B_mf)[0].factor variables = {A_mf.uuid: A, B_mf.uuid: B, eval.C.uuid: C} res_eval = eval.eval(F=mx.nd, variables=variables) res_mx = f_mx(A, B, C) assert np.allclose(res_eval[0].asnumpy(), res_mx[0].asnumpy()) assert np.allclose(res_eval[1].asnumpy(), res_mx[1].asnumpy())
def test_module_clone(self): D, X, Y, Z, noise_var, lengthscale, variance, qU_mean, \ qU_cov_W, qU_cov_diag, qU_chol = self.gen_data() dtype = 'float64' m = Model() m.N = Variable() m.X = Variable(shape=(m.N, 3)) 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=mx.nd.zeros((2, 3)), kernel=kernel, noise_var=mx.nd.ones((1, )), dtype=dtype) m.clone()
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_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_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 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_gluon_parameters(self): self.setUp() m = Model() m.x = Variable(shape=(1, 1)) m.f = MXFusionGluonFunction(self.net, num_outputs=1) m.y = m.f(m.x) infr = Inference(ForwardSamplingAlgorithm(m, observed=[m.x])) infr.run(x=mx.nd.ones((1, 1))) assert all([ v.uuid in infr.params.param_dict for v in m.f.parameters.values() ])
def test_draw_samples_w_mean(self): D, X, Y, noise_var, lengthscale, variance = self.gen_data() dtype = 'float64' rand_gen = MockMXNetRandomGenerator( mx.nd.array(np.random.rand(20 * D), dtype=dtype)) m, net = self.gen_mxfusion_model_w_mean(dtype, D, noise_var, lengthscale, variance, 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)) mean_func = MXFusionGluonFunction(net, num_outputs=1, broadcastable=True) mean_var = mean_func(X_var) gp = GaussianProcess.define_variable(X=X_var, kernel=kern, mean=mean_var, shape=(10, D), 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), mean_var.uuid: mx.nd.expand_dims(net(mx.nd.array(X, 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_draw_samples(self, dtype, X, X_isSamples, rbf_lengthscale, rbf_lengthscale_isSamples, rbf_variance, rbf_variance_isSamples, rv_shape, 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) rand = np.random.randn(num_samples, *rv_shape) rand_gen = MockMXNetRandomGenerator( mx.nd.array(rand.flatten(), dtype=dtype)) rbf = RBF(2, True, 1., 1., 'rbf', None, dtype) X_var = Variable(shape=(5, 2)) gp = GaussianProcess.define_variable(X=X_var, kernel=rbf, shape=rv_shape, dtype=dtype, rand_gen=rand_gen).factor variables = { gp.X.uuid: X_mx, gp.rbf_lengthscale.uuid: rbf_lengthscale_mx, gp.rbf_variance.uuid: rbf_variance_mx } samples_rt = gp.draw_samples(F=mx.nd, variables=variables, num_samples=num_samples).asnumpy() samples_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 rand_i = rand[i] 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) L_np = np.linalg.cholesky(K_np) sample_np = L_np.dot(rand_i) samples_np.append(sample_np) samples_np = np.array(samples_np) assert np.issubdtype(samples_rt.dtype, dtype) assert get_num_samples(mx.nd, samples_rt) == num_samples assert np.allclose(samples_np, samples_rt)
def test_save_reload_constants(self): constants = {Variable(): 5, 'uuid': mx.nd.array([1])} ip = InferenceParameters(constants=constants) ip.save(prefix="constants_test") # assert the file is there ip2 = InferenceParameters.load_parameters( mxnet_constants_file='constants_test_mxnet_constants.json', variable_constants_file='constants_test_variable_constants.json') print(ip.constants) print(ip2.constants) assert ip.constants == ip2.constants self.remove_saved_files("constants_test")
def test_decode_component(self): v = Variable() v2 = Variable() v.predecessors = [('first', v2)] v.attributes = [Variable()] #[('shape', (Variable(), 1))] data = { "var": v } a = json.dumps(data, cls=ModelComponentEncoder, indent=2) b = json.loads(a, cls=ModelComponentDecoder) assert b == data
def test_encode_component(self): v = Variable() v2 = Variable() v.predecessors = [('first', v2)] # TODO: extend attributes to support generic representation v.attributes = [Variable()]#[('shape', (Variable(), 1))] data = { "var": v } a = json.dumps(data, cls=ModelComponentEncoder, indent=2) print(a)
def make_simple_model(self): m = Model() mean = Variable() variance = Variable() m.r = Normal.define_variable(mean=mean, variance=variance) 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_draw_samples_w_mean(self, dtype, X, X_isSamples, rbf_lengthscale, rbf_lengthscale_isSamples, rbf_variance, rbf_variance_isSamples, rv_shape, num_samples): net = nn.HybridSequential(prefix='nn_') with net.name_scope(): net.add( nn.Dense(rv_shape[-1], flatten=False, activation="tanh", in_units=X.shape[-1], dtype=dtype)) net.initialize(mx.init.Xavier(magnitude=3)) 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) mean_mx = net(X_mx) mean_np = mean_mx.asnumpy() rand = np.random.randn(num_samples, *rv_shape) rand_gen = MockMXNetRandomGenerator( mx.nd.array(rand.flatten(), dtype=dtype)) rbf = RBF(2, True, 1., 1., 'rbf', None, dtype) X_var = Variable(shape=(5, 2)) mean_func = MXFusionGluonFunction(net, num_outputs=1, broadcastable=True) mean_var = mean_func(X_var) gp = GaussianProcess.define_variable(X=X_var, kernel=rbf, shape=rv_shape, mean=mean_var, dtype=dtype, rand_gen=rand_gen).factor variables = { gp.X.uuid: X_mx, gp.rbf_lengthscale.uuid: rbf_lengthscale_mx, gp.rbf_variance.uuid: rbf_variance_mx, gp.mean.uuid: mean_mx } samples_rt = gp.draw_samples(F=mx.nd, variables=variables, num_samples=num_samples).asnumpy() samples_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 rand_i = rand[i] 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) L_np = np.linalg.cholesky(K_np) sample_np = L_np.dot(rand_i) samples_np.append(sample_np) samples_np = np.array(samples_np) + mean_np assert np.issubdtype(samples_rt.dtype, dtype) assert get_num_samples(mx.nd, samples_rt) == num_samples assert np.allclose(samples_np, samples_rt)
def test_log_pdf_w_mean(self, dtype, X, X_isSamples, rbf_lengthscale, rbf_lengthscale_isSamples, rbf_variance, rbf_variance_isSamples, rv, rv_isSamples, num_samples): net = nn.HybridSequential(prefix='nn_') with net.name_scope(): net.add( nn.Dense(rv.shape[-1], flatten=False, activation="tanh", in_units=X.shape[-1], dtype=dtype)) net.initialize(mx.init.Xavier(magnitude=3)) 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 mean_mx = net(X_mx) mean_np = mean_mx.asnumpy() rbf = RBF(2, True, 1., 1., 'rbf', None, dtype) X_var = Variable(shape=(5, 2)) mean_func = MXFusionGluonFunction(net, num_outputs=1, broadcastable=True) mean_var = mean_func(X_var) gp = GaussianProcess.define_variable(X=X_var, kernel=rbf, shape=rv_shape, mean=mean_var, dtype=dtype).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, gp.mean.uuid: mean_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 rv_i = rv_i - mean_np[i] if X_isSamples else rv_i - mean_np[0] 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_success(self): self.setUp() f = MXFusionGluonFunction(self.net, num_outputs=1) x = Variable() y = f(x)