def test01_beta(self): """Check beta applied consistently""" Prior10 = LaplacianPrior({'Vm': self.Vm, 'gamma': 0.0, 'beta':1e-10}) error = 0.0 for mm in self.M: r1 = (self.Priorb.grad(mm)).array() r10 = (Prior10.grad(mm)).array() err = np.linalg.norm(r1 - 1e5*r10)/np.linalg.norm(r1) error = max(error, err) self.assertTrue(error < 3e-16, error)
def __init__(self, mesh, k, regularization='tikhonov'): """ Inputs: pbtype = 'denoising' or 'deblurring' mesh = Fenics mesh k = Fenics Expression of the blurring kernel; must have parameter t f = target image """ self.mesh = mesh self.V = dl.FunctionSpace(self.mesh, 'Lagrange', 1) self.dimV = self.V.dim() self.xx = self.V.dofmap().tabulate_all_coordinates(self.mesh) self.test, self.trial = dl.TestFunction(self.V), dl.TrialFunction( self.V) # Target data: self.f_true = 0.75 * (self.xx >= .1) * (self.xx <= .25) self.f_true += (self.xx >= 0.28) * (self.xx <= 0.3) * (15 * self.xx - 15 * 0.28) self.f_true += (self.xx > 0.3) * (self.xx < 0.33) * 0.3 self.f_true += (self.xx >= 0.33) * (self.xx <= 0.35) * (-15 * self.xx + 15 * 0.35) self.f_true += (self.xx >= .4) * (self.xx <= .9) * ( self.xx - .4)**2 * (self.xx - 0.9)**2 / .25**4 self.g = None # current iterate # kernel operator self.k = k self.Kweak = dl.inner(self.k, self.test) * dl.dx self.assembleK() # mass matrix self.Mweak = dl.inner(self.test, self.trial) * dl.dx self.M = dl.assemble(self.Mweak) # regularization self.parameters['regularization'] = regularization if regularization == 'tikhonov': self.RegTikh = LaplacianPrior({ 'gamma': 1.0, 'beta': 0.0, 'Vm': self.V }) self.R = self.RegTikh.Minvprior.array() elif regularization == 'TV': self.RegTV = TV({'eps': 1e-2, 'Vm': self.V}) # line search parameters self.parameters['alpha0'] = 1.0 self.parameters['rho'] = 0.5 self.parameters['c'] = 5e-5 self.parameters['max_backtrack'] = 12
def setUp(self): mesh = UnitSquareMesh(5,5,'crossed') self.Vm = FunctionSpace(mesh, 'Lagrange', 2) self.m = Function(self.Vm) self.m.vector()[:] = np.random.randn(self.Vm.dim()) self.Priorg = LaplacianPrior({'Vm': self.Vm, 'gamma': 1e-5}) self.Priorb = LaplacianPrior({'Vm': self.Vm, 'gamma': 0.0, 'beta':1e-5}) self.Prior = LaplacianPrior({'Vm': self.Vm, 'gamma': 1e-5, \ 'beta':1e-10, 'm0': self.m}) self.M = [] for ii in range(10): self.M.append(Function(self.Vm)) self.lenm = self.Vm.dim() for mm in self.M: mm.vector()[:] = np.random.randn(self.lenm)
def __init__(self, CGdeg, regularizationtype, h=1.0, parameters=[], image='image.dat'): class Image(dl.Expression): def __init__(self, Lx, Ly, data): self.data = data self.hx = Lx / float(self.data.shape[1] - 1) self.hy = Ly / float(self.data.shape[0] - 1) def eval(self, values, x): j = math.floor(x[0] / self.hx) i = math.floor(x[1] / self.hy) values[0] = self.data[i, j] data = np.loadtxt(image, delimiter=',') #Lx, Ly = float(data.shape[1])/float(data.shape[0]), 1. Lx, Ly = 2., 1. scaling = 100. * h # =1.0 => h~0.01 Lx, Ly = scaling * Lx, scaling * Ly np.random.seed(seed=1) noise_std_dev = 0.3 noise = noise_std_dev * np.random.randn(data.shape[0], data.shape[1]) print '||noise||={}'.format(np.linalg.norm(noise)) mesh = dl.RectangleMesh(dl.Point(0, 0), dl.Point(Lx, Ly), 200, 100) mcoord = mesh.coordinates() print 'hx={}, hy={}'.format((mcoord[-1][0] - mcoord[0][0]) / 200., (mcoord[-1][1] - mcoord[0][1]) / 100.) V = dl.FunctionSpace(mesh, 'Lagrange', CGdeg) trueImage = Image(Lx, Ly, data) noisyImage = Image(Lx, Ly, data + noise) print 'min(data)={}, max(data)={}'.format(np.amin(data), np.amax(data)) print 'min(data+noise)={}, max(data+noise)={}'.format( np.amin(data + noise), np.amax(data + noise)) self.u_true = dl.interpolate(trueImage, V) self.u_0 = dl.interpolate(noisyImage, V) self.u = dl.Function(V) self.ucopy = dl.Function(V) self.G = dl.Function(V) self.du = dl.Function(V) u_test = dl.TestFunction(V) u_trial = dl.TrialFunction(V) Mweak = dl.inner(u_test, u_trial) * dl.dx self.M = dl.assemble(Mweak) self.solverM = dl.LUSolver('petsc') self.solverM.parameters['symmetric'] = True self.solverM.parameters['reuse_factorization'] = True self.solverM.set_operator(self.M) self.regul = regularizationtype if self.regul == 'tikhonov': self.Regul = LaplacianPrior({'Vm': V, 'gamma': 1.0, 'beta': 0.0}) elif self.regul == 'TV': paramTV = {'Vm': V, 'k': 1.0, 'eps': 1e-4, 'GNhessian': True} paramTV.update(parameters) self.Regul = TV(paramTV) self.inexact = False elif self.regul == 'TVPD': paramTV = {'Vm': V, 'k': 1.0, 'eps': 1e-4, 'exact': False} paramTV.update(parameters) self.Regul = TVPD(paramTV) self.inexact = False self.alpha = 1.0 self.Hess = self.M self.parametersLS = {'alpha0':1.0, 'rho':0.5, 'c':5e-5, \ 'max_backtrack':12, 'cgtol':0.5, 'maxiter':50000} filename, ext = os.path.splitext(sys.argv[0]) #if os.path.isdir(filename + '/'): shutil.rmtree(filename + '/') self.myplot = PlotFenics(filename) try: solver = PETScKrylovSolver('cg', 'ml_amg') self.precond = 'ml_amg' except: print '*** WARNING: ML not installed -- using petsc_amg instead' self.precond = 'petsc_amg'
class TestGaussianprior(unittest.TestCase): def setUp(self): mesh = UnitSquareMesh(5,5,'crossed') self.Vm = FunctionSpace(mesh, 'Lagrange', 2) self.m = Function(self.Vm) self.m.vector()[:] = np.random.randn(self.Vm.dim()) self.Priorg = LaplacianPrior({'Vm': self.Vm, 'gamma': 1e-5}) self.Priorb = LaplacianPrior({'Vm': self.Vm, 'gamma': 0.0, 'beta':1e-5}) self.Prior = LaplacianPrior({'Vm': self.Vm, 'gamma': 1e-5, \ 'beta':1e-10, 'm0': self.m}) self.M = [] for ii in range(10): self.M.append(Function(self.Vm)) self.lenm = self.Vm.dim() for mm in self.M: mm.vector()[:] = np.random.randn(self.lenm) def test00a_inst(self): """Default instantiation and check default values""" Prior = LaplacianPrior({'Vm': self.Vm, 'gamma': 1e-5}) error = Prior.beta + np.linalg.norm(Prior.m0.vector().array()) self.assertTrue(error < 1e-16, error) def test00b_inst(self): """Default instantiation""" Prior = LaplacianPrior({'Vm': self.Vm, 'gamma': 1e-5, \ 'beta': 1e-7, 'm0': self.m}) def test01_gamma(self): """Check gamma applied consistently""" Prior10 = LaplacianPrior({'Vm': self.Vm, 'gamma': 1e-10}) error = 0.0 for mm in self.M: r1 = (self.Priorg.grad(mm)).array() r10 = (Prior10.grad(mm)).array() err = np.linalg.norm(r1 - 1e5*r10)/np.linalg.norm(r1) error = max(error, err) self.assertTrue(error < 3e-16, error) def test01_beta(self): """Check beta applied consistently""" Prior10 = LaplacianPrior({'Vm': self.Vm, 'gamma': 0.0, 'beta':1e-10}) error = 0.0 for mm in self.M: r1 = (self.Priorb.grad(mm)).array() r10 = (Prior10.grad(mm)).array() err = np.linalg.norm(r1 - 1e5*r10)/np.linalg.norm(r1) error = max(error, err) self.assertTrue(error < 3e-16, error) def test02_precond(self): """Check preconditioner when beta is defined""" prec = self.Prior.get_precond() gR = self.Prior.gamma*self.Prior.R + \ self.Prior.beta*self.Prior.M error = 0.0 for mm in self.M: r1 = (prec * mm.vector()).array() r2 = (gR * mm.vector()).array() err = np.linalg.norm(r1 - r2)/np.linalg.norm(r1) error = max(error, err) self.assertTrue(error < 1e-16, error) def test02_precond2(self): """Check preconditioner when beta is not defined""" prec = self.Priorg.get_precond() gR = self.Priorg.R gM = self.Priorg.M gRM = self.Priorg.gamma*gR + (1e-14)*gM error = 0.0 for mm in self.M: r1 = (prec * mm.vector()).array() r2 = (gRM * mm.vector()).array() err = np.linalg.norm(r1 - r2)/np.linalg.norm(r1) error = max(error, err) self.assertTrue(error < 1e-16, error) def test03_costnull(self): """Check null space of regularization""" self.m.vector()[:] = np.ones(self.lenm) cost = self.Priorg.cost(self.m) self.assertTrue(cost < 1e-16, cost) def test03_costposit(self): """Check cost is nonnegative""" mincost = 1.0 for mm in self.M: cost = self.Priorg.cost(mm) mincost = min(mincost, cost) self.assertTrue(mincost > 0.0, mincost) def test04_grad(self): """Check cost and gradient are consistent""" error = 0.0 h = 1e-5 for mm in self.M: grad = self.Prior.grad(mm) mm_arr = mm.vector().array() for dm in self.M: dm_arr = dm.vector().array() dm_arr /= np.linalg.norm(dm_arr) gradxdm = np.dot(grad.array(), dm_arr) self.m.vector()[:] = mm_arr + h*dm_arr cost1 = self.Prior.cost(self.m) self.m.vector()[:] = mm_arr - h*dm_arr cost2 = self.Prior.cost(self.m) gradxdm_fd = (cost1-cost2) / (2.*h) err = abs(gradxdm - gradxdm_fd) / abs(gradxdm) error = max(error, err) self.assertTrue(error < 2e-7, error) def test05_hess(self): """Check gradient and Hessian do the same""" error = 0.0 for mm in self.M: gradm = self.Prior.grad(mm).array() hessm = self.Prior.hessian(mm.vector()-self.Prior.m0.vector())\ .array() err = np.linalg.norm(gradm-hessm)/np.linalg.norm(gradm) error = max(error, err) self.assertTrue(error < 1e-16, error) def test06_hess(self): """Check gradient and hessian are consistent""" error = 0.0 h = 1e-5 for mm in self.M: for dm in self.M: Hdm = self.Prior.hessian(dm.vector()).array() self.m.vector()[:] = mm.vector().array() + \ h*dm.vector().array() G1dm = self.Prior.grad(self.m).array() self.m.vector()[:] = mm.vector().array() - \ h*dm.vector().array() G2dm = self.Prior.grad(self.m).array() HFDdm = (G1dm-G2dm)/(2*h) err = np.linalg.norm(HFDdm-Hdm)/np.linalg.norm(Hdm) error = max(error, err) self.assertTrue(error < 1e-8, error)
def test00b_inst(self): """Default instantiation""" Prior = LaplacianPrior({'Vm': self.Vm, 'gamma': 1e-5, \ 'beta': 1e-7, 'm0': self.m})
def test00a_inst(self): """Default instantiation and check default values""" Prior = LaplacianPrior({'Vm': self.Vm, 'gamma': 1e-5}) error = Prior.beta + np.linalg.norm(Prior.m0.vector().array()) self.assertTrue(error < 1e-16, error)