def testValuesAreCorrectVectorTransform(self, feature_ndims, dims):
amplitude = self.dtype(5.)
length_scale = self.dtype(0.2)
kernel = tfpk.ExponentiatedQuadratic(amplitude, length_scale,
feature_ndims)
input_shape = [dims] * feature_ndims
scale_diag = np.random.uniform(-1, 1, size=(dims, )).astype(self.dtype)
bij = bijectors.Affine(scale_diag=scale_diag)
# Scaling the last dimension.
def vector_transform(x, feature_ndims, param_expansion_ndims):
del feature_ndims, param_expansion_ndims
return bij.forward(x)
vector_transformed_kernel = tfpk.FeatureTransformed(
kernel, transformation_fn=vector_transform)
x = np.random.uniform(-1, 1, size=input_shape).astype(self.dtype)
y = np.random.uniform(-1, 1, size=input_shape).astype(self.dtype)
self.assertAllClose(
_numpy_exp_quad(amplitude,
length_scale,
scale_diag * x,
scale_diag * y,
feature_ndims=feature_ndims),
self.evaluate(vector_transformed_kernel.apply(x, y)))
def testMean(self):
mean_fn = lambda x: x[:, 0]**2
kernel = psd_kernels.ExponentiatedQuadratic()
index_points = np.expand_dims(np.random.uniform(-1., 1., 10), -1)
gp = tfd.GaussianProcess(kernel, index_points, mean_fn=mean_fn)
expected_mean = mean_fn(index_points)
self.assertAllClose(expected_mean, self.evaluate(gp.mean()))
def testRetrieveIdentityTransform(self, feature_ndims, dims):
amplitude = np.random.uniform(low=1., high=10.,
size=[10, 2]).astype(self.dtype)
inner_length_scale = self.dtype(1.)
kernel = tfpk.ExponentiatedQuadratic(amplitude, inner_length_scale,
feature_ndims)
input_shape = [dims] * feature_ndims
# This is the identity transform.
concentration1 = self.dtype(1.)
concentration0 = self.dtype(1.)
kum_kernel = tfpk.KumaraswamyTransformed(kernel, concentration1,
concentration0)
x = np.random.uniform(size=input_shape).astype(self.dtype)
y = np.random.uniform(size=input_shape).astype(self.dtype)
self.assertAllClose(
_numpy_exp_quad(amplitude,
inner_length_scale,
x,
y,
feature_ndims=feature_ndims),
self.evaluate(kum_kernel.apply(x, y)))
z = np.random.uniform(size=[10] + input_shape).astype(self.dtype)
self.assertAllClose(
_numpy_exp_quad_matrix(amplitude[..., None, None],
inner_length_scale,
z,
feature_ndims=feature_ndims),
self.evaluate(kum_kernel.matrix(z, z)))
def testVarianceAndCovarianceMatrix(self):
amp = np.float64(.5)
len_scale = np.float64(.2)
jitter = np.float64(1e-4)
observation_noise_variance = np.float64(3e-3)
kernel = psd_kernels.ExponentiatedQuadratic(amp, len_scale)
index_points = np.expand_dims(np.random.uniform(-1., 1., 10), -1)
gp = tfd.GaussianProcess(
kernel,
index_points,
observation_noise_variance=observation_noise_variance,
jitter=jitter)
def _kernel_fn(x, y):
return amp * np.exp(-.5 * (np.squeeze((x - y)**2)) / (len_scale**2))
expected_covariance = (
_kernel_fn(np.expand_dims(index_points, 0),
np.expand_dims(index_points, 1)) +
(observation_noise_variance + jitter) * np.eye(10))
self.assertAllClose(expected_covariance,
self.evaluate(gp.covariance()))
self.assertAllClose(np.diag(expected_covariance),
self.evaluate(gp.variance()))
def testValuesAreCorrectScalarTransform(self, feature_ndims, dims):
amplitude = self.dtype(5.)
length_scale = self.dtype(0.2)
kernel = tfpk.ExponentiatedQuadratic(amplitude, length_scale,
feature_ndims)
input_shape = [dims] * feature_ndims
bij = bijectors.AffineScalar(self.dtype(0.), self.dtype(2.))
# Flat multiplication by 2.
def scale_transform(x, feature_ndims, param_expansion_ndims):
del feature_ndims, param_expansion_ndims
return bij.forward(x)
scale_transformed_kernel = tfpk.FeatureTransformed(
kernel, transformation_fn=scale_transform)
x = np.random.uniform(-1, 1, size=input_shape).astype(self.dtype)
y = np.random.uniform(-1, 1, size=input_shape).astype(self.dtype)
self.assertAllClose(
_numpy_exp_quad(amplitude,
length_scale,
2. * x,
2. * y,
feature_ndims=feature_ndims),
self.evaluate(scale_transformed_kernel.apply(x, y)))
def testVarianceAndCovarianceMatrix(self):
df = np.float64(4.)
amp = np.float64(.5)
len_scale = np.float64(.2)
jitter = np.float64(1e-4)
kernel = psd_kernels.ExponentiatedQuadratic(amp, len_scale)
index_points = np.expand_dims(np.random.uniform(-1., 1., 10), -1)
tp = tfd.StudentTProcess(
df=df,
kernel=kernel,
index_points=index_points,
jitter=jitter)
def _kernel_fn(x, y):
return amp ** 2 * np.exp(-.5 * (np.squeeze((x - y)**2)) / (len_scale**2))
expected_covariance = (
_kernel_fn(np.expand_dims(index_points, 0),
np.expand_dims(index_points, 1)) +
jitter * np.eye(10))
self.assertAllClose(expected_covariance,
self.evaluate(tp.covariance()))
self.assertAllClose(np.diag(expected_covariance),
self.evaluate(tp.variance()))
def testShapes(self):
# 5x5 grid of index points in R^2 and flatten to 25x2
index_points = np.linspace(-4., 4., 5, dtype=np.float32)
index_points = np.stack(np.meshgrid(index_points, index_points), axis=-1)
index_points = np.reshape(index_points, [-1, 2])
# ==> shape = [25, 2]
# Kernel with batch_shape [2, 4, 3, 1]
amplitude = np.array([1., 2.], np.float32).reshape([2, 1, 1, 1])
length_scale = np.array([1., 2., 3., 4.], np.float32).reshape([1, 4, 1, 1])
observation_noise_variance = np.array(
[1e-5, 1e-6, 1e-5], np.float32).reshape([1, 1, 3, 1])
batched_index_points = np.stack([index_points]*6)
# ==> shape = [6, 25, 2]
if not self.is_static:
amplitude = tf.compat.v1.placeholder_with_default(amplitude, shape=None)
length_scale = tf.compat.v1.placeholder_with_default(
length_scale, shape=None)
batched_index_points = tf.compat.v1.placeholder_with_default(
batched_index_points, shape=None)
kernel = psd_kernels.ExponentiatedQuadratic(amplitude, length_scale)
gp = tfd.GaussianProcess(
kernel,
batched_index_points,
observation_noise_variance=observation_noise_variance,
jitter=1e-5)
batch_shape = [2, 4, 3, 6]
event_shape = [25]
sample_shape = [5, 3]
samples = gp.sample(sample_shape)
if self.is_static or tf.executing_eagerly():
self.assertAllEqual(gp.batch_shape_tensor(), batch_shape)
self.assertAllEqual(gp.event_shape_tensor(), event_shape)
self.assertAllEqual(samples.shape,
sample_shape + batch_shape + event_shape)
self.assertAllEqual(gp.batch_shape, batch_shape)
self.assertAllEqual(gp.event_shape, event_shape)
self.assertAllEqual(samples.shape,
sample_shape + batch_shape + event_shape)
self.assertAllEqual(gp.mean().shape, batch_shape + event_shape)
self.assertAllEqual(gp.variance().shape, batch_shape + event_shape)
else:
self.assertAllEqual(self.evaluate(gp.batch_shape_tensor()), batch_shape)
self.assertAllEqual(self.evaluate(gp.event_shape_tensor()), event_shape)
self.assertAllEqual(
self.evaluate(samples).shape,
sample_shape + batch_shape + event_shape)
self.assertIsNone(tensorshape_util.rank(samples.shape))
self.assertIsNone(tensorshape_util.rank(gp.batch_shape))
self.assertEqual(tensorshape_util.rank(gp.event_shape), 1)
self.assertIsNone(
tf.compat.dimension_value(tensorshape_util.dims(gp.event_shape)[0]))
self.assertAllEqual(
self.evaluate(tf.shape(input=gp.mean())), batch_shape + event_shape)
self.assertAllEqual(self.evaluate(
tf.shape(input=gp.variance())), batch_shape + event_shape)
def testCopy(self):
# 5 random index points in R^2
index_points_1 = np.random.uniform(-4., 4., (5, 2)).astype(np.float32)
# 10 random index points in R^2
index_points_2 = np.random.uniform(-4., 4., (10, 2)).astype(np.float32)
# ==> shape = [6, 25, 2]
if not self.is_static:
index_points_1 = tf1.placeholder_with_default(index_points_1,
shape=None)
index_points_2 = tf1.placeholder_with_default(index_points_2,
shape=None)
mean_fn = lambda x: np.array([0.], np.float32)
kernel_1 = psd_kernels.ExponentiatedQuadratic()
kernel_2 = psd_kernels.ExpSinSquared()
tp1 = tfd.StudentTProcess(df=3.,
kernel=kernel_1,
index_points=index_points_1,
mean_fn=mean_fn,
jitter=1e-5,
validate_args=True)
tp2 = tp1.copy(df=4., index_points=index_points_2, kernel=kernel_2)
event_shape_1 = [5]
event_shape_2 = [10]
self.assertEqual(tp1.mean_fn, tp2.mean_fn)
self.assertIsInstance(tp1.kernel, psd_kernels.ExponentiatedQuadratic)
self.assertIsInstance(tp2.kernel, psd_kernels.ExpSinSquared)
if self.is_static or tf.executing_eagerly():
self.assertAllEqual(tp1.batch_shape, tp2.batch_shape)
self.assertAllEqual(tp1.event_shape, event_shape_1)
self.assertAllEqual(tp2.event_shape, event_shape_2)
self.assertEqual(self.evaluate(tp1.df), 3.)
self.assertEqual(self.evaluate(tp2.df), 4.)
self.assertAllEqual(tp2.index_points, index_points_2)
self.assertAllEqual(tp1.index_points, index_points_1)
self.assertAllEqual(tp2.index_points, index_points_2)
self.assertAllEqual(tf.get_static_value(tp1.jitter),
tf.get_static_value(tp2.jitter))
else:
self.assertAllEqual(self.evaluate(tp1.batch_shape_tensor()),
self.evaluate(tp2.batch_shape_tensor()))
self.assertAllEqual(self.evaluate(tp1.event_shape_tensor()),
event_shape_1)
self.assertAllEqual(self.evaluate(tp2.event_shape_tensor()),
event_shape_2)
self.assertEqual(self.evaluate(tp1.jitter),
self.evaluate(tp2.jitter))
self.assertEqual(self.evaluate(tp1.df), 3.)
self.assertEqual(self.evaluate(tp2.df), 4.)
self.assertAllEqual(self.evaluate(tp1.index_points),
index_points_1)
self.assertAllEqual(self.evaluate(tp2.index_points),
index_points_2)
def testKernelParametersBroadcast(self, feature_ndims, dims):
# Batch shape [10, 2]
amplitude = np.random.uniform(low=1., high=10.,
size=[10, 2]).astype(self.dtype)
length_scale = np.random.uniform(low=1., high=10.,
size=[1, 2]).astype(self.dtype)
kernel = tfpk.ExponentiatedQuadratic(amplitude, length_scale,
feature_ndims)
input_shape = [dims] * feature_ndims
# Batch shape [3, 1, 2].
scale_diag = np.random.uniform(-1, 1, size=(
3,
1,
2,
dims,
)).astype(self.dtype)
# Scaling the last dimension.
def vector_transform(x, feature_ndims, param_expansion_ndims):
diag = util.pad_shape_with_ones(scale_diag,
param_expansion_ndims +
feature_ndims - 1,
start=-2)
return diag * x
vector_transformed_kernel = tfpk.FeatureTransformed(
kernel, transformation_fn=vector_transform)
x = np.random.uniform(-1, 1, size=input_shape).astype(self.dtype)
y = np.random.uniform(-1, 1, size=input_shape).astype(self.dtype)
# Pad for each feature dimension.
expanded_scale_diag = scale_diag
for _ in range(feature_ndims - 1):
expanded_scale_diag = expanded_scale_diag[..., None, :]
self.assertAllClose(
_numpy_exp_quad(amplitude,
length_scale,
expanded_scale_diag * x,
expanded_scale_diag * y,
feature_ndims=feature_ndims),
self.evaluate(vector_transformed_kernel.apply(x, y)))
z = np.random.uniform(-1, 1,
size=[10] + input_shape).astype(self.dtype)
self.assertAllClose(
_numpy_exp_quad_matrix(
# We need to take in to account the event dimension.
amplitude[..., None, None],
length_scale[..., None, None],
# Extra dimension for the event dimension.
expanded_scale_diag[..., None, :] * z,
feature_ndims=feature_ndims),
self.evaluate(vector_transformed_kernel.matrix(z, z)))
def testShapes(self):
# 5x5 grid of index points in R^2 and flatten to 25x2
index_points = np.linspace(-4., 4., 5, dtype=np.float32)
index_points = np.stack(np.meshgrid(index_points, index_points), axis=-1)
index_points = np.reshape(index_points, [-1, 2])
# ==> shape = [25, 2]
# Kernel with batch_shape [2, 4, 1]
df = np.array(
[[3., 4., 5., 4.], [7.5, 8, 5., 5.]],
dtype=np.float32).reshape([2, 4, 1])
amplitude = np.array([1., 2.], np.float32).reshape([2, 1, 1])
length_scale = np.array([1., 2., 3., 4.], np.float32).reshape([1, 4, 1])
batched_index_points = np.stack([index_points]*6)
# ==> shape = [6, 25, 2]
if not self.is_static:
df = tf1.placeholder_with_default(df, shape=None)
amplitude = tf1.placeholder_with_default(amplitude, shape=None)
length_scale = tf1.placeholder_with_default(length_scale, shape=None)
batched_index_points = tf1.placeholder_with_default(
batched_index_points, shape=None)
kernel = psd_kernels.ExponentiatedQuadratic(amplitude, length_scale)
tp = tfd.StudentTProcess(
df, kernel, batched_index_points, jitter=1e-5, validate_args=True)
batch_shape = [2, 4, 6]
event_shape = [25]
sample_shape = [5, 3]
samples = tp.sample(sample_shape)
if self.is_static or tf.executing_eagerly():
self.assertAllEqual(tp.batch_shape_tensor(), batch_shape)
self.assertAllEqual(tp.event_shape_tensor(), event_shape)
self.assertAllEqual(samples.shape,
sample_shape + batch_shape + event_shape)
self.assertAllEqual(tp.batch_shape, batch_shape)
self.assertAllEqual(tp.event_shape, event_shape)
self.assertAllEqual(samples.shape,
sample_shape + batch_shape + event_shape)
self.assertAllEqual(tp.mean().shape, batch_shape + event_shape)
self.assertAllEqual(tp.variance().shape, batch_shape + event_shape)
else:
self.assertAllEqual(self.evaluate(tp.batch_shape_tensor()), batch_shape)
self.assertAllEqual(self.evaluate(tp.event_shape_tensor()), event_shape)
self.assertAllEqual(
self.evaluate(samples).shape,
sample_shape + batch_shape + event_shape)
self.assertIsNone(tensorshape_util.rank(samples.shape))
self.assertIsNone(tensorshape_util.rank(tp.batch_shape))
self.assertEqual(tensorshape_util.rank(tp.event_shape), 1)
self.assertIsNone(
tf.compat.dimension_value(tensorshape_util.dims(tp.event_shape)[0]))
self.assertAllEqual(
self.evaluate(tf.shape(tp.mean())), batch_shape + event_shape)
self.assertAllEqual(self.evaluate(
tf.shape(tp.variance())), batch_shape + event_shape)
def testInitParameterVariations(self, noise_kwargs, implied_values):
num_test_points = 3
num_obs_points = 4
kernel = psd_kernels.ExponentiatedQuadratic()
index_points = np.random.uniform(-1., 1., (num_test_points, 1))
observation_index_points = np.random.uniform(-1., 1.,
(num_obs_points, 1))
observations = np.random.uniform(-1., 1., num_obs_points)
jitter = 1e-6
gprm = tfd.GaussianProcessRegressionModel(
kernel=kernel,
index_points=index_points,
observation_index_points=observation_index_points,
observations=observations,
jitter=jitter,
validate_args=True,
**noise_kwargs)
# 'Property' means what was passed to CTOR. 'Parameter' is the effective
# value by which the distribution is parameterized.
implied_onv_param = implied_values[
'observation_noise_variance_parameter']
implied_pnv_param = implied_values[
'predictive_noise_variance_parameter']
# k_xx - k_xn @ (k_nn + ONV) @ k_nx + PNV
k = lambda x, y: _np_kernel_matrix_fn(1., 1., x, y)
k_tt_ = k(index_points, index_points)
k_tx_ = k(index_points, observation_index_points)
k_xx_plus_noise_ = (
k(observation_index_points, observation_index_points) +
(jitter + implied_onv_param) * np.eye(num_obs_points))
expected_predictive_covariance = (
k_tt_ - np.dot(k_tx_, np.linalg.solve(k_xx_plus_noise_, k_tx_.T)) +
implied_pnv_param * np.eye(num_test_points))
# Assertion 1: predictive covariance is correct.
self.assertAllClose(self.evaluate(gprm.covariance()),
expected_predictive_covariance)
# Assertion 2: predictive_noise_variance property is correct
self.assertIsInstance(gprm.predictive_noise_variance, tf.Tensor)
self.assertAllClose(self.evaluate(gprm.predictive_noise_variance),
implied_pnv_param)
# Assertion 3: observation_noise_variance property is correct.
self.assertIsInstance(gprm.observation_noise_variance, tf.Tensor)
self.assertAllClose(
self.evaluate(gprm.observation_noise_variance),
# Note that this is, somewhat unintuitively, expceted to equal the
# predictive_noise_variance. This is because of 1) the inheritance
# structure of GPRM as a subclass of GaussianProcess and 2) the poor
# choice of name of the GaussianProcess noise parameter. The latter
# issue is being cleaned up in cl/256413439.
implied_pnv_param)
def testMarginalHasCorrectTypes(self):
gp = tfd.GaussianProcess(kernel=psd_kernels.ExponentiatedQuadratic())
self.assertIsInstance(
gp.get_marginal_distribution(
index_points=np.ones([1, 1], dtype=np.float32)), tfd.Normal)
self.assertIsInstance(
gp.get_marginal_distribution(
index_points=np.ones([10, 1], dtype=np.float32)),
tfd.MultivariateNormalLinearOperator)
def testMean(self):
mean_fn = lambda x: x[:, 0]**2
kernel = psd_kernels.ExponentiatedQuadratic()
index_points = np.expand_dims(np.random.uniform(-1., 1., 10), -1)
tp = tfd.StudentTProcess(df=3.,
kernel=kernel,
index_points=index_points,
mean_fn=mean_fn,
validate_args=True)
expected_mean = mean_fn(index_points)
self.assertAllClose(expected_mean, self.evaluate(tp.mean()))
def testMarginalHasCorrectTypes(self):
tp = tfd.StudentTProcess(df=3.,
kernel=psd_kernels.ExponentiatedQuadratic())
self.assertIsInstance(
tp.get_marginal_distribution(
index_points=np.ones([1, 1], dtype=np.float32)), tfd.StudentT)
self.assertIsInstance(
tp.get_marginal_distribution(
index_points=np.ones([10, 1], dtype=np.float32)),
tfd.MultivariateStudentTLinearOperator)
def testBatchShape(self):
# Batch shape [10, 2]
amplitude = np.random.uniform(
low=1., high=10., size=[10, 2]).astype(self.dtype)
inner_length_scale = self.dtype(1.)
# Use 3 feature_ndims.
kernel = tfpk.ExponentiatedQuadratic(
amplitude, inner_length_scale, feature_ndims=3)
scale_diag = tf.ones([20, 1, 2, 1, 1, 1])
ard_kernel = tfpk.FeatureScaled(kernel, scale_diag=scale_diag)
self.assertAllEqual([20, 10, 2], ard_kernel.batch_shape)
self.assertAllEqual(
[20, 10, 2], self.evaluate(ard_kernel.batch_shape_tensor()))
def testShapes(self):
# 5x5 grid of index points in R^2 and flatten to 25x2
index_points = np.linspace(-4., 4., 5, dtype=np.float32)
index_points = np.stack(np.meshgrid(index_points, index_points),
axis=-1)
index_points = np.reshape(index_points, [-1, 2])
# ==> shape = [25, 2]
# Kernel with batch_shape [2, 4, 1]
amplitude = np.array([1., 2.], np.float32).reshape([2, 1, 1])
length_scale = np.array([1., 2., 3., 4.],
np.float32).reshape([1, 4, 1])
batched_index_points = np.stack([index_points] * 6)
# ==> shape = [6, 25, 2]
if not self.is_static:
amplitude = tf.placeholder_with_default(amplitude, shape=None)
length_scale = tf.placeholder_with_default(length_scale,
shape=None)
batched_index_points = tf.placeholder_with_default(
batched_index_points, shape=None)
kernel = psd_kernels.ExponentiatedQuadratic(amplitude, length_scale)
gp = tfd.GaussianProcess(kernel, batched_index_points, jitter=1e-5)
batch_shape = [2, 4, 6]
event_shape = [25]
sample_shape = [5, 3]
samples = gp.sample(sample_shape)
with self.test_session():
if self.is_static or tf.executing_eagerly():
self.assertAllEqual(gp.batch_shape_tensor(), batch_shape)
self.assertAllEqual(gp.event_shape_tensor(), event_shape)
self.assertAllEqual(samples.shape,
sample_shape + batch_shape + event_shape)
self.assertAllEqual(gp.batch_shape, batch_shape)
self.assertAllEqual(gp.event_shape, event_shape)
self.assertAllEqual(samples.shape,
sample_shape + batch_shape + event_shape)
else:
self.assertAllEqual(gp.batch_shape_tensor().eval(),
batch_shape)
self.assertAllEqual(gp.event_shape_tensor().eval(),
event_shape)
self.assertAllEqual(samples.eval().shape,
sample_shape + batch_shape + event_shape)
self.assertIsNone(samples.shape.ndims)
self.assertIsNone(gp.batch_shape.ndims)
self.assertEqual(gp.event_shape.ndims, 1)
self.assertIsNone(gp.event_shape.dims[0].value)
def testCopy(self):
# 5 random index points in R^2
index_points_1 = np.random.uniform(-4., 4., (5, 2)).astype(np.float32)
# 10 random index points in R^2
index_points_2 = np.random.uniform(-4., 4., (10, 2)).astype(np.float32)
# ==> shape = [6, 25, 2]
if not self.is_static:
index_points_1 = tf.placeholder_with_default(index_points_1,
shape=None)
index_points_2 = tf.placeholder_with_default(index_points_2,
shape=None)
mean_fn = lambda x: np.array([0.], np.float32)
kernel_1 = psd_kernels.ExponentiatedQuadratic()
kernel_2 = psd_kernels.ExpSinSquared()
gp1 = tfd.GaussianProcess(kernel_1,
index_points_1,
mean_fn,
jitter=1e-5)
gp2 = gp1.copy(index_points=index_points_2, kernel=kernel_2)
event_shape_1 = [5]
event_shape_2 = [10]
with self.test_session():
self.assertEqual(gp1.mean_fn, gp2.mean_fn)
self.assertIsInstance(gp1.kernel,
psd_kernels.ExponentiatedQuadratic)
self.assertIsInstance(gp2.kernel, psd_kernels.ExpSinSquared)
if self.is_static or tf.executing_eagerly():
self.assertAllEqual(gp1.batch_shape, gp2.batch_shape)
self.assertAllEqual(gp1.event_shape, event_shape_1)
self.assertAllEqual(gp2.event_shape, event_shape_2)
self.assertAllEqual(gp1.index_points, index_points_1)
self.assertAllEqual(gp2.index_points, index_points_2)
self.assertAllEqual(tensor_util.constant_value(gp1.jitter),
tensor_util.constant_value(gp2.jitter))
else:
self.assertAllEqual(gp1.batch_shape_tensor().eval(),
gp2.batch_shape_tensor().eval())
self.assertAllEqual(gp1.event_shape_tensor().eval(),
event_shape_1)
self.assertAllEqual(gp2.event_shape_tensor().eval(),
event_shape_2)
self.assertEqual(gp1.jitter.eval(), gp2.jitter.eval())
self.assertAllEqual(gp1.index_points.eval(), index_points_1)
self.assertAllEqual(gp2.index_points.eval(), index_points_2)
def testKernelParametersBroadcast(self, feature_ndims, dims):
# Batch shape [10, 2]
amplitude = np.random.uniform(low=1., high=10.,
size=[10, 2]).astype(self.dtype)
inner_length_scale = self.dtype(1.)
kernel = tfpk.ExponentiatedQuadratic(amplitude, inner_length_scale,
feature_ndims)
input_shape = [dims] * feature_ndims
# Batch shape [3, 1, 2].
concentration1 = np.random.uniform(
2, 5, size=([3, 1, 2] + input_shape)).astype(self.dtype)
concentration0 = np.random.uniform(
2, 5, size=([3, 1, 2] + input_shape)).astype(self.dtype)
kum_kernel = tfpk.KumaraswamyTransformed(kernel, concentration1,
concentration0)
x = np.random.uniform(size=input_shape).astype(self.dtype)
y = np.random.uniform(size=input_shape).astype(self.dtype)
self.assertAllClose(_numpy_exp_quad(
amplitude,
inner_length_scale,
_kumaraswamy_warp(x, concentration1, concentration0),
_kumaraswamy_warp(y, concentration1, concentration0),
feature_ndims=feature_ndims),
self.evaluate(kum_kernel.apply(x, y)),
rtol=1e-4,
atol=1e-4)
z = np.random.uniform(size=[10] + input_shape).astype(self.dtype)
expanded_c1 = np.expand_dims(concentration1, -(feature_ndims + 1))
expanded_c0 = np.expand_dims(concentration0, -(feature_ndims + 1))
self.assertAllClose(_numpy_exp_quad_matrix(
amplitude[..., None, None],
inner_length_scale,
_kumaraswamy_warp(z, expanded_c1, expanded_c0),
feature_ndims=feature_ndims),
self.evaluate(kum_kernel.matrix(z, z)),
atol=1e-4,
rtol=1e-4)
def testErrorCases(self):
kernel = psd_kernels.ExponentiatedQuadratic()
index_points = np.random.uniform(-1., 1., (10, 1)).astype(np.float64)
observation_index_points = (np.random.uniform(-1., 1., (5, 1)).astype(
np.float64))
observations = np.random.uniform(-1., 1., 3).astype(np.float64)
# Both or neither of `observation_index_points` and `observations` must be
# specified.
with self.assertRaises(ValueError):
tfd.GaussianProcessRegressionModel(kernel,
index_points,
observation_index_points=None,
observations=observations)
with self.assertRaises(ValueError):
tfd.GaussianProcessRegressionModel(kernel,
index_points,
observation_index_points,
observations=None)
# If specified, mean_fn must be a callable.
with self.assertRaises(ValueError):
tfd.GaussianProcessRegressionModel(kernel,
index_points,
mean_fn=0.)
# Observation index point and observation counts must be broadcastable.
if self.is_static or tf.executing_eagerly:
with self.assertRaises(ValueError):
tfd.GaussianProcessRegressionModel(
kernel,
index_points,
observation_index_points=np.ones([2, 2, 2]),
observations=np.ones([5, 5]))
else:
gprm = tfd.GaussianProcessRegressionModel(
kernel,
index_points,
observation_index_points=tf.placeholder_with_default(
np.ones([2, 2, 2]), shape=None),
observations=tf.placeholder_with_default(np.ones([5, 5]),
shape=None))
with self.assertRaises(ValueError):
self.evaluate(gprm.event_shape_tensor())
def testValuesAreCorrectIdentity(self, feature_ndims, dims):
amplitude = self.dtype(5.)
length_scale = self.dtype(0.2)
kernel = tfpk.ExponentiatedQuadratic(amplitude, length_scale,
feature_ndims)
input_shape = [dims] * feature_ndims
identity_transformed_kernel = tfpk.FeatureTransformed(
kernel,
transformation_fn=lambda x, feature_ndims, param_expansion_ndims: x
)
x = np.random.uniform(-1, 1, size=input_shape).astype(self.dtype)
y = np.random.uniform(-1, 1, size=input_shape).astype(self.dtype)
self.assertAllClose(
_numpy_exp_quad(amplitude,
length_scale,
x,
y,
feature_ndims=feature_ndims),
self.evaluate(identity_transformed_kernel.apply(x, y)))
def testEmptyDataMatchesGPPrior(self):
amp = np.float64(.5)
len_scale = np.float64(.2)
jitter = np.float64(1e-4)
index_points = np.random.uniform(-1., 1., (10, 1)).astype(np.float64)
# k_xx - k_xn @ (k_nn + sigma^2) @ k_nx + sigma^2
mean_fn = lambda x: x[:, 0]**2
kernel = psd_kernels.ExponentiatedQuadratic(amp, len_scale)
gp = tfd.GaussianProcess(kernel,
index_points,
mean_fn=mean_fn,
jitter=jitter,
validate_args=True)
gprm_nones = tfd.GaussianProcessRegressionModel(kernel,
index_points,
mean_fn=mean_fn,
jitter=jitter,
validate_args=True)
gprm_zero_shapes = tfd.GaussianProcessRegressionModel(
kernel,
index_points,
observation_index_points=tf.ones([5, 0, 1], tf.float64),
observations=tf.ones([5, 0], tf.float64),
mean_fn=mean_fn,
jitter=jitter,
validate_args=True)
for gprm in [gprm_nones, gprm_zero_shapes]:
self.assertAllClose(self.evaluate(gp.mean()),
self.evaluate(gprm.mean()))
self.assertAllClose(self.evaluate(gp.covariance()),
self.evaluate(gprm.covariance()))
self.assertAllClose(self.evaluate(gp.variance()),
self.evaluate(gprm.variance()))
observations = np.random.uniform(-1., 1., 10).astype(np.float64)
self.assertAllClose(self.evaluate(gp.log_prob(observations)),
self.evaluate(gprm.log_prob(observations)))
def testLateBindingIndexPoints(self):
amp = np.float64(.5)
len_scale = np.float64(.2)
kernel = psd_kernels.ExponentiatedQuadratic(amp, len_scale)
mean_fn = lambda x: x[:, 0]**2
jitter = np.float64(1e-4)
observation_noise_variance = np.float64(3e-3)
gp = tfd.GaussianProcess(
kernel=kernel,
mean_fn=mean_fn,
observation_noise_variance=observation_noise_variance,
jitter=jitter,
validate_args=True)
index_points = np.random.uniform(-1., 1., [10, 1])
expected_mean = mean_fn(index_points)
self.assertAllClose(expected_mean,
self.evaluate(gp.mean(index_points=index_points)))
def _kernel_fn(x, y):
return amp**2 * np.exp(-.5 * (np.squeeze(
(x - y)**2)) / (len_scale**2))
expected_covariance = (_kernel_fn(np.expand_dims(index_points, -3),
np.expand_dims(index_points, -2)) +
observation_noise_variance * np.eye(10))
self.assertAllClose(
expected_covariance,
self.evaluate(gp.covariance(index_points=index_points)))
self.assertAllClose(
np.diag(expected_covariance),
self.evaluate(gp.variance(index_points=index_points)))
self.assertAllClose(
np.sqrt(np.diag(expected_covariance)),
self.evaluate(gp.stddev(index_points=index_points)))
# Calling mean with no index_points should raise an Error
with self.assertRaises(ValueError):
gp.mean()
def testKernelParametersBroadcast(self, feature_ndims, dims):
# Batch shape [10, 2]
amplitude = np.random.uniform(
low=1., high=10., size=[10, 2]).astype(self.dtype)
inner_length_scale = self.dtype(1.)
kernel = tfpk.ExponentiatedQuadratic(
amplitude, inner_length_scale, feature_ndims)
input_shape = [dims] * feature_ndims
# Batch shape [3, 1, 2].
length_scale = np.random.uniform(
2, 5, size=([3, 1, 2] + input_shape)).astype(self.dtype)
ard_kernel = tfpk.FeatureScaled(kernel, scale_diag=length_scale)
x = np.random.uniform(-1, 1, size=input_shape).astype(self.dtype)
y = np.random.uniform(-1, 1, size=input_shape).astype(self.dtype)
self.assertAllClose(
_numpy_exp_quad(
amplitude,
inner_length_scale,
x / length_scale,
y / length_scale,
feature_ndims=feature_ndims
),
self.evaluate(ard_kernel.apply(x, y)))
z = np.random.uniform(-1, 1, size=[10] + input_shape).astype(self.dtype)
expanded_length_scale = np.expand_dims(length_scale, -(feature_ndims + 1))
self.assertAllClose(
_numpy_exp_quad_matrix(
amplitude[..., None, None],
inner_length_scale,
z / expanded_length_scale,
feature_ndims=feature_ndims
),
self.evaluate(ard_kernel.matrix(z, z)))
def testErrorCases(self):
kernel = psd_kernels.ExponentiatedQuadratic()
index_points = np.random.uniform(-1., 1., (10, 1)).astype(np.float64)
observation_index_points = (np.random.uniform(-1., 1., (5, 1)).astype(
np.float64))
observations = np.random.uniform(-1., 1., 3).astype(np.float64)
# Both or neither of `observation_index_points` and `observations` must be
# specified.
with self.assertRaises(ValueError):
tfd.GaussianProcessRegressionModel(kernel,
index_points,
observation_index_points=None,
observations=observations,
validate_args=True)
with self.assertRaises(ValueError):
tfd.GaussianProcessRegressionModel(kernel,
index_points,
observation_index_points,
observations=None,
validate_args=True)
# If specified, mean_fn must be a callable.
with self.assertRaises(ValueError):
tfd.GaussianProcessRegressionModel(kernel,
index_points,
mean_fn=0.,
validate_args=True)
# Observation index point and observation counts must be broadcastable.
# Errors based on conditions of dynamic shape in graph mode cannot be
# caught, so we only check this error case in static shape or eager mode.
if self.is_static or tf.executing_eagerly():
with self.assertRaises(ValueError):
tfd.GaussianProcessRegressionModel(
kernel,
index_points,
observation_index_points=np.ones([2, 2, 2]),
observations=np.ones([5, 5]),
validate_args=True)
def testLateBindingIndexPoints(self):
amp = np.float64(.5)
len_scale = np.float64(.2)
kernel = psd_kernels.ExponentiatedQuadratic(amp, len_scale)
mean_fn = lambda x: x[:, 0]**2
jitter = np.float64(1e-4)
tp = tfd.StudentTProcess(df=np.float64(3.),
kernel=kernel,
mean_fn=mean_fn,
jitter=jitter)
index_points = np.random.uniform(-1., 1., [10, 1]).astype(np.float64)
expected_mean = mean_fn(index_points)
self.assertAllClose(expected_mean,
self.evaluate(tp.mean(index_points=index_points)))
def _kernel_fn(x, y):
return amp**2 * np.exp(-.5 * (np.squeeze(
(x - y)**2)) / (len_scale**2))
expected_covariance = _kernel_fn(np.expand_dims(index_points, -3),
np.expand_dims(index_points, -2))
self.assertAllClose(
expected_covariance,
self.evaluate(tp.covariance(index_points=index_points)))
self.assertAllClose(
np.diag(expected_covariance),
self.evaluate(tp.variance(index_points=index_points)))
self.assertAllClose(
np.sqrt(np.diag(expected_covariance)),
self.evaluate(tp.stddev(index_points=index_points)))
# Calling mean with no index_points should raise an Error
with self.assertRaises(ValueError):
tp.mean()
def testShapes(self):
# 5x5 grid of index points in R^2 and flatten to 25x2
index_points = np.linspace(-4., 4., 5, dtype=np.float64)
index_points = np.stack(np.meshgrid(index_points, index_points), axis=-1)
index_points = np.reshape(index_points, [-1, 2])
# ==> shape = [25, 2]
batched_index_points = np.expand_dims(np.stack([index_points]*6), -3)
# ==> shape = [6, 1, 25, 2]
# Kernel with batch_shape [2, 4, 1, 1]
amplitude = np.array([1., 2.], np.float64).reshape([2, 1, 1, 1])
length_scale = np.array([.1, .2, .3, .4], np.float64).reshape([1, 4, 1, 1])
jitter = np.float64(1e-6)
observation_noise_variance = np.float64(1e-2)
observation_index_points = (
np.random.uniform(-1., 1., (3, 7, 2)).astype(np.float64))
observations = np.random.uniform(-1., 1., (3, 7)).astype(np.float64)
if not self.is_static:
amplitude = tf.placeholder_with_default(amplitude, shape=None)
length_scale = tf.placeholder_with_default(length_scale, shape=None)
batched_index_points = tf.placeholder_with_default(
batched_index_points, shape=None)
observation_index_points = tf.placeholder_with_default(
observation_index_points, shape=None)
observations = tf.placeholder_with_default(observations, shape=None)
kernel = psd_kernels.ExponentiatedQuadratic(amplitude, length_scale)
gprm = tfd.GaussianProcessRegressionModel(
kernel,
batched_index_points,
observation_index_points,
observations,
observation_noise_variance,
jitter=jitter)
batch_shape = [2, 4, 6, 3]
event_shape = [25]
sample_shape = [9, 3]
samples = gprm.sample(sample_shape)
if self.is_static or tf.executing_eagerly():
self.assertAllEqual(gprm.batch_shape_tensor(), batch_shape)
self.assertAllEqual(gprm.event_shape_tensor(), event_shape)
self.assertAllEqual(samples.shape,
sample_shape + batch_shape + event_shape)
self.assertAllEqual(gprm.batch_shape, batch_shape)
self.assertAllEqual(gprm.event_shape, event_shape)
self.assertAllEqual(samples.shape,
sample_shape + batch_shape + event_shape)
else:
self.assertAllEqual(self.evaluate(gprm.batch_shape_tensor()), batch_shape)
self.assertAllEqual(self.evaluate(gprm.event_shape_tensor()), event_shape)
self.assertAllEqual(self.evaluate(samples).shape,
sample_shape + batch_shape + event_shape)
self.assertIsNone(samples.shape.ndims)
self.assertIsNone(gprm.batch_shape.ndims)
self.assertEqual(gprm.event_shape.ndims, 1)
self.assertIsNone(gprm.event_shape.dims[0].value)
def testMeanVarianceAndCovariance(self):
amp = np.float64(.5)
len_scale = np.float64(.2)
observation_noise_variance = np.float64(1e-3)
jitter = np.float64(1e-4)
num_test = 10
num_obs = 3
index_points = np.random.uniform(-1., 1., (num_test, 1)).astype(np.float64)
observation_index_points = (
np.random.uniform(-1., 1., (num_obs, 1)).astype(np.float64))
observations = np.random.uniform(-1., 1., 3).astype(np.float64)
# k_xx - k_xn @ (k_nn + sigma^2) @ k_nx + sigma^2
k = lambda x, y: _np_kernel_matrix_fn(amp, len_scale, x, y)
k_xx_ = k(index_points, index_points)
k_xn_ = k(index_points, observation_index_points)
k_nn_plus_noise_ = (
k(observation_index_points, observation_index_points) +
(jitter + observation_noise_variance) * np.eye(num_obs))
expected_predictive_covariance_no_noise = (
k_xx_ - np.dot(k_xn_, np.linalg.solve(k_nn_plus_noise_, k_xn_.T)) +
np.eye(num_test) * jitter)
expected_predictive_covariance_with_noise = (
expected_predictive_covariance_no_noise +
np.eye(num_test) * observation_noise_variance)
mean_fn = lambda x: x[:, 0]**2
prior_mean = mean_fn(observation_index_points)
expected_mean = np.dot(
k_xn_, np.linalg.solve(k_nn_plus_noise_, observations - prior_mean))
kernel = psd_kernels.ExponentiatedQuadratic(amp, len_scale)
gprm = tfd.GaussianProcessRegressionModel(
kernel=kernel,
index_points=index_points,
observation_index_points=observation_index_points,
observations=observations,
observation_noise_variance=observation_noise_variance,
mean_fn=mean_fn,
jitter=jitter)
self.assertAllClose(expected_predictive_covariance_with_noise,
self.evaluate(gprm.covariance()))
self.assertAllClose(np.diag(expected_predictive_covariance_with_noise),
self.evaluate(gprm.variance()))
self.assertAllClose(expected_mean,
self.evaluate(gprm.mean()))
gprm_no_predictive_noise = tfd.GaussianProcessRegressionModel(
kernel=kernel,
index_points=index_points,
observation_index_points=observation_index_points,
observations=observations,
observation_noise_variance=observation_noise_variance,
predictive_noise_variance=0.,
mean_fn=mean_fn,
jitter=jitter)
self.assertAllClose(expected_predictive_covariance_no_noise,
self.evaluate(gprm_no_predictive_noise.covariance()))
self.assertAllClose(np.diag(expected_predictive_covariance_no_noise),
self.evaluate(gprm_no_predictive_noise.variance()))
self.assertAllClose(expected_mean,
self.evaluate(gprm_no_predictive_noise.mean()))
def testCopy(self):
# 5 random index points in R^2
index_points_1 = np.random.uniform(-4., 4., (5, 2)).astype(np.float32)
# 10 random index points in R^2
index_points_2 = np.random.uniform(-4., 4., (10, 2)).astype(np.float32)
observation_index_points_1 = (
np.random.uniform(-4., 4., (7, 2)).astype(np.float32))
observation_index_points_2 = (
np.random.uniform(-4., 4., (9, 2)).astype(np.float32))
observations_1 = np.random.uniform(-1., 1., 7).astype(np.float32)
observations_2 = np.random.uniform(-1., 1., 9).astype(np.float32)
# ==> shape = [6, 25, 2]
if not self.is_static:
index_points_1 = tf.placeholder_with_default(index_points_1, shape=None)
index_points_2 = tf.placeholder_with_default(index_points_2, shape=None)
observation_index_points_1 = tf.placeholder_with_default(
observation_index_points_1, shape=None)
observation_index_points_2 = tf.placeholder_with_default(
observation_index_points_2, shape=None)
observations_1 = tf.placeholder_with_default(observations_1, shape=None)
observations_2 = tf.placeholder_with_default(observations_2, shape=None)
mean_fn = lambda x: np.array([0.], np.float32)
kernel_1 = psd_kernels.ExponentiatedQuadratic()
kernel_2 = psd_kernels.ExpSinSquared()
gprm1 = tfd.GaussianProcessRegressionModel(
kernel=kernel_1,
index_points=index_points_1,
observation_index_points=observation_index_points_1,
observations=observations_1,
mean_fn=mean_fn,
jitter=1e-5)
gprm2 = gprm1.copy(
kernel=kernel_2,
index_points=index_points_2,
observation_index_points=observation_index_points_2,
observations=observations_2)
event_shape_1 = [5]
event_shape_2 = [10]
self.assertEqual(gprm1.mean_fn, gprm2.mean_fn)
self.assertIsInstance(gprm1.kernel, psd_kernels.ExponentiatedQuadratic)
self.assertIsInstance(gprm2.kernel, psd_kernels.ExpSinSquared)
if self.is_static or tf.executing_eagerly():
self.assertAllEqual(gprm1.batch_shape, gprm2.batch_shape)
self.assertAllEqual(gprm1.event_shape, event_shape_1)
self.assertAllEqual(gprm2.event_shape, event_shape_2)
self.assertAllEqual(gprm1.index_points, index_points_1)
self.assertAllEqual(gprm2.index_points, index_points_2)
self.assertAllEqual(tf.contrib.util.constant_value(gprm1.jitter),
tf.contrib.util.constant_value(gprm2.jitter))
else:
self.assertAllEqual(self.evaluate(gprm1.batch_shape_tensor()),
self.evaluate(gprm2.batch_shape_tensor()))
self.assertAllEqual(self.evaluate(gprm1.event_shape_tensor()),
event_shape_1)
self.assertAllEqual(self.evaluate(gprm2.event_shape_tensor()),
event_shape_2)
self.assertEqual(self.evaluate(gprm1.jitter), self.evaluate(gprm2.jitter))
self.assertAllEqual(self.evaluate(gprm1.index_points), index_points_1)
self.assertAllEqual(self.evaluate(gprm2.index_points), index_points_2)
