def check(D, N, K, mu=None, Lambda=None, rho=None):
if mu is None:
mu = np.zeros(D)
if Lambda is None:
Lambda = np.identity(D)
if rho is None:
rho = np.ones(D)
V = np.identity(D) + np.ones((D, D))
# Construct model
B = GaussianARD(3, 5, shape=(D, K), plates=(1, D))
S = GaussianARD(2, 4, shape=(K, ), plates=(N, 1))
A = SumMultiply('dk,k->d', B, S)
X = GaussianMarkovChain(mu,
Lambda,
A,
rho,
n=N + 1,
initialize=False)
Y = Gaussian(X, V, initialize=False)
# Posterior estimation
Y.observe(np.random.randn(N + 1, D))
X.update()
B.update()
S.update()
try:
mu.update()
except:
pass
try:
Lambda.update()
except:
pass
try:
rho.update()
except:
pass
# Construct rotator
rotB = RotateGaussianARD(B, axis=-2)
rotX = RotateVaryingMarkovChain(X, B, S, rotB)
rotX.setup()
# Check gradient with respect to R
R = np.random.randn(D, D)
def cost(r):
(b, dr) = rotX.bound(np.reshape(r, np.shape(R)))
return (b, np.ravel(dr))
err = optimize.check_gradient(cost, np.ravel(R), verbose=False)
self.assertAllClose(err, 0, atol=1e-6, msg="Gradient incorrect")
return
def check(D, N, mu=None, Lambda=None, rho=None, A=None):
if mu is None:
mu = np.zeros(D)
if Lambda is None:
Lambda = np.identity(D)
if rho is None:
rho = np.ones(D)
if A is None:
A = GaussianARD(3, 5, shape=(D, ), plates=(D, ))
V = np.identity(D) + np.ones((D, D))
# Construct model
X = GaussianMarkovChain(mu,
Lambda,
A,
rho,
n=N + 1,
initialize=False)
Y = Gaussian(X, V, initialize=False)
# Posterior estimation
Y.observe(np.random.randn(*(Y.get_shape(0))))
X.update()
try:
A.update()
except:
pass
try:
mu.update()
except:
pass
try:
Lambda.update()
except:
pass
try:
rho.update()
except:
pass
# Construct rotator
rotA = RotateGaussianARD(A, axis=-1)
rotX = RotateGaussianMarkovChain(X, rotA)
rotX.setup()
# Check gradient with respect to R
R = np.random.randn(D, D)
def cost(r):
(b, dr) = rotX.bound(np.reshape(r, np.shape(R)))
return (b, np.ravel(dr))
err = optimize.check_gradient(cost, np.ravel(R), verbose=False)
self.assertAllClose(err, 0, atol=1e-5, msg="Gradient incorrect")
return
def check(D, N, K, mu=None, Lambda=None, rho=None):
if mu is None:
mu = np.zeros(D)
if Lambda is None:
Lambda = np.identity(D)
if rho is None:
rho = np.ones(D)
V = np.identity(D) + np.ones((D, D))
# Construct model
B = GaussianARD(3, 5, shape=(D, K), plates=(1, D))
S = GaussianARD(2, 4, shape=(K, ), plates=(N, 1))
A = SumMultiply('dk,k->d', B, S)
X = GaussianMarkovChain(mu,
Lambda,
A,
rho,
n=N + 1,
initialize=False)
Y = Gaussian(X, V, initialize=False)
# Posterior estimation
Y.observe(np.random.randn(N + 1, D))
X.update()
B.update()
S.update()
try:
mu.update()
except:
pass
try:
Lambda.update()
except:
pass
try:
rho.update()
except:
pass
# Construct rotator
rotB = RotateGaussianARD(B, axis=-2)
rotX = RotateVaryingMarkovChain(X, B, S, rotB)
# Rotation
true_cost0 = X.lower_bound_contribution()
rotX.setup()
I = np.identity(D)
R = np.random.randn(D, D)
rot_cost0 = rotX.get_bound_terms(I)
rot_cost1 = rotX.get_bound_terms(R)
self.assertAllClose(sum(rot_cost0.values()),
rotX.bound(I)[0],
msg="Bound terms and total bound differ")
self.assertAllClose(sum(rot_cost1.values()),
rotX.bound(R)[0],
msg="Bound terms and total bound differ")
rotX.rotate(R)
true_cost1 = X.lower_bound_contribution()
self.assertAllClose(true_cost1 - true_cost0,
rot_cost1[X] - rot_cost0[X],
msg="Incorrect rotation cost for X")
return
def check(D, N, mu=None, Lambda=None, rho=None, A=None):
if mu is None:
mu = np.zeros(D)
if Lambda is None:
Lambda = np.identity(D)
if rho is None:
rho = np.ones(D)
if A is None:
A = GaussianARD(3, 5, shape=(D, ), plates=(D, ))
V = np.identity(D) + np.ones((D, D))
# Construct model
X = GaussianMarkovChain(mu,
Lambda,
A,
rho,
n=N + 1,
initialize=False)
Y = Gaussian(X, V, initialize=False)
# Posterior estimation
Y.observe(np.random.randn(*(Y.get_shape(0))))
X.update()
try:
A.update()
except:
pass
try:
mu.update()
except:
pass
try:
Lambda.update()
except:
pass
try:
rho.update()
except:
pass
# Construct rotator
rotA = RotateGaussianARD(A, axis=-1)
rotX = RotateGaussianMarkovChain(X, rotA)
# Rotation
true_cost0 = X.lower_bound_contribution()
rotX.setup()
I = np.identity(D)
R = np.random.randn(D, D)
rot_cost0 = rotX.get_bound_terms(I)
rot_cost1 = rotX.get_bound_terms(R)
self.assertAllClose(sum(rot_cost0.values()),
rotX.bound(I)[0],
msg="Bound terms and total bound differ")
self.assertAllClose(sum(rot_cost1.values()),
rotX.bound(R)[0],
msg="Bound terms and total bound differ")
rotX.rotate(R)
true_cost1 = X.lower_bound_contribution()
self.assertAllClose(true_cost1 - true_cost0,
rot_cost1[X] - rot_cost0[X],
msg="Incorrect rotation cost for X")
return
def test(shape,
plates,
axis=-1,
alpha_plates=None,
plate_axis=None,
mu=3):
if plate_axis is not None:
precomputes = [False, True]
else:
precomputes = [False]
for precompute in precomputes:
# Construct the model
D = shape[axis]
if alpha_plates is not None:
alpha = Gamma(2, 2, plates=alpha_plates)
alpha.initialize_from_random()
else:
alpha = 2
X = GaussianARD(mu, alpha, shape=shape, plates=plates)
# Some initial learning and rotator constructing
X.initialize_from_random()
Y = GaussianARD(X, 1)
Y.observe(np.random.randn(*(Y.get_shape(0))))
X.update()
if alpha_plates is not None:
alpha.update()
true_cost0_alpha = alpha.lower_bound_contribution()
rotX = RotateGaussianARD(X,
alpha,
axis=axis,
precompute=precompute)
else:
rotX = RotateGaussianARD(X,
axis=axis,
precompute=precompute)
true_cost0_X = X.lower_bound_contribution()
# Rotation matrices
I = np.identity(D)
R = np.random.randn(D, D)
if plate_axis is not None:
C = plates[plate_axis]
Q = np.random.randn(C, C)
Ic = np.identity(C)
else:
Q = None
Ic = None
# Compute bound terms
rotX.setup(plate_axis=plate_axis)
rot_cost0 = rotX.get_bound_terms(I, Q=Ic)
rot_cost1 = rotX.get_bound_terms(R, Q=Q)
self.assertAllClose(sum(rot_cost0.values()),
rotX.bound(I, Q=Ic)[0],
msg="Bound terms and total bound differ")
self.assertAllClose(sum(rot_cost1.values()),
rotX.bound(R, Q=Q)[0],
msg="Bound terms and total bound differ")
# Perform rotation
rotX.rotate(R, Q=Q)
# Check bound terms
true_cost1_X = X.lower_bound_contribution()
self.assertAllClose(true_cost1_X - true_cost0_X,
rot_cost1[X] - rot_cost0[X],
msg="Incorrect rotation cost for X")
if alpha_plates is not None:
true_cost1_alpha = alpha.lower_bound_contribution()
self.assertAllClose(
true_cost1_alpha - true_cost0_alpha,
rot_cost1[alpha] - rot_cost0[alpha],
msg="Incorrect rotation cost for alpha")
return
def test(shape,
plates,
axis=-1,
alpha_plates=None,
plate_axis=None,
mu=3):
if plate_axis is not None:
precomputes = [False, True]
else:
precomputes = [False]
for precompute in precomputes:
# Construct the model
D = shape[axis]
if alpha_plates is not None:
alpha = Gamma(3, 5, plates=alpha_plates)
alpha.initialize_from_random()
else:
alpha = 2
X = GaussianARD(mu, alpha, shape=shape, plates=plates)
# Some initial learning and rotator constructing
X.initialize_from_random()
Y = GaussianARD(X, 1)
Y.observe(np.random.randn(*(Y.get_shape(0))))
X.update()
if alpha_plates is not None:
alpha.update()
rotX = RotateGaussianARD(X,
alpha,
axis=axis,
precompute=precompute)
else:
rotX = RotateGaussianARD(X,
axis=axis,
precompute=precompute)
try:
mu.update()
except:
pass
# Rotation matrices
R = np.random.randn(D, D)
if plate_axis is not None:
C = plates[plate_axis]
Q = np.random.randn(C, C)
else:
Q = None
# Compute bound terms
rotX.setup(plate_axis=plate_axis)
if plate_axis is None:
def f_r(r):
(b, dr) = rotX.bound(np.reshape(r, np.shape(R)))
return (b, np.ravel(dr))
else:
def f_r(r):
(b, dr, dq) = rotX.bound(np.reshape(r, np.shape(R)),
Q=Q)
return (b, np.ravel(dr))
def f_q(q):
(b, dr, dq) = rotX.bound(R,
Q=np.reshape(q, np.shape(Q)))
return (b, np.ravel(dq))
# Check gradient with respect to R
err = optimize.check_gradient(f_r, np.ravel(R), verbose=False)
self.assertAllClose(err,
0,
atol=1e-4,
msg="Gradient incorrect for R")
# Check gradient with respect to Q
if plate_axis is not None:
err = optimize.check_gradient(f_q,
np.ravel(Q),
verbose=False)
self.assertAllClose(err,
0,
atol=1e-4,
msg="Gradient incorrect for Q")
return
def check(D, N, K,
mu=None,
Lambda=None,
rho=None):
if mu is None:
mu = np.zeros(D)
if Lambda is None:
Lambda = np.identity(D)
if rho is None:
rho = np.ones(D)
V = np.identity(D) + np.ones((D,D))
# Construct model
B = GaussianARD(3, 5,
shape=(D,K),
plates=(1,D))
S = GaussianARD(2, 4,
shape=(K,),
plates=(N,1))
A = SumMultiply('dk,k->d', B, S)
X = GaussianMarkovChain(mu,
Lambda,
A,
rho,
n=N+1,
initialize=False)
Y = Gaussian(X,
V,
initialize=False)
# Posterior estimation
Y.observe(np.random.randn(N+1,D))
X.update()
B.update()
S.update()
try:
mu.update()
except:
pass
try:
Lambda.update()
except:
pass
try:
rho.update()
except:
pass
# Construct rotator
rotB = RotateGaussianARD(B, axis=-2)
rotX = RotateVaryingMarkovChain(X, B, S, rotB)
# Rotation
true_cost0 = X.lower_bound_contribution()
rotX.setup()
I = np.identity(D)
R = np.random.randn(D, D)
rot_cost0 = rotX.get_bound_terms(I)
rot_cost1 = rotX.get_bound_terms(R)
self.assertAllClose(sum(rot_cost0.values()),
rotX.bound(I)[0],
msg="Bound terms and total bound differ")
self.assertAllClose(sum(rot_cost1.values()),
rotX.bound(R)[0],
msg="Bound terms and total bound differ")
rotX.rotate(R)
true_cost1 = X.lower_bound_contribution()
self.assertAllClose(true_cost1 - true_cost0,
rot_cost1[X] - rot_cost0[X],
msg="Incorrect rotation cost for X")
return
def check(D, N, mu=None, Lambda=None, rho=None, A=None):
if mu is None:
mu = np.zeros(D)
if Lambda is None:
Lambda = np.identity(D)
if rho is None:
rho = np.ones(D)
if A is None:
A = GaussianARD(3, 5,
shape=(D,),
plates=(D,))
V = np.identity(D) + np.ones((D,D))
# Construct model
X = GaussianMarkovChain(mu,
Lambda,
A,
rho,
n=N+1,
initialize=False)
Y = Gaussian(X,
V,
initialize=False)
# Posterior estimation
Y.observe(np.random.randn(*(Y.get_shape(0))))
X.update()
try:
A.update()
except:
pass
try:
mu.update()
except:
pass
try:
Lambda.update()
except:
pass
try:
rho.update()
except:
pass
# Construct rotator
rotA = RotateGaussianARD(A, axis=-1)
rotX = RotateGaussianMarkovChain(X, rotA)
rotX.setup()
# Check gradient with respect to R
R = np.random.randn(D, D)
def cost(r):
(b, dr) = rotX.bound(np.reshape(r, np.shape(R)))
return (b, np.ravel(dr))
err = optimize.check_gradient(cost,
np.ravel(R),
verbose=False)[1]
self.assertAllClose(err, 0,
atol=1e-5,
msg="Gradient incorrect")
return
def check(D, N, mu=None, Lambda=None, rho=None, A=None):
if mu is None:
mu = np.zeros(D)
if Lambda is None:
Lambda = np.identity(D)
if rho is None:
rho = np.ones(D)
if A is None:
A = GaussianARD(3, 5,
shape=(D,),
plates=(D,))
V = np.identity(D) + np.ones((D,D))
# Construct model
X = GaussianMarkovChain(mu,
Lambda,
A,
rho,
n=N+1,
initialize=False)
Y = Gaussian(X,
V,
initialize=False)
# Posterior estimation
Y.observe(np.random.randn(*(Y.get_shape(0))))
X.update()
try:
A.update()
except:
pass
try:
mu.update()
except:
pass
try:
Lambda.update()
except:
pass
try:
rho.update()
except:
pass
# Construct rotator
rotA = RotateGaussianARD(A, axis=-1)
rotX = RotateGaussianMarkovChain(X, rotA)
# Rotation
true_cost0 = X.lower_bound_contribution()
rotX.setup()
I = np.identity(D)
R = np.random.randn(D, D)
rot_cost0 = rotX.get_bound_terms(I)
rot_cost1 = rotX.get_bound_terms(R)
self.assertAllClose(sum(rot_cost0.values()),
rotX.bound(I)[0],
msg="Bound terms and total bound differ")
self.assertAllClose(sum(rot_cost1.values()),
rotX.bound(R)[0],
msg="Bound terms and total bound differ")
rotX.rotate(R)
true_cost1 = X.lower_bound_contribution()
self.assertAllClose(true_cost1 - true_cost0,
rot_cost1[X] - rot_cost0[X],
msg="Incorrect rotation cost for X")
return
def test(shape, plates,
axis=-1,
alpha_plates=None,
plate_axis=None,
mu=3):
if plate_axis is not None:
precomputes = [False, True]
else:
precomputes = [False]
for precompute in precomputes:
# Construct the model
D = shape[axis]
if alpha_plates is not None:
alpha = Gamma(2, 2,
plates=alpha_plates)
alpha.initialize_from_random()
else:
alpha = 2
X = GaussianARD(mu, alpha,
shape=shape,
plates=plates)
# Some initial learning and rotator constructing
X.initialize_from_random()
Y = GaussianARD(X, 1)
Y.observe(np.random.randn(*(Y.get_shape(0))))
X.update()
if alpha_plates is not None:
alpha.update()
true_cost0_alpha = alpha.lower_bound_contribution()
rotX = RotateGaussianARD(X, alpha,
axis=axis,
precompute=precompute)
else:
rotX = RotateGaussianARD(X,
axis=axis,
precompute=precompute)
true_cost0_X = X.lower_bound_contribution()
# Rotation matrices
I = np.identity(D)
R = np.random.randn(D, D)
if plate_axis is not None:
C = plates[plate_axis]
Q = np.random.randn(C, C)
Ic = np.identity(C)
else:
Q = None
Ic = None
# Compute bound terms
rotX.setup(plate_axis=plate_axis)
rot_cost0 = rotX.get_bound_terms(I, Q=Ic)
rot_cost1 = rotX.get_bound_terms(R, Q=Q)
self.assertAllClose(sum(rot_cost0.values()),
rotX.bound(I, Q=Ic)[0],
msg="Bound terms and total bound differ")
self.assertAllClose(sum(rot_cost1.values()),
rotX.bound(R, Q=Q)[0],
msg="Bound terms and total bound differ")
# Perform rotation
rotX.rotate(R, Q=Q)
# Check bound terms
true_cost1_X = X.lower_bound_contribution()
self.assertAllClose(true_cost1_X - true_cost0_X,
rot_cost1[X] - rot_cost0[X],
msg="Incorrect rotation cost for X")
if alpha_plates is not None:
true_cost1_alpha = alpha.lower_bound_contribution()
self.assertAllClose(true_cost1_alpha - true_cost0_alpha,
rot_cost1[alpha] - rot_cost0[alpha],
msg="Incorrect rotation cost for alpha")
return
def test(shape, plates,
axis=-1,
alpha_plates=None,
plate_axis=None,
mu=3):
if plate_axis is not None:
precomputes = [False, True]
else:
precomputes = [False]
for precompute in precomputes:
# Construct the model
D = shape[axis]
if alpha_plates is not None:
alpha = Gamma(3, 5,
plates=alpha_plates)
alpha.initialize_from_random()
else:
alpha = 2
X = GaussianARD(mu, alpha,
shape=shape,
plates=plates)
# Some initial learning and rotator constructing
X.initialize_from_random()
Y = GaussianARD(X, 1)
Y.observe(np.random.randn(*(Y.get_shape(0))))
X.update()
if alpha_plates is not None:
alpha.update()
rotX = RotateGaussianARD(X, alpha,
axis=axis,
precompute=precompute)
else:
rotX = RotateGaussianARD(X,
axis=axis,
precompute=precompute)
try:
mu.update()
except:
pass
# Rotation matrices
R = np.random.randn(D, D)
if plate_axis is not None:
C = plates[plate_axis]
Q = np.random.randn(C, C)
else:
Q = None
# Compute bound terms
rotX.setup(plate_axis=plate_axis)
if plate_axis is None:
def f_r(r):
(b, dr) = rotX.bound(np.reshape(r, np.shape(R)))
return (b, np.ravel(dr))
else:
def f_r(r):
(b, dr, dq) = rotX.bound(np.reshape(r, np.shape(R)),
Q=Q)
return (b, np.ravel(dr))
def f_q(q):
(b, dr, dq) = rotX.bound(R,
Q=np.reshape(q, np.shape(Q)))
return (b, np.ravel(dq))
# Check gradient with respect to R
err = optimize.check_gradient(f_r,
np.ravel(R),
verbose=False)[1]
self.assertAllClose(err, 0,
atol=1e-4,
msg="Gradient incorrect for R")
# Check gradient with respect to Q
if plate_axis is not None:
err = optimize.check_gradient(f_q,
np.ravel(Q),
verbose=False)[1]
self.assertAllClose(err, 0,
atol=1e-4,
msg="Gradient incorrect for Q")
return
def check(D, N, K,
mu=None,
Lambda=None,
rho=None):
if mu is None:
mu = np.zeros(D)
if Lambda is None:
Lambda = np.identity(D)
if rho is None:
rho = np.ones(D)
V = np.identity(D) + np.ones((D,D))
# Construct model
B = GaussianARD(3, 5,
shape=(D,K),
plates=(1,D))
S = GaussianARD(2, 4,
shape=(K,),
plates=(N,1))
A = SumMultiply('dk,k->d', B, S)
X = GaussianMarkovChain(mu,
Lambda,
A,
rho,
n=N+1,
initialize=False)
Y = Gaussian(X,
V,
initialize=False)
# Posterior estimation
Y.observe(np.random.randn(N+1,D))
X.update()
B.update()
S.update()
try:
mu.update()
except:
pass
try:
Lambda.update()
except:
pass
try:
rho.update()
except:
pass
# Construct rotator
rotB = RotateGaussianARD(B, axis=-2)
rotX = RotateVaryingMarkovChain(X, B, S, rotB)
rotX.setup()
# Check gradient with respect to R
R = np.random.randn(D, D)
def cost(r):
(b, dr) = rotX.bound(np.reshape(r, np.shape(R)))
return (b, np.ravel(dr))
err = optimize.check_gradient(cost,
np.ravel(R),
verbose=False)[1]
self.assertAllClose(err, 0,
atol=1e-6,
msg="Gradient incorrect")
return
