Question

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

我想我可以很容易地从头开始构建我想要的东西，所以我创建了一个新的组合内核对象，它在 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 导致的大小为 (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。

Answer 1

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

GPflow 2 自定义内核构建：构建时很好，但内核大小无优化

1 个答案: