def test_est_1d_2(): u = Unknown('u', ldim=1) phi = Constant('phi') # ... define a partial differential operator as a lambda function from sympy.abc import x L = lambda u: x*dx(u) + phi*u L_expected = lambda u: x*dx(u) + 2.*u # ... # ... symbolic functions for unknown and rhs from sympy.abc import x from sympy import sin, cos u_sym = sin(x) f_sym = L_expected(u_sym) # ... # ... lambdification + evaluation from numpy import linspace, pi u_num = lambdify((x), u_sym, "numpy") f_num = lambdify((x), f_sym, "numpy") x_u = linspace(0, 2*pi, 10) x_f = x_u us = u_num(x_u) fs = f_num(x_f) # ... # compute the likelihood nlml = NLML(L(u), u, 'RBF') # set values nlml.set_u(x_u, us) nlml.set_f(x_f, fs) from numpy.random import rand from numpy import exp, ones from time import time # ... using pure python implementation from symgp.nelder_mead import nelder_mead x_start = rand(len(nlml.args)) tb = time() m = nelder_mead(nlml, x_start, step=0.1, no_improve_thr=10e-6, no_improv_break=10, max_iter=0, alpha=1., gamma=2., rho=-0.5, sigma=0.5, verbose=False) te = time() elapsed_python = te-tb args = exp(m[0]) print('> estimated phi = ', nlml.map_args(args)['phi']) print('> elapsed time python = ', elapsed_python)
def test_kernel_2d_9(): beta = Constant('beta') alpha = Constant('alpha') mu = Constant('mu') L = beta*dx(dx(u)) + alpha*dx(u) + mu*u # ... expected = alpha*Derivative(k, xi) + beta*Derivative(k, xi, xi) + mu*k(xi, yi) assert(evaluate(L, u, Kernel('K'), (Tuple(xi, yi),)) == expected) # ... # ... expected = alpha*Derivative(k, xj) + beta*Derivative(k, xj, xj) + mu*k(xj, yj) assert(evaluate(L, u, Kernel('K'), (Tuple(xj, yj),)) == expected) # ... # ... expected = (alpha**2*Derivative(k, xi, xj) + alpha*beta*Derivative(k, xi, xi, xj) + alpha*beta*Derivative(k, xi, xj, xj) + alpha*mu*Derivative(k, xi) + alpha*mu*Derivative(k, xj) + beta**2*Derivative(k, xi, xi, xj, xj) + beta*mu*Derivative(k, xi, xi) + beta*mu*Derivative(k, xj, xj) + mu**2*k(xi, yi, xj, yj)) assert(evaluate(L, u, Kernel('K'), (Tuple(xi,yi), Tuple(xj,yj))) == expected)
def test_kernel_2d_5(): L = dx(dx(u)) # ... expected = Derivative(k, xi, xi) assert(evaluate(L, u, Kernel('K'), (Tuple(xi, yi),)) == expected) # ... # ... expected = Derivative(k, xj, xj) assert(evaluate(L, u, Kernel('K'), (Tuple(xj, yj),)) == expected) # ... # ... expected = Derivative(k, xi, xi, xj, xj) assert(evaluate(L, u, Kernel('K'), (Tuple(xi,yi), Tuple(xj,yj))) == expected)
def test_kernel_2d_11(): phi = Constant('phi') L = phi * u + dx(u) + dy(u) + dz(dz(u)) # ... expected = phi * k(xi, yi, zi) + Derivative(k, xi) + Derivative( k, yi) + Derivative(k, zi, zi) assert (evaluate(L, u, Kernel('K'), (Tuple(xi, yi, zi), )) == expected) # ... # ... expected = phi * k(xj, yj, zj) + Derivative(k, xj) + Derivative( k, yj) + Derivative(k, zj, zj) assert (evaluate(L, u, Kernel('K'), (Tuple(xj, yj, zj), )) == expected) # ... # ... expected = (phi**2 * k(xi, yi, zi, xj, yj, zj) + phi * Derivative(k, xi) + phi * Derivative(k, xj) + phi * Derivative(k, yi) + phi * Derivative(k, yj) + phi * Derivative(k, zi, zi) + phi * Derivative(k, zj, zj) + Derivative(k, xi, xj) + Derivative(k, xi, yj) + Derivative(k, yi, xj) + Derivative(k, yi, yj) + Derivative(k, xi, zj, zj) + Derivative(k, yi, zj, zj) + Derivative(k, zi, zi, xj) + Derivative(k, zi, zi, yj) + Derivative(k, zi, zi, zj, zj)) assert (evaluate(L, u, Kernel('K'), (Tuple(xi, yi, zi), Tuple(xj, yj, zj))) == expected)
def test_kernel_1d_2(): L = dx(u) + alpha*u # ... K = evaluate(L, u, Kernel('K'), xi) K = update_kernel(K, RBF, (xi, xj)) expected = theta_1*(1.0*alpha - 1.0*xi + 1.0*xj)*exp(-0.5*(xi - xj)**2) assert(K == expected) # ... # ... K = evaluate(L, u, Kernel('K'), xj) K = update_kernel(K, RBF, (xi, xj)) expected = theta_1*(1.0*alpha + 1.0*xi - 1.0*xj)*exp(-0.5*(xi - xj)**2) assert(K == expected) # ... # ... K = evaluate(L, u, Kernel('K'), (xi, xj)) K = update_kernel(K, RBF, (xi, xj)) expected = theta_1*(alpha**2 - 1.0*(xi - xj)**2 + 1.0)*exp(-0.5*(xi - xj)**2) assert(K == expected)
def test_kernel_1d_2(): L = dx(dx(u)) # ... expected = Derivative(k, xi, xi) assert (evaluate(L, u, Kernel('K'), xi) == expected) # ... # ... expected = Derivative(k, xj, xj) assert (evaluate(L, u, Kernel('K'), xj) == expected) # ... # ... expected = Derivative(k, xi, xi, xj, xj) assert (evaluate(L, u, Kernel('K'), (xi, xj)) == expected)
def test_kernel_1d_4(): L = dx(dx(u)) + dx(u) + u # ... expected = k(xi) + Derivative(k, xi) + Derivative(k, xi, xi) assert (evaluate(L, u, Kernel('K'), xi) == expected) # ... # ... expected = k(xj) + Derivative(k, xj) + Derivative(k, xj, xj) assert (evaluate(L, u, Kernel('K'), xj) == expected) # ... # ... expected = (k(xi, xj) + Derivative(k, xi) + Derivative(k, xj) + Derivative(k, xi, xi) + Derivative(k, xi, xj) + Derivative(k, xj, xj) + Derivative(k, xi, xi, xj) + Derivative(k, xi, xj, xj) + Derivative(k, xi, xi, xj, xj)) assert (evaluate(L, u, Kernel('K'), (xi, xj)) == expected)
def test_kernel_2d_10(): L = dx(dx(u)) + dy(dy(u)) + dz(dz(u)) # ... expected = Derivative(k, xi, xi) + Derivative(k, yi, yi) + Derivative( k, zi, zi) assert (evaluate(L, u, Kernel('K'), (Tuple(xi, yi, zi), )) == expected) # ... # ... expected = Derivative(k, xj, xj) + Derivative(k, yj, yj) + Derivative( k, zj, zj) assert (evaluate(L, u, Kernel('K'), (Tuple(xj, yj, zj), )) == expected) # ... # ... expected = (Derivative(k, xi, xi, xj, xj) + Derivative(k, xi, xi, yj, yj) + Derivative(k, xi, xi, zj, zj) + Derivative(k, yi, yi, xj, xj) + Derivative(k, yi, yi, yj, yj) + Derivative(k, yi, yi, zj, zj) + Derivative(k, zi, zi, xj, xj) + Derivative(k, zi, zi, yj, yj) + Derivative(k, zi, zi, zj, zj)) assert (evaluate(L, u, Kernel('K'), (Tuple(xi, yi, zi), Tuple(xj, yj, zj))) == expected)
def test_kernel_3d_2(): L = phi * u + dx(u) + dy(u) + dz(dz(u)) # ... K = evaluate(L, u, Kernel('K'), (Tuple(xi, yi, zi))) K = update_kernel(K, RBF, ((xi, yi, zi), (xj, yj, zj))) expected = theta_1 * theta_2 * theta_3 * ( phi**3 + 1.0 * phi**2 * (-xi + xj) + 1.0 * phi**2 * (-yi + yj) + 1.0 * phi**2 * (-zi + zj) + 1.0 * phi * (xi - xj) * (yi - yj) + 1.0 * phi * (xi - xj) * (zi - zj) + 1.0 * phi * (yi - yj) * (zi - zj) - 1.0 * (xi - xj) * (yi - yj) * (zi - zj)) * exp(-0.5 * (xi - xj)**2) * exp(-0.5 * (yi - yj)**2) * exp(-0.5 * (zi - zj)**2) assert (simplify(K - expected) == 0) # ... # ... K = evaluate(L, u, Kernel('K'), (Tuple(xj, yj, zj))) K = update_kernel(K, RBF, ((xi, yi, zi), (xj, yj, zj))) expected = theta_1 * theta_2 * theta_3 * ( phi**3 + 1.0 * phi**2 * (xi - xj) + 1.0 * phi**2 * (yi - yj) + 1.0 * phi**2 * (zi - zj) + 1.0 * phi * (xi - xj) * (yi - yj) + 1.0 * phi * (xi - xj) * (zi - zj) + 1.0 * phi * (yi - yj) * (zi - zj) + 1.0 * (xi - xj) * (yi - yj) * (zi - zj)) * exp(-0.5 * (xi - xj)**2) * exp(-0.5 * (yi - yj)**2) * exp(-0.5 * (zi - zj)**2) assert (simplify(K - expected) == 0) # ... # ... K = evaluate(L, u, Kernel('K'), (Tuple(xi, yi, zi), Tuple(xj, yj, zj))) K = update_kernel(K, RBF, ((xi, yi, zi), (xj, yj, zj))) expected = theta_1 * theta_2 * theta_3 * ( phi**2 + 2.0 * phi * ((zi - zj)**2 - 1) - 1.0 * (xi - xj)**2 - 2.0 * (xi - xj) * (yi - yj) - 1.0 * (yi - yj)**2 + 1.0 * (zi - zj)**4 - 6.0 * (zi - zj)**2 + 5.0) * exp(-0.5 * (xi - xj)**2) * exp( -0.5 * (yi - yj)**2) * exp(-0.5 * (zi - zj)**2) assert (simplify(K - expected) == 0)
def test_kernel_1d_5(): alpha = Constant('alpha') L = dx(u) + alpha * u # ... expected = alpha * k(xi) + Derivative(k, xi) assert (evaluate(L, u, Kernel('K'), xi) == expected) # ... # ... expected = alpha * k(xj) + Derivative(k, xj) assert (evaluate(L, u, Kernel('K'), xj) == expected) # ... # ... expected = (alpha**2 * k(xi, xj) + alpha * Derivative(k, xi) + alpha * Derivative(k, xj) + Derivative(k, xi, xj)) assert (evaluate(L, u, Kernel('K'), (xi, xj)) == expected)
def test_kernel_2d_2(): L = phi * u + dx(u) + dy(dy(u)) # ... K = evaluate(L, u, Kernel('K'), (Tuple(xi, yi))) K = update_kernel(K, RBF, ((xi, yi), (xj, yj))) expected = theta_1 * theta_2 * (phi**2 - 1.0 * phi * (xi - xj) - 1.0 * phi * (yi - yj) + 1.0 * (xi - xj) * (yi - yj)) * exp( -0.5 * (xi - xj)**2) * exp(-0.5 * (yi - yj)**2) assert (simplify(K - expected) == 0) # ... # ... K = evaluate(L, u, Kernel('K'), (Tuple(xj, yj))) K = update_kernel(K, RBF, ((xi, yi), (xj, yj))) expected = theta_1 * theta_2 * (phi**2 + 1.0 * phi * (xi - xj) + 1.0 * phi * (yi - yj) + 1.0 * (xi - xj) * (yi - yj)) * exp( -0.5 * (xi - xj)**2) * exp(-0.5 * (yi - yj)**2) assert (simplify(K - expected) == 0) # ... # ... K = evaluate(L, u, Kernel('K'), (Tuple(xi, yi), Tuple(xj, yj))) K = update_kernel(K, RBF, ((xi, yi), (xj, yj))) expected = theta_1 * theta_2 * (phi**2 + 2.0 * phi * ((yi - yj)**2 - 1) - 1.0 * (xi - xj)**2 + 1.0 * (yi - yj)**4 - 6.0 * (yi - yj)**2 + 4.0) * exp( -0.5 * (xi - xj)**2) * exp(-0.5 * (yi - yj)**2) assert (simplify(K - expected) == 0)
def test_est_1d_7(): """Explicit time step for Burgers""" u = Unknown('u', ldim=1) nu = Constant('nu') # ... define a partial differential operator as a lambda function from sympy.abc import x from sympy import sin, cos Dt = 0.0010995574287564279 nu_expected = 0.07 from numpy import genfromtxt xn = genfromtxt('x.txt') unew = genfromtxt('unew.txt') un = genfromtxt('un.txt') from scipy.interpolate import interp1d unew = interp1d(xn, unew) un = interp1d(xn, un) fn = Function('fn') L = lambda u: u + Dt*fn(x)*dx(u) + nu*Dt*dx(dx(u)) # ... # ... lambdification + evaluation from numpy import linspace, pi from numpy.random import rand # x_u = linspace(0, 2*pi, 50) x_u = rand(50) * 2*pi x_f = x_u us = un(x_u) fs = unew(x_f) # ... from numpy.random import rand from numpy import exp, ones, log from time import time from scipy.optimize import minimize # compute the likelihood nlml = NLML(L(u), u, 'SE') # set values nlml.set_u(x_u, us) nlml.set_f(x_f, fs) x_start = rand(len(nlml.args)) # ... using pure python implementation from symgp.nelder_mead import nelder_mead x_start = rand(len(nlml.args)) m = nelder_mead(nlml, x_start, step=1., no_improve_thr=1e-5, no_improv_break=6, max_iter=0, alpha=1., gamma=1.5, rho=-0.5, sigma=.5, verbose=False) args = exp(m[0]) print('> estimated nu = ', nlml.map_args(args)['nu'])
def test_est_1d_6(): """Explicit time step for Burgers""" u = Unknown('u', ldim=1) nu = Constant('nu') # ... define a partial differential operator as a lambda function from sympy.abc import x from sympy import sin, cos Dt = 0.0010995574287564279 nu_expected = 0.07 from numpy import genfromtxt xn = genfromtxt('x.txt') unew = genfromtxt('unew.txt') un = genfromtxt('un.txt') from scipy.interpolate import interp1d unew = interp1d(xn, unew) un = interp1d(xn, un) fn = Function('fn') L = lambda u: u + Dt*fn(x)*dx(u) + nu*Dt*dx(dx(u)) # ... # ... lambdification + evaluation from numpy import linspace, pi from numpy.random import rand # x_u = linspace(0, 2*pi, 30) x_u = rand(100) * 2*pi x_f = x_u us = un(x_u) fs = unew(x_f) # ... from numpy.random import rand from numpy import exp, ones, log from time import time from scipy.optimize import minimize from tabulate import tabulate # ... def solve(kernel): print('>>>> using : ', kernel) # compute the likelihood nlml = NLML(L(u), u, kernel) # set values nlml.set_u(x_u, us) nlml.set_f(x_f, fs) x_start = rand(len(nlml.args)) # methods = ['Nelder-Mead', 'Powell', 'CG', 'BFGS', 'L-BFGS-B', 'TNC', 'COBYLA'] # methods = ['Nelder-Mead', 'Powell', 'CG'] methods = ['Nelder-Mead'] phis = [] for method in methods: print('> {} method in progress ... '.format(method)) m = minimize(nlml, x_start, method=method, jac=False) args = exp(m.x) phi_h = nlml.map_args(args)['nu'] print('> estimated phi = ', phi_h) phis.append(phi_h) print(tabulate([phis], headers=methods)) # ... # for kernel in ['RBF', 'SE', 'GammaSE', 'RQ', 'Linear', 'Periodic']: # for kernel in ['RBF', 'SE']: for kernel in ['SE']: solve(kernel)
def test_est_2d_2(): u = Unknown('u', ldim=2) phi = Constant('phi') # ... define a partial differential operator as a lambda function L = lambda u: phi * u + dx(u) + dy(dy(u)) L_expected = lambda u: 2. * u + dx(u) + dy(dy(u)) # ... # ... symbolic functions for unknown and rhs from sympy.abc import x, y from sympy import sin, cos u_sym = x**2 + y f_sym = L_expected(u_sym) # ... # ... lambdification + evaluation from numpy import linspace, meshgrid, zeros from numpy.random import rand u_num = lambdify((x, y), u_sym, "numpy") f_num = lambdify((x, y), f_sym, "numpy") x_u = rand(50, 2) x_f = x_u us = u_num(x_u[:, 0], x_u[:, 1]) fs = f_num(x_f[:, 0], x_f[:, 1]) # ... # eps = 1.e-6 eps = 1.e-5 # eps = 1.e-4 niter = 10 # niter = 1 phis = [] scores = [] for i in range(0, niter): print('> sample ', i) # compute the likelihood # nlml = NLML(L(u), u, 'CSE', debug=False) nlml = NLML(L(u), u, 'SE', debug=False) # set values nlml.set_u(x_u, us) nlml.set_f(x_f, fs) # ... using pure python implementation x_start = rand(len(nlml.args)) _nlml = lambda y: nlml(y, s_u=eps, s_f=eps) m = nelder_mead(_nlml, x_start, step=0.1, no_improve_thr=10e-4, no_improv_break=4, max_iter=0, alpha=.5, gamma=1.5, rho=-0.5, sigma=0.5, verbose=False) args = exp(m[0]) score = m[1] phis.append(nlml.map_args(args)['phi']) scores.append(score) # ... phis = asarray(phis) scores = asarray(scores) i_max = argmax(scores) print(phis[i_max]) print(scores[i_max]) print(scores) print(phis)
def test_est_2d_3(): u = Unknown('u', ldim=2) phi = Constant('phi') # ... define a partial differential operator as a lambda function L = lambda u: phi * u + dx(u) + dy(dy(u)) L_expected = lambda u: 2. * u + dx(u) + dy(dy(u)) # ... # ... symbolic functions for unknown and rhs from sympy.abc import x, y from sympy import sin, cos u_sym = x**2 + y f_sym = L_expected(u_sym) # ... # ... lambdification + evaluation from numpy import linspace, meshgrid, zeros from numpy.random import rand u_num = lambdify((x, y), u_sym, "numpy") f_num = lambdify((x, y), f_sym, "numpy") x_u = rand(50, 2) x_f = x_u us = u_num(x_u[:, 0], x_u[:, 1]) fs = f_num(x_f[:, 0], x_f[:, 1]) # ... # compute the likelihood # nlml = NLML(L(u), u, 'SE') nlml = NLML(L(u), u, 'RBF') # set values nlml.set_u(x_u, us) nlml.set_f(x_f, fs) from numpy.random import rand, normal from numpy import exp, ones, log # ... using pure python implementation from symgp.nelder_mead import nelder_mead phi_expected = 2. phi_var = 0.5 n_samples = 1000 x_starts = rand(len(nlml.args), n_samples) i_phi = list(nlml.args).index('phi') x_starts[i_phi, :] = log(normal(phi_expected, phi_var, n_samples)) phis = [] scores = [] phiso = [] scoreso = [] for i in range(0, n_samples): print('> sample ', i) x_start = x_starts[:, i] # ... def f(params): params[i_phi] = x_starts[i_phi, i] return nlml(params) m = nelder_mead(f, x_start, step=0.1, no_improve_thr=10e-4, no_improv_break=4, max_iter=0, alpha=.5, gamma=1.5, rho=-0.5, sigma=0.5, verbose=False) args = exp(m[0]) score = m[1] phis.append(nlml.map_args(args)['phi']) scores.append(score) # ... # ... m = nelder_mead(nlml, x_start, step=0.1, no_improve_thr=10e-4, no_improv_break=4, max_iter=0, alpha=.5, gamma=1.5, rho=-0.5, sigma=0.5, verbose=False) args = exp(m[0]) score = m[1] phiso.append(nlml.map_args(args)['phi']) scoreso.append(score) # ... from numpy import savetxt savetxt('est_2d/phis.txt', asarray(phis)) savetxt('est_2d/scores.txt', asarray(scores)) savetxt('est_2d/phiso.txt', asarray(phiso)) savetxt('est_2d/scoreso.txt', asarray(scoreso)) plt.plot(phis, scores, '.b', label=r'fixed $\phi$', alpha=0.4) plt.plot(phiso, scoreso, '.r', label=r'free $\phi$', alpha=0.4) plt.axvline(x=phi_expected, color='green', alpha=0.5) plt.xlabel(r'$\phi$') plt.ylabel(r'Likelihood $\mathcal{L}$') title = '$L u := {}$'.format(latex(L(u))) title += '\n' title += r'$\phi_{exact}' + ' := {}$'.format(phi_expected) plt.title(title) plt.legend() plt.show()
def test_est_2d_1(): u = Unknown('u', ldim=2) phi = Constant('phi') # ... define a partial differential operator as a lambda function L = lambda u: phi * u + dx(u) + dy(dy(u)) L_expected = lambda u: 2. * u + dx(u) + dy(dy(u)) # ... # ... symbolic functions for unknown and rhs from sympy.abc import x, y from sympy import sin, cos u_sym = x**2 + y f_sym = L_expected(u_sym) # ... # ... lambdification + evaluation from numpy import linspace, meshgrid, zeros from numpy.random import rand u_num = lambdify((x, y), u_sym, "numpy") f_num = lambdify((x, y), f_sym, "numpy") # t = linspace(0, 1, 5) # x,y = meshgrid(t, t) # x_u = zeros((x.size, 2)) # x_u[:,0] = x.reshape(x.size) # x_u[:,1] = y.reshape(y.size) x_u = rand(100, 2) x_f = x_u us = u_num(x_u[:, 0], x_u[:, 1]) fs = f_num(x_f[:, 0], x_f[:, 1]) # ... # compute the likelihood debug = True nlml = NLML(L(u), u, 'SE', debug=debug) # set values nlml.set_u(x_u, us) nlml.set_f(x_f, fs) from numpy.random import rand from numpy import exp, ones, log # ... using pure python implementation from symgp.nelder_mead import nelder_mead x_start = rand(len(nlml.args)) print('> x_start = ', x_start) m = nelder_mead(nlml, x_start, step=0.1, no_improve_thr=10e-4, no_improv_break=4, max_iter=0, alpha=.5, gamma=1.5, rho=-0.5, sigma=0.5, verbose=False) args = exp(m[0]) print('> estimated phi = ', nlml.map_args(args)['phi']) if debug: plt.xlabel('number of data') plt.ylabel(r'eigenvalues in log-scale') plt.legend() plt.show()