def testSampleGammaHighConcentration(self):
concentration = np.linspace(10., 20., 10)
rate = np.float64(1.)
num_samples = int(1e5)
self.assertLess(
self.evaluate(
st.min_num_samples_for_dkwm_cdf_test(
discrepancy=0.04, false_fail_rate=1e-9, false_pass_rate=1e-9)),
num_samples)
samples = gamma_lib._random_gamma_noncpu(
shape=[num_samples, 10],
concentration=concentration,
rate=rate,
seed=test_util.test_seed())
gamma = tfd.Gamma(
concentration=concentration, rate=rate, validate_args=True)
self.evaluate(
st.assert_true_cdf_equal_by_dkwm(
samples,
gamma.cdf,
st.left_continuous_cdf_discrete_distribution(gamma),
false_fail_rate=1e-9))
self.assertAllClose(
self.evaluate(tf.math.reduce_mean(samples, axis=0)),
sp_stats.gamma.mean(concentration, scale=1 / rate),
rtol=0.01)
self.assertAllClose(
self.evaluate(tf.math.reduce_variance(samples, axis=0)),
sp_stats.gamma.mean(concentration, scale=1 / rate),
rtol=0.05)
def testSamplePoissonHighRates(self):
# High rate (>= log(10.)) samples would use rejection sampling.
rate = [10., 10.5, 11., 11.5, 12.0, 12.5, 13.0, 13.5, 14.0, 14.5]
log_rate = np.log(rate)
num_samples = int(1e5)
self.assertLess(
self.evaluate(
st.min_num_samples_for_dkwm_cdf_test(discrepancy=0.04,
false_fail_rate=1e-9,
false_pass_rate=1e-9)),
num_samples)
samples = poisson_lib._random_poisson_noncpu(
shape=[num_samples],
log_rates=log_rate,
output_dtype=tf.float64,
seed=test_util.test_seed())
poisson = tfd.Poisson(log_rate=log_rate, validate_args=True)
self.evaluate(
st.assert_true_cdf_equal_by_dkwm(
samples,
poisson.cdf,
st.left_continuous_cdf_discrete_distribution(poisson),
false_fail_rate=1e-9))
self.assertAllClose(self.evaluate(tf.math.reduce_mean(samples,
axis=0)),
stats.poisson.mean(rate),
rtol=0.01)
self.assertAllClose(self.evaluate(
tf.math.reduce_variance(samples, axis=0)),
stats.poisson.var(rate),
rtol=0.05)
def propSampleCorrectMarginals(self,
dist,
special_class,
under_hypothesis=False):
# Property: When projected on one class, multinomial should sample the
# binomial distribution.
seed = test_util.test_seed()
num_samples = 120000
needed = self.evaluate(
st.min_num_samples_for_dkwm_cdf_test(0.02,
false_fail_rate=1e-9,
false_pass_rate=1e-9))
self.assertGreater(num_samples, needed)
samples = dist.sample(num_samples, seed=seed)
successes = samples[..., special_class]
prob_success = dist._probs_parameter_no_checks()[..., special_class]
if under_hypothesis:
hp.note('Expected probability of success {}'.format(prob_success))
hp.note('Successes obtained {}'.format(successes))
expected_dist = tfd.Binomial(dist.total_count, probs=prob_success)
self.evaluate(
st.assert_true_cdf_equal_by_dkwm(
successes,
expected_dist.cdf,
st.left_continuous_cdf_discrete_distribution(expected_dist),
false_fail_rate=1e-9))
def testXLAFriendlySampler(self):
if tf.executing_eagerly():
msg = 'XLA requires tf.function, mode switching is meaningless.'
self.skipTest(msg)
dist = tfd.BetaBinomial(
total_count=50, concentration0=1e-7, concentration1=1e-5)
seed = test_util.test_seed(sampler_type='stateless')
num_samples = 20000
sample = self.evaluate(
tf.function(jit_compile=True)(dist.sample)(
num_samples, seed=seed))
self.assertAllEqual(np.zeros_like(sample), np.isnan(sample))
# Beta(1e-7, 1e-5) should basically always be either 1 or 0, and 1 should
# occur with probability 100/101.
# Ergo, the beta binomial samples should basically always be either 50 or 0,
# and 50 should occur with probability 100/101.
high_samples_mask = sample == 50
low_samples_mask = sample == 0
self.assertAllEqual(np.ones_like(sample),
high_samples_mask | low_samples_mask)
expect = tfd.Bernoulli(probs=100.0/101.0)
self.evaluate(st.assert_true_cdf_equal_by_dkwm(
samples=tf.cast(high_samples_mask, tf.float32),
cdf=expect.cdf,
left_continuous_cdf=st.left_continuous_cdf_discrete_distribution(
expect),
false_fail_rate=1e-9))
self.assertGreater(
num_samples,
self.evaluate(st.min_num_samples_for_dkwm_cdf_test(
0.05, false_fail_rate=1e-9, false_pass_rate=1e-9)))
def testSamplePoissonLowAndHighRates(self):
rate = [1., 3., 5., 6., 7., 10., 13.0, 14., 15., 18.]
log_rate = np.log(rate)
num_samples = int(1e5)
self.assertLess(
self.evaluate(
st.min_num_samples_for_dkwm_cdf_test(discrepancy=0.04,
false_fail_rate=1e-9,
false_pass_rate=1e-9)),
num_samples)
samples = self.evaluate(
poisson_dist.random_poisson_rejection_sampler(
[num_samples, 10], log_rate, seed=test_util.test_seed()))
poisson = tfd.Poisson(log_rate=log_rate, validate_args=True)
self.evaluate(
st.assert_true_cdf_equal_by_dkwm(
samples,
poisson.cdf,
st.left_continuous_cdf_discrete_distribution(poisson),
false_fail_rate=1e-9))
self.assertAllClose(self.evaluate(tf.math.reduce_mean(samples,
axis=0)),
stats.poisson.mean(rate),
rtol=0.01)
self.assertAllClose(self.evaluate(
tf.math.reduce_variance(samples, axis=0)),
stats.poisson.var(rate),
rtol=0.05)
def testSamplePoissonLowRates(self):
# Low log rate (< log(10.)) samples would use Knuth's algorithm.
rate = [1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5]
log_rate = np.log(rate)
num_samples = int(1e5)
self.assertLess(
self.evaluate(
st.min_num_samples_for_dkwm_cdf_test(discrepancy=0.04,
false_fail_rate=1e-9,
false_pass_rate=1e-9)),
num_samples)
samples = self.evaluate(
poisson_dist.random_poisson_rejection_sampler(
[num_samples, 10], log_rate, seed=test_util.test_seed()))
poisson = tfd.Poisson(log_rate=log_rate, validate_args=True)
self.evaluate(
st.assert_true_cdf_equal_by_dkwm(
samples,
poisson.cdf,
st.left_continuous_cdf_discrete_distribution(poisson),
false_fail_rate=1e-9))
self.assertAllClose(self.evaluate(tf.math.reduce_mean(samples,
axis=0)),
stats.poisson.mean(rate),
rtol=0.01)
self.assertAllClose(self.evaluate(
tf.math.reduce_variance(samples, axis=0)),
stats.poisson.var(rate),
rtol=0.05)
def testSamplePoissonLowAndHighRates(self):
rate = [1., 3., 5., 6., 7., 10., 13.0, 14., 15., 18.]
log_rate = np.log(rate)
num_samples = int(1e5)
poisson = tfd.Poisson(log_rate=log_rate, validate_args=True)
self.assertLess(
self.evaluate(
st.min_num_samples_for_dkwm_cdf_test(
discrepancy=0.04, false_fail_rate=1e-9, false_pass_rate=1e-9)),
num_samples)
samples = poisson_lib._random_poisson_noncpu(
shape=[num_samples],
log_rates=log_rate,
output_dtype=tf.float64,
seed=test_util.test_seed())
self.evaluate(
st.assert_true_cdf_equal_by_dkwm(
samples,
poisson.cdf,
st.left_continuous_cdf_discrete_distribution(poisson),
false_fail_rate=1e-9))
