def run_one(reg, n_dims, n_atoms, random_state):
current_time = time.time() - START
msg = f"{random_state} - {reg}: started at T={current_time:.0f} sec"
print(colorify(msg, BLUE))
x, D, _ = make_coding(n_samples=1,
n_atoms=n_atoms,
n_dim=n_dims,
normalize=True,
random_state=random_state)
def stopping_criterion(costs):
return stop_on_no_decrease(1e-13, costs)
_, cost, *_ = ista(D,
x,
reg,
max_iter=int(1e6),
stopping_criterion=stopping_criterion)
cost_stop = cost[-1] + 1e-8
def stopping_criterion(costs):
return stop_on_value(cost_stop, costs)
results = {}
for method, label in methods:
if 'Oracle' in label:
x_ = x[0]
else:
x_ = x
_, cost, times, *_ = method(D,
x_,
reg,
max_iter=int(1e6),
stopping_criterion=stopping_criterion)
results[label] = cost, np.cumsum(times)
duration = time.time() - START - current_time
msg = (f"{random_state} - {reg}: done in {duration:.0f} sec "
f"at T={current_time:.0f} sec")
print(colorify(msg, GREEN))
return (reg, n_dims, n_atoms, random_state, label, cost_stop, results)
def test_ista(reg):
n_dim = 20
n_atoms = 10
n_samples = 1000
random_state = 42
n_iters = 100
# Generate a problem
x, D, z = make_coding(n_samples=n_samples,
n_atoms=n_atoms,
n_dim=n_dim,
random_state=random_state)
z_hat, cost_ista, *_ = ista(D, x, reg, max_iter=n_iters)
assert all(np.diff(cost_ista) <= 0)
assert all(np.diff(cost_ista) <= 1e-8)
def test_facnet(reg):
n_dim = 20
n_atoms = 10
n_samples = 1000
random_state = 42
# Generate a problem
x, D, z = make_coding(n_samples=n_samples,
n_atoms=n_atoms,
n_dim=n_dim,
random_state=random_state)
z_hat_ista, cost_ista, *_ = ista(D, x, reg, max_iter=1)
L = np.linalg.norm(D.dot(D.T), 2)
A = np.eye(n_atoms)
S = L * np.ones((1, n_atoms))
z_hat = facnet_step(np.zeros_like(z), D, x, reg, A, S)
assert np.allclose(z_hat_ista, z_hat)
def test_fista(reg):
n_dim = 20
n_atoms = 10
n_samples = 1000
random_state = 42
n_iters = 100
# Generate a problem
x, D, z = make_coding(n_samples=n_samples,
n_atoms=n_atoms,
n_dim=n_dim,
random_state=random_state)
z_hat_ista, cost_ista, *_ = ista(D, x, reg, max_iter=n_iters * 10)
z_hat_fista, cost_fista, *_ = fista(D, x, reg, max_iter=n_iters)
assert np.isclose(cost_ista[1], cost_fista[1])
assert np.isclose(cost_ista[-1], cost_fista[-1])
diff = z_hat_fista - z_hat_ista
print(diff[abs(diff) > 1e-2])
def test_lista_init(reg, n_layers, parametrization, learn_th):
if parametrization == "alista":
pytest.skip(msg="ALISTA is not initialized to match ISTA.")
if "step" in parametrization and not learn_th:
pytest.skip(msg="For parametrization 'step' and 'coupled_step', "
"learn_th need to be set to True.")
n_dim = 20
n_atoms = 10
n_samples = 1000
random_state = 42
# Generate a problem
x, D, z = make_coding(n_samples=n_samples,
n_atoms=n_atoms,
n_dim=n_dim,
random_state=random_state)
z_hat, cost_ista, _ = ista(D, x, reg, max_iter=n_layers)
lista = Lista(D, n_layers, parametrization=parametrization)
cost_lista = lista.score(x, reg)
assert np.isclose(cost_ista[n_layers], cost_lista)
###########################################
# Parameters of the simulation
###########################################
n_atoms = 50
n_dims = 10
max_iter = 200
D = rng.randn(n_atoms, n_dims)
x = rng.randn(n_dims)
x /= np.max(np.abs(D.dot(x)))
lmbd = 0.5
############################################
# Benchmark computation function
############################################
_, cost_ista, times_ista = ista(D, x[None, :], lmbd, max_iter=max_iter)
_, cost_fista, times_fista = fista(D, x[None, :], lmbd, max_iter=max_iter)
_, cost_oista, times_oista, steps = oracle_ista(D, x, lmbd, max_iter=max_iter)
_, cost_btista, times_btista, steps_bt = backtracking_ista(D,
x,
lmbd,
eta=.95,
max_iter=max_iter)
cost_ista = np.array(cost_ista)
cost_oista = np.array(cost_oista)
cost_fista = np.array(cost_fista)
cost_btista = np.array(cost_btista)
z_hat, c_star, _ = ista(D, x[None, :], lmbd, max_iter=3000)
c_star = c_star[-1]
############################################
"""
import numpy as np
import matplotlib.pyplot as plt
from adopty.ista import ista
from adopty.datasets import make_coding
if __name__ == "__main__":
reg = .5
n_iters = 100
n_dim = 64
n_atoms = 100
n_samples = 1000
random_state = 42
# Generate a problem
x, D, z, lmbd_max = make_coding(n_samples=n_samples, n_atoms=n_atoms,
n_dim=n_dim, random_state=random_state)
# Compute the effective regularization
lmbd = lmbd_max * reg
_, cost_ista, _ = ista(D, x, lmbd, max_iter=100)
cost_ista = np.array(cost_ista)
plt.loglog(cost_ista - cost_ista.min() + 1e-16)
plt.show()
n_dim=n_dim,
normalize=True,
random_state=random_state)
x_test = x[n_samples:]
x_train = x[:n_samples]
for reg in regs:
print("Computing ISTA for {} with lmbd={:.1}".format(data, reg))
if data == 'images':
reg = reg
def stopping_criterion(costs):
return stop_on_no_decrease(1e-13, costs)
_, cost_test, *_ = ista(D,
x_test,
reg,
max_iter=int(1e3),
stopping_criterion=stopping_criterion,
verbose=1)
_, cost_train, *_ = ista(D,
x_train,
reg,
max_iter=int(1e3),
stopping_criterion=stopping_criterion,
verbose=1)
c0 = cost_test[0]
c_star = cost_test[-1]
results = [(*r, c0, c_star) if r[1] == data and r[2] == reg else r
for r in results]
for n_layer in range(n_layers):
results.append(
quad = .5 * np.sum(r**2) + .5 * L * np.sum((z - zt)**2) + g
return quad + lbda * np.sum(np.abs(z))
def t_x(x, D, zt, lbda, alpha):
z = zt - alpha * np.dot(D.T, D.dot(zt) - x)
return np.sign(z) * np.maximum(np.abs(z) - alpha * lbda, 0)
n, m = 2, 3
n_points = 100
D = rng.randn(n, m)
x = rng.randn(n)
x /= np.max(np.abs(D.T.dot(x)))
lbda = .1
z = ista(D.T, x[None, :], lbda, max_iter=1000)[0]
zt = z.ravel() + .1 * rng.randn(m)
L = np.linalg.norm(D.T.dot(D), ord=2)
alphas = np.linspace(0, 10 / L, n_points)
z_ = [t_x(x, D, zt, lbda, alpha) for alpha in alphas]
F = [lasso_cost(x, D, z, lbda) for z in z_]
L = .4 * L
S1 = [surrogate(x, D, z, zt, lbda, L) for z in z_]
fac = .6
S2 = [surrogate(x, D, z, zt, lbda, fac * L) for z in z_]
f = plt.figure(figsize=(3, 2))
plt.plot(L * alphas, F, label=r'$F_x$', color='k')
plt.plot(L * alphas,
