def test_douglas_rachford(self): """ Test douglas-rachford solver with L1-norm, L2-norm and dummy functions. """ y = [4, 5, 6, 7] solver = solvers.douglas_rachford() param = {'solver': solver, 'verbosity': 'NONE'} # L2-norm prox and dummy prox. f1 = functions.norm_l2(y=y) f2 = functions.dummy() ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'RTOL') self.assertEqual(ret['niter'], 35) # L2-norm prox and L1-norm prox. f1 = functions.norm_l2(y=y) f2 = functions.norm_l1(y=y) ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'RTOL') self.assertEqual(ret['niter'], 4) # Sanity checks x0 = np.zeros((4,)) solver.lambda_ = 2. self.assertRaises(ValueError, solver.pre, [f1, f2], x0) solver.lambda_ = -2. self.assertRaises(ValueError, solver.pre, [f1, f2], x0) self.assertRaises(ValueError, solver.pre, [f1, f2, f1], x0)
def test_forward_backward(self): """ Test forward-backward splitting algorithm without acceleration, and with L1-norm, L2-norm, and dummy functions. """ y = [4., 5., 6., 7.] solver = solvers.forward_backward(accel=acceleration.dummy()) param = {'solver': solver, 'rtol': 1e-6, 'verbosity': 'NONE'} # L2-norm prox and dummy gradient. f1 = functions.norm_l2(y=y) f2 = functions.dummy() ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'RTOL') self.assertEqual(ret['niter'], 35) # L1-norm prox and L2-norm gradient. f1 = functions.norm_l1(y=y, lambda_=1.0) f2 = functions.norm_l2(y=y, lambda_=0.8) ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'RTOL') self.assertEqual(ret['niter'], 4) # Sanity check f3 = functions.dummy() x0 = np.zeros((4,)) self.assertRaises(ValueError, solver.pre, [f1, f2, f3], x0)
def test_forward_backward_fista_backtracking(self): """ Test forward-backward splitting solver with fista acceleration and backtracking, solving problems with L1-norm, L2-norm, and dummy functions. """ y = [4., 5., 6., 7.] accel = acceleration.fista_backtracking() solver = solvers.forward_backward(accel=accel) param = {'solver': solver, 'rtol': 1e-6, 'verbosity': 'NONE'} # L2-norm prox and dummy gradient. f1 = functions.norm_l2(y=y) f2 = functions.dummy() ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'RTOL') self.assertEqual(ret['niter'], 60) # L1-norm prox and L2-norm gradient. f1 = functions.norm_l1(y=y, lambda_=1.0) f2 = functions.norm_l2(y=y, lambda_=0.8) ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'RTOL') self.assertEqual(ret['niter'], 3)
def test_backtracking(self): """ Test forward-backward splitting solver with backtracking, solving problems with L1-norm, L2-norm, and dummy functions. """ # Test constructor sanity a = acceleration.backtracking() self.assertRaises(ValueError, a.__init__, 2.) self.assertRaises(ValueError, a.__init__, -2.) y = [4., 5., 6., 7.] accel = acceleration.backtracking() step = 10 # Make sure backtracking is called solver = solvers.forward_backward(accel=accel, step=step) param = {'solver': solver, 'atol': 1e-32, 'verbosity': 'NONE'} # L2-norm prox and dummy gradient. f1 = functions.norm_l2(y=y) f2 = functions.dummy() ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'ATOL') self.assertEqual(ret['niter'], 13) # L1-norm prox and L2-norm gradient. f1 = functions.norm_l1(y=y, lambda_=1.0) f2 = functions.norm_l2(y=y, lambda_=0.8) ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'ATOL') self.assertLessEqual(ret['niter'], 4) # win64 takes one iteration
def test_backtracking(self): """ Test forward-backward splitting solver with backtracking, solving problems with L1-norm, L2-norm, and dummy functions. """ # Test constructor sanity a = acceleration.backtracking() self.assertRaises(ValueError, a.__init__, 2.) self.assertRaises(ValueError, a.__init__, -2.) y = [4., 5., 6., 7.] accel = acceleration.backtracking() step = 10 # Make sure backtracking is called solver = solvers.forward_backward(accel=accel, step=step) param = {'solver': solver, 'atol': 1e-32, 'verbosity': 'NONE'} # L2-norm prox and dummy gradient. f1 = functions.norm_l2(y=y) f2 = functions.dummy() ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'ATOL') self.assertEqual(ret['niter'], 13) # L1-norm prox and L2-norm gradient. f1 = functions.norm_l1(y=y, lambda_=1.0) f2 = functions.norm_l2(y=y, lambda_=0.8) ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'ATOL') self.assertEqual(ret['niter'], 4)
def test_forward_backward_fista_backtracking(self): """ Test forward-backward splitting solver with fista acceleration and backtracking, solving problems with L1-norm, L2-norm, and dummy functions. """ y = [4., 5., 6., 7.] accel = acceleration.fista_backtracking() solver = solvers.forward_backward(accel=accel) param = {'solver': solver, 'rtol': 1e-6, 'verbosity': 'NONE'} # L2-norm prox and dummy gradient. f1 = functions.norm_l2(y=y) f2 = functions.dummy() ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'RTOL') self.assertEqual(ret['niter'], 60) # L1-norm prox and L2-norm gradient. f1 = functions.norm_l1(y=y, lambda_=1.0) f2 = functions.norm_l2(y=y, lambda_=0.8) ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'RTOL') self.assertEqual(ret['niter'], 3)
def test_forward_backward(self): """ Test forward-backward splitting algorithm without acceleration, and with L1-norm, L2-norm, and dummy functions. """ y = [4., 5., 6., 7.] solver = solvers.forward_backward(accel=acceleration.dummy()) param = {'solver': solver, 'rtol': 1e-6, 'verbosity': 'NONE'} # L2-norm prox and dummy gradient. f1 = functions.norm_l2(y=y) f2 = functions.dummy() ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'RTOL') self.assertEqual(ret['niter'], 35) # L1-norm prox and L2-norm gradient. f1 = functions.norm_l1(y=y, lambda_=1.0) f2 = functions.norm_l2(y=y, lambda_=0.8) ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'RTOL') self.assertEqual(ret['niter'], 4) # Sanity check f3 = functions.dummy() x0 = np.zeros((4, )) self.assertRaises(ValueError, solver.pre, [f1, f2, f3], x0)
def test_douglas_rachford(self): """ Test douglas-rachford solver with L1-norm, L2-norm and dummy functions. """ y = [4, 5, 6, 7] solver = solvers.douglas_rachford() param = {'solver': solver, 'verbosity': 'NONE'} # L2-norm prox and dummy prox. f1 = functions.norm_l2(y=y) f2 = functions.dummy() ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'RTOL') self.assertEqual(ret['niter'], 35) # L2-norm prox and L1-norm prox. f1 = functions.norm_l2(y=y) f2 = functions.norm_l1(y=y) ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'RTOL') self.assertEqual(ret['niter'], 4) # Sanity checks x0 = np.zeros((4, )) solver.lambda_ = 2. self.assertRaises(ValueError, solver.pre, [f1, f2], x0) solver.lambda_ = -2. self.assertRaises(ValueError, solver.pre, [f1, f2], x0) self.assertRaises(ValueError, solver.pre, [f1, f2, f1], x0)
def test_mlfbf(self): """ Test the MLFBF solver with arbitrarily selected functions. """ x = [1., 1., 1.] L = np.array([[5, 9, 3], [7, 8, 5], [4, 4, 9], [0, 1, 7]]) max_step = 1 / (1 + np.linalg.norm(L, 2)) solver = solvers.mlfbf(L=L, step=max_step / 2.) params = {'solver': solver, 'verbosity': 'NONE'} def x0(): return np.zeros(len(x)) # L2-norm prox and dummy prox. f = functions.dummy() f._prox = lambda x, T: np.maximum(np.zeros(len(x)), x) g = functions.norm_l2(lambda_=0.5) h = functions.norm_l2(y=np.array([294, 390, 361]), lambda_=0.5) ret = solvers.solve([f, g, h], x0(), maxit=1000, rtol=0, **params) nptest.assert_allclose(ret['sol'], x, rtol=1e-5) # Same test, but with callable L solver = solvers.mlfbf(L=lambda x: np.dot(L, x), Lt=lambda y: np.dot(L.T, y), d0=np.dot(L, x0()), step=max_step / 2.) ret = solvers.solve([f, g, h], x0(), maxit=1000, rtol=0, **params) nptest.assert_allclose(ret['sol'], x, rtol=1e-5) # Sanity check self.assertRaises(ValueError, solver.pre, [f, g], x0())
def test_mlfbf(self): """ Test the MLFBF solver with arbitrarily selected functions. """ x = [1., 1., 1.] L = np.array([[5, 9, 3], [7, 8, 5], [4, 4, 9], [0, 1, 7]]) max_step = 1 / (1 + np.linalg.norm(L, 2)) solver = solvers.mlfbf(L=L, step=max_step / 2.) params = {'solver': solver, 'verbosity': 'NONE'} def x0(): return np.zeros(len(x)) # L2-norm prox and dummy prox. f = functions.dummy() f._prox = lambda x, T: np.maximum(np.zeros(len(x)), x) g = functions.norm_l2(lambda_=0.5) h = functions.norm_l2(y=np.array([294, 390, 361]), lambda_=0.5) ret = solvers.solve([f, g, h], x0(), maxit=1000, rtol=0, **params) nptest.assert_allclose(ret['sol'], x, rtol=1e-5) # Same test, but with callable L solver = solvers.mlfbf(L=lambda x: np.dot(L, x), Lt=lambda y: np.dot(L.T, y), d0=np.dot(L, x0()), step=max_step / 2.) ret = solvers.solve([f, g, h], x0(), maxit=1000, rtol=0, **params) nptest.assert_allclose(ret['sol'], x, rtol=1e-5) # Sanity check self.assertRaises(ValueError, solver.pre, [f, g], x0())
def test_norm_l2(self): """ Test the norm_l2 derived class. We test the three methods : eval, grad and prox. First with default class properties, then custom ones. """ f = functions.norm_l2(lambda_=3) self.assertEqual(f.eval([10, 0]), 300) self.assertEqual(f.eval(np.array([-10, 0])), 300) nptest.assert_allclose(f.grad([10, 0]), [60, 0]) nptest.assert_allclose(f.grad([-10, 0]), [-60, 0]) self.assertEqual(f.eval([3, 4]), 3 * 5**2) self.assertEqual(f.eval(np.array([-3, 4])), 3 * 5**2) nptest.assert_allclose(f.grad([3, 4]), [18, 24]) nptest.assert_allclose(f.grad([3, -4]), [18, -24]) self.assertEqual(f.prox(0, 1), 0) self.assertEqual(f.prox(7, 1. / 6), 3.5) f = functions.norm_l2(lambda_=4) nptest.assert_allclose(f.prox([7, -22], .125), [3.5, -11]) f = functions.norm_l2(lambda_=1, A=lambda x: 2 * x, At=lambda x: x / 2, y=[8, 12]) self.assertEqual(f.eval([4, 6]), 0) self.assertEqual(f.eval([5, -2]), 256 + 4) nptest.assert_allclose(f.grad([4, 6]), 0) # nptest.assert_allclose(f.grad([5, -2]), [8, -64]) nptest.assert_allclose(f.prox([4, 6], 1), [4, 6]) f = functions.norm_l2(lambda_=2, y=np.fft.fft([2, 4]) / np.sqrt(2), A=lambda x: np.fft.fft(x) / np.sqrt(x.size), At=lambda x: np.fft.ifft(x) * np.sqrt(x.size)) # self.assertEqual(f.eval(np.fft.ifft([2, 4])*np.sqrt(2)), 0) # self.assertEqual(f.eval([3, 5]), 2*np.sqrt(25+81)) nptest.assert_allclose(f.grad([2, 4]), 0) # nptest.assert_allclose(f.grad([3, 5]), [4*np.sqrt(5), 4*3]) nptest.assert_allclose(f.prox([2, 4], 1), [2, 4]) nptest.assert_allclose(f.prox([3, 5], 1), [2.2, 4.2]) nptest.assert_allclose(f.prox([2.2, 4.2], 1), [2.04, 4.04]) nptest.assert_allclose(f.prox([2.04, 4.04], 1), [2.008, 4.008]) # Test prox for non-tight matrices A L = np.array([[8, 1, 10], [1, 9, 1], [3, 7, 5], [1, 4, 4]]) f = functions.norm_l2(A=L, tight=False, y=np.array([1, 2, 3, 4]), w=np.array([1, 1, 0.5, 0.75])) nptest.assert_allclose(f.eval([1, 1, 1]), 455.0625) nptest.assert_allclose(f.grad([1, 1, 1]), [329.625, 262.500, 430.500], rtol=1e-3) nptest.assert_allclose(f.prox([1, 1, 1], 1), [-0.887, 0.252, 0.798], rtol=1e-3) nptest.assert_allclose(f.prox([6, 7, 3], 1), [-0.345, 0.298, 0.388], rtol=1e-3) nptest.assert_allclose(f.prox([10, 0, -5], 1), [1.103, 0.319, -0.732], rtol=1e-3)
def test_regularized_nonlinear(self): """ Test gradient descent solver with regularized non-linear acceleration, solving problems with L2-norm functions. """ dim = 25 np.random.seed(0) x0 = np.random.rand(dim) xstar = np.random.rand(dim) x0 = xstar + 5. * (x0 - xstar) / np.linalg.norm(x0 - xstar) A = np.random.rand(dim, dim) step = 1 / np.linalg.norm(np.dot(A.T, A)) accel = acceleration.regularized_nonlinear(k=5) solver = solvers.gradient_descent(step=step, accel=accel) param = { 'solver': solver, 'rtol': 0, 'maxit': 200, 'verbosity': 'NONE' } # L2-norm prox and dummy gradient. f1 = functions.norm_l2(lambda_=0.5, A=A, y=np.dot(A, xstar)) f2 = functions.dummy() ret = solvers.solve([f1, f2], x0, **param) pctdiff = 100 * np.sum((xstar - ret['sol'])**2) / np.sum(xstar**2) nptest.assert_array_less(pctdiff, 1.91) # Sanity checks accel = acceleration.regularized_nonlinear() self.assertRaises(ValueError, accel.__init__, 10, ['not', 'good']) self.assertRaises(ValueError, accel.__init__, 10, 'nope')
def test_solver_comparison(self): """ Test that all solvers return the same and correct solution. """ # Convex functions. y = [1, 0, 0.1, 8, -6.5, 0.2, 0.004, 0.01] sol = [0.75, 0, 0, 7.75, -6.25, 0, 0, 0] w1, w2 = .8, .4 f1 = functions.norm_l2(y=y, lambda_=w1 / 2.) # Smooth. f2 = functions.norm_l1(lambda_=w2 / 2.) # Non-smooth. # Solvers. L = w1 # Lipschitz continuous gradient. step = 1. / L lambda_ = 0.5 params = {'step': step, 'lambda_': lambda_} slvs = [] slvs.append( solvers.forward_backward(accel=acceleration.dummy(), step=step)) slvs.append(solvers.douglas_rachford(**params)) slvs.append(solvers.generalized_forward_backward(**params)) # Compare solutions. params = {'rtol': 1e-14, 'verbosity': 'NONE', 'maxit': 1e4} niters = [2, 61, 26] for solver, niter in zip(slvs, niters): x0 = np.zeros(len(y)) ret = solvers.solve([f1, f2], x0, solver, **params) nptest.assert_allclose(ret['sol'], sol) self.assertEqual(ret['niter'], niter) self.assertIs(ret['sol'], x0) # The initial value was modified.
def test_acceleration_comparison(self): """ Test that all solvers return the same and correct solution. """ # Convex functions. y = [1, 0, 0.1, 8, -6.5, 0.2, 0.004, 0.01] sol = [0.75, 0, 0, 7.75, -6.25, 0, 0, 0] w1, w2 = .8, .4 f1 = functions.norm_l2(y=y, lambda_=w1 / 2.) # Smooth. f2 = functions.norm_l1(lambda_=w2 / 2.) # Non-smooth. # Solvers. L = w1 # Lipschitz continuous gradient. step = 1. / L slvs = [] slvs.append( solvers.forward_backward(accel=acceleration.dummy(), step=step)) slvs.append( solvers.forward_backward(accel=acceleration.fista(), step=step)) slvs.append( solvers.forward_backward( accel=acceleration.fista_backtracking(eta=.999), step=step)) # Compare solutions. params = {'rtol': 1e-14, 'verbosity': 'NONE', 'maxit': 1e4} niters = [2, 2, 6] for solver, niter in zip(slvs, niters): x0 = np.zeros(len(y)) ret = solvers.solve([f1, f2], x0, solver, **params) nptest.assert_allclose(ret['sol'], sol) self.assertEqual(ret['niter'], niter)
def test_acceleration_comparison(self): """ Test that all solvers return the same and correct solution. """ # Convex functions. y = [1, 0, 0.1, 8, -6.5, 0.2, 0.004, 0.01] sol = [0.75, 0, 0, 7.75, -6.25, 0, 0, 0] w1, w2 = .8, .4 f1 = functions.norm_l2(y=y, lambda_=w1 / 2.) # Smooth. f2 = functions.norm_l1(lambda_=w2 / 2.) # Non-smooth. # Solvers. L = w1 # Lipschitz continuous gradient. step = 1. / L slvs = [] slvs.append(solvers.forward_backward(accel=acceleration.dummy(), step=step)) slvs.append(solvers.forward_backward(accel=acceleration.fista(), step=step)) slvs.append(solvers.forward_backward( accel=acceleration.fista_backtracking(eta=.999), step=step)) # Compare solutions. params = {'rtol': 1e-14, 'verbosity': 'NONE', 'maxit': 1e4} niters = [2, 2, 6] for solver, niter in zip(slvs, niters): x0 = np.zeros(len(y)) ret = solvers.solve([f1, f2], x0, solver, **params) nptest.assert_allclose(ret['sol'], sol) self.assertEqual(ret['niter'], niter)
def test_solver_comparison(self): """ Test that all solvers return the same and correct solution. """ # Convex functions. y = [1, 0, 0.1, 8, -6.5, 0.2, 0.004, 0.01] sol = [0.75, 0, 0, 7.75, -6.25, 0, 0, 0] w1, w2 = .8, .4 f1 = functions.norm_l2(y=y, lambda_=w1 / 2.) # Smooth. f2 = functions.norm_l1(lambda_=w2 / 2.) # Non-smooth. # Solvers. L = w1 # Lipschitz continuous gradient. step = 1. / L lambda_ = 0.5 params = {'step': step, 'lambda_': lambda_} slvs = [] slvs.append(solvers.forward_backward(accel=acceleration.dummy(), step=step)) slvs.append(solvers.douglas_rachford(**params)) slvs.append(solvers.generalized_forward_backward(**params)) # Compare solutions. params = {'rtol': 1e-14, 'verbosity': 'NONE', 'maxit': 1e4} niters = [2, 61, 26] for solver, niter in zip(slvs, niters): x0 = np.zeros(len(y)) ret = solvers.solve([f1, f2], x0, solver, **params) nptest.assert_allclose(ret['sol'], sol) self.assertEqual(ret['niter'], niter) self.assertIs(ret['sol'], x0) # The initial value was modified.
def test_regularized_nonlinear(self): """ Test gradient descent solver with regularized non-linear acceleration, solving problems with L2-norm functions. """ dim = 25 np.random.seed(0) x0 = np.random.rand(dim) xstar = np.random.rand(dim) x0 = xstar + 5. * (x0 - xstar) / np.linalg.norm(x0 - xstar) A = np.random.rand(dim, dim) step = 1 / np.linalg.norm(np.dot(A.T, A)) accel = acceleration.regularized_nonlinear(k=5) solver = solvers.gradient_descent(step=step, accel=accel) param = {'solver': solver, 'rtol': 0, 'maxit': 200, 'verbosity': 'NONE'} # L2-norm prox and dummy gradient. f1 = functions.norm_l2(lambda_=0.5, A=A, y=np.dot(A, xstar)) f2 = functions.dummy() ret = solvers.solve([f1, f2], x0, **param) pctdiff = 100 * np.sum((xstar - ret['sol'])**2) / np.sum(xstar**2) nptest.assert_array_less(pctdiff, 1.91) # Sanity checks accel = acceleration.regularized_nonlinear() self.assertRaises(ValueError, accel.__init__, 10, ['not', 'good']) self.assertRaises(ValueError, accel.__init__, 10, 'nope')
def test_gradient_descent(self): """ Test gradient descent solver with l2-norms in the objective. """ y = [4., 5., 6., 7.] A = np.array([[1., 1., 1., 0.], [0., 1., 1., 1.], [0., 1., 0., 0.], [1., 0., 0., 1.]]) sol = np.array([0.28846154, 0.11538462, 1.23076923, 1.78846154]) step = 0.5 / (np.linalg.norm(A) + 1.) solver = solvers.gradient_descent(step=step) param = {'solver': solver, 'rtol': 0, 'verbosity': 'NONE'} f1 = functions.norm_l2(y=y) f2 = functions.norm_l2(A=A) ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], sol) self.assertEqual(ret['crit'], 'MAXIT') self.assertEqual(ret['niter'], 200)
def test_gradient_descent(self): """ Test gradient descent solver with l2-norms in the objective. """ y = [4., 5., 6., 7.] A = np.array([[1., 1., 1., 0.], [0., 1., 1., 1.], [0., 1., 0., 0.], [1., 0., 0., 1.]]) sol = np.array([0.28846154, 0.11538462, 1.23076923, 1.78846154]) step = 0.5 / (np.linalg.norm(A) + 1.) solver = solvers.gradient_descent(step=step) param = {'solver': solver, 'rtol': 0, 'verbosity': 'NONE'} f1 = functions.norm_l2(y=y) f2 = functions.norm_l2(A=A) ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], sol) self.assertEqual(ret['crit'], 'MAXIT') self.assertEqual(ret['niter'], 200)
def test_primal_dual_solver_comparison(self): """ Test that all primal-dual solvers return the same and correct solution. I had to create this separate function because the primal-dual solvers were too slow for the problem above. """ # Convex functions. y = np.random.randn(3) L = np.random.randn(4, 3) sol = y y2 = L.dot(y) f1 = functions.norm_l1(y=y) f2 = functions.norm_l2(y=y2) f3 = functions.dummy() # Solvers. step = 0.5 / (1 + np.linalg.norm(L, 2)) slvs = [] slvs.append(solvers.mlfbf(step=step, L=L)) slvs.append(solvers.projection_based(step=step, L=L)) # Compare solutions. niter = 1000 params = {'rtol': 0, 'verbosity': 'NONE', 'maxit': niter} for solver in slvs: x0 = np.zeros(len(y)) if type(solver) is solvers.mlfbf: ret = solvers.solve([f1, f2, f3], x0, solver, **params) else: ret = solvers.solve([f1, f2], x0, solver, **params) nptest.assert_allclose(ret['sol'], sol) self.assertEqual(ret['niter'], niter) # The initial value was not modified. nptest.assert_array_equal(x0, np.zeros(len(y))) if type(solver) is solvers.mlfbf: ret = solvers.solve([f1, f2, f3], x0, solver, inplace=True, **params) else: ret = solvers.solve([f1, f2], x0, solver, inplace=True, **params) # The initial value was modified. self.assertIs(ret['sol'], x0) nptest.assert_allclose(ret['sol'], sol)
def test_generalized_forward_backward(self): """ Test the generalized forward-backward algorithm. """ y = [4, 5, 6, 7] L = 4 # Gradient of the smooth function is Lipschitz continuous. solver = solvers.generalized_forward_backward(step=.9 / L, lambda_=.8) params = {'solver': solver, 'verbosity': 'NONE'} # Functions. f1 = functions.norm_l1(y=y, lambda_=.7) # Non-smooth. f2 = functions.norm_l2(y=y, lambda_=L / 2.) # Smooth. # Solve with 1 smooth and 1 non-smooth. ret = solvers.solve([f1, f2], np.zeros(len(y)), **params) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['niter'], 25) # Solve with 1 smooth. ret = solvers.solve([f1], np.zeros(len(y)), **params) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['niter'], 77) # Solve with 1 non-smooth. ret = solvers.solve([f2], np.zeros(len(y)), **params) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['niter'], 18) # Solve with 1 smooth and 2 non-smooth. ret = solvers.solve([f1, f2, f2], np.zeros(len(y)), **params) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['niter'], 26) # Solve with 2 smooth and 2 non-smooth. ret = solvers.solve([f2, f1, f2, f1], np.zeros(len(y)), **params) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['niter'], 25) # Sanity checks x0 = np.zeros((4,)) solver.lambda_ = 2. self.assertRaises(ValueError, solver.pre, [f1, f2], x0) solver.lambda_ = -2. self.assertRaises(ValueError, solver.pre, [f1, f2], x0) f1 = functions.func() f2 = functions.func() f3 = functions.func() solver.lambda_ = 1. self.assertRaises(ValueError, solver.pre, [f1, f2, f3], x0)
def test_generalized_forward_backward(self): """ Test the generalized forward-backward algorithm. """ y = [4, 5, 6, 7] L = 4 # Gradient of the smooth function is Lipschitz continuous. solver = solvers.generalized_forward_backward(step=.9 / L, lambda_=.8) params = {'solver': solver, 'verbosity': 'NONE'} # Functions. f1 = functions.norm_l1(y=y, lambda_=.7) # Non-smooth. f2 = functions.norm_l2(y=y, lambda_=L / 2.) # Smooth. # Solve with 1 smooth and 1 non-smooth. ret = solvers.solve([f1, f2], np.zeros(len(y)), **params) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['niter'], 25) # Solve with 1 smooth. ret = solvers.solve([f1], np.zeros(len(y)), **params) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['niter'], 77) # Solve with 1 non-smooth. ret = solvers.solve([f2], np.zeros(len(y)), **params) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['niter'], 18) # Solve with 1 smooth and 2 non-smooth. ret = solvers.solve([f1, f2, f2], np.zeros(len(y)), **params) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['niter'], 26) # Solve with 2 smooth and 2 non-smooth. ret = solvers.solve([f2, f1, f2, f1], np.zeros(len(y)), **params) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['niter'], 25) # Sanity checks x0 = np.zeros((4, )) solver.lambda_ = 2. self.assertRaises(ValueError, solver.pre, [f1, f2], x0) solver.lambda_ = -2. self.assertRaises(ValueError, solver.pre, [f1, f2], x0) f1 = functions.func() f2 = functions.func() f3 = functions.func() solver.lambda_ = 1. self.assertRaises(ValueError, solver.pre, [f1, f2, f3], x0)
def lasso(A, b, err, nvis, nt3phi, l, maxit): from pyunlocbox import functions from pyunlocbox import solvers x = np.zeros(A.shape[1]) x = x.reshape(-1, 1) for ty in range(A.shape[1]): A[nvis:, ty] = np.rad2deg(np.arctan(np.tan(np.deg2rad(A[nvis:, ty])))) b[nvis:, 0] = np.rad2deg(np.arctan(np.tan(np.deg2rad(b[nvis:, 0])))) f1 = functions.norm_l1(lambda_=l) f2 = functions.norm_l2(y=b, A=A) step = 0.5 / np.linalg.norm(A, ord=2)**2 solver = solvers.forward_backward(step=step) ret = solvers.solve([f1, f2], x, solver, rtol=1e-6, maxit=maxit) return ret
def solve_lasso(A_val, y_val, hparams): #(n,m), (1,m) if hparams.lasso_solver == 'sklearn': lasso_est = Lasso(alpha=hparams.lmbd) lasso_est.fit(A_val.T, y_val.reshape(hparams.num_measurements)) x_hat = lasso_est.coef_ x_hat = np.reshape(x_hat, [-1]) elif hparams.lasso_solver == 'cvxopt': A_mat = matrix(A_val.T) #[m,n] y_mat = matrix(y_val.T) ### x_hat_mat = l1regls(A_mat, y_mat) x_hat = np.asarray(x_hat_mat) x_hat = np.reshape(x_hat, [-1]) #[n, ] elif hparams.lasso_solver == 'pyunlocbox': tau = hparams.tau f1 = functions.norm_l1(lambda_=tau) f2 = functions.norm_l2(y=y_val.T, A=A_val.T) if hparams.model_type == 'compressing': if hparams.image_mode == '3D': A_real = np.random.normal( size=(int(hparams.num_measurements / 3), sig_shape)) else: A_real = np.random.normal( size=(hparams.num_measurements, sig_shape)) step = 0.5 / np.linalg.norm(A_real, ord=2)**2 else: step = 0.5 / np.linalg.norm(A_val, ord=2)**2 solver = solvers.forward_backward(step=step) x0 = np.zeros((sig_shape, 1)) ret = solvers.solve([f1, f2], x0, solver, rtol=1e-4, maxit=3000) x_hat_mat = ret['sol'] x_hat = np.asarray(x_hat_mat) x_hat = np.reshape(x_hat, [-1]) #[n, ] return x_hat
def main_tv(hparams): ## === Set up=== ## # Printer setup #sys.stdout = open(hparams.text_file_path, 'w') # Get inputs if hparams.image_mode == '1D': x_real = np.array(load_1D(hparams.path, hparams.img_name)).astype( np.float32) #[4096,1] elif hparams.image_mode == '2D': x_real = np.array(load_2D(hparams.path, hparams.img_name)).astype( np.float32) #[64,64] elif hparams.image_mode == '3D': x_real = np.array( load_img(hparams.path, hparams.img_name, hparams.decoder_type)).astype( np.float32) #[178,218,3] / [224,224,3] # Initialization #np.random.seed(7) sig_shape = x_real.shape[0] * x_real.shape[ 1] #n = 4096*1 or 64*64 or 178*218 or 224*224 random_vector = None #initialization A = None #initialization selection_mask = None #initialization random_arr = random_flip(sig_shape) #initialization #[n,] mask = None #initialization # Get measurement matirx if hparams.model_type == 'denoising' or hparams.model_type == 'compressing': if hparams.type_measurements == 'random': #compressed sensing if hparams.image_mode != '3D': A = np.random.randn(hparams.num_measurements, sig_shape).astype(np.float32) #[m,n] noise_shape = [hparams.num_measurements, 1] #[m,1] else: A = np.random.randn(int(hparams.num_measurements / 3), sig_shape).astype(np.float32) #[m,n] noise_shape = [int(hparams.num_measurements / 3), 1] #[m,1] elif hparams.type_measurements == 'identity': #denoising A = np.identity(sig_shape).astype(np.float32) #[n,n] noise_shape = [sig_shape, 1] #[n,1] observ_noise = hparams.noise_level * np.random.randn( noise_shape[0], noise_shape[1]) #[n,1] elif hparams.type_measurements == 'circulant': #compressed sensing if hparams.image_mode != '3D': random_vector = np.random.normal(size=sig_shape) #[n,] selection_mask = create_A_selection( sig_shape, hparams.num_measurements) #[1,n] else: random_vector = np.random.normal(size=sig_shape) #[n,] selection_mask = create_A_selection( sig_shape, int(hparams.num_measurements / 3)) #[1,n] def circulant_np(signal_vector, random_arr_p=random_arr.reshape(-1, 1), random_vector_p=random_vector.reshape(-1, 1), selection_mask_p=selection_mask.reshape(-1, 1)): #step 0: Flip signal_vector = signal_vector * random_arr_p #[n,1] * [n,1] -> [n,1] #step 1: F^{-1} @ x r1 = ifft(signal_vector) #[n,1] #step 2: Diag() @ F^{-1} @ x Ft = fft(random_vector_p) #[n,1] r2 = np.multiply(r1, Ft) #[n,1] * [n,1] -> [n,1] #step 3: F @ Diag() @ F^{-1} @ x compressive = fft(r2) #[n,1] #step 4: R_{omega} @ C_{t} @ D){epsilon} compressive = compressive.real #[n,1] select_compressive = compressive * selection_mask_p #[n,1] * [n,1] -> [n,1] return select_compressive elif hparams.model_type == 'inpainting': if hparams.image_mode == '1D': mask = load_mask('Masks', hparams.mask_name_1D, hparams.image_mode, hparams.decoder_type) #[n,1] elif hparams.image_mode == '2D' or hparams.image_mode == '3D': mask = load_mask('Masks', hparams.mask_name_2D, hparams.image_mode, hparams.decoder_type) #[n,n] ## === TV norm === ## if hparams.decoder_type == 'tv_norm': # Construct observation and perform reconstruction if hparams.model_type == 'inpainting': # measurements and observation g = lambda x: mask * x #[4096,1] * [4096,1] / [178,218,3] * [178,218,3] y_real = g(x_real) #[4096,1] / [178,218,3] # tv norm if hparams.image_mode == '1D': f1 = functions.norm_tv(dim=1) elif hparams.image_mode == '2D': f1 = functions.norm_tv(dim=2) elif hparams.image_mode == '3D': f1 = functions.norm_tv(dim=3) # L2 norm tau = hparams.tau f2 = functions.norm_l2(y=y_real, A=g, lambda_=tau) # optimisation solver = solvers.forward_backward(step=0.5 / tau) x0 = np.array(y_real) # Make a copy to preserve im_masked. ret = solvers.solve([f1, f2], x0, solver, maxit=3000) #output = ret['sol'] # output out_img = ret['sol'] #[4096,1] / [178,218,3] elif hparams.model_type == 'denoising': assert hparams.type_measurements == 'identity' if hparams.image_mode == '3D': out_img_list = [] for i in range(x_real.shape[-1]): # measurements and observation y_real = np.matmul(A, x_real[:, :, i].reshape( -1, 1)) + observ_noise # [n,n] * [n,1] -> [n,1] # tv norm f1 = functions.norm_tv(dim=1) # epsilon N = math.sqrt(sig_shape) epsilon = N * hparams.noise_level # L2 ball y = np.reshape(y_real, -1) #[n,1] -> [n,] f = functions.proj_b2(y=y, epsilon=epsilon) f2 = functions.func() # Indicator functions f2._eval = lambda x: 0 def prox(x, step): return np.reshape(f.prox(np.reshape(x, -1), 0), y_real.shape) f2._prox = prox # solver solver = solvers.douglas_rachford(step=0.1) x0 = np.array(y_real) #[n,1] ret = solvers.solve([f1, f2], x0, solver) # output out_img_piece = ret['sol'].reshape( x_real.shape[0], x_real.shape[1]) #[178,218] out_img_list.append(out_img_piece) out_img = np.transpose(np.array(out_img_list), (1, 2, 0)) else: # measurements and observation y_real = np.matmul(A, x_real.reshape( -1, 1)) + observ_noise # [n,n] * [n,1] -> [n,1] # tv norm f1 = functions.norm_tv(dim=1) # epsilon N = math.sqrt(sig_shape) epsilon = N * hparams.noise_level # L2 ball y = np.reshape(y_real, -1) #[n,1] -> [n,] f = functions.proj_b2(y=y, epsilon=epsilon) f2 = functions.func() # Indicator functions f2._eval = lambda x: 0 def prox(x, step): return np.reshape(f.prox(np.reshape(x, -1), 0), y_real.shape) f2._prox = prox # solver solver = solvers.douglas_rachford(step=0.1) x0 = np.array(y_real) #[n,1] ret = solvers.solve([f1, f2], x0, solver) # output out_img = ret['sol'] #[n,1] elif hparams.model_type == 'compressing': assert hparams.type_measurements == 'circulant' if hparams.image_mode == '3D': out_img_list = [] for i in range(x_real.shape[-1]): # construct observation g = circulant_np y_real = g(x_real[:, :, i].reshape(-1, 1)) #[n,1] -> [n,1] # tv norm f1 = functions.norm_tv(dim=1) # L2 norm tau = hparams.tau f2 = functions.norm_l2(y=y_real, A=g, lambda_=tau) # optimisation solver A_real = np.random.normal( size=(int(hparams.num_measurements / 3), sig_shape)) step = 0.5 / np.linalg.norm(A_real, ord=2)**2 solver = solvers.forward_backward( step=step ) #solver = solvers.forward_backward(step=0.5/tau) # initialisation x0 = np.array(y_real) #[n,1] # output ret = solvers.solve([f1, f2], x0, solver, rtol=1e-4, maxit=3000) #output = ret['sol'] out_img_piece = ret['sol'].reshape( x_real.shape[0], x_real.shape[1]) #[178,218] out_img_list.append(out_img_piece) out_img = np.transpose(np.array(out_img_list), (1, 2, 0)) else: # construct observation g = circulant_np y_real = g(x_real.reshape(-1, 1)) #[n,1] -> [n,1] # tv norm f1 = functions.norm_tv(dim=1) # L2 norm tau = hparams.tau f2 = functions.norm_l2(y=y_real, A=g, lambda_=tau) # optimisation solver A_real = np.random.normal(size=(hparams.num_measurements, sig_shape)) step = 0.5 / np.linalg.norm(A_real, ord=2)**2 solver = solvers.forward_backward( step=step ) #solver = solvers.forward_backward(step=0.5/tau) # initialisation x0 = np.array(y_real) #[n,1] # output ret = solvers.solve([f1, f2], x0, solver, rtol=1e-4, maxit=3000) #output = ret['sol'] out_img = ret['sol'] #[n,1] # ## === Lasso wavelet === ## elif hparams.decoder_type == 'lasso_wavelet': # Construct lasso wavelet functions def solve_lasso(A_val, y_val, hparams): #(n,m), (1,m) if hparams.lasso_solver == 'sklearn': lasso_est = Lasso(alpha=hparams.lmbd) lasso_est.fit(A_val.T, y_val.reshape(hparams.num_measurements)) x_hat = lasso_est.coef_ x_hat = np.reshape(x_hat, [-1]) elif hparams.lasso_solver == 'cvxopt': A_mat = matrix(A_val.T) #[m,n] y_mat = matrix(y_val.T) ### x_hat_mat = l1regls(A_mat, y_mat) x_hat = np.asarray(x_hat_mat) x_hat = np.reshape(x_hat, [-1]) #[n, ] elif hparams.lasso_solver == 'pyunlocbox': tau = hparams.tau f1 = functions.norm_l1(lambda_=tau) f2 = functions.norm_l2(y=y_val.T, A=A_val.T) if hparams.model_type == 'compressing': if hparams.image_mode == '3D': A_real = np.random.normal( size=(int(hparams.num_measurements / 3), sig_shape)) else: A_real = np.random.normal( size=(hparams.num_measurements, sig_shape)) step = 0.5 / np.linalg.norm(A_real, ord=2)**2 else: step = 0.5 / np.linalg.norm(A_val, ord=2)**2 solver = solvers.forward_backward(step=step) x0 = np.zeros((sig_shape, 1)) ret = solvers.solve([f1, f2], x0, solver, rtol=1e-4, maxit=3000) x_hat_mat = ret['sol'] x_hat = np.asarray(x_hat_mat) x_hat = np.reshape(x_hat, [-1]) #[n, ] return x_hat #generate basis def generate_basis(size): """generate the basis""" x = np.zeros((size, size)) coefs = pywt.wavedec2(x, 'db1') n_levels = len(coefs) basis = [] for i in range(n_levels): coefs[i] = list(coefs[i]) n_filters = len(coefs[i]) for j in range(n_filters): for m in range(coefs[i][j].shape[0]): try: for n in range(coefs[i][j].shape[1]): coefs[i][j][m][n] = 1 temp_basis = pywt.waverec2(coefs, 'db1') basis.append(temp_basis) coefs[i][j][m][n] = 0 except IndexError: coefs[i][j][m] = 1 temp_basis = pywt.waverec2(coefs, 'db1') basis.append(temp_basis) coefs[i][j][m] = 0 basis = np.array(basis) return basis def wavelet_basis(path_): if path_ == 'Ieeg_signal': W_ = generate_basis(32) W_ = W_.reshape((1024, 1024)) elif path_ == 'Celeb_signal': W_ = generate_basis(128) W_ = W_.reshape((16384, 16384)) else: W_ = generate_basis(64) W_ = W_.reshape((4096, 4096)) return W_ def lasso_wavelet_estimator(A_val, y_val, hparams): #(n,m), (1,m) W = wavelet_basis(hparams.path) #[n,n] if not callable(A_val): WA = np.dot(W, A_val) #[n,n] * [n,m] = [n,m] else: WA = np.array([ A_val(W[i, :].reshape(-1, 1)).reshape(-1) for i in range(len(W)) ]) #[n,n] -> [n,n] z_hat = solve_lasso(WA, y_val, hparams) # [n, ] x_hat = np.dot(z_hat, W) #[n, ] * [n,n] = [n, ] x_hat_max = np.abs(x_hat).max() x_hat = x_hat / (1.0 * x_hat_max) return x_hat # Construct inpainting masks def get_A_inpaint(mask_p): mask = mask_p.reshape(1, -1) A = np.eye(np.prod(mask.shape)) * np.tile(mask, [np.prod(mask.shape), 1]) A = np.asarray([a for a in A if np.sum(a) != 0]) A = np.sqrt( sig_shape ) * A # Make sure that the norm of each row of A is sig_shape assert all(np.abs(np.sum(A**2, 1) - sig_shape) < 1e-6) return A.T # Perofrm reconstruction if hparams.model_type == 'inpainting': # measurements and observation A_val = get_A_inpaint(mask) #(n,m) if hparams.image_mode == '3D': out_img_list = [] for i in range(x_real.shape[-1]): y_real = np.matmul(x_real[:, :, i].reshape(1, -1), A_val) #(1,m) out_img_piece = lasso_wavelet_estimator( A_val, y_real, hparams) out_img_piece = out_img_piece.reshape( x_real.shape[0], x_real.shape[1]) out_img_list.append(out_img_piece) out_img = np.transpose(np.array(out_img_list), (1, 2, 0)) elif hparams.image_mode == '1D': y_real = np.matmul(x_real.reshape(1, -1), A_val) #(1,m) out_img = lasso_wavelet_estimator(A_val, y_real, hparams) out_img = out_img.reshape(-1, 1) elif hparams.model_type == 'denoising': assert hparams.type_measurements == 'identity' A_val = A #(n,n) if hparams.image_mode == '3D': out_img_list = [] for i in range(x_real.shape[-1]): y_real = x_real[:, :, i].reshape(1, -1) + observ_noise.T out_img_piece = lasso_wavelet_estimator( A_val, y_real, hparams) out_img_piece = out_img_piece.reshape( x_real.shape[0], x_real.shape[1]) out_img_list.append(out_img_piece) out_img = np.transpose(np.array(out_img_list), (1, 2, 0)) elif hparams.image_mode == '1D': y_real = np.matmul(x_real.reshape(1, -1), A_val) + observ_noise.T out_img = lasso_wavelet_estimator(A_val, y_real, hparams) out_img = out_img.reshape(-1, 1) elif hparams.model_type == 'compressing': assert hparams.type_measurements == 'circulant' A_val = circulant_np if hparams.image_mode == '3D': out_img_list = [] for i in range(x_real.shape[-1]): y_real = A_val(x_real[:, :, i].reshape(-1, 1)).reshape( 1, -1) #[n,1] -> [1,n] out_img_piece = lasso_wavelet_estimator( A_val, y_real, hparams) out_img_piece = out_img_piece.reshape( x_real.shape[0], x_real.shape[1]) out_img_list.append(out_img_piece) out_img = np.transpose(np.array(out_img_list), (1, 2, 0)) elif hparams.image_mode == '1D': y_real = A_val(x_real).reshape(1, -1) #[n,1] -> [1,n] out_img = lasso_wavelet_estimator(A_val, y_real, hparams) out_img = out_img.reshape(-1, 1) ## === Printer === ## # Compute and print measurement and l2 loss # if hparams.image_mode == '3D' and hparams.model_type != 'inpainting': # x_real = x_real.reshape(-1,1) l2_losses = get_l2_loss(out_img, x_real, hparams.image_mode, hparams.decoder_type) psnr = 10 * np.log10(1 * 1 / l2_losses) #PSNR # Printer info if hparams.model_type == 'inpainting': if hparams.image_mode == '1D': mask_info = hparams.mask_name_1D[8:-4] elif hparams.image_mode == '2D' or hparams.image_mode == '3D': mask_info = hparams.mask_name_2D[8:-4] type_mea_info = 'NA' num_mea_info = 'NA' noise_level_info = 'NA' elif hparams.model_type == 'compressing': mask_info = 'NA' type_mea_info = hparams.type_measurements num_mea_info = str(hparams.num_measurements) noise_level_info = 'NA' elif hparams.model_type == 'denoising': mask_info = 'NA' type_mea_info = 'NA' num_mea_info = 'NA' noise_level_info = str(hparams.noise_level) # Print result print( 'Final representation PSNR for img_name:{}, model_type:{}, type_mea:{}, num_mea:{}, mask:{}, decoder:{} tau:{} noise:{} is {}' .format(hparams.img_name, hparams.model_type, type_mea_info, num_mea_info, mask_info, hparams.decoder_type, hparams.tau, noise_level_info, psnr)) print('END') print('\t') #sys.stdout.close() ## == to pd frame == ## if hparams.pickle == 1: pickle_file_path = hparams.pickle_file_path if not os.path.exists(pickle_file_path): d = { 'img_name': [hparams.img_name], 'model_type': [hparams.model_type], 'type_mea': [type_mea_info], 'num_mea': [num_mea_info], 'mask_info': [mask_info], 'decoder_type': [hparams.decoder_type], 'tau': [hparams.tau], 'noise': [noise_level_info], 'psnr': [psnr] } df = pd.DataFrame(data=d) df.to_pickle(pickle_file_path) else: d = { 'img_name': hparams.img_name, 'model_type': hparams.model_type, 'type_mea': type_mea_info, 'num_mea': num_mea_info, 'mask_info': mask_info, 'decoder_type': hparams.decoder_type, 'tau': hparams.tau, 'noise': noise_level_info, 'psnr': psnr } df = pd.read_pickle(pickle_file_path) df = df.append(d, ignore_index=True) df.to_pickle(pickle_file_path) ## === Save === ## if hparams.save == 1: save_out_img(out_img, 'result/', hparams.img_name, hparams.decoder_type, hparams.model_type, num_mea_info, mask_info, noise_level_info, hparams.image_mode)
def test_mlfbf(self): """ Test the MLFBF solver with arbitrarily selected functions. """ x = [1., 1., 1.] L = np.array([[5, 9, 3], [7, 8, 5], [4, 4, 9], [0, 1, 7]]) max_step = 1 / (1 + np.linalg.norm(L, 2)) solver = solvers.mlfbf(L=L, step=max_step / 2.) params = {'solver': solver, 'verbosity': 'NONE'} def x0(): return np.zeros(len(x)) # L2-norm prox and dummy prox. f = functions.dummy() f._prox = lambda x, T: np.maximum(np.zeros(len(x)), x) g = functions.norm_l2(lambda_=0.5) h = functions.norm_l2(y=np.array([294, 390, 361]), lambda_=0.5) ret = solvers.solve([f, g, h], x0(), maxit=1000, rtol=0, **params) nptest.assert_allclose(ret['sol'], x, rtol=1e-5) # Same test, but with callable L solver = solvers.mlfbf(L=lambda x: np.dot(L, x), Lt=lambda y: np.dot(L.T, y), d0=np.dot(L, x0()), step=max_step / 2.) ret = solvers.solve([f, g, h], x0(), maxit=1000, rtol=0, **params) nptest.assert_allclose(ret['sol'], x, rtol=1e-5) # Sanity check self.assertRaises(ValueError, solver.pre, [f, g], x0()) # Make a second test where the solution is calculated by hand n = 10 y = np.random.rand(n) * 2 z = np.random.rand(n) c = 1 delta = (y - z - c)**2 + 4 * (1 + y * z - z * c) sol = 0.5 * ((y - z - c) + np.sqrt(delta)) class mlog(functions.func): def __init__(self, z): super().__init__() self.z = z def _eval(self, x): return -np.sum(np.log(x + self.z)) def _prox(self, x, T): delta = (x - self.z)**2 + 4 * (T + x * self.z) sol = 0.5 * (x - self.z + np.sqrt(delta)) return sol f = functions.norm_l1(lambda_=c) g = mlog(z=z) h = functions.norm_l2(lambda_=0.5, y=y) mu = 1 + 1 step = 1 / mu / 2 solver = solvers.mlfbf(step=step) ret = solvers.solve([f, g, h], y.copy(), solver, maxit=200, rtol=0, verbosity="NONE") nptest.assert_allclose(ret["sol"], sol, atol=1e-10) # Make a final test where the function g can not be evaluate # on the primal variables y = np.random.rand(3) y_2 = L.dot(y) L = np.array([[5, 9, 3], [7, 8, 5], [4, 4, 9], [0, 1, 7]]) x0 = np.zeros(len(y)) f = functions.norm_l1(y=y) g = functions.norm_l2(lambda_=0.5, y=y_2) h = functions.norm_l2(y=y, lambda_=0.5) max_step = 1 / (1 + np.linalg.norm(L, 2)) solver = solvers.mlfbf(L=L, step=max_step / 2.) ret = solvers.solve([f, g, h], x0, solver, maxit=1000, rtol=0) np.testing.assert_allclose(ret["sol"], y)
def test_solve(self): """ Test some features of the solving function. """ # We have to set a seed here for the random draw if we are required # below to assert that the number of iterations of the solvers are # equal to some specific values. Otherwise, we get trivial errors when # x0 is a little farther away from y in a given draw. rs = np.random.RandomState(42) y = 5 - 10 * rs.uniform(size=(15, 4)) def x0(): return np.zeros(y.shape) nverb = {'verbosity': 'NONE'} # Function verbosity. f = functions.dummy() self.assertEqual(f.verbosity, 'NONE') f.verbosity = 'LOW' solvers.solve([f], x0(), **nverb) self.assertEqual(f.verbosity, 'LOW') # Input parameters. self.assertRaises(ValueError, solvers.solve, [f], x0(), verbosity='??') # Addition of dummy function. self.assertRaises(ValueError, solvers.solve, [], x0(), **nverb) solver = solvers.forward_backward() solvers.solve([f], x0(), solver, **nverb) # self.assertIsInstance(solver.f1, functions.dummy) # self.assertIsInstance(solver.f2, functions.dummy) # Automatic solver selection. f0 = functions.func() f0._eval = lambda x: 0 f0._grad = lambda x: x f1 = functions.func() f1._eval = lambda x: 0 f1._grad = lambda x: x f1._prox = lambda x, T: x f2 = functions.func() f2._eval = lambda x: 0 f2._prox = lambda x, T: x self.assertRaises(ValueError, solvers.solve, [f0, f0], x0(), **nverb) ret = solvers.solve([f0, f1], x0(), **nverb) self.assertEqual(ret['solver'], 'forward_backward') ret = solvers.solve([f1, f0], x0(), **nverb) self.assertEqual(ret['solver'], 'forward_backward') ret = solvers.solve([f1, f2], x0(), **nverb) self.assertEqual(ret['solver'], 'forward_backward') ret = solvers.solve([f2, f2], x0(), **nverb) self.assertEqual(ret['solver'], 'douglas_rachford') ret = solvers.solve([f1, f2, f0], x0(), **nverb) self.assertEqual(ret['solver'], 'generalized_forward_backward') # Stopping criteria. f = functions.norm_l2(y=y) tol = 1e-6 r = solvers.solve([f], x0(), None, tol, None, None, None, None, 'NONE') self.assertEqual(r['crit'], 'ATOL') self.assertLess(np.sum(r['objective'][-1]), tol) self.assertEqual(r['niter'], 9) tol = 1e-8 r = solvers.solve([f], x0(), None, None, tol, None, None, None, 'NONE') self.assertEqual(r['crit'], 'DTOL') err = np.abs(np.sum(r['objective'][-1]) - np.sum(r['objective'][-2])) self.assertLess(err, tol) self.assertEqual(r['niter'], 17) tol = .1 r = solvers.solve([f], x0(), None, None, None, tol, None, None, 'NONE') self.assertEqual(r['crit'], 'RTOL') err = np.abs(np.sum(r['objective'][-1]) - np.sum(r['objective'][-2])) err /= np.sum(r['objective'][-1]) self.assertLess(err, tol) self.assertEqual(r['niter'], 13) tol = 1e-4 r = solvers.solve([f], x0(), None, None, None, None, tol, None, 'NONE') self.assertEqual(r['crit'], 'XTOL') r2 = solvers.solve([f], x0(), maxit=r['niter'] - 1, **nverb) err = np.linalg.norm(r['sol'] - r2['sol']) / np.sqrt(x0().size) self.assertLess(err, tol) self.assertEqual(r['niter'], 14) nit = 15 r = solvers.solve([f], x0(), None, None, None, None, None, nit, 'NONE') self.assertEqual(r['crit'], 'MAXIT') self.assertEqual(r['niter'], nit) # Return values. f = functions.norm_l2(y=y) ret = solvers.solve([f], x0(), **nverb) self.assertEqual(len(ret), 6) self.assertIsInstance(ret['sol'], np.ndarray) self.assertIsInstance(ret['solver'], str) self.assertIsInstance(ret['crit'], str) self.assertIsInstance(ret['niter'], int) self.assertIsInstance(ret['time'], float) self.assertIsInstance(ret['objective'], list)
def graph_pnorm_interpolation(self, gradient, P, w, labels_bin, x0=None, p=1., **kwargs): r""" Solve an interpolation problem via gradient p-norm minimization. A signal :math:`x` is estimated from its measurements :math:`y = A(x)` by solving :math:`\text{arg}\underset{z \in \mathbb{R}^n}{\min} \| \nabla_G z \|_p^p \text{ subject to } Az = y` via a primal-dual, forward-backward-forward algorithm. Parameters ---------- gradient : array_like A matrix representing the graph gradient operator P : callable Orthogonal projection operator mapping points in :math:`z \in \mathbb{R}^n` onto the set satisfying :math:`A P(z) = A z`. x0 : array_like, optional Initial point of the iteration. Must be of dimension n. (Default is `numpy.random.randn(n)`) p : {1., 2.} labels_bin : array_like A vector that holds the binary labels. kwargs : Additional solver parameters, such as maximum number of iterations (maxit), relative tolerance on the objective (rtol), and verbosity level (verbosity). See :func:`pyunlocbox.solvers.solve` for the full list of options. Returns ------- x : array_like The solution to the optimization problem. """ grad = lambda z: gradient.dot(z) div = lambda z: gradient.transpose().dot(z) # Indicator function of the set satisfying :math:`y = A(z)` f = functions.func() f._eval = lambda z: 0 f._prox = lambda z, gamma: P(z, w, labels_bin) # :math:`\ell_1` norm of the dual variable :math:`d = \nabla_G z` g = functions.func() g._eval = lambda z: np.sum(np.abs(grad(z))) g._prox = lambda d, gamma: functions._soft_threshold(d, gamma) # :math:`\ell_2` norm of the gradient (for the smooth case) h = functions.norm_l2(A=grad, At=div) stepsize = (0.9 / (1. + scipy.sparse.linalg.norm(gradient, ord='fro'))) ** p solver = solvers.mlfbf(L=grad, Lt=div, step=stepsize) if p == 1.: problem = solvers.solve([f, g, functions.dummy()], x0=x0, solver=solver, **kwargs) return problem['sol'] if p == 2.: problem = solvers.solve([f, functions.dummy(), h], x0=x0, solver=solver, **kwargs) return problem['sol'] else: return x0
def test_solve(self): """ Test some features of the solving function. """ # We have to set a seed here for the random draw if we are required # below to assert that the number of iterations of the solvers are # equal to some specific values. Otherwise, we get trivial errors when # x0 is a little farther away from y in a given draw. rs = np.random.RandomState(42) y = 5 - 10 * rs.uniform(size=(15, 4)) def x0(): return np.zeros(y.shape) nverb = {'verbosity': 'NONE'} # Function verbosity. f = functions.dummy() self.assertEqual(f.verbosity, 'NONE') f.verbosity = 'LOW' solvers.solve([f], x0(), **nverb) self.assertEqual(f.verbosity, 'LOW') # Input parameters. self.assertRaises(ValueError, solvers.solve, [f], x0(), verbosity='??') # Addition of dummy function. self.assertRaises(ValueError, solvers.solve, [], x0(), **nverb) solver = solvers.forward_backward() solvers.solve([f], x0(), solver, **nverb) # self.assertIsInstance(solver.f1, functions.dummy) # self.assertIsInstance(solver.f2, functions.dummy) # Automatic solver selection. f0 = functions.func() f0._eval = lambda x: 0 f0._grad = lambda x: x f1 = functions.func() f1._eval = lambda x: 0 f1._grad = lambda x: x f1._prox = lambda x, T: x f2 = functions.func() f2._eval = lambda x: 0 f2._prox = lambda x, T: x self.assertRaises(ValueError, solvers.solve, [f0, f0], x0(), **nverb) ret = solvers.solve([f0, f1], x0(), **nverb) self.assertEqual(ret['solver'], 'forward_backward') ret = solvers.solve([f1, f0], x0(), **nverb) self.assertEqual(ret['solver'], 'forward_backward') ret = solvers.solve([f1, f2], x0(), **nverb) self.assertEqual(ret['solver'], 'forward_backward') ret = solvers.solve([f2, f2], x0(), **nverb) self.assertEqual(ret['solver'], 'douglas_rachford') ret = solvers.solve([f1, f2, f0], x0(), **nverb) self.assertEqual(ret['solver'], 'generalized_forward_backward') # Stopping criteria. f = functions.norm_l2(y=y) tol = 1e-6 r = solvers.solve([f], x0(), None, tol, None, None, None, None, 'NONE') self.assertEqual(r['crit'], 'ATOL') self.assertLess(np.sum(r['objective'][-1]), tol) self.assertEqual(r['niter'], 9) tol = 1e-8 r = solvers.solve([f], x0(), None, None, tol, None, None, None, 'NONE') self.assertEqual(r['crit'], 'DTOL') err = np.abs(np.sum(r['objective'][-1]) - np.sum(r['objective'][-2])) self.assertLess(err, tol) self.assertEqual(r['niter'], 17) tol = .1 r = solvers.solve([f], x0(), None, None, None, tol, None, None, 'NONE') self.assertEqual(r['crit'], 'RTOL') err = np.abs(np.sum(r['objective'][-1]) - np.sum(r['objective'][-2])) err /= np.sum(r['objective'][-1]) self.assertLess(err, tol) self.assertEqual(r['niter'], 13) tol = 1e-4 r = solvers.solve([f], x0(), None, None, None, None, tol, None, 'NONE') self.assertEqual(r['crit'], 'XTOL') r2 = solvers.solve([f], x0(), maxit=r['niter'] - 1, **nverb) err = np.linalg.norm(r['sol'] - r2['sol']) / np.sqrt(x0().size) self.assertLess(err, tol) self.assertEqual(r['niter'], 14) nit = 15 r = solvers.solve([f], x0(), None, None, None, None, None, nit, 'NONE') self.assertEqual(r['crit'], 'MAXIT') self.assertEqual(r['niter'], nit) # Return values. f = functions.norm_l2(y=y) ret = solvers.solve([f], x0(), **nverb) self.assertEqual(len(ret), 6) self.assertIsInstance(ret['sol'], np.ndarray) self.assertIsInstance(ret['solver'], str) self.assertIsInstance(ret['crit'], str) self.assertIsInstance(ret['niter'], int) self.assertIsInstance(ret['time'], float) self.assertIsInstance(ret['objective'], list)
def test_forward_backward_fista(self): """ Test forward-backward splitting solver with fista acceleration, solving problems with L1-norm, L2-norm, and dummy functions. """ y = [4., 5., 6., 7.] solver = solvers.forward_backward(accel=acceleration.fista()) param = {'solver': solver, 'rtol': 1e-6, 'verbosity': 'NONE'} # L2-norm prox and dummy gradient. f1 = functions.norm_l2(y=y) f2 = functions.dummy() ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'RTOL') self.assertEqual(ret['niter'], 60) # Dummy prox and L2-norm gradient. f1 = functions.dummy() f2 = functions.norm_l2(y=y, lambda_=0.6) ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'RTOL') self.assertEqual(ret['niter'], 84) # L2-norm prox and L2-norm gradient. f1 = functions.norm_l2(y=y) f2 = functions.norm_l2(y=y) ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y, rtol=1e-2) self.assertEqual(ret['crit'], 'MAXIT') self.assertEqual(ret['niter'], 200) # L1-norm prox and dummy gradient. f1 = functions.norm_l1(y=y) f2 = functions.dummy() ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'RTOL') self.assertEqual(ret['niter'], 6) # Dummy prox and L1-norm gradient. As L1-norm possesses no gradient, # the algorithm exchanges the functions : exact same solution. f1 = functions.dummy() f2 = functions.norm_l1(y=y) ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'RTOL') self.assertEqual(ret['niter'], 6) # L1-norm prox and L1-norm gradient. L1-norm possesses no gradient. f1 = functions.norm_l1(y=y) f2 = functions.norm_l1(y=y) self.assertRaises(ValueError, solvers.solve, [f1, f2], np.zeros(len(y)), **param) # L1-norm prox and L2-norm gradient. f1 = functions.norm_l1(y=y, lambda_=1.0) f2 = functions.norm_l2(y=y, lambda_=0.8) ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'RTOL') self.assertEqual(ret['niter'], 10)
im_original = np.dot(im_original[..., :3], [0.299, 0.587, 0.144]) np.random.seed(14) # Reproducible results. mask = np.random.uniform(size=im_original.shape) mask = mask > 0.05 g = lambda x: mask * x im_masked = g(im_original) mask = 1 g = lambda x: mask * x from pyunlocbox import functions f1 = functions.norm_tv(maxit=50, dim=2) tau = 100 f2 = functions.norm_l2(y=im_masked, A=g, lambda_=tau) from pyunlocbox import solvers solver = solvers.forward_backward(step=0.5 / tau) x0 = np.array(im_masked) # Make a copy to preserve im_masked. ret = solvers.solve([f1, f2], x0, solver, maxit=100) import matplotlib.pyplot as plt fig = plt.figure(figsize=(8, 2.5)) ax1 = fig.add_subplot(1, 3, 1) _ = ax1.imshow(im_original, cmap='gray') _ = ax1.axis('off') _ = ax1.set_title('Original image') ax2 = fig.add_subplot(1, 3, 2) _ = ax2.imshow(im_masked, cmap='gray')
def test_forward_backward_fista(self): """ Test forward-backward splitting solver with fista acceleration, solving problems with L1-norm, L2-norm, and dummy functions. """ y = [4., 5., 6., 7.] solver = solvers.forward_backward(accel=acceleration.fista()) param = {'solver': solver, 'rtol': 1e-6, 'verbosity': 'NONE'} # L2-norm prox and dummy gradient. f1 = functions.norm_l2(y=y) f2 = functions.dummy() ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'RTOL') self.assertEqual(ret['niter'], 60) # Dummy prox and L2-norm gradient. f1 = functions.dummy() f2 = functions.norm_l2(y=y, lambda_=0.6) ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'RTOL') self.assertEqual(ret['niter'], 84) # L2-norm prox and L2-norm gradient. f1 = functions.norm_l2(y=y) f2 = functions.norm_l2(y=y) ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y, rtol=1e-2) self.assertEqual(ret['crit'], 'MAXIT') self.assertEqual(ret['niter'], 200) # L1-norm prox and dummy gradient. f1 = functions.norm_l1(y=y) f2 = functions.dummy() ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'RTOL') self.assertEqual(ret['niter'], 6) # Dummy prox and L1-norm gradient. As L1-norm possesses no gradient, # the algorithm exchanges the functions : exact same solution. f1 = functions.dummy() f2 = functions.norm_l1(y=y) ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'RTOL') self.assertEqual(ret['niter'], 6) # L1-norm prox and L1-norm gradient. L1-norm possesses no gradient. f1 = functions.norm_l1(y=y) f2 = functions.norm_l1(y=y) self.assertRaises(ValueError, solvers.solve, [f1, f2], np.zeros(len(y)), **param) # L1-norm prox and L2-norm gradient. f1 = functions.norm_l1(y=y, lambda_=1.0) f2 = functions.norm_l2(y=y, lambda_=0.8) ret = solvers.solve([f1, f2], np.zeros(len(y)), **param) nptest.assert_allclose(ret['sol'], y) self.assertEqual(ret['crit'], 'RTOL') self.assertEqual(ret['niter'], 10)
def run(scale=1.99, sigma_blur=0.1, noise_level_denoiser=0.005, num=None, method='FBS', pretrained_weights=True): if not os.path.isdir('results_conv'): os.mkdir('results_conv') # declare model act = tf.keras.activations.relu num_filters = 64 max_dim = 128 num_layers = 8 sizes = [None] * (num_layers) conv_shapes = [(num_filters, max_dim)] * num_layers filter_length = 5 model = StiefelModel(sizes, None, convolutional=True, filter_length=filter_length, dim=2, conv_shapes=conv_shapes, activation=act, scale_layer=scale) pred = model(tf.random.normal((10, 40, 40))) model.fast_execution = True # load weights if pretrained_weights: file_name = 'data/pretrained_weights/scale' + str( scale) + '_noise_level' + str(noise_level_denoiser) + '.pickle' else: if num is None: file_name = 'results_conv/scale' + str( scale) + '_noise_level' + str( noise_level_denoiser) + '/adam.pickle' else: file_name = 'results_conv/scale' + str( scale) + '_noise_level' + str( noise_level_denoiser) + '/adam' + str(num) + '.pickle' with open(file_name, 'rb') as f: trainable_vars = pickle.load(f) for i in range(len(model.trainable_variables)): model.trainable_variables[i].assign(trainable_vars[i]) beta = 1e8 project = True if project: # project convolution matrices on the Stiefel manifold for i in range(len(model.stiefel)): convs = model.stiefel[i].convs smaller = convs.shape[0] < convs.shape[1] if smaller: convs = transpose_convs(convs) iden = np.zeros((convs.shape[1], convs.shape[1], 4 * filter_length + 1, 4 * filter_length + 1), dtype=np.float32) for j in range(convs.shape[1]): iden[j, j, 2 * filter_length, 2 * filter_length] = 1 iden = tf.constant(iden) C = tf.identity(convs) def projection_objective(C): return 0.5 * beta * tf.reduce_sum( (conv_mult(transpose_convs(C), C) - iden)** 2) + .5 * tf.reduce_sum((C - convs)**2) for iteration in range(100): with tf.GradientTape(persistent=True) as tape: tape.watch(C) val = projection_objective(C) grad = tape.gradient(val, C) grad_sum = tf.reduce_sum(grad * grad) hess = tape.gradient(grad_sum, C) hess *= 0.5 / tf.sqrt(grad_sum) C -= grad / tf.sqrt(tf.reduce_sum(hess * hess)) if smaller: C = transpose_convs(C) model.stiefel[i].convs.assign(C) # load data test_directory = 'data/BSD68' fileList = os.listdir(test_directory + '/') fileList.sort() img_names = fileList save_path = 'results_conv/PnP_blur_' + method + str(sigma_blur) if not os.path.isdir(save_path): os.mkdir(save_path) if not os.path.isdir(save_path + '/blurred_data'): os.mkdir(save_path + '/blurred_data') if not os.path.isdir(save_path + '/l2tv'): os.mkdir(save_path + '/l2tv') psnr_sum = 0. psnr_noisy_sum = 0. psnr_l2tv_sum = 0. error_sum = 0. error_bm3d_sum = 0. counter = 0 sig = sigma_blur sig_sq = sig**2 noise_level = 0.01 kernel_width = 9 x_range = 1. * np.array(range(kernel_width)) kernel_x = np.tile(x_range[:, np.newaxis], (1, kernel_width)) - .5 * (kernel_width - 1) y_range = 1. * np.array(range(kernel_width)) kernel_y = np.tile(y_range[np.newaxis, :], (kernel_width, 1)) - .5 * (kernel_width - 1) kernel = np.exp(-(kernel_x**2 + kernel_y**2) / (2 * sig_sq)) kernel /= np.sum(kernel) kernel = tf.constant(kernel, dtype=tf.float32) myfile = open(save_path + "/psnrs.txt", "w") myfile.write("PSNRs:\n") myfile.close() np.random.seed(25) for name in img_names: # load image and compute blurred version counter += 1 img = Image.open(test_directory + '/' + name) img = img.convert('L') img_gray = 1.0 * np.array(img) img_gray /= 255.0 img_gray_pil = Image.fromarray(img_gray * 255.0) img_gray_pil = img_gray_pil.convert('RGB') img_gray_pil.save(save_path + '/original' + name) one_img = tf.ones(img_gray.shape) img_blurred = tf.nn.conv2d( tf.expand_dims( tf.expand_dims(tf.constant(img_gray, dtype=tf.float32), 0), -1), tf.expand_dims(tf.expand_dims(kernel, -1), -1), 1, 'SAME') img_blurred = tf.squeeze(img_blurred).numpy() ones_blurred = tf.nn.conv2d( tf.expand_dims( tf.expand_dims(tf.constant(one_img, dtype=tf.float32), 0), -1), tf.expand_dims(tf.expand_dims(kernel, -1), -1), 1, 'SAME') ones_blurred = tf.squeeze(ones_blurred).numpy() img_blurred /= ones_blurred noise = np.random.normal(0, 1, img_blurred.shape) img_blurred += noise_level * noise pad = kernel_width // 2 img_obs = img_blurred[pad:-pad, pad:-pad] img_start = np.pad(img_obs, ((pad, pad), (pad, pad)), 'edge') img_obs_big = np.concatenate([ np.zeros((img_obs.shape[0], pad)), img_obs, np.zeros((img_obs.shape[0], pad)) ], 1) img_obs_big = np.concatenate([ np.zeros((pad, img_obs_big.shape[1])), img_obs_big, np.zeros((pad, img_obs_big.shape[1])) ], 0) savemat(save_path + '/blurred_data/' + name[:-4] + '_blurred.mat', {'img_blur': (img_blurred) * 255}) scalar = scale alpha_star = 0.5 conv_coord = 1 - scalar + 2 * alpha_star * scalar # declare functions for PnP def my_f(signal, inp_signal): signal_blurred = tf.nn.conv2d( tf.expand_dims(signal, -1), tf.expand_dims(tf.expand_dims(kernel, -1), -1), 1, 'VALID') signal_blurred = tf.reshape(signal_blurred, signal_blurred.shape[:3]) out = .5 * tf.reduce_sum((signal_blurred - img_obs)**2) return out def prox_my_f(signal, lam, inp_signal): out_signal = tf.identity(signal) for i in range(50): with tf.GradientTape(persistent=True) as tape: tape.watch(out_signal) term1 = my_f(out_signal, inp_signal) term2 = .5 * tf.reduce_sum((out_signal - signal)**2) objective = term1 / lam + term2 grad = tape.gradient(objective, out_signal) grad_sum = tf.reduce_sum(grad**2) hess = .5 * tape.gradient(grad_sum, out_signal) / tf.sqrt(grad_sum) out_signal -= grad / tf.sqrt(tf.reduce_sum(hess**2)) return out_signal def grad_f(signal): signal_blurred = tf.nn.conv2d( tf.expand_dims(signal, -1), tf.expand_dims(tf.expand_dims(kernel, -1), -1), 1, 'SAME') signal_blurred_minus_inp = tf.reshape( signal_blurred, signal_blurred.shape[:3]) - img_blurred AtA = tf.nn.conv2d(tf.expand_dims(signal_blurred_minus_inp, -1), tf.expand_dims(tf.expand_dims(kernel, -1), -1), 1, 'SAME') AtA = tf.reshape(AtA, signal_blurred.shape[:3]) return AtA #L2-TV def g(signal): signal_blurred = tf.nn.conv2d( tf.expand_dims( tf.expand_dims(tf.constant(signal, tf.float32), -1), 0), tf.expand_dims(tf.expand_dims(kernel, -1), -1), 1, 'VALID') signal_blurred = tf.squeeze(signal_blurred) signal_blurred = np.concatenate([ np.zeros((signal_blurred.shape[0], pad)), signal_blurred.numpy(), np.zeros((signal_blurred.shape[0], pad)) ], 1) signal_blurred = np.concatenate([ np.zeros((pad, signal_blurred.shape[1])), signal_blurred, np.zeros((pad, signal_blurred.shape[1])) ], 0) return signal_blurred f1 = functions.norm_tv(maxit=50, dim=2) l2tv_lambda = 0.001 f2 = functions.norm_l2(y=img_obs_big, A=g, lambda_=1 / l2tv_lambda) solver = solvers.forward_backward(step=0.5 * l2tv_lambda) img_blurred2 = tf.identity(img_start).numpy() l2tv = solvers.solve([f1, f2], img_blurred2, solver, maxit=100, verbosity='NONE') l2tv = l2tv['sol'] def my_T(inp, model): my_fac = 1. return (1 - 1 / (conv_coord)) * l2tv + 1 / (conv_coord) * (inp - model( (inp - .5) * my_fac)) # Compute PnP result if method == 'FBS': pred = PnP_FBS(model, l2tv[np.newaxis, :, :], tau=1.9, T_fun=my_T, eps=1e-3, fun=my_f) elif method == 'ADMM': pred = PnP_ADMM(l2tv[np.newaxis, :, :], lambda x: my_T(x, model), gamma=.52, prox_fun=prox_my_f) else: raise ValueError('Unknown method!') # save results noisy = (img_start) * 255 reconstructed = (tf.reshape( pred, [pred.shape[1], pred.shape[2]]).numpy()) * 255. img_gray = (img_gray) * 255. l2tv *= 255 error_sum += tf.reduce_sum( ((reconstructed - img_gray) / 255.)**2).numpy() psnr = meanPSNR( tf.keras.backend.flatten(reconstructed[2 * pad:-2 * pad, 2 * pad:-2 * pad]).numpy() / 255.0, tf.keras.backend.flatten( img_gray[2 * pad:-2 * pad, 2 * pad:-2 * pad]).numpy() / 255.0, one_dist=True) psnr_l2tv = meanPSNR( tf.keras.backend.flatten(l2tv[2 * pad:-2 * pad, 2 * pad:-2 * pad]).numpy() / 255.0, tf.keras.backend.flatten( img_gray[2 * pad:-2 * pad, 2 * pad:-2 * pad]).numpy() / 255.0, one_dist=True) psnr_noisy = meanPSNR( tf.keras.backend.flatten(noisy[2 * pad:-2 * pad, 2 * pad:-2 * pad]).numpy() / 255.0, tf.keras.backend.flatten( img_gray[2 * pad:-2 * pad, 2 * pad:-2 * pad]).numpy() / 255.0, one_dist=True) print('PSNR of ' + name + ': ' + str(psnr)) print('PSNR L2TV of ' + name + ': ' + str(psnr_l2tv)) print('PSNR of noisy ' + name + ': ' + str(psnr_noisy)) psnr_sum += psnr psnr_noisy_sum += psnr_noisy psnr_l2tv_sum += psnr_l2tv print('Mean PSNR PPNN: ' + str(psnr_sum / counter)) print('Mean PSNR L2TV: ' + str(psnr_l2tv_sum / counter)) print('Mean PSNR noisy: ' + str(psnr_noisy_sum / counter)) myfile = open(save_path + "/psnrs.txt", "a") myfile.write('PSNR of ' + name + ': ' + str(psnr) + '\n') myfile.write('PSNR L2TV of ' + name + ': ' + str(psnr_l2tv) + '\n') myfile.write('PSNR of noisy ' + name + ': ' + str(psnr_noisy) + '\n') myfile.close() img = Image.fromarray(noisy) img = img.convert('RGB') img.save(save_path + '/noisy' + name) img = Image.fromarray(l2tv) img = img.convert('RGB') img.save(save_path + '/l2tv/l2tv' + name) img = Image.fromarray(reconstructed) img = img.convert('RGB') img.save(save_path + '/reconstructed' + name) print('Mean PSNR on images: ' + str(psnr_sum / len(img_names))) print('Mean PSNR on noisy images: ' + str(psnr_noisy_sum / len(img_names)))
H_estimated_wf_gaussian = l_to_h_wf(blurred_image_gaussian_l, K_gaussian) plt.figure(14) plt.title("Estimated Super resolution gaussian - Wiener filter") plt.imshow(H_estimated_wf_gaussian, cmap='gray') plt.figure(15) plt.title("Estimated Super resolution box - Wiener filter") plt.imshow(H_estimated_wf_box, cmap='gray') # Task 5.2 tau = 100 g = lambda H: signal.convolve2d(H, K_gaussian, boundary='symm', mode='same') l_blurred_cpy = np.array(blurred_image_gaussian_l) tv_prior_f = functions.norm_tv(maxit=50, dim=2) norm_l2_f = functions.norm_l2(y=l_blurred_cpy, A=g, lambda_=tau) solver = solvers.forward_backward(step=0.0001 / tau) H_estimated_lms_tv_gaussian = solvers.solve([tv_prior_f, norm_l2_f], l_blurred_cpy, solver, maxit=100) g = lambda H: signal.convolve2d(H, K_box, boundary='symm', mode='same') l_blurred_cpy = np.array(blurred_image_box_l) tv_prior_f = functions.norm_tv(maxit=50, dim=2) norm_l2_f = functions.norm_l2(y=l_blurred_cpy, A=g, lambda_=tau) solver = solvers.forward_backward(step=0.0001 / tau) H_estimated_lms_tv_box = solvers.solve([tv_prior_f, norm_l2_f], l_blurred_cpy, solver, maxit=100) plt.figure(16) plt.title("Estimated Super resolution gaussian - Least mean square with TV prior") plt.imshow(H_estimated_lms_tv_gaussian['sol'], cmap='gray') plt.figure(17)