def testNoneShapes(self): k = tfpk.ExponentiatedQuadratic( amplitude=np.reshape(np.arange(12.), [2, 3, 2])) self.assertEqual([2, 3, 2], k.batch_shape.as_list())
def kernel(self): kernel = tfk.ExponentiatedQuadratic(self._amplitude, self._length_scale) return kernel
def testMismatchedFloatTypesAreBad(self): tfpk.ExponentiatedQuadratic(1, 1) # Should be OK (float32 fallback). tfpk.ExponentiatedQuadratic(np.float32(1.), 1.) # Should be OK. with self.assertRaises(TypeError): tfpk.ExponentiatedQuadratic(np.float32(1.), np.float64(1.))
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] # 9 inducing index points in R^2 inducing_index_points = np.linspace(-4., 4., 3, dtype=np.float64) inducing_index_points = np.stack(np.meshgrid(inducing_index_points, inducing_index_points), axis=-1) inducing_index_points = np.reshape(inducing_index_points, [-1, 2]) # ==> shape = [9, 2] variational_inducing_observations_loc = np.zeros([3, 9], dtype=np.float64) variational_inducing_observations_scale = np.eye(9, dtype=np.float64) # 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) 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) inducing_index_points = tf.compat.v1.placeholder_with_default( inducing_index_points, shape=None) variational_inducing_observations_loc = tf.compat.v1.placeholder_with_default( variational_inducing_observations_loc, shape=None) variational_inducing_observations_scale = tf.compat.v1.placeholder_with_default( variational_inducing_observations_scale, shape=None) kernel = psd_kernels.ExponentiatedQuadratic(amplitude, length_scale) vgp = tfd.VariationalGaussianProcess( kernel=kernel, index_points=batched_index_points, inducing_index_points=inducing_index_points, variational_inducing_observations_loc=( variational_inducing_observations_loc), variational_inducing_observations_scale=( variational_inducing_observations_scale), observation_noise_variance=observation_noise_variance, jitter=jitter) batch_shape = [2, 4, 6, 3] event_shape = [25] sample_shape = [9, 3] samples = vgp.sample(sample_shape) if self.is_static or tf.executing_eagerly(): self.assertAllEqual(vgp.batch_shape_tensor(), batch_shape) self.assertAllEqual(vgp.event_shape_tensor(), event_shape) self.assertAllEqual(samples.shape, sample_shape + batch_shape + event_shape) self.assertAllEqual(vgp.batch_shape, batch_shape) self.assertAllEqual(vgp.event_shape, event_shape) self.assertAllEqual(samples.shape, sample_shape + batch_shape + event_shape) else: self.assertAllEqual(self.evaluate(vgp.batch_shape_tensor()), batch_shape) self.assertAllEqual(self.evaluate(vgp.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(vgp.batch_shape)) self.assertEqual(tensorshape_util.rank(vgp.event_shape), 1) self.assertIsNone( tf.compat.dimension_value( tensorshape_util.dims(vgp.event_shape)[0]))
def testVariationalLossShapes(self): # 2x2 grid of index points in R^2 and flatten to 4x2 index_points = np.linspace(-4., 4., 2, dtype=np.float64) index_points = np.stack(np.meshgrid(index_points, index_points), axis=-1) index_points = np.reshape(index_points, [-1, 2]) # ==> shape = [4, 2] batched_index_points = np.expand_dims(np.stack([index_points] * 6), -3) # ==> shape = [6, 1, 4, 2] # 3x3 grid of index points in R^2 and flatten to 9x2 observation_index_points = np.linspace(-4., 4., 3, dtype=np.float64) observation_index_points = np.stack(np.meshgrid( observation_index_points, observation_index_points), axis=-1) observation_index_points = np.reshape(observation_index_points, [-1, 2]) # ==> shape = [9, 2] observation_index_points = np.expand_dims( np.stack([observation_index_points] * 6), -3) # ==> shape = [6, 1, 9, 2] observations = np.sin(observation_index_points[..., 0]) # ==> shape = [6, 1, 9] # 9 inducing index points in R^2 inducing_index_points = np.linspace(-4., 4., 3, dtype=np.float64) inducing_index_points = np.stack(np.meshgrid(inducing_index_points, inducing_index_points), axis=-1) inducing_index_points = np.reshape(inducing_index_points, [-1, 2]) # ==> shape = [9, 2] variational_inducing_observations_loc = np.zeros([3, 9], dtype=np.float64) variational_inducing_observations_scale = np.eye(9, dtype=np.float64) # 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) 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) observations = tf.compat.v1.placeholder_with_default(observations, shape=None) observation_index_points = tf.compat.v1.placeholder_with_default( observation_index_points, shape=None) inducing_index_points = tf.compat.v1.placeholder_with_default( inducing_index_points, shape=None) variational_inducing_observations_loc = tf.compat.v1.placeholder_with_default( variational_inducing_observations_loc, shape=None) variational_inducing_observations_scale = tf.compat.v1.placeholder_with_default( variational_inducing_observations_scale, shape=None) kernel = psd_kernels.ExponentiatedQuadratic(amplitude, length_scale) vgp = tfd.VariationalGaussianProcess( kernel=kernel, index_points=batched_index_points, inducing_index_points=inducing_index_points, variational_inducing_observations_loc=( variational_inducing_observations_loc), variational_inducing_observations_scale=( variational_inducing_observations_scale), observation_noise_variance=observation_noise_variance, jitter=jitter) loss = vgp.variational_loss( observations=observations, observation_index_points=observation_index_points) # Expect a scalar loss. self.assertAllClose([], tf.shape(input=loss))
length_scale_assign = invert_softplus(len_p, len_var) observation_noise_variance = (np.finfo(np.float64).tiny + tf.nn.softplus( tf.Variable(initial_value=INIT_OBSNOISEVAR, name='observation_noise_variance', dtype=np.float64))) ##################################### # Create the covariance kernel, which will be shared between the prior (which we # use for maximum likelihood training) and the posterior (which we use for # posterior predictive sampling) assert amplitude.shape == AMPLITUDE_INIT.shape assert length_scale.shape == LENGTHSCALE_INIT.shape assert amplitude.shape == length_scale.shape kernel = tfk.ExponentiatedQuadratic(amplitude, length_scale) def kernel_test(): k = None # select two points: X1, X2; k = kernel(X1, X2) for i in range(observation_index_points_.shape[0]): for j in range(observation_index_points_.shape[0]): if i != j: k = kernel._apply(observation_index_points_[i, :], observation_index_points_[j, :]) pass # kernel_test() #####################################
def cov_kernel(amplitude_, length_scale_): return tfk.ExponentiatedQuadratic(amplitude_, length_scale_)