def testBijectorScalarCongruencyLowerTemperature(self):
floor = tfb.Softfloor(self.dtype(0.1))
bijector_test_util.assert_scalar_congruency(floor,
self.dtype(-1.1),
self.dtype(1.1),
eval_func=self.evaluate,
rtol=5e-2)
def testBijectorForwardGradient(self):
x_np = np.array([0.1, 2.23, 4.1], dtype=self.dtype)
x = tf.constant(x_np)
with tf.GradientTape() as tape:
tape.watch(x)
value = tfb.Softfloor(self.dtype(1.2)).forward(x)
grad = tape.gradient(value, x)
self.assertAllClose(_softfloor_grad_np(x_np, 1.2), grad)
def testBijectiveAndFiniteLowTemperature(self):
floor = tfb.Softfloor(self.dtype(1e-1))
x = np.sort(5 * self._rng.randn(3, 10), axis=-1).astype(self.dtype)
y = 5 * self._rng.randn(3, 10).astype(self.dtype)
bijector_test_util.assert_bijective_and_finite(floor,
x,
y,
eval_func=self.evaluate,
event_ndims=1)
def testVariableTemperature(self):
temperature = tf.Variable(1.)
b = tfb.Softfloor(temperature, validate_args=True)
self.evaluate(temperature.initializer)
self.assertIs(temperature, b.temperature)
self.assertEqual((), self.evaluate(b.forward(0.5)).shape)
with self.assertRaisesOpError(
'Argument `temperature` was not positive.'):
with tf.control_dependencies([temperature.assign(0.)]):
self.evaluate(b.forward(0.5))
def testBijectorApproximatesFloorLowTemperature(self):
# Let's make this look floor.
floor = tfb.Softfloor(self.dtype(1e-4))
# We chose a high temperature, and truncated range so that
# we are likely to be retrieving 2.
pos_values = np.linspace(2.01, 2.99, 100).astype(self.dtype)
neg_values = np.linspace(-2.99, -2.01, 100).astype(self.dtype)
self.assertAllClose(self.evaluate(floor.forward(pos_values)),
np.floor(pos_values))
self.assertAllClose(self.evaluate(floor.forward(neg_values)),
np.floor(neg_values))
def testBijectorEndpointsAtLimit(self):
# Check that we don't get NaN at half-integer and the floor matches.
floor = tfb.Softfloor(self.dtype(1e-5))
half_integers = np.linspace(0.5, 10.5, 11).astype(self.dtype)
self.assertAllClose(self.evaluate(floor.forward(half_integers)),
np.floor(half_integers))
self.assertAllFinite(self.evaluate(floor.inverse(half_integers)))
# At integer values, check we don't have NaN's, and this is close to
# integer - 0.5 (which is only true in the limit!).
integers = np.linspace(0., 10., 11).astype(self.dtype)
self.assertAllClose(self.evaluate(floor.forward(integers)),
integers - 0.5,
rtol=3e-3)
self.assertAllFinite(self.evaluate(floor.inverse(integers)))
def testShapeGetters(self):
x = tf.TensorShape([4])
y = tf.TensorShape([4])
bijector = tfb.Softfloor(self.dtype(1.), validate_args=True)
self.assertAllEqual(y, bijector.forward_event_shape(x))
self.assertAllEqual(
tensorshape_util.as_list(y),
self.evaluate(
bijector.forward_event_shape_tensor(tensorshape_util.as_list(x))))
self.assertAllEqual(x, bijector.inverse_event_shape(y))
self.assertAllEqual(
tensorshape_util.as_list(x),
self.evaluate(
bijector.inverse_event_shape_tensor(tensorshape_util.as_list(y))))
def testBijectorApproximatesIdentityHighTemperature(self):
# Let's make this look like the identity.
floor = tfb.Softfloor(self.dtype(1e4))
pos_values = np.linspace(2.01, 2.99, 100).astype(self.dtype)
neg_values = np.linspace(-2.99, -2.01, 100).astype(self.dtype)
self.assertAllClose(self.evaluate(floor.forward(pos_values)),
pos_values,
rtol=1e-5)
self.assertAllClose(self.evaluate(floor.forward(neg_values)),
neg_values,
rtol=1e-5)
self.assertAllClose(self.evaluate(floor.inverse(pos_values)),
pos_values,
rtol=5e-4)
self.assertAllClose(self.evaluate(floor.inverse(neg_values)),
neg_values,
rtol=5e-4)
def testBijectorForwardGradient(self):
x_np = np.array([0.1, 2.23, 4.1], dtype=self.dtype)
x = tf.constant(x_np)
grad = value_and_gradient(tfb.Softfloor(self.dtype(1.2)).forward, x)[1]
self.assertAllClose(_softfloor_grad_np(x_np, 1.2), grad)
def testBijectorScalarCongruencyMediumTemperature(self):
floor = tfb.Softfloor(self.dtype(5.))
bijector_test_util.assert_scalar_congruency(floor,
self.dtype(-1.1),
self.dtype(1.1),
eval_func=self.evaluate)