def testInverseGammaNonPositiveInitializationParamsRaises(self):
with self.cached_session():
alpha_v = constant_op.constant(0.0, name="alpha")
beta_v = constant_op.constant(1.0, name="beta")
inv_gamma = inverse_gamma.InverseGamma(
concentration=alpha_v, rate=beta_v, validate_args=True)
with self.assertRaisesOpError("alpha"):
inv_gamma.mean().eval()
alpha_v = constant_op.constant(1.0, name="alpha")
beta_v = constant_op.constant(0.0, name="beta")
inv_gamma = inverse_gamma.InverseGamma(
concentration=alpha_v, rate=beta_v, validate_args=True)
with self.assertRaisesOpError("beta"):
inv_gamma.mean().eval()
def testInverseGammaNonPositiveInitializationParamsRaises(self):
with self.cached_session():
alpha_v = constant_op.constant(0.0, name="alpha")
beta_v = constant_op.constant(1.0, name="beta")
with self.assertRaisesWithPredicateMatch(errors.InvalidArgumentError,
"alpha"):
_ = inverse_gamma.InverseGamma(
concentration=alpha_v, rate=beta_v, validate_args=True)
# Error detected statically; no need for _.mean().eval()
alpha_v = constant_op.constant(1.0, name="alpha")
beta_v = constant_op.constant(0.0, name="beta")
with self.assertRaisesWithPredicateMatch(errors.InvalidArgumentError,
"beta"):
_ = inverse_gamma.InverseGamma(
concentration=alpha_v, rate=beta_v, validate_args=True)
def testInverseGammaPdfOfSampleMultiDims(self):
with session.Session() as sess:
inv_gamma = inverse_gamma.InverseGamma(alpha=[7., 11.],
beta=[[5.], [6.]])
num = 50000
samples = inv_gamma.sample(num, seed=137)
pdfs = inv_gamma.pdf(samples)
sample_vals, pdf_vals = sess.run([samples, pdfs])
self.assertEqual(samples.get_shape(), (num, 2, 2))
self.assertEqual(pdfs.get_shape(), (num, 2, 2))
self.assertAllClose(stats.invgamma.mean([[7., 11.], [7., 11.]],
scale=np.array([[5., 5.],
[6.,
6.]])),
sample_vals.mean(axis=0),
atol=.1)
self.assertAllClose(stats.invgamma.var([[7., 11.], [7., 11.]],
scale=np.array([[5., 5.],
[6., 6.]])),
sample_vals.var(axis=0),
atol=.1)
self._assertIntegral(sample_vals[:, 0, 0],
pdf_vals[:, 0, 0],
err=0.02)
self._assertIntegral(sample_vals[:, 0, 1],
pdf_vals[:, 0, 1],
err=0.02)
self._assertIntegral(sample_vals[:, 1, 0],
pdf_vals[:, 1, 0],
err=0.02)
self._assertIntegral(sample_vals[:, 1, 1],
pdf_vals[:, 1, 1],
err=0.02)
def testInverseGammaSampleMultiDimensional(self):
with session.Session():
alpha_v = np.array([np.arange(3, 103,
dtype=np.float32)]) # 1 x 100
beta_v = np.array([np.arange(1, 11, dtype=np.float32)]).T # 10 x 1
inv_gamma = inverse_gamma.InverseGamma(alpha=alpha_v, beta=beta_v)
n = 10000
samples = inv_gamma.sample(n, seed=137)
sample_values = samples.eval()
self.assertEqual(samples.get_shape(), (n, 10, 100))
self.assertEqual(sample_values.shape, (n, 10, 100))
zeros = np.zeros_like(alpha_v + beta_v) # 10 x 100
alpha_bc = alpha_v + zeros
beta_bc = beta_v + zeros
self.assertAllClose(sample_values.mean(axis=0),
stats.invgamma.mean(alpha_bc, scale=beta_bc),
atol=.25)
self.assertAllClose(sample_values.var(axis=0),
stats.invgamma.var(alpha_bc, scale=beta_bc),
atol=4.5)
fails = 0
trials = 0
for ai, a in enumerate(np.reshape(alpha_v, [-1])):
for bi, b in enumerate(np.reshape(beta_v, [-1])):
s = sample_values[:, bi, ai]
trials += 1
fails += 0 if self._kstest(a, b, s) else 1
self.assertLess(fails, trials * 0.03)
def testInverseGammaVarianceAllowNanStats(self):
with self.cached_session():
alpha_v = np.array([1.5, 3.0, 2.5])
beta_v = np.array([1.0, 4.0, 5.0])
inv_gamma = inverse_gamma.InverseGamma(
concentration=alpha_v, rate=beta_v, allow_nan_stats=False)
with self.assertRaisesOpError("x < y"):
inv_gamma.variance().eval()
def testInverseGammaVarianceAllDefined(self):
with self.cached_session():
alpha_v = np.array([7.0, 3.0, 2.5])
beta_v = np.array([1.0, 4.0, 5.0])
inv_gamma = inverse_gamma.InverseGamma(concentration=alpha_v, rate=beta_v)
expected_variances = stats.invgamma.var(alpha_v, scale=beta_v)
self.assertEqual(inv_gamma.variance().get_shape(), (3,))
self.assertAllClose(inv_gamma.variance().eval(), expected_variances)
def testInverseGammaMeanAllDefined(self):
with self.test_session():
alpha_v = np.array([5.5, 3.0, 2.5])
beta_v = np.array([1.0, 4.0, 5.0])
inv_gamma = inverse_gamma.InverseGamma(alpha=alpha_v, beta=beta_v)
expected_means = stats.invgamma.mean(alpha_v, scale=beta_v)
self.assertEqual(inv_gamma.mean().get_shape(), (3, ))
self.assertAllClose(inv_gamma.mean().eval(), expected_means)
def testInverseGammaEntropy(self):
with self.test_session():
alpha_v = np.array([1.0, 3.0, 2.5])
beta_v = np.array([1.0, 4.0, 5.0])
expected_entropy = stats.invgamma.entropy(alpha_v, scale=beta_v)
inv_gamma = inverse_gamma.InverseGamma(alpha=alpha_v, beta=beta_v)
self.assertEqual(inv_gamma.entropy().get_shape(), (3, ))
self.assertAllClose(inv_gamma.entropy().eval(), expected_entropy)
def testInverseGammaMode(self):
with self.test_session():
alpha_v = np.array([5.5, 3.0, 2.5])
beta_v = np.array([1.0, 4.0, 5.0])
inv_gamma = inverse_gamma.InverseGamma(alpha=alpha_v, beta=beta_v)
expected_modes = beta_v / (alpha_v + 1)
self.assertEqual(inv_gamma.mode().get_shape(), (3, ))
self.assertAllClose(inv_gamma.mode().eval(), expected_modes)
def testInverseGammaMeanAllowNanStats(self):
with self.cached_session():
# Mean will not be defined for the first entry.
alpha_v = np.array([1.0, 3.0, 2.5])
beta_v = np.array([1.0, 4.0, 5.0])
inv_gamma = inverse_gamma.InverseGamma(
concentration=alpha_v, rate=beta_v, allow_nan_stats=False)
with self.assertRaisesOpError("x < y"):
inv_gamma.mean().eval()
def testInverseGammaShape(self):
with self.test_session():
alpha = constant_op.constant([3.0] * 5)
beta = constant_op.constant(11.0)
inv_gamma = inverse_gamma.InverseGamma(alpha=alpha, beta=beta)
self.assertEqual(inv_gamma.batch_shape().eval(), (5, ))
self.assertEqual(inv_gamma.get_batch_shape(),
tensor_shape.TensorShape([5]))
self.assertAllEqual(inv_gamma.event_shape().eval(), [])
self.assertEqual(inv_gamma.get_event_shape(),
tensor_shape.TensorShape([]))
def testInverseGammaMeanNanStats(self):
with self.cached_session():
# Mode will not be defined for the first two entries.
alpha_v = np.array([0.5, 1.0, 3.0, 2.5])
beta_v = np.array([1.0, 2.0, 4.0, 5.0])
inv_gamma = inverse_gamma.InverseGamma(
concentration=alpha_v, rate=beta_v, allow_nan_stats=True)
expected_means = beta_v / (alpha_v - 1)
expected_means[0] = np.nan
expected_means[1] = np.nan
self.assertEqual(inv_gamma.mean().get_shape(), (4,))
self.assertAllClose(inv_gamma.mean().eval(), expected_means)
def testInverseGammaShape(self):
with self.cached_session():
alpha = constant_op.constant([3.0] * 5)
beta = constant_op.constant(11.0)
inv_gamma = inverse_gamma.InverseGamma(concentration=alpha, rate=beta)
self.assertEqual(inv_gamma.batch_shape_tensor().eval(), (5,))
self.assertEqual(inv_gamma.batch_shape,
tensor_shape.TensorShape([5]))
self.assertAllEqual(inv_gamma.event_shape_tensor().eval(), [])
self.assertEqual(inv_gamma.event_shape, tensor_shape.TensorShape(
[]))
def testInverseGammaVarianceNanStats(self):
with self.test_session():
alpha_v = np.array([1.5, 3.0, 2.5])
beta_v = np.array([1.0, 4.0, 5.0])
inv_gamma = inverse_gamma.InverseGamma(alpha=alpha_v,
beta=beta_v,
allow_nan_stats=True)
expected_variances = stats.invgamma.var(alpha_v, scale=beta_v)
expected_variances[0] = np.nan
self.assertEqual(inv_gamma.variance().get_shape(), (3, ))
self.assertAllClose(inv_gamma.variance().eval(),
expected_variances)
def testInverseGammaCDF(self):
with self.test_session():
batch_size = 6
alpha_v = 2.0
beta_v = 3.0
alpha = constant_op.constant([alpha_v] * batch_size)
beta = constant_op.constant([beta_v] * batch_size)
x = np.array([2.5, 2.5, 4.0, 0.1, 1.0, 2.0], dtype=np.float32)
inv_gamma = inverse_gamma.InverseGamma(alpha=alpha, beta=beta)
expected_cdf = stats.invgamma.cdf(x, alpha_v, scale=beta_v)
cdf = inv_gamma.cdf(x)
self.assertEqual(cdf.get_shape(), (batch_size, ))
self.assertAllClose(cdf.eval(), expected_cdf)
def testInverseGammaLogPDF(self):
with self.test_session():
batch_size = 6
alpha = constant_op.constant([2.0] * batch_size)
beta = constant_op.constant([3.0] * batch_size)
alpha_v = 2.0
beta_v = 3.0
x = np.array([2.5, 2.5, 4.0, 0.1, 1.0, 2.0], dtype=np.float32)
inv_gamma = inverse_gamma.InverseGamma(alpha=alpha, beta=beta)
expected_log_pdf = stats.invgamma.logpdf(x, alpha_v, scale=beta_v)
log_pdf = inv_gamma.log_pdf(x)
self.assertEqual(log_pdf.get_shape(), (6, ))
self.assertAllClose(log_pdf.eval(), expected_log_pdf)
pdf = inv_gamma.pdf(x)
self.assertEqual(pdf.get_shape(), (6, ))
self.assertAllClose(pdf.eval(), np.exp(expected_log_pdf))
def testInverseGammaLogPDFMultidimensionalBroadcasting(self):
with self.test_session():
batch_size = 6
alpha = constant_op.constant([[2.0, 4.0]] * batch_size)
beta = constant_op.constant(3.0)
alpha_v = np.array([2.0, 4.0])
beta_v = 3.0
x = np.array([[2.5, 2.5, 4.0, 0.1, 1.0, 2.0]], dtype=np.float32).T
inv_gamma = inverse_gamma.InverseGamma(alpha=alpha, beta=beta)
expected_log_pdf = stats.invgamma.logpdf(x, alpha_v, scale=beta_v)
log_pdf = inv_gamma.log_pdf(x)
log_pdf_values = log_pdf.eval()
self.assertEqual(log_pdf.get_shape(), (6, 2))
self.assertAllClose(log_pdf_values, expected_log_pdf)
pdf = inv_gamma.pdf(x)
pdf_values = pdf.eval()
self.assertEqual(pdf.get_shape(), (6, 2))
self.assertAllClose(pdf_values, np.exp(expected_log_pdf))
def testInverseGammaSample(self):
with session.Session():
alpha_v = 4.0
beta_v = 3.0
alpha = constant_op.constant(alpha_v)
beta = constant_op.constant(beta_v)
n = 100000
inv_gamma = inverse_gamma.InverseGamma(alpha=alpha, beta=beta)
samples = inv_gamma.sample(n, seed=137)
sample_values = samples.eval()
self.assertEqual(samples.get_shape(), (n, ))
self.assertEqual(sample_values.shape, (n, ))
self.assertAllClose(sample_values.mean(),
stats.invgamma.mean(alpha_v, scale=beta_v),
atol=.0025)
self.assertAllClose(sample_values.var(),
stats.invgamma.var(alpha_v, scale=beta_v),
atol=.15)
self.assertTrue(self._kstest(alpha_v, beta_v, sample_values))
