1

我正在创建一些 GPflow 模型，其中我需要阈值前后的观察x0是先验独立的。我可以仅使用 GP 模型或使用具有无限陡度的 ChangePoints 内核来实现这一点，但是这两种解决方案都不适用于我未来的扩展（尤其是 MOGP）。

我想我可以轻松地从头开始构建我想要的东西，所以我制作了一个新的 Combination 内核对象，它使用适当的子内核 pre- 或 post x0。当我在一组输入点上评估内核时，这按预期工作；阈值前后点之间的预期相关性为零，其余由子内核确定：

import numpy as np
import gpflow
from gpflow.kernels import Matern32
import matplotlib.pyplot as plt
import tensorflow as tf
from gpflow.kernels import Combination


class IndependentKernel(Combination):

    def __init__(self, kernels, x0, forcing_variable=0, name=None):

        self.x0 = x0
        self.forcing_variable = forcing_variable
        super().__init__(kernels, name=name)

    def K(self, X, X2=None):
        # threshold X, X2 based on self.x0, and construct a joint tensor
        if X2 is None:
            X2 = X

        fv = self.forcing_variable
        mask = tf.dtypes.cast(X[:, fv] >= self.x0, tf.int32)

        X_partitioned = tf.dynamic_partition(X, mask, 2)
        X2_partitioned = tf.dynamic_partition(X2, mask, 2)

        K_pre = self.kernels[0].K(X_partitioned[0], X2_partitioned[0])
        K_post = self.kernels[1].K(X_partitioned[1], X2_partitioned[1])

        zero_block_1 = tf.zeros([K_pre.shape[0], K_post.shape[1]], tf.float64)
        zero_block_2 = tf.zeros([K_post.shape[0], K_pre.shape[1]], tf.float64)
        upper_row = tf.concat([K_pre, zero_block_1], axis=1)
        lower_row = tf.concat([zero_block_2, K_post], axis=1)

        return tf.concat([upper_row, lower_row], axis=0)

    #
    def K_diag(self, X):
        fv = self.forcing_variable
        mask = tf.dtypes.cast(X[:, fv] >= self.x0, tf.int32)

        X_partitioned = tf.dynamic_partition(X, mask, 2)
        return tf.concat([self.kernels[0].K_diag(X_partitioned[0]),
                          self.kernels[1].K_diag(X_partitioned[1])],
                         axis=1)

    #
#


def f(x):
    return np.sin(6*(x-0.7))


x0 = 0.3
n = 100
x = np.linspace(0, 1, n)
sigma = 0.5
y = np.random.normal(loc=f(x), scale=sigma)
fv = 0
X = x[:, None]

kernel = IndependentKernel([Matern32(), Matern32()], x0=x0, name='indep')
x_pred = np.linspace(0, 1, 100)

K = kernel.K(x_pred[:, None])  # <- kernel is evaluated correctly here

但是，当我想用​​这个内核训练一个 GPflow 模型时，我收到错误消息TypeError: Expected int32, got None of type 'NoneType' instead.这似乎是由子内核矩阵产生的K_pre，并且K_post是 size (None, 1)，而不是预期的正方形（如果我评估内核，它们是正确的） '手动'）。

m = gpflow.models.GPR(data=(X, y[:, None]), kernel=kernel)

gpflow.optimizers.Scipy().minimize(m.training_loss,
                                   m.trainable_variables,
                                   options=dict(maxiter=10000),
                                   method="L-BFGS-B")  # <- K_pre & K_post are of size (None, 1) now?

我该怎么做才能使内核正确训练？

我正在使用 GPflow 2.1.3 和 TensorFlow 2.4.1。

4

1 回答 1

0

这不是 GPflow 问题，而是 TensorFlow 的渴望与图形模式的微妙之处：在渴望模式下（这是您在调用内核时“手动”与张量交互时的默认行为）K_pre.shape按预期工作。在图形模式下（当您将代码包装在 中时会发生这种情况tf.function()，这通常并不总是有效（例如，形状可能取决于具有无形状的 tf.Variables），并且您必须改为使用tf.shape(K_pre)来获取动态形状（这取决于变量中的实际值）。默认情况下，GPflow 的 Scipy 类将损失和梯度计算包装在内部tf.function()以加速优化。如果您通过传递显式关闭它compile=False对于最小化（）调用，您的代码示例运行良好。如果您.shape用调用来替换属性以tf.shape()正确修复它，它同样会运行良好。

于 2021-03-31T14:11:08.100 回答