def one_run(X, n_channels, method, n_atoms, n_times_atom, random_state, reg): func, label, n_iter = method current_time = time.time() - START print('{}-{}-{}: started at {:.0f} sec'.format(label, n_channels, random_state, current_time)) # use the same init for all methods D_init = generate_D_init(n_atoms, n_channels, n_times_atom, random_state) X = X[:, :n_channels] lmbd_max = get_lambda_max(X, D_init).mean() reg_ = reg * lmbd_max # run the selected algorithm with one iter to remove compilation overhead _, _, _, _ = func(X, D_init, reg_, 1, random_state, label, n_channels) # run the selected algorithm pobj, times, d_hat, z_hat = func(X, D_init, reg_, n_iter, random_state, label, n_channels) # store z_hat in a sparse matrix to reduce size for z in z_hat: z[z < 1e-3] = 0 z_hat = [sp.csr_matrix(z) for z in z_hat] current_time = time.time() - START print('{}-{}-{}: done at {:.0f} sec'.format(label, n_channels, random_state, current_time)) assert len(times) > 5 return (n_channels, random_state, label, np.asarray(pobj), np.asarray(times), np.asarray(d_hat), np.asarray(z_hat), n_atoms, n_times_atom, reg)
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 plot_loss(reg_ratio): n_trials = 1 n_channels = 1 n_times, n_atoms, n_times_atom = 100000, 10, 100 rng = np.random.RandomState(0) X = rng.randn(n_trials, n_channels, n_times) D = rng.randn(n_atoms, n_channels, n_times_atom) reg = reg_ratio * get_lambda_max(X, D).max() results = [] for func, max_iter in all_func: print(func.__name__) res = run_one(func, n_times, n_atoms, n_times_atom, reg, max_iter, X, D) results.append(res) best = np.inf for res in results: func_name, n_times, n_atoms, n_times_atom, reg, times, pobj = res if pobj[-1] < best: best = pobj[-1] fig = plt.figure() for (func, max_iter), res in zip(all_func, results): style = '-' if 'cd' in func.__name__ else '--' func_name, n_times, n_atoms, n_times_atom, reg, times, pobj = res plt.loglog(times, np.array(pobj) - best, style, label=func.__name__) plt.legend() plt.xlim(1e-2, None) name = ('T=%s_K=%s_L=%s_reg=%.3f' % (n_times, n_atoms, n_times_atom, reg_ratio)) plt.title(name) plt.xlabel('Time (s)') plt.ylabel('loss function') save_name = 'figures/bench_gcd/' + name + '.png' print('Saving %s' % (save_name, )) fig.savefig(save_name) # plt.show() plt.close(fig)