0

我有一个关于在Tensorflow-probability.

通常，如果我想创建一个内核对象，我会写

import tensorflow as tf
import tensorflow_probability as tfp
tfp_kernels = tfp.positive_semidefinite_kernels

kernel_obj = tfp_kernels.ExponentiateQuadratic(*args, **karwgs)

我知道内核对象支持批量广播。但是，如果我想构建一个内核对象，它是几个不同内核对象的总和，比如加性高斯过程，该怎么办？

我不确定如何在 Tensorflow 中“总结”内核对象。我能做的是创建几个单独的内核对象K1, ... KJ，网上好像没有类似的问题。

我在这里先向您的帮助表示感谢。

更新：我试过 direct +，但协方差矩阵有些奇怪。

我编写了以下示例：

feature1 = np.array([1, 2, 3, 5], dtype=np.float32)[:, np.newaxis]
feature2 = np.array([4.2, 6.5, 7.4, 8.3], dtype=np.float32)[:, np.newaxis]
features = np.concatenate([feature1, feature2], axis=1)

k1 = tfp_kernels.ExponentiatedQuadratic(amplitude=tf.cast(2.0, tf.float32),
                                        length_scale=tf.cast(2.0, tf.float32),
                                        feature_ndims=1,
                                        name='k1')

k2 = tfp_kernels.ExponentiatedQuadratic(amplitude=tf.cast(1.5, tf.float32),
                                        length_scale=tf.cast(1.5, tf.float32),
                                        feature_ndims=1,
                                        name='k2')

K = k1 + k2


gp_1 = tfd.GaussianProcess(kernel=k1,
                           index_points=feature1,
                           jitter=tf.cast(0, tf.float32),
                           name='gp_1')

gp_2 = tfd.GaussianProcess(kernel=k2,
                           index_points=feature2,
                           jitter=tf.cast(0, tf.float32),
                           name='gp_2')

gp_K1 = tfd.GaussianProcess(kernel=K,
                           index_points=feature1,
                           jitter=tf.cast(0, tf.float32),
                           name='gp_K')

gp_K2 = tfd.GaussianProcess(kernel=K,
                           index_points=feature2,
                           jitter=tf.cast(0, tf.float32),
                           name='gp_K')

gp_K = tfd.GaussianProcess(kernel=K,
                           index_points=features,
                           jitter=tf.cast(0, tf.float32),
                           name='gp_K')


gp_1_cov = gp_1.covariance()
gp_2_cov = gp_2.covariance()
gp_K1_cov = gp_K1.covariance()
gp_K2_cov = gp_K2.covariance()
gp_K_cov = gp_K.covariance()

with tf.Session() as my_sess:
    [gp_1_cov_, gp_2_cov_, gp_K1_cov_, gp_K2_cov_, gp_K_cov_] = my_sess.run([gp_1_cov, gp_2_cov, gp_K1_cov, gp_K2_cov, gp_K_cov])
my_sess.close()

print(gp_1_cov_)
print(gp_2_cov_)
print(gp_K1_cov_)
print(gp_K2_cov_)
print(gp_K_cov_)

前四个协方差矩阵很好，我通过逐k(x_i, x_j)元素比较来仔细检查。

但是，我不知道它如何计算最后一个。我试过了

  1. 带有 kernel_1 的 feature_1 和带有 kernel_2 的 feature_2
  2. 带有 kernel_2 的 feature_1 和带有 kernel_1 的 feature_2

下面是最后三个矩阵的结果：

[[6.25       5.331647   3.3511252  0.60561347]
 [5.331647   6.25       5.331647   1.6031142 ]
 [3.3511252  5.331647   6.25       3.3511252 ]
 [0.60561347 1.6031142  3.3511252  6.25      ]]
[[6.25       2.7592793  1.3433135  0.54289836]
 [2.7592793  6.25       5.494186   3.7630994 ]
 [1.3433135  5.494186   6.25       5.494186  ]
 [0.54289836 3.7630994  5.494186   6.25      ]]
[[6.25       2.3782768  0.769587   0.06774138]
 [2.3782768  6.25       4.694947   1.0143608 ]
 [0.769587   4.694947   6.25       2.9651313 ]
 [0.06774138 1.0143608  2.9651313  6.25      ]]

它们与我的结果不匹配。有谁知道他们如何计算不同的最后一个矩阵index_points？

或者在一般情况下，我如何指定内核，以便它们可以拟合模型，例如additive Gaussian processes，其中不同index_points对应于不同的内核函数，以便我可以y_i = f_1(x_{1,i}) + f_2(x_{2,i}) + ...在 TensorFlow Probability 框架下拟合模型？

4

1 回答 1

0

你可以写k_sum = k1 + k2！查看基类 PositiveSemidefinedKernel，我们在其中覆盖了加法和乘法运算符，你想看看它是如何工作的。

于 2019-05-19T16:53:02.167 回答