def run_dicodile_hubble(size, reg, L): X = get_hubble(size=size) D_init = init_dictionary(X, n_atoms, (L, L), random_state=random_state) dicod_kwargs = dict(soft_lock='border') pobj, times, D_hat, z_hat = dicodile(X, D_init, reg=reg, z_positive=True, n_iter=100, n_workers=400, eps=1e-5, tol=1e-3, verbose=2, dicod_kwargs=dicod_kwargs) # Save the atoms prefix = (f"K{n_atoms}_L{L}_reg{reg}" f"_seed{random_state}_dicodile_{size}_") prefix = prefix.replace(" ", "") np.save(f"hubble/{prefix}D_hat.npy", D_hat) z_hat[z_hat < 1e-2] = 0 z_hat_save = [sparse.csr_matrix(z) for z in z_hat] np.save(f"hubble/{prefix}z_hat.npy", z_hat_save) plot_atom_and_coefs(D_hat, z_hat, prefix)
def test_dicodile(): X, D = simulate_data(n_times=100, n_times_atom=10, n_atoms=2, n_channels=3, noise_level=1e-5, seed=42) pobj, times, D_hat, z_hat = dicodile( X, D, reg=.1, z_positive=True, n_iter=10, eps=1e-4, n_jobs=1, verbose=2, tol=1e-10) assert is_deacreasing(pobj)
def compute_cdl(X, n_atoms, atom_support, D_init, reg=.2, window=False, n_jobs=10): """Compute dictionary using Dicodile. Parameters ---------- X : ndarray, shape (n_channels, *signal_support) Signal from which the patterns are extracted. Note that this function is only working for a single image and a single channel. n_atoms : int Number of pattern to learn form the data atom_support : tuple(int, int) Support of the patterns that are learned. D_init: ndarray, shape (n_atoms, n_channels, *atom_support) Initial dictionary, used to start the algorithm. window: boolean (default: False) If set to True, use a window to force dictionary boundaries to zero. n_jobs: int (default: 10) Number of CPUs that can be used for the computations. Returns ------- D_hat: ndarray, shape (n_atoms, n_channels, *atom_support) The learned dictionary """ # Add a small noise to avoid having coefficients that are equals. They # might make the distributed optimization complicated. X_0 = X.copy() X_0 += X_0.std() * 1e-8 * np.random.randn(*X.shape) meta = dict(reg=reg, tol=1e-3, z_positive=True, n_iter=100, window=window) # fit the dictionary with dicodile pobj, times, D_hat, z_hat = dicodile( X_0, D_init, n_workers=n_jobs, w_world='auto', **meta, raise_on_increase=True, verbose=1, ) # Order the dictionary based on the l1 norm of its activation i0 = abs(z_hat).sum(axis=(1, 2)).argsort()[::-1] return D_hat[i0], meta
def run_one(method, n_atoms, atom_support, reg, z_positive, n_jobs, n_iter, tol, eps, random_state): X = get_hubble()[:, 512:1024, 512:1024] D_init = init_dictionary(X, n_atoms, atom_support, random_state=random_state) if method == 'wohlberg': ################################################################ # Run parallel consensus ADMM # lmbd_max = get_lambda_max(X, D_init).max() print("Lambda max = {}".format(lmbd_max)) reg_ = reg * lmbd_max D_init_ = np.transpose(D_init, axes=(3, 2, 1, 0)) X_ = np.transpose(X[None], axes=(3, 2, 1, 0)) options = { 'Verbose': True, 'StatusHeader': False, 'MaxMainIter': n_iter, 'CCMOD': { 'rho': 1.0, 'ZeroMean': False }, 'CBPDN': { 'rho': 50.0 * reg_ + 0.5, 'NonNegCoef': z_positive }, 'DictSize': D_init_.shape, } opt = ConvBPDNDictLearn_Consensus.Options(options) cdl = ConvBPDNDictLearn_Consensus(D_init_, X_, lmbda=reg_, nproc=n_jobs, opt=opt, dimK=1, dimN=2) _, pobj = cdl.solve() print(pobj) itstat = cdl.getitstat() times = itstat.Time elif method == "dicodile": pobj, times, D_hat, z_hat = dicodile(X, D_init, reg=reg, z_positive=z_positive, n_iter=n_iter, eps=eps, n_jobs=n_jobs, verbose=2, tol=tol) pobj = pobj[::2] times = np.cumsum(times)[::2] else: raise NotImplementedError() return ResultItem(n_atoms=n_atoms, atom_support=atom_support, reg=reg, n_jobs=n_jobs, random_state=random_state, method=method, z_positive=z_positive, times=times, pobj=pobj)