def test_wav_op(): wav = 'dirac' levels = 3 shape = (128, ) op = linear_operators.db_wavelets(wav, levels, shape) inp = np.random.normal(0, 10., shape) out = op.dir_op(inp) forward_operator(op, inp, out) inp = np.random.normal(0, 10., out.shape) out = op.adj_op(inp) adjoint_operator(op, inp, out) buff1 = op.adj_op(op.dir_op(out)) assert np.allclose(out, buff1, 1e-6) wav = 'db1' levels = 3 shape = (128, ) op = linear_operators.db_wavelets(wav, levels, shape) inp = np.random.normal(0, 10., shape) out = op.dir_op(inp) forward_operator(op, inp, out) inp = np.random.normal(0, 10., out.shape) out = op.adj_op(inp) adjoint_operator(op, inp, out) buff1 = op.adj_op(op.dir_op(out)) assert np.allclose(out, buff1, 1e-6) wav = ['db1', 'db2', 'dirac'] levels = 3 shape = (128, ) op = linear_operators.dictionary(wav, levels, shape) inp = np.random.normal(0, 10., shape) out = op.dir_op(inp) forward_operator(op, inp, out) inp = np.random.normal(0, 10., out.shape) out = op.adj_op(inp) adjoint_operator(op, inp, out) buff1 = op.adj_op(op.dir_op(out)) assert np.allclose(out, buff1, 1e-6) wav = 'db2' levels = 3 shape = (128, 128) op = linear_operators.db_wavelets(wav, levels, shape) inp = np.random.normal(0, 10., shape) out = op.dir_op(inp) forward_operator(op, inp, out) inp = np.random.normal(0, 10., out.shape) out = op.adj_op(inp) adjoint_operator(op, inp, out) buff1 = op.adj_op(op.dir_op(out)) assert np.allclose(out, buff1, 1e-6) wav = ['db1', 'db2', 'dirac'] levels = 3 shape = (128, 128) op = linear_operators.dictionary(wav, levels, shape) inp = np.random.normal(0, 10., shape) out = op.dir_op(inp) forward_operator(op, inp, out) inp = np.random.normal(0, 10., out.shape) out = op.adj_op(inp) adjoint_operator(op, inp, out) buff1 = op.adj_op(op.dir_op(out))
def test_l1_constrained(): options = { 'tol': 1e-5, 'iter': 5000, 'update_iter': 50, 'record_iters': False } ISNR = 40. sigma = 10**(-ISNR / 20.) size = 1024 epsilon = np.sqrt(size + 2. * np.sqrt(size)) * sigma x = np.linspace(0, 1 * np.pi, size) W = np.ones((size, )) y = W * x + np.random.normal(0, sigma, size) p = prox_operators.l2_ball(epsilon, y, linear_operators.diag_matrix_operator(W)) wav = ['db1', 'db4'] levels = 6 shape = (size, ) psi = linear_operators.dictionary(wav, levels, shape) h = prox_operators.l1_norm(np.max(np.abs(psi.dir_op(y))) * 1e-3, psi) h.beta = 1. f = prox_operators.real_prox() z, diag = primal_dual.FBPD(y, options, None, f, h, p) assert (np.linalg.norm(z - W * y) < epsilon * 1.05) assert (diag['max_iter'] < 500) #testing warm start z1, diag1 = primal_dual.FBPD_warm_start(z, diag['y'], diag['z'], diag['w'], options, None, f, h, p) assert (diag1['max_iter'] < diag['max_iter'])
def test_l1_unconstrained(): options = { 'tol': 1e-5, 'iter': 500, 'update_iter': 50, 'record_iters': False } ISNR = 20. sigma = 10**(-ISNR / 20.) size = 1024 epsilon = np.sqrt(size + 2. * np.sqrt(size)) * sigma x = np.linspace(0, 1 * np.pi, size) W = np.ones((size, )) y = W * x + np.random.normal(0, sigma, size) g = grad_operators.l2_norm(sigma, y, linear_operators.diag_matrix_operator(W)) wav = ['db1', 'db4'] levels = 6 shape = (size, ) psi = linear_operators.dictionary(wav, levels, shape) h = prox_operators.l1_norm(np.max(np.abs(psi.dir_op(y))) * 5e-3, psi) h.beta = 1. f = prox_operators.real_prox() z, diag = primal_dual.FBPD(y, options, g, f, h)
def uncertainty_quantification( x_sol, data, sigma, weights, wav, levels, gamma, options={ 'alpha': 0.99, "top": 1e3, "bottom": 0, "region_size": 16, "iters": 10, "tol": 1e-3 }): psi = linear_operators.dictionary(wav, levels, x_sol.shape) W = weights obj = lambda data_sol, data_mask, wav_sol, wav_mask: gamma * np.sum( np.abs(wav_sol + wav_mask)) + np.sum( np.abs(W * (data_sol + data_mask) - W * data)**2) / (2 * sigma**2) bound = obj(x_sol, 0, psi.dir_op(x_sol), 0) + float(len( np.ravel(x_sol))) + np.sqrt( float(len(np.ravel(x_sol))) * 16. * np.log(3. / options['alpha'])) print(obj(x_sol, 0, psi.dir_op(x_sol), 0)) print( np.sqrt( float(len(np.ravel(x_sol))) * 16. * np.log(3. / options['alpha']))) phi = linear_operators.identity() return map_uncertainty.create_local_credible_interval_fast( x_sol, phi, psi, options['region_size'], obj, bound, options['iters'], options['tol'], options['bottom'], options['top'])
def separation_solver( algo, image, sigma, weights, wav1=["dirac"], wav2=["fourier"], levels=6, gamma=1, beta=1e-3, options={ 'tol': 1e-5, 'iter': 5000, 'update_iter': 50, 'record_iters': False, "positivity": False }, warm_start=None, background=None, axes=None): """ Chooses algorithm and solver """ logger.info("Image shape %s", image.shape) logger.info("Using wavelets %s with %s levels", wav1, levels) logger.info("Using wavelets %s with %s levels", wav2, levels) logger.info( "Using an estimated noise level of %s (weighted image units, i.e. Jy/Beam)", sigma) psi1 = linear_operators.dictionary(wav1, levels, image.shape, axes) psi2 = linear_operators.dictionary(wav2, levels, image.shape, axes) data = image * weights starting_data = data * weights if (warm_start is not None): logger.info("Using warm start.") starting_data = warm_start if algo == algorithm.l1_constrained: logger.info("Signal separation using constrained l1 regularization") return clearskies.core.l1_constrained_separation_solver( data, starting_data, sigma, weights, psi1, psi2, gamma, beta, options) if algo == algorithm.tv_constrained: logger.info("Signal separation using constrained tv regularization") return clearskies.core.tv_constrained_separation_solver( data, starting_data, sigma, weights, psi1, gamma, beta, options)
def test_constrained(): input_file = "data/lmc.fits" x_true = open_fits(input_file) x_true = x_true[:128, :128] options = { 'tol': 1e-5, 'iter': 5000, 'update_iter': 50, 'record_iters': False, 'real': False, 'positivity': False } ISNR = 30. sigma = 10**(-ISNR / 20.) * np.sqrt( np.sum(np.abs(x_true)**2) / (x_true.shape[0] * x_true.shape[1])) width, height = x_true.shape W = np.ones(x_true.shape) y = W * x_true + np.random.normal(0, sigma, x_true.shape) wav = ["dirac", "db1", "db2", "db3", "db4", "db5", "db6", "db7", "db8"] levels = 2 psi = linear_operators.dictionary(wav, levels, y.shape, None) data = y warm_start = data z, diag = solver.solver(solver.algorithm.l1_constrained, y, sigma, W, wav, levels, 1e-2, options) z_expected, diag_expected = core.l1_constrained_solver( data, warm_start, sigma, W, psi, 1e-2, options) SNR = np.log10( np.sqrt(np.sum(np.abs(x_true)**2)) / np.sqrt(np.sum(np.abs(x_true - z)**2))) * 20. assert (SNR > ISNR) size = z.shape[0] * z.shape[1] assert (np.linalg.norm(W * z - y) < np.sqrt(size + 2 * np.sqrt(size)) * sigma * 1.1) assert (np.all(np.isclose(z, z_expected)))
size = 1024 epsilon = np.sqrt(size + 2. * np.sqrt(size)) * sigma x = np.linspace(0, 1 * np.pi, size) W = np.ones((size, )) y = W * x + np.random.normal(0, sigma, size) p = prox_operators.l2_ball(epsilon, y, linear_operators.diag_matrix_operator(W)) p.beta = 1. wav = ['db1', 'db4'] levels = 6 shape = (size, ) psi = linear_operators.dictionary(wav, levels, shape) h = prox_operators.l1_norm(np.max(np.abs(psi.dir_op(y))) * 1e-3, psi) h.beta = 1. f = prox_operators.real_prox() z, diag = primal_dual.FBPD(y, options, None, f, h, p, None) plt.plot(np.real(y)) plt.plot(np.real(x)) plt.plot(np.real(z)) plt.legend(['data', 'true', 'fit']) SNR = np.log10( np.sqrt(np.sum(np.abs(x)**2)) / np.sqrt(np.sum(np.abs(x - z)**2))) * 20. plt.title('SNR = ' + str(SNR)) plt.savefig(output_dir + '1d_constrained_example.png')
def solver( algo, image, sigma, weights, wav=["dirac"], levels=6, beta=1e-3, options={ 'tol': 1e-5, 'iter': 5000, 'update_iter': 50, 'record_iters': False, "positivity": False }, warm_start=None, background=None, axes=None): """ Chooses algorithm and solver """ logger.info("Image shape %s", image.shape) logger.info("Using wavelets %s with %s levels", wav, levels) logger.info( "Using an estimated noise level of %s (weighted image units, i.e. Jy/Beam)", sigma) psi = linear_operators.dictionary(wav, levels, image.shape, axes) data = image * weights starting_data = data * weights if (warm_start is not None): logger.info("Using warm start.") starting_data = warm_start if algo == algorithm.l1_constrained: logger.info("Denosing using constrained l1 regularization") return clearskies.core.l1_constrained_solver(data, starting_data, sigma, weights, psi, beta, options) if algo == algorithm.l1_unconstrained: logger.info("Denosing using unconstrained l1 regularization") return clearskies.core.l1_unconstrained_solver(data, starting_data, sigma, weights, psi, beta, options) if algo == algorithm.l2_unconstrained: logger.info("Denosing using unconstrained l2 regularization") return clearskies.core.l2_unconstrained_solver(data, starting_data, sigma, weights, psi, beta, options) if algo == algorithm.l1_poisson_constrained: logger.info( "Denosing using constrained l1 regularization with poisson constraint" ) logger.info( "Ignoring Sigma since noise level is determined by the data") if (background is not None): logger.info("Using background.") else: background = image * 0 return clearskies.core.l1_poissonian_constrained_solver( data, starting_data, len(np.ravel(image[image > 0])), weights, background, psi, beta, options) if algo == algorithm.l1_poisson_unconstrained: logger.info( "Denosing using unconstrained l1 regularization with poisson likelihood" ) logger.info( "Ignoring Sigma since noise level is determined by the data") if (background is not None): logger.info("Using background.") else: background = image * 0 return clearskies.core.l1_poissonian_unconstrained_solver( data, starting_data, weights, background, psi, beta, options) if algo == algorithm.tv_constrained: logger.info("Denosing using constrained tv regularization") return clearskies.core.tv_constrained_solver(data, starting_data, sigma, weights, beta, options) if algo == algorithm.tv_unconstrained: logger.info("Denosing using unconstrained tv regularization") return clearskies.core.tv_unconstrained_solver(data, starting_data, sigma, weights, beta, options) raise ValueError("Algorithm not reconginized.")