def optim_test3():
from pymanopt import Problem
from pymanopt.solvers import TrustRegions
from pymanopt.function import Callable
n = 1000
# problem Tr(AXBX^T)
for i in range(1):
# Stiefel manifold
dvec = np.array([0, 50])
dvec[0] = n - dvec[1:].sum()
d = dvec[1:].sum()
p = dvec.shape[0] - 1
alpha = randint(1, 10, (p, p + 1)) * .1
alpha0 = randint(1, 10, (p))
# alpha0 = randint(1, 2, (p))
alpha = make_simple_alpha(alpha0, 0)
B = np.diag(np.concatenate([randint(1, 10, d), np.zeros(n - d)]))
D = randint(1, 10, n) * 0.02 + 1
OO = random_orthogonal(n)
A = OO @ np.diag(D) @ OO.T
man = ComplexFlag(dvec, alpha)
cf = 10
B2 = B @ B
@Callable
def cost(X):
return cf * trace(
B @ X @ st(X) @ B2 @ X @ st(X) @ B) +\
trace(st(X) @ A @ X)
@Callable
def egrad(X):
R = cf * 4 * B2 @ X @ st(X) @ B2 @ X + 2 * A @ X
return R
@Callable
def ehess(X, H):
return 4*cf*B2 @ H @ st(X) @ B2 @ X +\
4*cf*B2 @ X @ st(H) @ B2 @ X +\
4*cf*B2 @ X @ st(X) @ B2 @ H + 2*A @ H
if False:
X = man.rand()
xi = man.randvec(X)
d1 = num_deriv(man, X, xi, cost)
d2 = trace(egrad(X) @ st(xi)).real
print(check_zero(d1 - d2))
d3 = num_deriv(man, X, xi, egrad)
d4 = ehess(X, xi)
print(check_zero(d3 - d4))
XInit = man.rand()
prob = Problem(man, cost, egrad=egrad, ehess=ehess)
solver = TrustRegions(maxtime=100000, maxiter=100)
opt = solver.solve(prob, x=XInit, Delta_bar=2500)
print(cost(opt))
if False:
# print(opt)
# double check:
# print(cost(opt))
min_val = 1e190
# min_X = None
for i in range(100):
Xi = man.rand()
c = cost(Xi)
if c < min_val:
# min_X = Xi
min_val = c
if i % 1000 == 0:
print('i=%d min=%f' % (i, min_val))
print(min_val)
alpha0 = randint(1, 2, (p))
alpha1 = make_simple_alpha(alpha0, 0)
man1 = ComplexFlag(dvec, alpha=alpha1)
prob = Problem(man1, cost, egrad=egrad, ehess=ehess)
solver = TrustRegions(maxtime=100000, maxiter=100)
opt = solver.solve(prob, x=XInit, Delta_bar=250)
alpha0 = randint(1, 2, (p))
alpha2 = make_simple_alpha(alpha0, -1)
man1 = ComplexFlag(dvec, alpha=alpha2)
# man1 = RealStiefel(n, d, alpha=np.array([1, 1]))
prob = Problem(man1, cost, egrad=egrad, ehess=ehess)
solver = TrustRegions(maxtime=100000, maxiter=100)
opt = solver.solve(prob, x=XInit, Delta_bar=250)
def optim_test():
from pymanopt import Problem
from pymanopt.solvers import TrustRegions
from pymanopt.function import Callable
n = 300
# problem Tr(AXBX^T)
for i in range(1):
dvec = np.array([0, 5, 4, 10])
dvec[0] = n - dvec[1:].sum()
d = dvec[1:].sum()
alpha = randint(1, 10, 2) * .1
D = randint(1, 10, n) * 0.02 + 1
OO = random_orthogonal(n)
A = OO @ np.diag(D) @ OO.T.conjugate()
B = make_sym_pos(d)
p = dvec.shape[0] - 1
alpha = randint(1, 10, (p, p + 1)) * .1
alpha0 = randint(1, 10, (p))
# alpha0 = randint(1, 2, (p))
alpha = make_simple_alpha(alpha0, 0)
man = ComplexFlag(dvec, alpha)
@Callable
def cost(X):
return trace(A @ X @ B @ X.T.conjugate()).real
@Callable
def egrad(X):
return 2 * A @ X @ B
@Callable
def ehess(X, H):
return 2 * A @ H @ B
X = man.rand()
if False:
xi = man.randvec(X)
d1 = num_deriv(man, X, xi, cost)
d2 = trace(egrad(X) @ xi.T.conjugate()).real
print(check_zero(d1 - d2))
prob = Problem(man, cost, egrad=egrad)
XInit = man.rand()
prob = Problem(man, cost, egrad=egrad, ehess=ehess)
solver = TrustRegions(maxtime=100000, maxiter=100)
opt = solver.solve(prob, x=XInit, Delta_bar=250)
print(cost(opt))
alpha0 = randint(1, 2, (p))
alpha1 = make_simple_alpha(alpha0, 0)
man1 = ComplexFlag(dvec, alpha=alpha1)
prob = Problem(man1, cost, egrad=egrad, ehess=ehess)
solver = TrustRegions(maxtime=100000, maxiter=100)
opt = solver.solve(prob, x=XInit, Delta_bar=250)
alpha0 = randint(1, 2, (p))
alpha2 = make_simple_alpha(alpha0, -1)
man1 = ComplexFlag(dvec, alpha=alpha2)
prob = Problem(man1, cost, egrad=egrad, ehess=ehess)
solver = TrustRegions(maxtime=100000, maxiter=100)
opt = solver.solve(prob, x=XInit, Delta_bar=250)
def optim_test3():
from pymanopt import Problem
from pymanopt.solvers import TrustRegions
from pymanopt.function import Callable
n = 200
d = 20
# problem Tr(AXBX^T)
for i in range(1):
B = np.diag(np.concatenate([randint(1, 10, d), np.zeros(n - d)]))
D = randint(1, 10, n) * 0.02 + 1
OO = random_orthogonal(n)
A = OO @ np.diag(D) @ OO.T.conj()
alpha = randint(1, 10, 2)
alpha = alpha / alpha[0]
print(alpha)
man = ComplexStiefel(n, d, alpha)
cf = 10
B2 = B @ B
@Callable
def cost(X):
return cf * rtrace(
B @ X @ X.T.conj() @ B2 @ X @ X.T.conj() @ B) +\
rtrace(X.T.conj() @ A @ X)
@Callable
def egrad(X):
R = cf * 4 * B2 @ X @ X.T.conj() @ B2 @ X + 2 * A @ X
return R
@Callable
def ehess(X, H):
return 4*cf*B2 @ H @ X.T.conj() @ B2 @ X +\
4*cf*B2 @ X @ H.T.conj() @ B2 @ X +\
4*cf*B2 @ X @ X.T.conj() @ B2 @ H + 2*A @ H
if False:
X = man.rand()
xi = man.randvec(X)
d1 = num_deriv(man, X, xi, cost)
d2 = rtrace(egrad(X) @ xi.T.conj())
print(check_zero(d1 - d2))
d3 = num_deriv(man, X, xi, egrad)
d4 = ehess(X, xi)
print(check_zero(d3 - d4))
XInit = man.rand()
prob = Problem(man, cost, egrad=egrad, ehess=ehess)
solver = TrustRegions(maxtime=100000, maxiter=100)
opt = solver.solve(prob, x=XInit, Delta_bar=2500)
print(cost(opt))
if False:
# print(opt)
# double check:
# print(cost(opt))
min_val = 1e190
# min_X = None
for i in range(100):
Xi = man.rand()
c = cost(Xi)
if c < min_val:
# min_X = Xi
min_val = c
if i % 1000 == 0:
print('i=%d min=%f' % (i, min_val))
print(min_val)
man1 = ComplexStiefel(n, d, alpha=np.array([1, 1]))
prob = Problem(man1, cost, egrad=egrad, ehess=ehess)
solver = TrustRegions(maxtime=100000, maxiter=100)
opt = solver.solve(prob, x=XInit, Delta_bar=250)
man1 = ComplexStiefel(n, d, alpha=np.array([1, .5]))
# man1 = ComplexStiefel(n, d, alpha=np.array([1, 1]))
prob = Problem(man1, cost, egrad=egrad, ehess=ehess)
solver = TrustRegions(maxtime=100000, maxiter=100)
opt = solver.solve(prob, x=XInit, Delta_bar=250)
def optim_test2():
from pymanopt import Problem
from pymanopt.solvers import TrustRegions
from pymanopt.function import Callable
n = 100
d = 20
# problem Tr(AXBX^T)
for i in range(1):
D = randint(1, 10, n) * 0.02 + 1
OO = random_orthogonal(n)
A = OO @ np.diag(D) @ OO.T.conj()
B = make_sym_pos(d)
alpha = randint(1, 10, 2) * .1
alpha = alpha / alpha[0]
print(alpha)
man = ComplexStiefel(n, d, alpha)
A2 = A @ A
@Callable
def cost(X):
return rtrace(A @ X @ B @ X.T.conj() @ A2 @ X @ B @ X.T.conj() @ A)
@Callable
def egrad(X):
R = 4 * A2 @ X @ B @ X.T.conj() @ A2 @ X @ B
return R
@Callable
def ehess(X, H):
return 4*A2 @ H @ B @ X.T.conj() @ A2 @ X @ B +\
4*A2 @ X @ B @ H.T.conj() @ A2 @ X @ B +\
4*A2 @ X @ B @ X.T.conj() @ A2 @ H @ B
if False:
X = man.rand()
xi = man.randvec(X)
d1 = num_deriv(man, X, xi, cost)
d2 = rtrace(egrad(X) @ xi.T.conj())
print(check_zero(d1 - d2))
d3 = num_deriv(man, X, xi, egrad)
d4 = ehess(X, xi)
print(check_zero(d3 - d4))
prob = Problem(man, cost, egrad=egrad)
XInit = man.rand()
prob = Problem(man, cost, egrad=egrad, ehess=ehess)
solver = TrustRegions(maxtime=100000, maxiter=100)
opt = solver.solve(prob, x=XInit, Delta_bar=2500)
print(cost(opt))
if False:
# print(opt)
# double check:
# print(cost(opt))
min_val = 1e190
# min_X = None
for i in range(100):
Xi = man.rand()
c = cost(Xi)
if c < min_val:
# min_X = Xi
min_val = c
if i % 1000 == 0:
print('i=%d min=%f' % (i, min_val))
print(min_val)
man1 = ComplexStiefel(n, d, alpha=np.array([1, 1]))
prob = Problem(man1, cost, egrad=egrad, ehess=ehess)
solver = TrustRegions(maxtime=100000, maxiter=100)
opt = solver.solve(prob, x=XInit, Delta_bar=250)
man1 = ComplexStiefel(n, d, alpha=np.array([1, .5]))
prob = Problem(man1, cost, egrad=egrad, ehess=ehess)
solver = TrustRegions(maxtime=100000, maxiter=100)
opt = solver.solve(prob, x=XInit, Delta_bar=250)
def optim_test():
from pymanopt import Problem
from pymanopt.solvers import TrustRegions
from pymanopt.function import Callable
n = 1000
# problem Tr(AXBX^T)
for i in range(1):
dvec = np.array([0, 30, 2, 1])
dvec[0] = 1000 - dvec[1:].sum()
d = dvec[1:].sum()
D = randint(1, 10, n) * 0.02 + 1
OO = random_orthogonal(n)
A = OO @ np.diag(D) @ OO.T
B = make_sym_pos(d)
p = dvec.shape[0]-1
alpha = randint(1, 10, (p, p+1)) * .1
alpha0 = randint(1, 10, (p))
# alpha0 = randint(1, 2, (p))
alpha = make_simple_alpha(alpha0, 0)
man = RealFlag(dvec, alpha=alpha)
@Callable
def cost(X):
return trace(A @ X @ B @ X.T)
@Callable
def egrad(X):
return 2*A @ X @ B
@Callable
def ehess(X, H):
return 2*A @ H @ B
if False:
X = man.rand()
xi = man.randvec(X)
d1 = num_deriv(man, X, xi, cost)
d2 = trace(egrad(X) @ xi.T)
print(check_zero(d1-d2))
prob = Problem(
man, cost, egrad=egrad)
XInit = man.rand()
prob = Problem(
man, cost, egrad=egrad, ehess=ehess)
solver = TrustRegions(maxtime=100000, maxiter=100)
opt = solver.solve(prob, x=XInit, Delta_bar=250)
print(cost(opt))
if False:
min_val = 1e190
# min_X = None
for i in range(100):
Xi = man.rand()
c = cost(Xi)
if c < min_val:
# min_X = Xi
min_val = c
if i % 1000 == 0:
print('i=%d min=%f' % (i, min_val))
print(min_val)
alpha_c = alpha.copy()
alpha_c[:] = 1
man1 = RealFlag(dvec, alpha=alpha_c)
prob = Problem(
man1, cost, egrad=egrad, ehess=ehess)
solver = TrustRegions(maxtime=100000, maxiter=100)
opt = solver.solve(prob, x=XInit, Delta_bar=250)
alpha_c5 = alpha_c.copy()
alpha_c5[:, 1:] = .5
man1 = RealFlag(dvec, alpha=alpha_c5)
prob = Problem(
man1, cost, egrad=egrad, ehess=ehess)
solver = TrustRegions(maxtime=100000, maxiter=100)
opt = solver.solve(prob, x=XInit, Delta_bar=250)
def optim_test():
from pymanopt import Problem
from pymanopt.solvers import TrustRegions
from pymanopt.function import Callable
n = 100
d = 20
# problem Tr(AXBX^T)
for i in range(1):
D = randint(1, 10, n) * 0.02 + 1
OO = random_orthogonal(n)
A = OO @ np.diag(D) @ OO.T
B = make_sym_pos(d)
man = RealStiefelWoodbury(n,
d,
A=np.diag(D),
B=np.diag(np.diagonal(B)))
@Callable
def cost(X):
return trace(A @ X @ B @ X.T)
@Callable
def egrad(X):
return 2 * A @ X @ B
@Callable
def ehess(X, H):
return 2 * A @ H @ B
X = man.rand()
if False:
xi = man.randvec(X)
d1 = num_deriv(man, X, xi, cost)
d2 = trace(egrad(X) @ xi.T)
print(check_zero(d1 - d2))
XInit = man.rand()
prob = Problem(man, cost, egrad=egrad, ehess=ehess)
solver = TrustRegions(maxtime=100000, maxiter=100)
man.retr_method = 'geo'
opt = solver.solve(prob, x=XInit, Delta_bar=250)
print(cost(opt))
# print(opt)
# double check:
print(cost(opt))
min_val = 1e190
min_X = None
for i in range(100):
Xi = man.rand()
c = cost(Xi)
if c < min_val:
min_X = Xi
min_val = c
if i % 1000 == 0:
print('i=%d min=%f' % (i, min_val))
print(min_val)
man1 = RealStiefelWoodbury(n, d, np.eye(n), np.eye(d))
prob1 = Problem(man1, cost, egrad=egrad, ehess=ehess)
man1.retr_method = 'svd'
solver1 = TrustRegions(maxtime=100000, maxiter=100)
opt1 = solver1.solve(prob1, x=XInit, Delta_bar=250)