def compute_global_xbetainc():
global_mean = tf.reduce_mean(class_means, axis=0, name='global_mean')
class_diffs = (class_means - global_mean)**2.
class_counts = tf.reshape(tf.cast(unique_counts,tf.float32), (-1, 1) )
between = tf.reduce_sum(tf.multiply(class_counts, class_diffs), axis=0)
within = tf.reduce_sum(within_diffs, axis=0)
d1 = n_classes - 1
d2 = tf.cast(tf.reduce_sum(unique_counts), tf.float32) - n_classes
s = (between / d1) / (within / d2)
xmin = 1.0e-20
xmax = 1. - xmin
return tf.clip_by_value(1.-tf.betainc(d1/2., d2/2., (d1*s) / (d1*s + d2) ), xmin, xmax)
def compute_pair_f(item):
between,within,pair_count,r_mean = item
d1 = 1.0 #(two classes) - 1
d2 = tf.cast(pair_count, tf.float32) - 2.0 #n - n_classes
x = (between / (between + within))
# Clip the probabilities to prevent numerical instability
xmin = 1.0e-37
xmax = 1. - 1.0e-5
x_limit = tf.clip_by_value(x, xmin, xmax)
xbetainc = tf.betainc(d1/2.0, d2/2.0, x_limit)
d = model.params.f_statistic_d
top_k, top_k_ind = tf.nn.top_k(xbetainc, k=d, sorted=False)
result = tf.reduce_sum(tf.log(top_k))
return result
def _bdtr(k, n, p):
"""The binomial cumulative distribution function.
Args:
k: floating point `Tensor`.
n: floating point `Tensor`.
p: floating point `Tensor`.
Returns:
`sum_{j=0}^k p^j (1 - p)^(n - j)`.
"""
# Trick for getting safe backprop/gradients into n, k when
# betainc(a = 0, ..) = nan
# Write:
# where(unsafe, safe_output, betainc(where(unsafe, safe_input, input)))
ones = tf.ones_like(n - k)
k_eq_n = tf.equal(k, n)
safe_dn = tf.where(k_eq_n, ones, n - k)
dk = tf.betainc(a=safe_dn, b=k + 1, x=1 - p)
return tf.where(k_eq_n, ones, dk)
def _bdtr(k, n, p):
"""The binomial cumulative distribution function.
Args:
k: floating point `Tensor`.
n: floating point `Tensor`.
p: floating point `Tensor`.
Returns:
`sum_{j=0}^k p^j (1 - p)^(n - j)`.
"""
# Trick for getting safe backprop/gradients into n, k when
# betainc(a = 0, ..) = nan
# Write:
# where(unsafe, safe_output, betainc(where(unsafe, safe_input, input)))
ones = tf.ones_like(n - k)
k_eq_n = tf.equal(k, n)
safe_dn = tf.where(k_eq_n, ones, n - k)
dk = tf.betainc(a=safe_dn, b=k + 1, x=1 - p)
return tf.where(k_eq_n, ones, dk)
def _verifySampleAndPdfConsistency(self, vmf, rtol=0.075):
"""Verifies samples are consistent with the PDF using importance sampling.
In particular, we verify an estimate the surface area of the n-dimensional
hypersphere, and the surface areas of the spherical caps demarcated by
a handful of survival rates.
Args:
vmf: A `VonMisesFisher` distribution instance.
rtol: Relative difference tolerable.
"""
dim = vmf.event_shape[-1].value
nsamples = 50000
samples = vmf.sample(sample_shape=[nsamples])
samples = tf.check_numerics(samples, 'samples')
log_prob = vmf.log_prob(samples)
log_prob = tf.check_numerics(log_prob, 'log_prob')
log_importance = -log_prob
sphere_surface_area_estimate, samples, importance, conc = self.evaluate(
[
tf.exp(
tf.reduce_logsumexp(log_importance, axis=0) -
tf.log(tf.to_float(nsamples))), samples,
tf.exp(log_importance), vmf.concentration
])
true_sphere_surface_area = 2 * (np.pi)**(dim / 2) * self.evaluate(
tf.exp(-tf.lgamma(dim / 2)))
# Broadcast to correct size
true_sphere_surface_area += np.zeros_like(sphere_surface_area_estimate)
# Highly concentrated distributions do not get enough coverage to provide
# a reasonable full-sphere surface area estimate. These are covered below
# by CDF-based hypersphere cap surface area estimates.
self.assertAllClose(true_sphere_surface_area[np.where(conc < 3)],
sphere_surface_area_estimate[np.where(conc < 3)],
rtol=rtol)
# Assert surface area of hyperspherical cap For some CDFs in [.05,.45],
# (h must be greater than 0 for the hypersphere cap surface area
# calculation to hold).
for survival_rate in 0.95, .9, .75, .6:
cdf = (1 - survival_rate)
mean_dir = self.evaluate(vmf.mean_direction)
dotprods = np.sum(samples * mean_dir, -1)
# Empirical estimate of the effective dot-product of the threshold that
# selects for a given CDF level, that is the cosine of the largest
# passable angle, or the minimum cosine for a within-CDF sample.
dotprod_thresh = np.percentile(dotprods,
100 * survival_rate,
axis=0,
keepdims=True)
dotprod_above_thresh = np.float32(dotprods > dotprod_thresh)
sphere_cap_surface_area_ests = (
cdf * (importance * dotprod_above_thresh).sum(0) /
dotprod_above_thresh.sum(0))
h = (1 - dotprod_thresh)
self.assertGreaterEqual(h.min(),
0) # h must be >= 0 for the eqn below
true_sphere_cap_surface_area = (
0.5 * true_sphere_surface_area *
self.evaluate(tf.betainc((dim - 1) / 2, 0.5, 2 * h - h**2)))
if dim == 3: # For 3-d we have a simpler form we can double-check.
self.assertAllClose(2 * np.pi * h,
true_sphere_cap_surface_area)
self.assertAllClose(true_sphere_cap_surface_area,
sphere_cap_surface_area_ests +
np.zeros_like(true_sphere_cap_surface_area),
rtol=rtol)
import tensorflow as tf
"""tf.betainc(a,b,x,name=None)
功能：计算I_x(a, b)。I_x(a, b) = {B(x; a, b)}/{B(a, b)}。
B(x; a, b) = \intergral_from_0_to_x t^{a-1} (1 - t)^{b-1} dt。
B(a, b) = \intergral_from_0_to_1 t^{a-1} (1 - t)^{b-1} dt。即完全beta函数。
输入：x为张量，可以为`float32`, `float64`类型。a,b与x同类型。"""
a = tf.constant(1, tf.float64)
b = tf.constant(1, tf.float64)
x = tf.constant([[0, 0.5, 1]], tf.float64)
z = tf.betainc(a, b, x)
sess = tf.Session()
print(sess.run(z))
sess.close()
# z==>[[0. 0.5 1.]]
def test_Betainc(self):
t = tf.betainc(*self.random((3, 3), (3, 3), (3, 3)))
self.check(t)
def _cdf(self, x): return tf.betainc(self.concentration1, self.concentration0, x)
def _cdf(self, x):
if self.validate_args:
x = distribution_util.embed_check_nonnegative_integer_form(x)
return tf.betainc(self.total_count, 1. + x, tf.sigmoid(-self.logits))
def _cdf(self, x):
return tf.betainc(self.concentration1, self.concentration0, x)
def _cdf(self, x): # Take Abs(scale) to make subsequent where work correctly. y = (x - self.loc) / tf.abs(self.scale) x_t = self.df / (y**2. + self.df) neg_cdf = 0.5 * tf.betainc(0.5 * self.df, 0.5, x_t) return tf.where(tf.less(y, 0.), neg_cdf, 1. - neg_cdf)
def _testBetaInc(self, dtype):
try:
from scipy import special # pylint: disable=g-import-not-at-top
np_dt = dtype.as_numpy_dtype
# Test random values
a_s = np.abs(np.random.randn(10, 10) * 30).astype(
np_dt) # in (0, infty)
b_s = np.abs(np.random.randn(10, 10) * 30).astype(
np_dt) # in (0, infty)
x_s = np.random.rand(10, 10).astype(np_dt) # in (0, 1)
with self.test_session(use_gpu=self.use_gpu):
tf_a_s = tf.constant(a_s, dtype=dtype)
tf_b_s = tf.constant(b_s, dtype=dtype)
tf_x_s = tf.constant(x_s, dtype=dtype)
tf_out = tf.betainc(tf_a_s, tf_b_s, tf_x_s).eval()
scipy_out = special.betainc(a_s, b_s, x_s).astype(np_dt)
# the scipy version of betainc uses a double-only implementation.
# TODO(ebrevdo): identify reasons for (sometime) precision loss
# with doubles
tol = 1e-4 if dtype == tf.float32 else 5e-5
self.assertAllCloseAccordingToType(scipy_out,
tf_out,
rtol=tol,
atol=tol)
# Test out-of-range values (most should return nan output)
combinations = list(
itertools.product([-1, 0, 0.5, 1.0, 1.5], repeat=3))
a_comb, b_comb, x_comb = np.asarray(list(zip(*combinations)),
dtype=np_dt)
with self.test_session(use_gpu=self.use_gpu):
tf_comb = tf.betainc(a_comb, b_comb, x_comb).eval()
scipy_comb = special.betainc(a_comb, b_comb, x_comb).astype(np_dt)
self.assertAllCloseAccordingToType(scipy_comb, tf_comb)
# Test broadcasting between scalars and other shapes
with self.test_session(use_gpu=self.use_gpu):
self.assertAllCloseAccordingToType(special.betainc(
0.1, b_s, x_s).astype(np_dt),
tf.betainc(0.1, b_s,
x_s).eval(),
rtol=tol,
atol=tol)
self.assertAllCloseAccordingToType(special.betainc(
a_s, 0.1, x_s).astype(np_dt),
tf.betainc(a_s, 0.1,
x_s).eval(),
rtol=tol,
atol=tol)
self.assertAllCloseAccordingToType(special.betainc(
a_s, b_s, 0.1).astype(np_dt),
tf.betainc(a_s, b_s,
0.1).eval(),
rtol=tol,
atol=tol)
self.assertAllCloseAccordingToType(special.betainc(
0.1, b_s, 0.1).astype(np_dt),
tf.betainc(0.1, b_s,
0.1).eval(),
rtol=tol,
atol=tol)
self.assertAllCloseAccordingToType(special.betainc(
0.1, 0.1, 0.1).astype(np_dt),
tf.betainc(0.1, 0.1,
0.1).eval(),
rtol=tol,
atol=tol)
with self.assertRaisesRegexp(ValueError,
"Shapes .* are not compatible"):
tf.betainc(0.5, [0.5], [[0.5]])
with self.test_session(use_gpu=self.use_gpu):
with self.assertRaisesOpError("Shapes of .* are inconsistent"):
a_p = tf.placeholder(dtype)
b_p = tf.placeholder(dtype)
x_p = tf.placeholder(dtype)
tf.betainc(a_p, b_p, x_p).eval(feed_dict={
a_p: 0.5,
b_p: [0.5],
x_p: [[0.5]]
})
except ImportError as e:
tf.logging.warn("Cannot test special functions: %s" % str(e))
def _cdf(self, x): # Take Abs(scale) to make subsequent where work correctly. y = (x - self.loc) / tf.abs(self.scale) x_t = self.df / (y**2. + self.df) neg_cdf = 0.5 * tf.betainc(0.5 * self.df, 0.5, x_t) return tf.where(tf.less(y, 0.), neg_cdf, 1. - neg_cdf)
def _testBetaInc(self, dtype):
try:
from scipy import special # pylint: disable=g-import-not-at-top
np_dt = dtype.as_numpy_dtype
# Test random values
a_s = np.abs(np.random.randn(10, 10) * 30).astype(np_dt) # in (0, infty)
b_s = np.abs(np.random.randn(10, 10) * 30).astype(np_dt) # in (0, infty)
x_s = np.random.rand(10, 10).astype(np_dt) # in (0, 1)
with self.test_session(use_gpu=self.use_gpu):
tf_a_s = tf.constant(a_s, dtype=dtype)
tf_b_s = tf.constant(b_s, dtype=dtype)
tf_x_s = tf.constant(x_s, dtype=dtype)
tf_out = tf.betainc(tf_a_s, tf_b_s, tf_x_s).eval()
scipy_out = special.betainc(a_s, b_s, x_s).astype(np_dt)
# the scipy version of betainc uses a double-only implementation.
# TODO(ebrevdo): identify reasons for (sometime) precision loss
# with doubles
tol = 1e-4 if dtype == tf.float32 else 5e-5
self.assertAllCloseAccordingToType(scipy_out, tf_out, rtol=tol, atol=tol)
# Test out-of-range values (most should return nan output)
combinations = list(itertools.product([-1, 0, 0.5, 1.0, 1.5], repeat=3))
a_comb, b_comb, x_comb = np.asarray(
list(zip(*combinations)), dtype=np_dt)
with self.test_session(use_gpu=self.use_gpu):
tf_comb = tf.betainc(a_comb, b_comb, x_comb).eval()
scipy_comb = special.betainc(a_comb, b_comb, x_comb).astype(np_dt)
self.assertAllCloseAccordingToType(scipy_comb, tf_comb)
# Test broadcasting between scalars and other shapes
with self.test_session(use_gpu=self.use_gpu):
self.assertAllCloseAccordingToType(
special.betainc(0.1, b_s, x_s).astype(np_dt),
tf.betainc(0.1, b_s, x_s).eval(), rtol=tol, atol=tol)
self.assertAllCloseAccordingToType(
special.betainc(a_s, 0.1, x_s).astype(np_dt),
tf.betainc(a_s, 0.1, x_s).eval(), rtol=tol, atol=tol)
self.assertAllCloseAccordingToType(
special.betainc(a_s, b_s, 0.1).astype(np_dt),
tf.betainc(a_s, b_s, 0.1).eval(), rtol=tol, atol=tol)
self.assertAllCloseAccordingToType(
special.betainc(0.1, b_s, 0.1).astype(np_dt),
tf.betainc(0.1, b_s, 0.1).eval(), rtol=tol, atol=tol)
self.assertAllCloseAccordingToType(
special.betainc(0.1, 0.1, 0.1).astype(np_dt),
tf.betainc(0.1, 0.1, 0.1).eval(), rtol=tol, atol=tol)
with self.assertRaisesRegexp(ValueError, "Shapes .* are not compatible"):
tf.betainc(0.5, [0.5], [[0.5]])
with self.test_session(use_gpu=self.use_gpu):
with self.assertRaisesOpError("Shapes of .* are inconsistent"):
a_p = tf.placeholder(dtype)
b_p = tf.placeholder(dtype)
x_p = tf.placeholder(dtype)
tf.betainc(a_p, b_p, x_p).eval(
feed_dict={a_p: 0.5, b_p: [0.5], x_p: [[0.5]]})
except ImportError as e:
tf.logging.warn("Cannot test special functions: %s" % str(e))
def _cdf(self, x):
if self.validate_args:
x = distribution_util.embed_check_nonnegative_integer_form(x)
return tf.betainc(self.total_count, 1. + x, tf.sigmoid(-self.logits))
