def test_window(rank1, solver_d, uv_constraint): # Smoke test that the parameter window does something n_trials, n_channels, n_times = 2, 3, 100 n_times_atom, n_atoms = 10, 4 rng = check_random_state(42) X = rng.randn(n_trials, n_channels, n_times) *_, uv_constraint_ = check_solver_and_constraints(rank1, solver_d, uv_constraint) D_init = init_dictionary(X, n_atoms, n_times_atom, rank1=rank1, uv_constraint=uv_constraint_, random_state=0) kwargs = dict(X=X, n_atoms=n_atoms, n_times_atom=n_times_atom, verbose=0, uv_constraint=uv_constraint, solver_d=solver_d, rank1=rank1, random_state=0, n_iter=1, solver_z='l-bfgs', D_init=D_init) res_False = learn_d_z_multi(window=False, **kwargs) res_True = learn_d_z_multi(window=True, **kwargs) assert not np.allclose(res_False[2], res_True[2])
def test_online_learning(): # smoke test for learn_d_z_multi n_trials, n_channels, n_times = 2, 3, 100 n_times_atom, n_atoms = 10, 4 rng = check_random_state(42) X = rng.randn(n_trials, n_channels, n_times) pobj_0, _, _, _, _ = learn_d_z_multi(X, n_atoms, n_times_atom, uv_constraint="separate", solver_d="joint", random_state=0, n_iter=30, solver_z='l-bfgs', algorithm="batch", loss='l2') pobj_1, _, _, _, _ = learn_d_z_multi(X, n_atoms, n_times_atom, uv_constraint="separate", solver_d="joint", random_state=0, n_iter=30, solver_z='l-bfgs', algorithm="online", algorithm_params=dict( batch_size=n_trials, alpha=0), loss='l2') assert np.allclose(pobj_0, pobj_1)
def test_learn_d_z_multi_dicodile(window): pytest.importorskip('dicodile') # smoke test for learn_d_z_multi # XXX For DiCoDiLe, n_trials cannot be >1 n_trials, n_channels, n_times = 1, 3, 30 n_times_atom, n_atoms = 6, 4 rng = check_random_state(42) X = rng.randn(n_trials, n_channels, n_times) pobj, times, uv_hat, z_hat, reg = learn_d_z_multi(X, n_atoms, n_times_atom, uv_constraint='auto', rank1=False, solver_d='auto', random_state=0, n_iter=30, eps=-np.inf, solver_z='dicodile', window=window, verbose=0, loss='l2', loss_params=None) msg = "Cost function does not go down" try: assert np.sum(np.diff(pobj) > 1e-13) == 0, msg except AssertionError: import matplotlib.pyplot as plt plt.semilogy(pobj - np.min(pobj) + 1e-6) plt.title(msg) plt.show() raise
def test_learn_d_z_multi(loss, solver_d, uv_constraint, rank1, window): # smoke test for learn_d_z_multi n_trials, n_channels, n_times = 2, 3, 30 n_times_atom, n_atoms = 6, 4 loss_params = dict(gamma=1, sakoe_chiba_band=10, ordar=10) rng = check_random_state(42) X = rng.randn(n_trials, n_channels, n_times) pobj, times, uv_hat, z_hat, reg = learn_d_z_multi( X, n_atoms, n_times_atom, uv_constraint=uv_constraint, rank1=rank1, solver_d=solver_d, random_state=0, n_iter=30, eps=-np.inf, solver_z='l-bfgs', window=window, verbose=0, loss=loss, loss_params=loss_params) msg = "Cost function does not go down for uv_constraint {}".format( uv_constraint) try: assert np.sum(np.diff(pobj) > 1e-13) == 0, msg except AssertionError: import matplotlib.pyplot as plt plt.semilogy(pobj - np.min(pobj) + 1e-6) plt.title(msg) plt.show() raise
def run_multichannel_gcd(X, ds_init, reg, n_iter, random_state, label): if X.ndim == 2: n_atoms, n_times_atom = ds_init.shape ds_init = np.c_[np.ones((n_atoms, 1)), ds_init] X = X[:, None, :] else: n_atoms, n_channels, n_times_atom = ds_init.shape ds_init = get_uv(ds_init) # project init to rank 1 solver_z_kwargs = dict(max_iter=2, tol=1e-3) pobj, times, d_hat, z_hat, reg = learn_d_z_multi( X, n_atoms, n_times_atom, solver_d='alternate_adaptive', solver_z="lgcd", uv_constraint='separate', eps=-np.inf, solver_z_kwargs=solver_z_kwargs, reg=reg, solver_d_kwargs=dict(max_iter=100), n_iter=n_iter, random_state=random_state, raise_on_increase=False, D_init=ds_init, n_jobs=1, verbose=verbose) # remove the ds init duration times[0] = 0 return pobj[::2], np.cumsum(times)[::2], d_hat, z_hat
def run_multichannel_gcd_fullrank(X, ds_init, reg, n_iter, random_state, label): assert X.ndim == 3 n_atoms, n_channels, n_times_atom = ds_init.shape solver_z_kwargs = dict(max_iter=2, tol=1e-3) pobj, times, d_hat, z_hat, reg = learn_d_z_multi( X, n_atoms, n_times_atom, solver_d='fista', solver_z="lgcd", uv_constraint='separate', eps=-np.inf, solver_z_kwargs=solver_z_kwargs, reg=reg, solver_d_kwargs=dict(max_iter=100), n_iter=n_iter, random_state=random_state, raise_on_increase=False, D_init=ds_init, n_jobs=1, verbose=verbose, rank1=False) # remove the ds init duration times[0] = 0 return pobj[::2], np.cumsum(times)[::2], d_hat, z_hat
def test_init_random(rank1, solver_d, uv_constraint): """""" n_trials, n_channels, n_times = 5, 3, 100 n_times_atom, n_atoms = 10, 4 _, uv_constraint_ = check_solver_and_constraints(rank1, solver_d, uv_constraint) if rank1: expected_shape = (n_atoms, n_channels + n_times_atom) prox = functools.partial(prox_uv, uv_constraint=uv_constraint_, n_channels=n_channels) else: expected_shape = (n_atoms, n_channels, n_times_atom) prox = prox_d X = np.random.randn(n_trials, n_channels, n_times) # Test that init_dictionary is doing what we expect for D_init random random_state = 42 D_hat = init_dictionary(X, n_atoms, n_times_atom, D_init='random', rank1=rank1, uv_constraint=uv_constraint_, random_state=random_state) rng = check_random_state(random_state) D_init = rng.randn(*expected_shape) D_init = prox(D_init) assert_allclose(D_hat, D_init, err_msg="The random state is not correctly " "used in init_dictionary .") # Test that learn_d_z_multi is doing what we expect for D_init random random_state = 27 _, _, D_hat, _, _ = learn_d_z_multi(X, n_atoms, n_times_atom, D_init='random', n_iter=0, rank1=rank1, solver_d=solver_d, uv_constraint=uv_constraint, random_state=random_state) rng = check_random_state(random_state) D_init = rng.randn(*expected_shape) D_init = prox(D_init) assert_allclose(D_hat, D_init, err_msg="The random state is not correctly " "used in learn_d_z_multi.")
def test_unbiased_z_hat(solver_z): n_trials, n_channels, n_times = 2, 3, 30 n_times_atom, n_atoms = 6, 4 loss_params = dict(gamma=1, sakoe_chiba_band=10, ordar=10) rng = check_random_state(42) X = rng.randn(n_trials, n_channels, n_times) _, _, _, z_hat, _ = learn_d_z_multi(X, n_atoms, n_times_atom, uv_constraint='auto', rank1=False, solver_d='auto', random_state=0, unbiased_z_hat=False, n_iter=1, eps=-np.inf, solver_z=solver_z, window=False, verbose=0, loss='l2', loss_params=loss_params) _, _, _, z_hat_unbiased, _ = learn_d_z_multi(X, n_atoms, n_times_atom, uv_constraint='auto', rank1=False, solver_d='auto', random_state=0, unbiased_z_hat=True, n_iter=1, eps=-np.inf, solver_z=solver_z, window=False, verbose=0, loss='l2', loss_params=loss_params) assert np.all(z_hat_unbiased[z_hat == 0] == 0)
def run_multichannel(X, D_init, reg, n_iter, random_state, label, n_channels): n_atoms, n_channels_n_times_atom = D_init.shape n_times_atom = n_channels_n_times_atom - n_channels solver_z_kwargs = dict(max_iter=500, tol=1e-1) return learn_d_z_multi( X, n_atoms, n_times_atom, reg=reg, n_iter=n_iter, uv_constraint='separate', rank1=True, D_init=D_init, solver_d='alternate_adaptive', solver_d_kwargs=dict(max_iter=50), solver_z="lgcd", solver_z_kwargs=solver_z_kwargs, use_sparse_z=False, name="rank1-{}-{}".format(n_channels, random_state), random_state=random_state, n_jobs=1, verbose=VERBOSE)
def run_one(reg, sigma, n_atoms, n_times_atom, max_n_channels, n_times_valid, n_iter, run_n_channels, random_state): """Run the benchmark for a given set of parameter.""" X, uv, uv_init = get_signals(max_n_channels, n_times_atom, n_times_valid, sigma, random_state) reg_ = reg * get_lambda_max(X, uv_init).max() # reg_ *= run_n_channels uv_init_ = prox_uv(np.c_[uv_init[:, :run_n_channels], uv_init[:, max_n_channels:]]) uv_ = prox_uv(np.c_[uv[:, :run_n_channels], uv[:, max_n_channels:]], uv_constraint='separate', n_channels=max_n_channels) def cb(X, uv_hat, z_hat, pobj): it = len(pobj) // 2 if it % 10 == 0: print("[channels{}] iter{} score sig={:.2e}: {:.3e}".format( run_n_channels, it, sigma, score_uv(uv_, uv_hat, run_n_channels))) pobj, times, uv_hat, z_hat, reg = learn_d_z_multi( X[:, :run_n_channels, :], n_atoms, n_times_atom, random_state=random_state, # callback=cb, n_iter=n_iter, n_jobs=1, reg=reg_, uv_constraint='separate', solver_d='alternate_adaptive', solver_d_kwargs={'max_iter': 50}, solver_z="lgcd", solver_z_kwargs=dict(tol=1e-3, maxiter=500), use_sparse_z=True, D_init=uv_init_, verbose=VERBOSE, ) score = score_uv(uv_, uv_hat, run_n_channels) print("=" * 79 + "\n" + "[channels{}-{:.2e}-{}] iter {} score sig={:.2e}: {:.3e}\n".format( run_n_channels, reg, random_state, len(pobj) // 2, sigma, score) + "=" * 79) return random_state, sigma, run_n_channels, score, uv, uv_hat, reg
def run_multivariate(X, D_init, reg, n_iter, random_state, label, n_channels): n_atoms, n_channels_n_times_atom = D_init.shape n_times_atom = n_channels_n_times_atom - n_channels D_init = get_D(D_init, n_channels) solver_z_kwargs = dict(max_iter=500, tol=1e-1) return learn_d_z_multi( X, n_atoms, n_times_atom, reg=reg, n_iter=n_iter, uv_constraint='separate', rank1=False, D_init=D_init, solver_d='l-bfgs', solver_d_kwargs=dict(max_iter=50), solver_z="lgcd", solver_z_kwargs=solver_z_kwargs, use_sparse_z=False, name="dense-{}-{}".format(n_channels, random_state), random_state=random_state, n_jobs=1, verbose=VERBOSE, raise_on_increase=False)
def test_init_array(rank1, solver_d, uv_constraint): n_trials, n_channels, n_times = 5, 3, 100 n_times_atom, n_atoms = 10, 4 _, uv_constraint_ = check_solver_and_constraints(rank1, solver_d, uv_constraint) if rank1: expected_shape = (n_atoms, n_channels + n_times_atom) prox = functools.partial(prox_uv, uv_constraint=uv_constraint_, n_channels=n_channels) else: expected_shape = (n_atoms, n_channels, n_times_atom) prox = prox_d X = np.random.randn(n_trials, n_channels, n_times) # Test that init_dictionary is doing what we expect for D_init array D_init = np.random.randn(*expected_shape) D_hat = init_dictionary(X, n_atoms, n_times_atom, D_init=D_init, rank1=rank1, uv_constraint=uv_constraint_) D_init = prox(D_init) assert_allclose(D_hat, D_init) assert id(D_hat) != id(D_init) # Test that learn_d_z_multi is doing what we expect for D_init array D_init = np.random.randn(*expected_shape) _, _, D_hat, _, _ = learn_d_z_multi(X, n_atoms, n_times_atom, D_init=D_init, n_iter=0, rank1=rank1, solver_d=solver_d, uv_constraint=uv_constraint) D_init = prox(D_init) assert_allclose(D_hat, D_init)