def kernel(self, points1, points2=None):
if points2 is None:
points2 = points1
white_noise = self.white * util.eye(tf.shape(points1)[0])
else:
white_noise = 0.0
kern = tf.matmul(points1 * self.variance, tf.transpose(points2))
return kern + white_noise
def kernel(self, points1, points2=None):
if points2 is None:
points2 = points1
white_noise = self.white * util.eye(tf.shape(points1)[0])
else:
white_noise = 0.0
# Introduce dummy dimension so we can use broadcasting
f = tf.expand_dims(points1, 1) # now N x 1 x D
f2 = tf.expand_dims(points2, 0) # now 1 x M x D
r = np.float32(np.pi) * (f - f2) / self.period
r = tf.reduce_sum(tf.square(tf.sin(r) / self.lengthscale), 2)
return self.variance * tf.exp(-2 * r) + white_noise
def kernel(self, points1, points2=None):
if points2 is None:
points2 = points1
white_noise = self.white * util.eye(tf.shape(points1)[0])
else:
white_noise = 0.0
points1 = points1 / self.lengthscale
points2 = points2 / self.lengthscale
magnitude_square1 = tf.expand_dims(tf.reduce_sum(points1 ** 2, 1), 1)
magnitude_square2 = tf.expand_dims(tf.reduce_sum(points2 ** 2, 1), 1)
distances = (magnitude_square1 - 2 * tf.matmul(points1, tf.transpose(points2)) +
tf.transpose(magnitude_square2))
distances = tf.clip_by_value(distances, 0.0, self.MAX_DIST);
kern = ((self.std_dev ** 2) * tf.exp(-distances / 2.0))
return kern + white_noise
def kernel(self, points1, points2=None):
if points2 is None:
points2 = points1
white_noise = self.white * util.eye(tf.shape(points1)[0])
else:
white_noise = 0.0
# Compute the euclidian distances
magnitude_square1 = tf.expand_dims(tf.reduce_sum(points1**2, 1), 1)
magnitude_square2 = tf.expand_dims(tf.reduce_sum(points2**2, 1), 1)
distances_root = tf.sqrt(
(magnitude_square1 -
2.0 * tf.matmul(points1, tf.transpose(points2)) +
tf.transpose(magnitude_square2)))
distances_root = tf.clip_by_value(distances_root, 0.0, self.MAX_DIST)
kern = ((self.std_dev**2) * tf.exp(-distances_root / self.lengthscale))
return kern + white_noise
def kernel_split(self, points1, points2=None):
if points2 is None:
points2 = points1
white_noise = self.white * util.eye(tf.shape(points1)[0])
else:
white_noise = 0.0
X = points1 / self.lengthscale
Xs = tf.reduce_sum(tf.square(X), axis=1)
X2 = points2 / self.lengthscale
X2s = tf.reduce_sum(tf.square(X2), axis=1)
r2 = -2.0 * tf.matmul(X, X2, transpose_b=True)
r2 += tf.reshape(Xs, (-1, 1)) + tf.reshape(X2s, (1, -1))
r2 = tf.clip_by_value(r2, 0.0, self.MAX_DIST)
r = tf.sqrt(r2 + 1e-12)
kernel_matrix = (self.std_dev**2) * (1. + np.sqrt(3.) * r) * tf.exp(
-np.sqrt(3.) * r)
return (self.std_dev**2), (1. + np.sqrt(3.) * r), r
def kernel(self, points1, points2=None):
if points2 is None:
points2 = points1
white_noise = self.white * util.eye(tf.shape(points1)[0])
else:
white_noise = 0.0
# # Compute the euclidian distances
# magnitude_square1 = tf.expand_dims(tf.reduce_sum(points1 ** 2, 1), 1)
# magnitude_square2 = tf.expand_dims(tf.reduce_sum(points2 ** 2, 1), 1)
# distances_root = tf.sqrt((magnitude_square1 - 2.0 * tf.matmul(points1, tf.transpose(points2)) +
# tf.transpose(magnitude_square2))) #Numerical stability problem!!
# distances_root = tf.clip_by_value(distances_root, 0.0, self.MAX_DIST);
# # Compute constant for 3/2
# constant = np.sqrt(5.0)/self.lengthscale
# # Compute the two terms goving the kernel
# first_term=(1.0 + constant*distances_root + (5.0/3.0)*distances_root**2)
# second_term = tf.exp(-constant*distances_root)
# kernel_matrix = tf.multiply(first_term,second_term) * (self.std_dev ** 2)
X = points1 / self.lengthscale
Xs = tf.reduce_sum(tf.square(X), axis=1)
X2 = points2 / self.lengthscale
X2s = tf.reduce_sum(tf.square(X2), axis=1)
r2 = -2.0 * tf.matmul(X, X2, transpose_b=True)
r2 += tf.reshape(Xs, (-1, 1)) + tf.reshape(X2s, (1, -1))
r = tf.sqrt(r2 + 1e-12)
kernel_matrix = (self.std_dev**2) * (
1. + np.sqrt(5.) * r + 5. / 3. * r2) * tf.exp(-np.sqrt(5.) * r)
return kernel_matrix + white_noise