def test_basic_batch_equality():
"""
Test basic batch equality specification.
"""
dims = [4, 8]
for dim in dims:
block_dim = int(dim/2)
# Generate random configurations
A = np.random.rand(block_dim, block_dim)
B = np.random.rand(block_dim, block_dim)
B = np.dot(B.T, B)
D = np.random.rand(block_dim, block_dim)
D = np.dot(D.T, D)
tr_B_D = np.trace(B) + np.trace(D)
B = B / tr_B_D
D = D / tr_B_D
As, bs, Cs, ds, Fs, gradFs, Gs, gradGs = \
basic_batch_equality(dim, A, B, D)
tol = 1e-3
eps = 1e-4
N_rand = 10
for (g, gradg) in zip(Gs, gradGs):
for i in range(N_rand):
X = np.random.rand(dim, dim)
val = g(X)
grad = gradg(X)
print "grad:\n", grad
num_grad = numerical_derivative(g, X, eps)
print "num_grad:\n", num_grad
assert np.sum(np.abs(grad - num_grad)) < tol
def test_Q_constraints():
import pdb, traceback, sys
try:
dims = [4, 8]
N_rand = 10
eps = 1e-4
tol = 1e-3
for dim in dims:
block_dim = int(dim/4)
# Generate initial data
D = np.eye(block_dim)
Dinv = np.linalg.inv(D)
B = np.eye(block_dim)
A = 0.5 * np.eye(block_dim)
c = 0.5
As, bs, Cs, ds, Fs, gradFs, Gs, gradGs = \
Q_constraints(block_dim, A, B, D, c)
N_rand = 10
for (g, gradg) in zip(Gs, gradGs):
for i in range(N_rand):
X = np.random.rand(dim, dim)
val = g(X)
grad = gradg(X)
print "grad:\n", grad
num_grad = numerical_derivative(g, X, eps)
print "num_grad:\n", num_grad
assert np.sum(np.abs(grad - num_grad)) < tol
except:
type, value, tb = sys.exc_info()
traceback.print_exc()
pdb.post_mortem(tb)
def test_A_constraints():
import pdb, traceback, sys
try:
dims = [4, 8]
N_rand = 10
eps = 1e-5
tol = 1e-3
np.set_printoptions(precision=3)
for dim in dims:
block_dim = int(dim/4)
# Generate initial data
D = np.eye(block_dim)
Dinv = np.linalg.inv(D)
Q = 0.5*np.eye(block_dim)
mu = np.ones((block_dim, 1))
As, bs, Cs, ds, Fs, gradFs, Gs, gradGs = \
A_constraints(block_dim, D, Dinv, Q, mu)
tol = 1e-3
eps = 1e-4
N_rand = 10
for (g, gradg) in zip(Gs, gradGs):
for i in range(N_rand):
X = np.random.rand(dim, dim)
val = g(X)
grad = gradg(X)
print "grad:\n", grad
num_grad = numerical_derivative(g, X, eps)
print "num_grad:\n", num_grad
assert np.sum(np.abs(grad - num_grad)) < tol
except:
type, value, tb = sys.exc_info()
traceback.print_exc()
pdb.post_mortem(tb)
def test_A_dynamics():
dims = [4, 8]
N_rand = 10
tol = 1e-3
eps = 1e-4
for dim in dims:
block_dim = int(dim/4)
(D_Q_cds, Dinv_cds, I_1_cds, I_2_cds,
A_1_cds, A_T_1_cds, A_2_cds, A_T_2_cds) = A_coords(dim)
# Generate initial data
D = np.eye(block_dim)
Q = 0.5*np.eye(block_dim)
Qinv = np.linalg.inv(Q)
C = 2*np.eye(block_dim)
B = np.eye(block_dim)
E = np.eye(block_dim)
#B = np.eye(block_dim)
def obj(X):
return A_dynamics(X, block_dim, C, B, E, Qinv)
def grad_obj(X):
return grad_A_dynamics(X, block_dim, C, B, E, Qinv)
for i in range(N_rand):
X = np.random.rand(dim, dim)
val = obj(X)
grad = grad_obj(X)
num_grad = numerical_derivative(obj, X, eps)
diff = np.sum(np.abs(grad - num_grad))
print "X:\n", X
print "grad:\n", grad
print "num_grad:\n", num_grad
print "diff: ", diff
assert diff < tol
def test_log_det():
dims = [4]
N_rand = 10
tol = 1e-3
eps = 1e-4
for dim in dims:
block_dim = int(dim/4)
(D_ADA_T_cds, I_1_cds, I_2_cds, R_1_cds,
D_cds, c_I_1_cds, c_I_2_cds, R_2_cds) = \
Q_coords(block_dim)
# Generate initial data
B = np.random.rand(block_dim, block_dim)
#B = np.eye(block_dim)
def obj(X):
return log_det_tr(X, B)
def grad_obj(X):
return grad_log_det_tr(X, B)
for i in range(N_rand):
X = np.random.rand(dim, dim)
R1 = get_entries(X, R_1_cds)
R2 = get_entries(X, R_2_cds)
if (np.linalg.det(R1) <= 0 or np.linalg.det(R2) <= 0):
"Continue!"
continue
val = obj(X)
grad = grad_obj(X)
num_grad = numerical_derivative(obj, X, eps)
diff = np.sum(np.abs(grad - num_grad))
if diff >= tol:
print "grad:\n", grad
print "num_grad:\n", num_grad
print "diff: ", diff
assert diff < tol
def test7():
"""
BROKEN: Check log-sum-exp gradient on many linear and nonlinear
equalities.
"""
tol = 1e-3
eps = 1e-4
N_rand = 10
dims = [16]
for dim in dims:
As, bs, Cs, ds, Fs, gradFs, Gs, gradGs = \
stress_inequalities_and_equalities(dim)
M = compute_scale(len(As), len(Cs), len(Fs), len(Gs), tol)
def f(X):
return log_sum_exp_penalty(X, M, As, bs, Cs, ds, Fs, Gs)
def gradf(X):
return log_sum_exp_grad_penalty(X, M, As,
bs, Cs, ds, Fs, gradFs, Gs, gradGs)
for i in range(N_rand):
X = np.random.rand(dim, dim)
val = f(X)
grad = gradf(X)
print "grad:\n", grad
num_grad = numerical_derivative(f, X, eps)
print "num_grad:\n", num_grad
diff = np.sum(np.abs(grad - num_grad))
print "diff: ", diff
assert diff < tol
def test_tr():
dims = [1, 5, 10]
N_rand = 10
tol = 1e-3
eps = 1e-4
for dim in dims:
for i in range(N_rand):
X = np.random.rand(dim, dim)
val = trace_obj(X)
grad = grad_trace_obj(X)
num_grad = numerical_derivative(trace_obj, X, eps)
assert np.sum(np.abs(grad - num_grad)) < tol
def test_sum_squares():
dims = [1, 5, 10]
N_rand = 10
tol = 1e-3
eps = 1e-4
for dim in dims:
for i in range(N_rand):
X = np.random.rand(dim, dim)
val = neg_sum_squares(X)
grad = grad_neg_sum_squares(X)
num_grad = numerical_derivative(neg_sum_squares, X, eps)
assert np.sum(np.abs(grad - num_grad)) < tol
def test_quadratic_inequality():
"""
Test quadratic inequality specification.
"""
dim, As, bs, Cs, ds, Fs, gradFs, Gs, gradGs = \
quadratic_inequality()
tol = 1e-3
eps = 1e-4
N_rand = 10
for (f, gradf) in zip(Fs, gradFs):
for i in range(N_rand):
X = np.random.rand(dim, dim)
val = f(X)
grad = gradf(X)
print "grad:\n", grad
num_grad = numerical_derivative(f, X, eps)
print "num_grad:\n", num_grad
assert np.sum(np.abs(grad - num_grad)) < tol
def test_l2_batch_equals():
"""
Test l2_batch_equals operation.
"""
dims = [4, 16]
N_rand = 10
eps = 1e-4
tol = 1e-3
for dim in dims:
block_dim = int(dim/2)
A = np.random.rand(block_dim, block_dim)
coord = (0, block_dim, 0, block_dim)
def f(X):
return l2_batch_equals(X, A, coord)
def gradf(X):
return grad_l2_batch_equals(X, A, coord)
A = np.dot(A.T, A)
for i in range(N_rand):
X = np.random.rand(dim, dim)
val = f(X)
grad = gradf(X)
num_grad = numerical_derivative(f, X, eps)
assert np.sum(np.abs(grad - num_grad)) < tol
def test4():
"""
Check log-sum-exp gradient on quadratic equality problem.
"""
dim, As, bs, Cs, ds, Fs, gradFs, Gs, gradGs = \
quadratic_equality()
tol = 1e-3
M = compute_scale(len(As), len(Cs), len(Fs), len(Gs), tol)
def f(X):
return log_sum_exp_penalty(X, M, As, bs, Cs, ds, Fs, Gs)
def gradf(X):
return log_sum_exp_grad_penalty(X, M, As,
bs, Cs, ds, Fs, gradFs, Gs, gradGs)
eps = 1e-4
N_rand = 10
for i in range(N_rand):
X = np.random.rand(dim, dim)
val = f(X)
grad = gradf(X)
print "grad:\n", grad
num_grad = numerical_derivative(f, X, eps)
print "num_grad:\n", num_grad
assert np.sum(np.abs(grad - num_grad)) < tol
def test8():
"""
Check log-sum-exp gradient on basic batch equalities
"""
tol = 1e-3
eps = 1e-5
N_rand = 10
dims = [16]
for dim in dims:
block_dim = int(dim/2)
# Generate random configurations
A = np.random.rand(block_dim, block_dim)
B = np.random.rand(block_dim, block_dim)
B = np.dot(B.T, B)
D = np.random.rand(block_dim, block_dim)
D = np.dot(D.T, D)
tr_B_D = np.trace(B) + np.trace(D)
B = B / tr_B_D
D = D / tr_B_D
As, bs, Cs, ds, Fs, gradFs, Gs, gradGs = \
basic_batch_equality(dim, A, B, D)
M = compute_scale(len(As), len(Cs), len(Fs), len(Gs), tol)
def f(X):
return log_sum_exp_penalty(X, M, As, bs, Cs, ds, Fs, Gs)
def gradf(X):
return log_sum_exp_grad_penalty(X, M, As,
bs, Cs, ds, Fs, gradFs, Gs, gradGs)
for i in range(N_rand):
X = np.random.rand(dim, dim)
val = f(X)
grad = gradf(X)
print "grad:\n", grad
num_grad = numerical_derivative(f, X, eps)
print "num_grad:\n", num_grad
diff = np.sum(np.abs(grad - num_grad))
print "diff: ", diff
assert diff < tol
