def test_l21_mxne():
"""Test convergence of MxNE solver"""
n, p, t, alpha = 30, 40, 20, 1
rng = np.random.RandomState(0)
G = rng.randn(n, p)
G /= np.std(G, axis=0)[None, :]
X = np.zeros((p, t))
X[0] = 3
X[4] = -2
M = np.dot(G, X)
X_hat_prox, active_set, _ = mixed_norm_solver(M,
G, alpha, maxit=1000, tol=1e-8,
active_set_size=None, debias=True,
solver='prox')
assert_array_equal(np.where(active_set)[0], [0, 4])
X_hat_cd, active_set, _ = mixed_norm_solver(M,
G, alpha, maxit=1000, tol=1e-8,
active_set_size=None, debias=True,
solver='cd')
assert_array_equal(np.where(active_set)[0], [0, 4])
assert_array_almost_equal(X_hat_prox, X_hat_cd, 5)
X_hat_prox, active_set, _ = mixed_norm_solver(M,
G, alpha, maxit=1000, tol=1e-8,
active_set_size=2, debias=True,
solver='prox')
assert_array_equal(np.where(active_set)[0], [0, 4])
X_hat_cd, active_set, _ = mixed_norm_solver(M,
G, alpha, maxit=1000, tol=1e-8,
active_set_size=2, debias=True,
solver='cd')
assert_array_equal(np.where(active_set)[0], [0, 4])
assert_array_almost_equal(X_hat_prox, X_hat_cd, 5)
X_hat_prox, active_set, _ = mixed_norm_solver(M,
G, alpha, maxit=1000, tol=1e-8,
active_set_size=2, debias=True,
n_orient=2, solver='prox')
assert_array_equal(np.where(active_set)[0], [0, 1, 4, 5])
# suppress a coordinate-descent warning here
with warnings.catch_warnings(record=True):
X_hat_cd, active_set, _ = mixed_norm_solver(M,
G, alpha, maxit=1000, tol=1e-8,
active_set_size=2, debias=True,
n_orient=2, solver='cd')
assert_array_equal(np.where(active_set)[0], [0, 1, 4, 5])
assert_array_equal(X_hat_prox, X_hat_cd)
X_hat_prox, active_set, _ = mixed_norm_solver(M,
G, alpha, maxit=1000, tol=1e-8,
active_set_size=2, debias=True,
n_orient=5)
assert_array_equal(np.where(active_set)[0], [0, 1, 2, 3, 4])
with warnings.catch_warnings(record=True): # coordinate-ascent warning
X_hat_cd, active_set, _ = mixed_norm_solver(M,
G, alpha, maxit=1000, tol=1e-8,
active_set_size=2, debias=True,
n_orient=5, solver='cd')
assert_array_equal(np.where(active_set)[0], [0, 1, 2, 3, 4])
def test_l21_mxne():
"""Test convergence of MxNE solver"""
n, p, t, alpha = 30, 40, 20, 1
rng = np.random.RandomState(0)
G = rng.randn(n, p)
G /= np.std(G, axis=0)[None, :]
X = np.zeros((p, t))
X[0] = 3
X[4] = -2
M = np.dot(G, X)
X_hat_prox, active_set, _ = mixed_norm_solver(M,
G, alpha, maxit=1000, tol=1e-8,
active_set_size=None, debias=True,
solver='prox')
assert_array_equal(np.where(active_set)[0], [0, 4])
X_hat_cd, active_set, _ = mixed_norm_solver(M,
G, alpha, maxit=1000, tol=1e-8,
active_set_size=None, debias=True,
solver='cd')
assert_array_equal(np.where(active_set)[0], [0, 4])
assert_array_almost_equal(X_hat_prox, X_hat_cd, 5)
X_hat_prox, active_set, _ = mixed_norm_solver(M,
G, alpha, maxit=1000, tol=1e-8,
active_set_size=2, debias=True,
solver='prox')
assert_array_equal(np.where(active_set)[0], [0, 4])
X_hat_cd, active_set, _ = mixed_norm_solver(M,
G, alpha, maxit=1000, tol=1e-8,
active_set_size=2, debias=True,
solver='cd')
assert_array_equal(np.where(active_set)[0], [0, 4])
assert_array_almost_equal(X_hat_prox, X_hat_cd, 5)
X_hat_prox, active_set, _ = mixed_norm_solver(M,
G, alpha, maxit=1000, tol=1e-8,
active_set_size=2, debias=True,
n_orient=2, solver='prox')
assert_array_equal(np.where(active_set)[0], [0, 1, 4, 5])
# suppress a coordinate-descent warning here
with warnings.catch_warnings(True) as w:
X_hat_cd, active_set, _ = mixed_norm_solver(M,
G, alpha, maxit=1000, tol=1e-8,
active_set_size=2, debias=True,
n_orient=2, solver='cd')
assert_array_equal(np.where(active_set)[0], [0, 1, 4, 5])
assert_array_equal(X_hat_prox, X_hat_cd)
X_hat_prox, active_set, _ = mixed_norm_solver(M,
G, alpha, maxit=1000, tol=1e-8,
active_set_size=2, debias=True,
n_orient=5)
assert_array_equal(np.where(active_set)[0], [0, 1, 2, 3, 4])
X_hat_cd, active_set, _ = mixed_norm_solver(M,
G, alpha, maxit=1000, tol=1e-8,
active_set_size=2, debias=True,
n_orient=5, solver='cd')
assert_array_equal(np.where(active_set)[0], [0, 1, 2, 3, 4])
def test_l21_mxne():
"""Test convergence of MxNE solver."""
n, p, t, alpha = 30, 40, 20, 1.
rng = np.random.RandomState(0)
G = rng.randn(n, p)
G /= np.std(G, axis=0)[None, :]
X = np.zeros((p, t))
X[0] = 3
X[4] = -2
M = np.dot(G, X)
args = (M, G, alpha, 1000, 1e-8)
with pytest.warns(None): # CD
X_hat_cd, active_set, _, gap_cd = mixed_norm_solver(
*args, active_set_size=None,
debias=True, solver='cd', return_gap=True)
assert_array_less(gap_cd, 1e-8)
assert_array_equal(np.where(active_set)[0], [0, 4])
with pytest.warns(None): # CD
X_hat_bcd, active_set, E, gap_bcd = mixed_norm_solver(
M, G, alpha, maxit=1000, tol=1e-8, active_set_size=None,
debias=True, solver='bcd', return_gap=True)
assert_array_less(gap_bcd, 9.6e-9)
assert_array_equal(np.where(active_set)[0], [0, 4])
assert_allclose(X_hat_bcd, X_hat_cd, rtol=1e-2)
with pytest.warns(None): # CD
X_hat_cd, active_set, _ = mixed_norm_solver(
*args, active_set_size=2, debias=True, solver='cd')
assert_array_equal(np.where(active_set)[0], [0, 4])
with pytest.warns(None): # CD
X_hat_bcd, active_set, _ = mixed_norm_solver(
*args, active_set_size=2, debias=True, solver='bcd')
assert_array_equal(np.where(active_set)[0], [0, 4])
assert_allclose(X_hat_bcd, X_hat_cd, rtol=1e-2)
with pytest.warns(None): # CD
X_hat_bcd, active_set, _ = mixed_norm_solver(
*args, active_set_size=2, debias=True, n_orient=2, solver='bcd')
assert_array_equal(np.where(active_set)[0], [0, 1, 4, 5])
# suppress a coordinate-descent warning here
with pytest.warns(RuntimeWarning, match='descent'):
X_hat_cd, active_set, _ = mixed_norm_solver(
*args, active_set_size=2, debias=True, n_orient=2, solver='cd')
assert_array_equal(np.where(active_set)[0], [0, 1, 4, 5])
assert_allclose(X_hat_bcd, X_hat_cd, rtol=1e-2)
with pytest.warns(None): # CD
X_hat_bcd, active_set, _ = mixed_norm_solver(
*args, active_set_size=2, debias=True, n_orient=5, solver='bcd')
assert_array_equal(np.where(active_set)[0], [0, 1, 2, 3, 4])
with pytest.warns(RuntimeWarning, match='descent'):
X_hat_cd, active_set, _ = mixed_norm_solver(
*args, active_set_size=2, debias=True, n_orient=5, solver='cd')
assert_array_equal(np.where(active_set)[0], [0, 1, 2, 3, 4])
assert_allclose(X_hat_bcd, X_hat_cd)
def test_tf_mxne_vs_mxne():
"""Test equivalence of TF-MxNE (with alpha_time=0) and MxNE."""
alpha_space = 60.
alpha_time = 0.
M, G, active_set = _generate_tf_data()
X_hat_tf, active_set_hat_tf, E = tf_mixed_norm_solver(M,
G,
alpha_space,
alpha_time,
maxit=200,
tol=1e-8,
verbose=True,
debias=False,
n_orient=1,
tstep=4,
wsize=32)
# Also run L21 and check that we get the same
X_hat_l21, _, _ = mixed_norm_solver(M,
G,
alpha_space,
maxit=200,
tol=1e-8,
verbose=False,
n_orient=1,
active_set_size=None,
debias=False)
assert_allclose(X_hat_tf, X_hat_l21, rtol=1e-1)
def test_iterative_reweighted_mxne():
"""Test convergence of irMxNE solver"""
n, p, t, alpha = 30, 40, 20, 1
rng = np.random.RandomState(0)
G = rng.randn(n, p)
G /= np.std(G, axis=0)[None, :]
X = np.zeros((p, t))
X[0] = 3
X[4] = -2
M = np.dot(G, X)
X_hat_l21, _, _ = mixed_norm_solver(
M, G, alpha, maxit=1000, tol=1e-8, verbose=False, n_orient=1,
active_set_size=None, debias=False, solver='bcd')
X_hat_bcd, active_set, _ = iterative_mixed_norm_solver(
M, G, alpha, 1, maxit=1000, tol=1e-8, active_set_size=None,
debias=False, solver='bcd')
X_hat_prox, active_set, _ = iterative_mixed_norm_solver(
M, G, alpha, 1, maxit=1000, tol=1e-8, active_set_size=None,
debias=False, solver='prox')
assert_allclose(X_hat_bcd, X_hat_l21, rtol=1e-3)
assert_allclose(X_hat_prox, X_hat_l21, rtol=1e-3)
X_hat_prox, active_set, _ = iterative_mixed_norm_solver(
M, G, alpha, 5, maxit=1000, tol=1e-8, active_set_size=None,
debias=True, solver='prox')
assert_array_equal(np.where(active_set)[0], [0, 4])
X_hat_bcd, active_set, _ = iterative_mixed_norm_solver(
M, G, alpha, 5, maxit=1000, tol=1e-8, active_set_size=2,
debias=True, solver='bcd')
assert_array_equal(np.where(active_set)[0], [0, 4])
X_hat_cd, active_set, _ = iterative_mixed_norm_solver(
M, G, alpha, 5, maxit=1000, tol=1e-8, active_set_size=None,
debias=True, solver='cd')
assert_array_equal(np.where(active_set)[0], [0, 4])
assert_array_almost_equal(X_hat_prox, X_hat_cd, 5)
assert_array_almost_equal(X_hat_bcd, X_hat_cd, 5)
X_hat_bcd, active_set, _ = iterative_mixed_norm_solver(
M, G, alpha, 5, maxit=1000, tol=1e-8, active_set_size=2,
debias=True, n_orient=2, solver='bcd')
assert_array_equal(np.where(active_set)[0], [0, 1, 4, 5])
# suppress a coordinate-descent warning here
with warnings.catch_warnings(record=True):
X_hat_cd, active_set, _ = iterative_mixed_norm_solver(
M, G, alpha, 5, maxit=1000, tol=1e-8, active_set_size=2,
debias=True, n_orient=2, solver='cd')
assert_array_equal(np.where(active_set)[0], [0, 1, 4, 5])
assert_array_equal(X_hat_bcd, X_hat_cd, 5)
X_hat_bcd, active_set, _ = iterative_mixed_norm_solver(
M, G, alpha, 5, maxit=1000, tol=1e-8, active_set_size=2, debias=True,
n_orient=5)
assert_array_equal(np.where(active_set)[0], [0, 1, 2, 3, 4])
with warnings.catch_warnings(record=True): # coordinate-ascent warning
X_hat_cd, active_set, _ = iterative_mixed_norm_solver(
M, G, alpha, 5, maxit=1000, tol=1e-8, active_set_size=2,
debias=True, n_orient=5, solver='cd')
assert_array_equal(np.where(active_set)[0], [0, 1, 2, 3, 4])
assert_array_equal(X_hat_bcd, X_hat_cd, 5)
def test_tf_mxne_vs_mxne():
"""Test equivalence of TF-MxNE (with alpha_time=0) and MxNE"""
alpha_space = 60
alpha_time = 0
M, G, active_set = _generate_tf_data()
X_hat, active_set_hat, E = tf_mixed_norm_solver(M,
G,
alpha_space,
alpha_time,
maxit=200,
tol=1e-8,
verbose=True,
debias=False,
n_orient=1,
tstep=4,
wsize=32)
# Also eggie L21 and check that we get the same
X_hat_l21, _, _ = mixed_norm_solver(M,
G,
alpha_space,
maxit=200,
tol=1e-8,
verbose=False,
n_orient=1,
active_set_size=None,
debias=False)
assert_array_almost_equal(X_hat, X_hat_l21, decimal=2)
def test_non_convergence():
"""Test non-convergence of MxNE solver to catch unexpected bugs."""
n, p, t, alpha = 30, 40, 20, 1.
rng = np.random.RandomState(0)
G = rng.randn(n, p)
G /= np.std(G, axis=0)[None, :]
X = np.zeros((p, t))
X[0] = 3
X[4] = -2
M = np.dot(G, X)
# Impossible to converge with only 1 iteration and tol 1e-12
# In case of non-convegence, we test that no error is returned.
args = (M, G, alpha, 1, 1e-12)
with catch_logging() as log:
mixed_norm_solver(*args, active_set_size=None, debias=True,
solver='bcd', verbose=True)
log = log.getvalue()
assert 'Convergence reached' not in log
def L21_gamma_hypermodel_optimizer(G, M, gamma, alpha, beta, n_orient, maxIter,
lambdaRef, epsilon=1.e-6):
n_locations = G.shape[1] // n_orient
n_times = M.shape[1]
nu = alpha - 1 - n_times * n_orient
X = np.zeros((n_locations * n_orient, n_times))
energy = np.zeros((maxIter,))
relResiduum = np.zeros((maxIter,))
# print('starting posterior optimization')
active_set = np.ones((G.shape[1],), dtype='bool')
Gbar = np.zeros(G.shape)
for i_iter in range(maxIter):
print("iter %s - active set %s" % (i_iter, active_set.sum()))
Xold = X.copy()
X = np.zeros((n_locations * n_orient, n_times))
# update X
gamma_bar = np.tile(gamma, [n_orient, 1]).ravel(order='F')
Gbar = G * (lambdaRef * gamma_bar)
Xbis, active_set, _ = mixed_norm_solver(
M, Gbar, lambdaRef, maxit=3000, tol=1e-4, n_orient=n_orient,
debias=False, verbose=False)
X[active_set, :] = Xbis
X = (X.T * (lambdaRef * gamma_bar)).T
# update gamma
XBlocNorms = compute_block_norms(X, n_orient)
gamma = beta * (nu + np.sqrt(nu ** 2 + XBlocNorms / beta)) + epsilon
# compute relative change in X and energy
XChange = 1.
if X.shape[0] == Xold.shape[0]:
XChange = norm(X - Xold, 'fro')
if XChange > 0:
XChange = 0.5 * XChange / (norm(X, 'fro') + norm(Xold, 'fro'))
# else:
# break
energy[i_iter], relResiduum[i_iter] = neg_log_post_prob(
G, X, M, n_orient, gamma[active_set[::n_orient]],
alpha, beta, n_times)
# output
return X, active_set, gamma, energy, relResiduum
def test_tf_mxne_vs_mxne():
"""Test equivalence of TF-MxNE (with alpha_time=0) and MxNE"""
alpha_space = 60
alpha_time = 0
M, G, active_set = _generate_tf_data()
X_hat, active_set_hat, E = tf_mixed_norm_solver(
M, G, alpha_space, alpha_time, maxit=200, tol=1e-8, verbose=True,
debias=False, n_orient=1, tstep=4, wsize=32)
# Also run L21 and check that we get the same
X_hat_l21, _, _ = mixed_norm_solver(
M, G, alpha_space, maxit=200, tol=1e-8, verbose=False, n_orient=1,
active_set_size=None, debias=False)
assert_array_almost_equal(X_hat, X_hat_l21, decimal=2)
def test_l21_mxne():
"""Test convergence of MxNE solver."""
n, p, t, alpha = 30, 40, 20, 1.
rng = np.random.RandomState(0)
G = rng.randn(n, p)
G /= np.std(G, axis=0)[None, :]
X = np.zeros((p, t))
X[0] = 3
X[4] = -2
M = np.dot(G, X)
args = (M, G, alpha, 1000, 1e-8)
with pytest.warns(None): # CD
X_hat_prox, active_set, _ = mixed_norm_solver(
*args, active_set_size=None,
debias=True, solver='prox')
assert_array_equal(np.where(active_set)[0], [0, 4])
with pytest.warns(None): # CD
X_hat_cd, active_set, _, gap_cd = mixed_norm_solver(
*args, active_set_size=None,
debias=True, solver='cd', return_gap=True)
assert_array_less(gap_cd, 1e-8)
assert_array_equal(np.where(active_set)[0], [0, 4])
with pytest.warns(None): # CD
X_hat_bcd, active_set, E, gap_bcd = mixed_norm_solver(
M, G, alpha, maxit=1000, tol=1e-8, active_set_size=None,
debias=True, solver='bcd', return_gap=True)
assert_array_less(gap_bcd, 9.6e-9)
assert_array_equal(np.where(active_set)[0], [0, 4])
assert_allclose(X_hat_prox, X_hat_cd, rtol=1e-2)
assert_allclose(X_hat_prox, X_hat_bcd, rtol=1e-2)
assert_allclose(X_hat_bcd, X_hat_cd, rtol=1e-2)
with pytest.warns(None): # CD
X_hat_prox, active_set, _ = mixed_norm_solver(
*args, active_set_size=2, debias=True, solver='prox')
assert_array_equal(np.where(active_set)[0], [0, 4])
with pytest.warns(None): # CD
X_hat_cd, active_set, _ = mixed_norm_solver(
*args, active_set_size=2, debias=True, solver='cd')
assert_array_equal(np.where(active_set)[0], [0, 4])
with pytest.warns(None): # CD
X_hat_bcd, active_set, _ = mixed_norm_solver(
*args, active_set_size=2, debias=True, solver='bcd')
assert_array_equal(np.where(active_set)[0], [0, 4])
assert_allclose(X_hat_bcd, X_hat_cd, rtol=1e-2)
assert_allclose(X_hat_bcd, X_hat_prox, rtol=1e-2)
with pytest.warns(None): # CD
X_hat_prox, active_set, _ = mixed_norm_solver(
*args, active_set_size=2, debias=True, n_orient=2, solver='prox')
assert_array_equal(np.where(active_set)[0], [0, 1, 4, 5])
with pytest.warns(None): # CD
X_hat_bcd, active_set, _ = mixed_norm_solver(
*args, active_set_size=2, debias=True, n_orient=2, solver='bcd')
assert_array_equal(np.where(active_set)[0], [0, 1, 4, 5])
# suppress a coordinate-descent warning here
with pytest.warns(RuntimeWarning, match='descent'):
X_hat_cd, active_set, _ = mixed_norm_solver(
*args, active_set_size=2, debias=True, n_orient=2, solver='cd')
assert_array_equal(np.where(active_set)[0], [0, 1, 4, 5])
assert_allclose(X_hat_bcd, X_hat_prox, rtol=1e-2)
assert_allclose(X_hat_bcd, X_hat_cd, rtol=1e-2)
with pytest.warns(None): # CD
X_hat_bcd, active_set, _ = mixed_norm_solver(
*args, active_set_size=2, debias=True, n_orient=5, solver='bcd')
assert_array_equal(np.where(active_set)[0], [0, 1, 2, 3, 4])
with pytest.warns(None): # CD
X_hat_prox, active_set, _ = mixed_norm_solver(
*args, active_set_size=2, debias=True, n_orient=5, solver='prox')
assert_array_equal(np.where(active_set)[0], [0, 1, 2, 3, 4])
with pytest.warns(RuntimeWarning, match='descent'):
X_hat_cd, active_set, _ = mixed_norm_solver(
*args, active_set_size=2, debias=True, n_orient=5, solver='cd')
assert_array_equal(np.where(active_set)[0], [0, 1, 2, 3, 4])
assert_array_equal(X_hat_bcd, X_hat_cd)
assert_allclose(X_hat_bcd, X_hat_prox, rtol=1e-2)
def test_iterative_reweighted_mxne():
"""Test convergence of irMxNE solver."""
n, p, t, alpha = 30, 40, 20, 1
rng = np.random.RandomState(0)
G = rng.randn(n, p)
G /= np.std(G, axis=0)[None, :]
X = np.zeros((p, t))
X[0] = 3
X[4] = -2
M = np.dot(G, X)
with pytest.warns(None): # CD
X_hat_l21, _, _ = mixed_norm_solver(
M, G, alpha, maxit=1000, tol=1e-8, verbose=False, n_orient=1,
active_set_size=None, debias=False, solver='bcd')
with pytest.warns(None): # CD
X_hat_bcd, active_set, _ = iterative_mixed_norm_solver(
M, G, alpha, 1, maxit=1000, tol=1e-8, active_set_size=None,
debias=False, solver='bcd')
with pytest.warns(None): # CD
X_hat_prox, active_set, _ = iterative_mixed_norm_solver(
M, G, alpha, 1, maxit=1000, tol=1e-8, active_set_size=None,
debias=False, solver='prox')
assert_allclose(X_hat_bcd, X_hat_l21, rtol=1e-3)
assert_allclose(X_hat_prox, X_hat_l21, rtol=1e-3)
with pytest.warns(None): # CD
X_hat_prox, active_set, _ = iterative_mixed_norm_solver(
M, G, alpha, 5, maxit=1000, tol=1e-8, active_set_size=None,
debias=True, solver='prox')
assert_array_equal(np.where(active_set)[0], [0, 4])
with pytest.warns(None): # CD
X_hat_bcd, active_set, _ = iterative_mixed_norm_solver(
M, G, alpha, 5, maxit=1000, tol=1e-8, active_set_size=2,
debias=True, solver='bcd')
assert_array_equal(np.where(active_set)[0], [0, 4])
with pytest.warns(None): # CD
X_hat_cd, active_set, _ = iterative_mixed_norm_solver(
M, G, alpha, 5, maxit=1000, tol=1e-8, active_set_size=None,
debias=True, solver='cd')
assert_array_equal(np.where(active_set)[0], [0, 4])
assert_array_almost_equal(X_hat_prox, X_hat_cd, 5)
assert_array_almost_equal(X_hat_bcd, X_hat_cd, 5)
with pytest.warns(None): # CD
X_hat_bcd, active_set, _ = iterative_mixed_norm_solver(
M, G, alpha, 5, maxit=1000, tol=1e-8, active_set_size=2,
debias=True, n_orient=2, solver='bcd')
assert_array_equal(np.where(active_set)[0], [0, 1, 4, 5])
# suppress a coordinate-descent warning here
with pytest.warns(RuntimeWarning, match='descent'):
X_hat_cd, active_set, _ = iterative_mixed_norm_solver(
M, G, alpha, 5, maxit=1000, tol=1e-8, active_set_size=2,
debias=True, n_orient=2, solver='cd')
assert_array_equal(np.where(active_set)[0], [0, 1, 4, 5])
assert_array_equal(X_hat_bcd, X_hat_cd, 5)
X_hat_bcd, active_set, _ = iterative_mixed_norm_solver(
M, G, alpha, 5, maxit=1000, tol=1e-8, active_set_size=2, debias=True,
n_orient=5)
assert_array_equal(np.where(active_set)[0], [0, 1, 2, 3, 4])
with pytest.warns(RuntimeWarning, match='descent'):
X_hat_cd, active_set, _ = iterative_mixed_norm_solver(
M, G, alpha, 5, maxit=1000, tol=1e-8, active_set_size=2,
debias=True, n_orient=5, solver='cd')
assert_array_equal(np.where(active_set)[0], [0, 1, 2, 3, 4])
assert_array_equal(X_hat_bcd, X_hat_cd, 5)