def _test_normal_normal(self, default, dtype):
with self.test_session() as sess:
x_data = np.array([0.0] * 50, dtype=np.float32)
mu = Normal(loc=tf.constant(0.0, dtype=dtype),
scale=tf.constant(1.0, dtype=dtype))
x = Normal(loc=mu,
scale=tf.constant(1.0, dtype=dtype),
sample_shape=50)
n_samples = 2000
# analytic solution: N(loc=0.0, scale=\sqrt{1/51}=0.140)
if not default:
qmu = Empirical(
params=tf.Variable(tf.ones(n_samples, dtype=dtype)))
inference = ed.MetropolisHastings({mu: qmu}, {mu: mu},
data={x: x_data})
else:
inference = ed.MetropolisHastings([mu], {mu: mu},
data={x: x_data})
qmu = inference.latent_vars[mu]
inference.run()
self.assertAllClose(qmu.mean().eval(), 0, rtol=1e-1, atol=1e-1)
self.assertAllClose(qmu.stddev().eval(),
np.sqrt(1 / 51),
rtol=1e-1,
atol=1e-1)
old_t, old_n_accept = sess.run([inference.t, inference.n_accept])
if not default:
self.assertEqual(old_t, n_samples)
else:
self.assertEqual(old_t, 1e4)
self.assertGreater(old_n_accept, 0.1)
sess.run(inference.reset)
new_t, new_n_accept = sess.run([inference.t, inference.n_accept])
self.assertEqual(new_t, 0)
self.assertEqual(new_n_accept, 0)
def test_normalnormal_run(self):
with self.test_session() as sess:
x_data = np.array([0.0] * 50, dtype=np.float32)
mu = Normal(mu=0.0, sigma=1.0)
x = Normal(mu=tf.ones(50) * mu, sigma=1.0)
qmu = Empirical(params=tf.Variable(tf.ones(2000)))
proposal_mu = Normal(mu=0.0, sigma=1.0)
# analytic solution: N(mu=0.0, sigma=\sqrt{1/51}=0.140)
inference = ed.MetropolisHastings({mu: qmu},
{mu: proposal_mu},
data={x: x_data})
inference.run()
self.assertAllClose(qmu.mean().eval(), 0, rtol=1e-2, atol=1e-2)
self.assertAllClose(qmu.std().eval(), np.sqrt(1 / 51),
rtol=1e-2, atol=1e-2)
def test_normalnormal_float32(self):
with self.test_session() as sess:
x_data = np.array([0.0] * 50, dtype=np.float32)
mu = Normal(loc=tf.constant(0.0, dtype=tf.float64),
scale=tf.constant(1.0, dtype=tf.float64))
x = Normal(loc=mu,
scale=tf.constant(1.0, dtype=tf.float64),
sample_shape=50)
n_samples = 2000
qmu = Empirical(params=tf.Variable(tf.ones(n_samples, dtype=tf.float64)))
# analytic solution: N(loc=0.0, scale=\sqrt{1/51}=0.140)
inference = ed.MetropolisHastings({mu: qmu},
{mu: mu},
data={x: x_data})
inference.run()
self.assertAllClose(qmu.mean().eval(), 0, rtol=1e-1, atol=1e-1)
self.assertAllClose(qmu.stddev().eval(), np.sqrt(1 / 51),
rtol=1e-1, atol=1e-1)
def main(_):
# Data generation (known mean)
xn_data = np.random.normal(FLAGS.loc, FLAGS.scale, FLAGS.N)
print("scale: {}".format(FLAGS.scale))
# Prior definition
alpha = 0.5
beta = 0.7
# Posterior inference
# Probabilistic model
ig = InverseGamma(alpha, beta)
xn = Normal(FLAGS.loc, tf.sqrt(ig), sample_shape=FLAGS.N)
# Inference
qig = Empirical(params=tf.get_variable(
"qig/params", [1000], initializer=tf.constant_initializer(0.5)))
proposal_ig = InverseGamma(2.0, 2.0)
inference = ed.MetropolisHastings({ig: qig}, {ig: proposal_ig},
data={xn: xn_data})
inference.run()
sess = ed.get_session()
print("Inferred scale: {}".format(sess.run(tf.sqrt(qig.mean()))))
ed.set_seed(42)
# DATA
x_data = np.array([0.0] * 50, dtype=np.float32)
# MODEL: Normal-Normal with known variance
mu = Normal(mu=0.0, sigma=1.0)
x = Normal(mu=tf.ones(50) * mu, sigma=1.0)
# INFERENCE
qmu = Empirical(params=tf.Variable(tf.zeros([1000])))
proposal_mu = Normal(mu=0.0, sigma=tf.sqrt(1.0 / 51.0))
# analytic solution: N(mu=0.0, sigma=\sqrt{1/51}=0.140)
inference = ed.MetropolisHastings({mu: qmu}, {mu: proposal_mu},
data={x: x_data})
inference.run()
# CRITICISM
# Check convergence with visual diagnostics.
sess = ed.get_session()
mean, std = sess.run([qmu.mean(), qmu.std()])
print("Inferred posterior mean:")
print(mean)
print("Inferred posterior std:")
print(std)
# Check convergence with visual diagnostics.
samples = sess.run(qmu.params)
# Plot histogram.
import numpy as np
import tensorflow as tf
from edward.models import Bernoulli, Beta, Empirical
ed.set_seed(42)
# DATA
x_data = np.array([0, 1, 0, 0, 0, 0, 0, 0, 0, 1])
# MODEL
p = Beta(1.0, 1.0)
x = Bernoulli(probs=p, sample_shape=10)
# INFERENCE
qp = Empirical(params=tf.Variable(tf.zeros([1000]) + 0.5))
proposal_p = Beta(3.0, 9.0)
inference = ed.MetropolisHastings({p: qp}, {p: proposal_p}, data={x: x_data})
inference.run()
# CRITICISM
# exact posterior has mean 0.25 and std 0.12
sess = ed.get_session()
mean, stddev = sess.run([qp.mean(), qp.stddev()])
print("Inferred posterior mean:")
print(mean)
print("Inferred posterior stddev:")
print(stddev)
import tensorflow as tf
from edward.models import InverseGamma, Normal, Empirical
N = 1000
# Data generation (known mean)
mu = 7.0
sigma = 0.7
xn_data = np.random.normal(mu, sigma, N)
print('sigma={}'.format(sigma))
# Prior definition
alpha = tf.Variable(0.5, dtype=tf.float32, trainable=False)
beta = tf.Variable(0.7, dtype=tf.float32, trainable=False)
# Posterior inference
# Probabilistic model
ig = InverseGamma(alpha=alpha, beta=beta)
xn = Normal(mu=mu, sigma=tf.ones([N]) * tf.sqrt(ig))
# Inference
qig = Empirical(params=tf.Variable(tf.zeros(1000) + 0.5))
proposal_ig = InverseGamma(alpha=2.0, beta=2.0)
inference = ed.MetropolisHastings({ig: qig}, {ig: proposal_ig},
data={xn: xn_data})
inference.run()
sess = ed.get_session()
print('Inferred sigma={}'.format(sess.run(tf.sqrt(qig.mean()))))
qc = Empirical(params=tf.Variable(tf.zeros([T, N], dtype=tf.int32)))
gpi = Dirichlet(alpha=tf.constant([1.4, 1.6]))
gmu = Normal(mu=tf.constant([[1.0, 1.0], [-1.0, -1.0]]),
sigma=tf.constant([[0.5, 0.5], [0.5, 0.5]]))
gsigma = InverseGamma(alpha=tf.constant([[1.1, 1.1], [1.1, 1.1]]),
beta=tf.constant([[1.0, 1.0], [1.0, 1.0]]))
gc = Categorical(logits=tf.zeros([N, K]))
inference = ed.MetropolisHastings(latent_vars={
pi: qpi,
mu: qmu,
sigma: qsigma,
c: qc
},
proposal_vars={
pi: gpi,
mu: gmu,
sigma: gsigma,
c: gc
},
data={x: x_data})
inference.initialize()
sess = ed.get_session()
init = tf.initialize_all_variables()
init.run()
for _ in range(T):
info_dict = inference.update()
def test_monte_carlo(self):
tf.InteractiveSession()
ed.set_seed(42)
# DATA
X_train = np.zeros([500, 100])
y_train = np.zeros(500)
N = X_train.shape[0] # data points
D = X_train.shape[1] # feature
T = 1 # number of MCMC samples
# MODEL
W_1 = Normal(mu=tf.zeros([D, 20]), sigma=tf.ones([D, 20]) * 100)
W_2 = Normal(mu=tf.zeros([20, 15]), sigma=tf.ones([20, 15]) * 100)
W_3 = Normal(mu=tf.zeros([15, 1]), sigma=tf.ones([15, 1]) * 100)
b_1 = Normal(mu=tf.zeros(20), sigma=tf.ones(20) * 100)
b_2 = Normal(mu=tf.zeros(15), sigma=tf.ones(15) * 100)
x_ph = tf.placeholder(tf.float32, [N, D])
y = Bernoulli(logits=four_layer_nn(x_ph, W_1, W_2, W_3, b_1, b_2))
# INFERENCE
qW_1 = Empirical(params=tf.Variable(tf.random_normal([T, D, 20])))
qW_2 = Empirical(params=tf.Variable(tf.random_normal([T, 20, 15])))
qW_3 = Empirical(params=tf.Variable(tf.random_normal([T, 15, 1])))
qb_1 = Empirical(params=tf.Variable(tf.random_normal([T, 20])))
qb_2 = Empirical(params=tf.Variable(tf.random_normal([T, 15])))
# note ideally these would be separate test methods; there's an
# issue with the tensorflow graph when re-running the above
# unfortunately
inference = ed.HMC(
{
W_1: qW_1,
b_1: qb_1,
W_2: qW_2,
b_2: qb_2,
W_3: qW_3
},
data={
y: y_train,
x_ph: X_train
})
inference.run()
inference = ed.SGLD(
{
W_1: qW_1,
b_1: qb_1,
W_2: qW_2,
b_2: qb_2,
W_3: qW_3
},
data={
y: y_train,
x_ph: X_train
})
inference.run()
inference = ed.MetropolisHastings(
{
W_1: qW_1,
b_1: qb_1,
W_2: qW_2,
b_2: qb_2,
W_3: qW_3
}, {
W_1: W_1,
b_1: b_1,
W_2: W_2,
b_2: b_2,
W_3: W_3
},
data={
y: y_train,
x_ph: X_train
})
inference.run()
def main(_):
ed.set_seed(42)
# DATA
x_data = build_toy_dataset(FLAGS.N)
# MODEL
pi = Dirichlet(concentration=tf.ones(FLAGS.K))
mu = Normal(0.0, 1.0, sample_shape=[FLAGS.K, FLAGS.D])
sigma = InverseGamma(concentration=1.0,
rate=1.0,
sample_shape=[FLAGS.K, FLAGS.D])
c = Categorical(logits=tf.log(pi) - tf.log(1.0 - pi), sample_shape=FLAGS.N)
x = Normal(loc=tf.gather(mu, c), scale=tf.gather(sigma, c))
# INFERENCE
qpi = Empirical(
params=tf.get_variable("qpi/params", [FLAGS.T, FLAGS.K],
initializer=tf.constant_initializer(1.0 /
FLAGS.K)))
qmu = Empirical(
params=tf.get_variable("qmu/params", [FLAGS.T, FLAGS.K, FLAGS.D],
initializer=tf.zeros_initializer()))
qsigma = Empirical(
params=tf.get_variable("qsigma/params", [FLAGS.T, FLAGS.K, FLAGS.D],
initializer=tf.ones_initializer()))
qc = Empirical(params=tf.get_variable("qc/params", [FLAGS.T, FLAGS.N],
initializer=tf.zeros_initializer(),
dtype=tf.int32))
gpi = Dirichlet(concentration=tf.constant([1.4, 1.6]))
gmu = Normal(loc=tf.constant([[1.0, 1.0], [-1.0, -1.0]]),
scale=tf.constant([[0.5, 0.5], [0.5, 0.5]]))
gsigma = InverseGamma(concentration=tf.constant([[1.1, 1.1], [1.1, 1.1]]),
rate=tf.constant([[1.0, 1.0], [1.0, 1.0]]))
gc = Categorical(logits=tf.zeros([FLAGS.N, FLAGS.K]))
inference = ed.MetropolisHastings(latent_vars={
pi: qpi,
mu: qmu,
sigma: qsigma,
c: qc
},
proposal_vars={
pi: gpi,
mu: gmu,
sigma: gsigma,
c: gc
},
data={x: x_data})
inference.initialize()
sess = ed.get_session()
tf.global_variables_initializer().run()
for _ in range(inference.n_iter):
info_dict = inference.update()
inference.print_progress(info_dict)
t = info_dict['t']
if t == 1 or t % inference.n_print == 0:
qpi_mean, qmu_mean = sess.run([qpi.mean(), qmu.mean()])
print("")
print("Inferred membership probabilities:")
print(qpi_mean)
print("Inferred cluster means:")
print(qmu_mean)
"qmu/params", [T, K, d], initializer=tf.zeros_initializer()))
qsigma = ed.models.Empirical(params=tf.get_variable(
"qsigma/params", [T, K, d], initializer=tf.ones_initializer()))
qz = ed.models.Empirical(params=tf.get_variable(
"qz/params", [T, N], initializer=tf.zeros_initializer(), dtype=tf.int32))
gp = ed.models.Dirichlet(concentration=tf.ones(K))
gmu = ed.models.Normal(loc=tf.ones([K, d]), scale=tf.ones([K, d]))
gsigma = ed.models.InverseGamma(concentration=tf.ones([K, d]),
rate=tf.ones([K, d]))
gz = ed.models.Categorical(logits=tf.zeros([N, K]))
inference = ed.MetropolisHastings(latent_vars={
p: qp,
mu: qmu,
sigma: qsigma,
z: qz
},
proposal_vars={
p: gp,
mu: gmu,
sigma: gsigma,
z: gz
},
data={x: x_train})
inference.run()
# print the posterior
print(qmu.params.eval())
def _test_linear_regression(self, default, dtype):
def build_toy_dataset(N, w, noise_std=0.1):
D = len(w)
x = np.random.randn(N, D)
y = np.dot(x, w) + np.random.normal(0, noise_std, size=N)
return x, y
with self.test_session() as sess:
N = 40 # number of data points
D = 10 # number of features
w_true = np.random.randn(D)
X_train, y_train = build_toy_dataset(N, w_true)
X_test, y_test = build_toy_dataset(N, w_true)
X = tf.placeholder(dtype, [N, D])
w = Normal(loc=tf.zeros(D, dtype=dtype),
scale=tf.ones(D, dtype=dtype))
b = Normal(loc=tf.zeros(1, dtype=dtype),
scale=tf.ones(1, dtype=dtype))
y = Normal(loc=ed.dot(X, w) + b,
scale=0.1 * tf.ones(N, dtype=dtype))
proposal_w = Normal(loc=w, scale=0.5 * tf.ones(D, dtype=dtype))
proposal_b = Normal(loc=b, scale=0.5 * tf.ones(1, dtype=dtype))
n_samples = 2000
if not default:
qw = Empirical(
tf.Variable(tf.zeros([n_samples, D], dtype=dtype)))
qb = Empirical(
tf.Variable(tf.zeros([n_samples, 1], dtype=dtype)))
inference = ed.MetropolisHastings({
w: qw,
b: qb
}, {
w: proposal_w,
b: proposal_b
},
data={
X: X_train,
y: y_train
})
else:
inference = ed.MetropolisHastings([w, b], {
w: proposal_w,
b: proposal_b
},
data={
X: X_train,
y: y_train
})
qw = inference.latent_vars[w]
qb = inference.latent_vars[b]
inference.run()
self.assertAllClose(qw.mean().eval(), w_true, rtol=5e-1, atol=5e-1)
self.assertAllClose(qb.mean().eval(), [0.0], rtol=5e-1, atol=5e-1)
old_t, old_n_accept = sess.run([inference.t, inference.n_accept])
if not default:
self.assertEqual(old_t, n_samples)
else:
self.assertEqual(old_t, 1e4)
self.assertGreater(old_n_accept, 0.1)
sess.run(inference.reset)
new_t, new_n_accept = sess.run([inference.t, inference.n_accept])
self.assertEqual(new_t, 0)
self.assertEqual(new_n_accept, 0)
