def testGammaGammaSampleConcentrationCausesBroadcast(self): gg = tfd.GammaGamma(concentration=[1., 2.], mixing_concentration=1., mixing_rate=1.) n = 3 samples = self.evaluate(gg.sample(n, seed=tfp_test_util.test_seed())) self.assertAllEqual((n, 2), samples.shape)
def testGammaGammaLogPDF(self): batch_size = 5 alpha = tf.constant([2.] * batch_size, dtype=np.float32) alpha0 = tf.constant([3.] * batch_size, dtype=np.float32) beta0 = tf.constant([4.] * batch_size, dtype=np.float32) x = np.array([6.] * batch_size, dtype=np.float32) # Let # alpha = concentration = 2. # alpha0 = mixing_concentration = 3., # beta0 = mixing_rate = 4. # # See the PDF derivation in formula (1) of # http://www.brucehardie.com/notes/025/gamma_gamma.pdf. # # x**(alpha - 1) * beta0**alpha0 # prob(x=6) = ------------------------------------------------ # B(alpha, alpha0) * (x + beta0)**(alpha + alpha0) # # 6 * 4**3 # = --------------- = 0.04608 # B(2, 3) * 10**5 # # log_prob(x=6) = -3.077376 expected_log_pdf = [-3.077376] * batch_size gg = tfd.GammaGamma(concentration=alpha, mixing_concentration=alpha0, mixing_rate=beta0) log_pdf = gg.log_prob(x) self.assertEqual(log_pdf.shape, (5, )) self.assertAllClose(self.evaluate(log_pdf), expected_log_pdf)
def testAssertValidSample(self): gg = tfd.GammaGamma(concentration=2., mixing_concentration=.1, mixing_rate=3., validate_args=True) with self.assertRaisesOpError('Sample must be non-negative.'): self.evaluate(gg.log_prob(-.1))
def testGammaGammaLogPDFAtZero(self): # When concentration = 1., the log pdf should be finite. gg = tfd.GammaGamma(concentration=1., mixing_concentration=[0.01, 0.1, 2, 3], mixing_rate=[0.01, 0.1, 2, 3]) log_pdf = self.evaluate(gg.log_prob(0.)) self.assertAllEqual(np.ones_like(log_pdf, dtype=np.bool), np.isfinite(log_pdf))
def testSupportBijectorOutsideRange(self): dist = tfd.GammaGamma(concentration=[3., 2., 5.4], mixing_concentration=2., mixing_rate=1., validate_args=True) with self.assertRaisesOpError('must be greater than or equal to 0'): dist.experimental_default_event_space_bijector().inverse( [-4.2, -0.3, -1e-6])
def testGammaGammaShape(self): gg = tfd.GammaGamma(concentration=[[2.], [4.]], mixing_concentration=[1., 2., 3.], mixing_rate=0.5) self.assertAllEqual(self.evaluate(gg.batch_shape_tensor()), [2, 3]) self.assertEqual(gg.batch_shape, tf.TensorShape([2, 3])) self.assertAllEqual(self.evaluate(gg.event_shape_tensor()), []) self.assertEqual(gg.event_shape, tf.TensorShape([]))
def testGammaGammaLogPDFAtZero(self): # When concentration = 1., the log pdf should be finite. gg = tfd.GammaGamma(concentration=1., mixing_concentration=[0.01, 0.1, 2, 3], mixing_rate=[0.01, 0.1, 2, 3], validate_args=True) log_pdf = self.evaluate(gg.log_prob(0.)) self.assertAllEqual(np.ones_like(log_pdf, dtype=np.bool_), np.isfinite(log_pdf)) gg = tfd.GammaGamma(concentration=2., mixing_concentration=[0.01, 0.1, 2, 3], mixing_rate=[0.01, 0.1, 2, 3], validate_args=True) log_pdf = self.evaluate(gg.log_prob(0.)) self.assertAllNegativeInf(log_pdf) pdf = self.evaluate(gg.prob(0.)) self.assertAllEqual(pdf, np.zeros_like(pdf))
def testGammaGammaMeanAllDefined(self): alpha_v = np.array([2., 4.]) alpha0_v = np.array([3., 6.]) beta0_v = np.array([4., 8.]) expected_mean = alpha_v * beta0_v / (alpha0_v - 1.) gg = tfd.GammaGamma(concentration=alpha_v, mixing_concentration=alpha0_v, mixing_rate=beta0_v) self.assertEqual(gg.mean().shape, (2, )) self.assertAllClose(self.evaluate(gg.mean()), expected_mean)
def testGammaGammaLogPDFMultidimensionalBroadcasting(self): batch_size = 6 alpha = tf.constant([[2., 4.]] * batch_size) alpha0 = tf.constant(3.0) beta0 = tf.constant([4., 8.]) x = np.array([[2.5, 2.5, 4.0, 0.1, 1.0, 2.0]], dtype=np.float32).T gg = tfd.GammaGamma( concentration=alpha, mixing_concentration=alpha0, mixing_rate=beta0) log_pdf = gg.log_prob(x) self.assertEqual(log_pdf.shape, (6, 2))
def testGammaGammaMeanNanStats(self): # Mean will not be defined for the first entry. alpha_v = np.array([2., 4.]) alpha0_v = np.array([1., 6.]) beta0_v = np.array([4., 8.]) expected_mean = np.array([np.nan, 6.4]) gg = tfd.GammaGamma(concentration=alpha_v, mixing_concentration=alpha0_v, mixing_rate=beta0_v) self.assertEqual(gg.mean().shape, (2, )) self.assertAllClose(self.evaluate(gg.mean()), expected_mean)
def testGammaGammaMeanAllowNanStats(self): # Mean will not be defined for the first entry. alpha_v = np.array([2., 4.]) alpha0_v = np.array([1., 6.]) beta0_v = np.array([4., 8.]) gg = tfd.GammaGamma(concentration=alpha_v, mixing_concentration=alpha0_v, mixing_rate=beta0_v, allow_nan_stats=False) with self.assertRaisesOpError('x < y'): self.evaluate(gg.mean())
def testGammaGammaInvalidArgs(self): with self.assertRaisesOpError('`concentration` must be positive'): gg = tfd.GammaGamma(concentration=-1., mixing_concentration=2., mixing_rate=0.5, validate_args=True) self.evaluate(gg.mean()) with self.assertRaisesOpError( '`mixing_concentration` must be positive'): gg = tfd.GammaGamma(concentration=1., mixing_concentration=-2., mixing_rate=0.5, validate_args=True) self.evaluate(gg.mean()) with self.assertRaisesOpError('`mixing_rate` must be positive'): gg = tfd.GammaGamma(concentration=1., mixing_concentration=2., mixing_rate=-0.5, validate_args=True) self.evaluate(gg.mean())
def testGammaGammaSample(self): alpha_v = 2.0 alpha0_v = 3.0 beta0_v = 5.0 n = 100000 gg = tfd.GammaGamma(concentration=alpha_v, mixing_concentration=alpha0_v, mixing_rate=beta0_v) samples = gg.sample(n, seed=tfp_test_util.test_seed()) sample_values = self.evaluate(samples) self.assertEqual(samples.shape, (n, )) self.assertEqual(sample_values.shape, (n, )) self.assertAllClose(sample_values.mean(), self.evaluate(gg.mean()), rtol=.02)
def testGammaGammaSampleMultidimensional(self): alpha_v = np.array([np.arange(5, 25, 2, dtype=np.float32)]) # 1 x 10 alpha0_v = 5. beta0_v = np.array([np.arange(5, 15, 2, dtype=np.float32)]).T # 5 x 1 n = 75000 gg = tfd.GammaGamma( concentration=alpha_v, mixing_concentration=alpha0_v, mixing_rate=beta0_v) samples = gg.sample(n, seed=tfp_test_util.test_seed()) sample_values = self.evaluate(samples) expected_shape = (n, beta0_v.shape[0], alpha_v.shape[-1]) self.assertEqual(samples.shape, expected_shape) self.assertEqual(sample_values.shape, expected_shape) self.assertAllClose( self.evaluate(gg.variance()), sample_values.var(axis=0), rtol=.6) self.assertAllClose( self.evaluate(gg.mean()), sample_values.mean(axis=0), rtol=.02)