def test_dkwm_mean_one_sample_assertion(self):
rng = np.random.RandomState(seed=0)
num_samples = 5000
# Test that the test assertion agrees that the mean of the standard
# uniform distribution is 0.5.
samples = rng.uniform(size=num_samples).astype(np.float32)
self.evaluate(
st.assert_true_mean_equal_by_dkwm(samples,
0.,
1.,
0.5,
false_fail_rate=1e-6))
# Test that the test assertion confirms that the mean of the
# standard uniform distribution is not 0.4.
with self.assertRaisesOpError("true mean greater than expected"):
self.evaluate(
st.assert_true_mean_equal_by_dkwm(samples,
0.,
1.,
0.4,
false_fail_rate=1e-6))
# Test that the test assertion confirms that the mean of the
# standard uniform distribution is not 0.6.
with self.assertRaisesOpError("true mean smaller than expected"):
self.evaluate(
st.assert_true_mean_equal_by_dkwm(samples,
0.,
1.,
0.6,
false_fail_rate=1e-6))
def testWeibullSample(self):
concentration = self.dtype(4.)
scale = self.dtype(1.)
n = int(100e3)
weibull = tfd.Weibull(concentration=self.make_input(concentration),
scale=self.make_input(scale),
validate_args=True)
samples = weibull.sample(n, seed=test_util.test_seed())
sample_values = self.evaluate(samples)
low = self.dtype(0.)
high = self.dtype(np.inf)
self.assertAllClose(stats.weibull_min.mean(c=concentration,
scale=scale,
loc=0),
sample_values.mean(),
rtol=0.01)
self.evaluate(
st.assert_true_mean_equal_by_dkwm(
samples,
low=low,
high=high,
expected=weibull.mean(),
false_fail_rate=self.dtype(1e-6)))
self.assertAllClose(stats.weibull_min.var(c=concentration,
scale=scale,
loc=0),
sample_values.var(),
rtol=0.01)
def testMean(self, dtype):
testee_lkj = tfd.LKJ(dimension=3,
concentration=dtype([1., 3., 5.]),
validate_args=True)
num_samples = 20000
results = testee_lkj.sample(sample_shape=[num_samples])
mean = testee_lkj.mean()
self.assertEqual(mean.shape, [3, 3, 3])
check1 = st.assert_true_mean_equal_by_dkwm(samples=results,
low=-1.,
high=1.,
expected=mean,
false_fail_rate=1e-6)
check2 = assert_util.assert_less(
st.min_discrepancy_of_true_means_detectable_by_dkwm(
num_samples,
low=-1.,
high=1.,
# Smaller false fail rate because of different batch sizes between
# these two checks.
false_fail_rate=1e-7,
false_pass_rate=1e-6),
# 4% relative error
0.08)
self.evaluate([check1, check2])
def testTriangularSample(self):
low = self._dtype([-3.] * 4)
high = np.arange(7., 11., dtype=self._dtype)
peak = np.array([0.] * 4, dtype=self._dtype)
tri = self._create_triangular_dist(low, high, peak)
num_samples = int(3e6)
samples = tri.sample(num_samples, seed=tfp_test_util.test_seed())
detectable_discrepancies = self.evaluate(
st.min_discrepancy_of_true_means_detectable_by_dkwm(
num_samples,
low,
high,
false_fail_rate=self._dtype(1e-6),
false_pass_rate=self._dtype(1e-6)))
below_threshold = detectable_discrepancies <= 0.05
self.assertTrue(np.all(below_threshold))
self.evaluate(
st.assert_true_mean_equal_by_dkwm(
samples,
low=low,
high=high,
expected=tri.mean(),
false_fail_rate=self._dtype(1e-6)))
def testRejection4D(self):
num_samples = int(1e5) # Chosen for a small min detectable discrepancy
det_bounds = np.array([0.0], dtype=np.float32)
exact_volumes = [four_by_four_volume()]
(rej_weights, rej_proposal_volume
) = corr.correlation_matrix_volume_rejection_samples(det_bounds,
4,
[num_samples, 1],
dtype=np.float32,
seed=45)
# shape of rej_weights: [num_samples, 1, 4, 4]
chk1 = st.assert_true_mean_equal_by_dkwm(rej_weights,
low=0.,
high=rej_proposal_volume,
expected=exact_volumes,
false_fail_rate=1e-6)
chk2 = tf1.assert_less(
st.min_discrepancy_of_true_means_detectable_by_dkwm(
num_samples,
low=0.,
high=rej_proposal_volume,
false_fail_rate=1e-6,
false_pass_rate=1e-6),
# Going for about a 10% relative error
1.1)
with tf.control_dependencies([chk1, chk2]):
rej_weights = tf.identity(rej_weights)
self.evaluate(rej_weights)
def testRejection2D(self):
num_samples = int(1e5) # Chosen for a small min detectable discrepancy
det_bounds = np.array(
[0.01, 0.02, 0.03, 0.04, 0.05, 0.3, 0.35, 0.4, 0.5],
dtype=np.float32)
exact_volumes = two_by_two_volume(det_bounds)
(rej_weights, rej_proposal_volume
) = corr.correlation_matrix_volume_rejection_samples(det_bounds,
2,
[num_samples, 9],
dtype=np.float32,
seed=43)
# shape of rej_weights: [num_samples, 9, 2, 2]
chk1 = st.assert_true_mean_equal_by_dkwm(rej_weights,
low=0.,
high=rej_proposal_volume,
expected=exact_volumes,
false_fail_rate=1e-6)
chk2 = tf1.assert_less(
st.min_discrepancy_of_true_means_detectable_by_dkwm(
num_samples,
low=0.,
high=rej_proposal_volume,
# Correct the false fail rate due to different broadcasting
false_fail_rate=1.1e-7,
false_pass_rate=1e-6),
0.036)
with tf.control_dependencies([chk1, chk2]):
rej_weights = tf.identity(rej_weights)
self.evaluate(rej_weights)
def VerifyMean(self, dim):
num_samples = int(7e4)
uniform = tfp.distributions.SphericalUniform(batch_shape=[2, 1],
dimension=dim,
dtype=self.dtype,
validate_args=True,
allow_nan_stats=False)
samples = uniform.sample(num_samples, seed=test_util.test_seed())
sample_mean = tf.reduce_mean(samples, axis=0)
true_mean, sample_mean = self.evaluate([uniform.mean(), sample_mean])
check1 = st.assert_true_mean_equal_by_dkwm(samples=samples,
low=-(1. + 1e-7),
high=1. + 1e-7,
expected=true_mean,
false_fail_rate=1e-6)
check2 = assert_util.assert_less(
st.min_discrepancy_of_true_means_detectable_by_dkwm(
num_samples,
low=-1.,
high=1.,
# Smaller false fail rate because of different batch sizes between
# these two checks.
false_fail_rate=1e-7,
false_pass_rate=1e-6),
# 4% relative error
0.08)
self.evaluate([check1, check2])
def testBetaQuotientSample(self):
a = tf.random.uniform(
shape=[2, 1, 1, 1],
minval=1., maxval=5., seed=test_util.test_seed(), dtype=self.dtype)
b = tf.random.uniform(
shape=[1, 3, 1, 1],
minval=1., maxval=5., seed=test_util.test_seed(), dtype=self.dtype)
c = tf.random.uniform(
shape=[1, 1, 5, 1],
minval=1., maxval=5., seed=test_util.test_seed(), dtype=self.dtype)
d = tf.random.uniform(
shape=[1, 1, 1, 7],
minval=1., maxval=5., seed=test_util.test_seed(), dtype=self.dtype)
beta_quotient = tfd.BetaQuotient(a, b, c, d, validate_args=True)
# TODO(b/179283344): Increase this to 3e5 when CPU-only gamma sampler is
# fixed.
n = int(3e4)
samples = beta_quotient.sample(n, seed=test_util.test_seed())
sample_values = self.evaluate(samples)
self.assertEqual(sample_values.shape, (n, 2, 3, 5, 7))
self.assertFalse(np.any(sample_values < 0.0))
self.evaluate(
st.assert_true_mean_equal_by_dkwm(
samples,
low=self.dtype(0.),
high=self.dtype(np.inf),
expected=beta_quotient.mean(),
false_fail_rate=self.dtype(1e-6)))
def _testSampleLogProbExact(
self, concentrations, det_bounds, dim, means,
num_samples=int(1e5), dtype=np.float32, target_discrepancy=0.1, seed=42):
# For test methodology see the comment in
# _testSampleConsistentLogProbInterval, except that this test
# checks those parameter settings where the true volume is known
# analytically.
concentration = np.array(concentrations, dtype=dtype)
det_bounds = np.array(det_bounds, dtype=dtype)
means = np.array(means, dtype=dtype)
# Add a tolerance to guard against some of the importance_weights exceeding
# the theoretical maximum (importance_maxima) due to numerical inaccuracies
# while lower bounding the determinant. See corresponding comment in
# _testSampleConsistentLogProbInterval.
high_tolerance = 1e-6
testee_lkj = tfd.LKJ(
dimension=dim, concentration=concentration, validate_args=True)
x = testee_lkj.sample(num_samples, seed=seed)
importance_weights = (
tf.exp(-testee_lkj.log_prob(x)) * _det_ok_mask(x, det_bounds))
importance_maxima = (1. / det_bounds) ** (concentration - 1) * tf.exp(
testee_lkj._log_normalization())
chk1 = st.assert_true_mean_equal_by_dkwm(
importance_weights, low=0., high=importance_maxima + high_tolerance,
expected=means, false_fail_rate=1e-6)
chk2 = tf.assert_less(
st.min_discrepancy_of_true_means_detectable_by_dkwm(
num_samples, low=0., high=importance_maxima + high_tolerance,
false_fail_rate=1e-6, false_pass_rate=1e-6),
dtype(target_discrepancy))
self.evaluate([chk1, chk2])
def test_dkwm_mean_one_sample_assertion(self):
rng = np.random.RandomState(seed=0)
num_samples = 5000
# Test that the test assertion agrees that the mean of the standard
# uniform distribution is 0.5.
samples = rng.uniform(size=num_samples).astype(np.float32)
self.evaluate(st.assert_true_mean_equal_by_dkwm(
samples, 0., 1., 0.5, false_fail_rate=1e-6))
# Test that the test assertion confirms that the mean of the
# standard uniform distribution is not 0.4.
with self.assertRaisesOpError("true mean greater than expected"):
self.evaluate(st.assert_true_mean_equal_by_dkwm(
samples, 0., 1., 0.4, false_fail_rate=1e-6))
# Test that the test assertion confirms that the mean of the
# standard uniform distribution is not 0.6.
with self.assertRaisesOpError("true mean smaller than expected"):
self.evaluate(st.assert_true_mean_equal_by_dkwm(
samples, 0., 1., 0.6, false_fail_rate=1e-6))
def _testSampleLogProbExact(self,
concentrations,
det_bounds,
dim,
means,
num_samples=int(1e5),
dtype=np.float32,
target_discrepancy=0.1,
input_output_cholesky=False,
seed=42):
# For test methodology see the comment in
# _testSampleConsistentLogProbInterval, except that this test
# checks those parameter settings where the true volume is known
# analytically.
concentration = np.array(concentrations, dtype=dtype)
det_bounds = np.array(det_bounds, dtype=dtype)
means = np.array(means, dtype=dtype)
# Add a tolerance to guard against some of the importance_weights exceeding
# the theoretical maximum (importance_maxima) due to numerical inaccuracies
# while lower bounding the determinant. See corresponding comment in
# _testSampleConsistentLogProbInterval.
high_tolerance = 1e-6
testee_lkj = tfd.LKJ(dimension=dim,
concentration=concentration,
input_output_cholesky=input_output_cholesky,
validate_args=True)
x = testee_lkj.sample(num_samples, seed=seed)
importance_weights = (
tf.exp(-testee_lkj.log_prob(x)) *
_det_ok_mask(x, det_bounds, input_output_cholesky))
importance_maxima = (1. / det_bounds)**(concentration - 1) * tf.exp(
testee_lkj._log_normalization())
chk1 = st.assert_true_mean_equal_by_dkwm(importance_weights,
low=0.,
high=importance_maxima +
high_tolerance,
expected=means,
false_fail_rate=1e-6)
chk2 = assert_util.assert_less(
st.min_discrepancy_of_true_means_detectable_by_dkwm(
num_samples,
low=0.,
high=importance_maxima + high_tolerance,
false_fail_rate=1e-6,
false_pass_rate=1e-6), dtype(target_discrepancy))
self.evaluate([chk1, chk2])
def testRejection4D(self):
num_samples = int(1e5) # Chosen for a small min detectable discrepancy
det_bounds = np.array([0.0], dtype=np.float32)
exact_volumes = [four_by_four_volume()]
(rej_weights,
rej_proposal_volume) = corr.correlation_matrix_volume_rejection_samples(
det_bounds, 4, [num_samples, 1], dtype=np.float32, seed=45)
# shape of rej_weights: [num_samples, 1, 4, 4]
chk1 = st.assert_true_mean_equal_by_dkwm(
rej_weights, low=0., high=rej_proposal_volume, expected=exact_volumes,
false_fail_rate=1e-6)
chk2 = tf.assert_less(
st.min_discrepancy_of_true_means_detectable_by_dkwm(
num_samples, low=0., high=rej_proposal_volume,
false_fail_rate=1e-6, false_pass_rate=1e-6),
# Going for about a 10% relative error
1.1)
with tf.control_dependencies([chk1, chk2]):
rej_weights = tf.identity(rej_weights)
self.evaluate(rej_weights)
def testMean(self, dtype):
testee_lkj = tfd.LKJ(dimension=3, concentration=dtype([1., 3., 5.]))
num_samples = 20000
results = testee_lkj.sample(sample_shape=[num_samples])
mean = testee_lkj.mean()
self.assertEqual(mean.shape, [3, 3, 3])
check1 = st.assert_true_mean_equal_by_dkwm(
samples=results, low=-1., high=1.,
expected=mean,
false_fail_rate=1e-6)
check2 = tf.assert_less(
st.min_discrepancy_of_true_means_detectable_by_dkwm(
num_samples, low=-1., high=1.,
# Smaller false fail rate because of different batch sizes between
# these two checks.
false_fail_rate=1e-7,
false_pass_rate=1e-6),
# 4% relative error
0.08)
self.evaluate([check1, check2])
def testTriangularSample(self):
low = self._dtype([-3.] * 4)
high = np.arange(7., 11., dtype=self._dtype)
peak = np.array([0.] * 4, dtype=self._dtype)
tri = self._create_triangular_dist(low, high, peak)
num_samples = int(3e6)
samples = tri.sample(num_samples, seed=123)
detectable_discrepancies = self.evaluate(
st.min_discrepancy_of_true_means_detectable_by_dkwm(
num_samples, low, high,
false_fail_rate=self._dtype(1e-6),
false_pass_rate=self._dtype(1e-6)))
below_threshold = detectable_discrepancies <= 0.05
self.assertTrue(np.all(below_threshold))
self.evaluate(
st.assert_true_mean_equal_by_dkwm(
samples, low=low, high=high, expected=tri.mean(),
false_fail_rate=self._dtype(1e-6)))
def testRejection2D(self):
num_samples = int(1e5) # Chosen for a small min detectable discrepancy
det_bounds = np.array(
[0.01, 0.02, 0.03, 0.04, 0.05, 0.3, 0.35, 0.4, 0.5], dtype=np.float32)
exact_volumes = two_by_two_volume(det_bounds)
(rej_weights,
rej_proposal_volume) = corr.correlation_matrix_volume_rejection_samples(
det_bounds, 2, [num_samples, 9], dtype=np.float32, seed=43)
# shape of rej_weights: [num_samples, 9, 2, 2]
chk1 = st.assert_true_mean_equal_by_dkwm(
rej_weights, low=0., high=rej_proposal_volume, expected=exact_volumes,
false_fail_rate=1e-6)
chk2 = tf.assert_less(
st.min_discrepancy_of_true_means_detectable_by_dkwm(
num_samples, low=0., high=rej_proposal_volume,
# Correct the false fail rate due to different broadcasting
false_fail_rate=1.1e-7, false_pass_rate=1e-6),
0.036)
with tf.control_dependencies([chk1, chk2]):
rej_weights = tf.identity(rej_weights)
self.evaluate(rej_weights)
def _testSampleLogProbExact(self,
concentrations,
det_bounds,
dim,
means,
num_samples=int(1e5),
target_discrepancy=0.1,
seed=42):
# For test methodology see the comment in
# _testSampleConsistentLogProbInterval, except that this test
# checks those parameter settings where the true volume is known
# analytically.
concentration = np.array(concentrations, dtype=np.float32)
det_bounds = np.array(det_bounds, dtype=np.float32)
means = np.array(means, dtype=np.float32)
testee_lkj = tfd.LKJ(dimension=dim,
concentration=concentration,
validate_args=True)
x = testee_lkj.sample(num_samples, seed=seed)
importance_weights = (tf.exp(-testee_lkj.log_prob(x)) *
_det_ok_mask(x, det_bounds))
importance_maxima = (1. / det_bounds)**(concentration - 1) * tf.exp(
testee_lkj._log_normalization())
chk1 = st.assert_true_mean_equal_by_dkwm(importance_weights,
low=0.,
high=importance_maxima,
expected=means,
false_fail_rate=1e-6)
chk2 = tf.assert_less(
st.min_discrepancy_of_true_means_detectable_by_dkwm(
num_samples,
low=0.,
high=importance_maxima,
false_fail_rate=1e-6,
false_pass_rate=1e-6), target_discrepancy)
self.evaluate([chk1, chk2])
