def eval(cls, *args): if not (len(args) == 2): raise ValueError('> Expecting two arguments') if isinstance(args[0], Symbol): ldim = 1 elif isinstance(args[0], (tuple, list, Tuple)): ldim = len(args[0]) # TODO must check that all arguments are of the same type (Symbols or # tuples) if ldim == 1: raise NotImplementedError('') elif ldim == 2: theta_1 = Constant('theta_1') theta_2 = Constant('theta_2') l_1 = Constant('l_1') l_2 = Constant('l_2') l_12 = Constant('l_12') xi, yi = args[0] xj, yj = args[1] expr_1 = theta_1 * exp(-0.5 * (xi - xj)**2 / l_1**2) expr_2 = theta_2 * exp(-0.5 * (yi - yj)**2 / l_2**2) expr_12 = exp(-(xi - xj) * (yi - yj) / l_12) expr = expr_1 * expr_2 * expr_12 elif ldim == 3: raise NotImplementedError('') return expr
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_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_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_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 eval(cls, *args): if not (len(args) == 2): raise ValueError('> Expecting two arguments') if isinstance(args[0], Symbol): ldim = 1 elif isinstance(args[0], (tuple, list, Tuple)): ldim = len(args[0]) # TODO must check that all arguments are of the same type (Symbols or # tuples) theta_b = Constant('theta_b') theta_v = Constant('theta_v') if ldim == 1: c_1 = Constant('c_1') xi, xj = args expr = theta_b + theta_v * (xi - c_1) * (xj - c_1) elif ldim == 2: c_1 = Constant('c_1') c_2 = Constant('c_2') xi, yi = args[0] xj, yj = args[1] expr = theta_b + theta_v * ((xi - c_1) * (xj - c_1) + (yi - c_2) * (yj - c_2)) elif ldim == 3: c_1 = Constant('c_1') c_2 = Constant('c_2') c_3 = Constant('c_3') xi, yi, zi = args[0] xj, yj, zj = args[1] expr = theta_b + theta_v * ((xi - c_1) * (xj - c_1) + (yi - c_2) * (yj - c_2) + (zi - c_3) * (zj - c_3)) return expr
def eval(cls, *args): if not (len(args) == 2): raise ValueError('> Expecting two arguments') if isinstance(args[0], Symbol): ldim = 1 elif isinstance(args[0], (tuple, list, Tuple)): ldim = len(args[0]) # TODO must check that all arguments are of the same type (Symbols or # tuples) if ldim == 1: theta_1 = Constant('theta_1') xi, xj = args expr = theta_1 * exp(-0.5 * (xi - xj)**2) elif ldim == 2: theta_1 = Constant('theta_1') theta_2 = Constant('theta_2') xi, yi = args[0] xj, yj = args[1] expr_1 = theta_1 * exp(-0.5 * (xi - xj)**2) expr_2 = theta_2 * exp(-0.5 * (yi - yj)**2) expr = expr_1 * expr_2 elif ldim == 3: theta_1 = Constant('theta_1') theta_2 = Constant('theta_2') theta_3 = Constant('theta_3') xi, yi, zi = args[0] xj, yj, zj = args[1] expr_1 = theta_1 * exp(-0.5 * (xi - xj)**2) expr_2 = theta_2 * exp(-0.5 * (yi - yj)**2) expr_3 = theta_3 * exp(-0.5 * (zi - zj)**2) expr = expr_1 * expr_2 * expr_3 return expr
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)
from sympy import Expr, Basic, Add from sympy.core.function import UndefinedFunction from sympy import exp from symfe import dx, Unknown, Constant from symgp.kernel import Kernel from symgp.kernel import RBF from symgp.kernel import evaluate from symgp.kernel import update_kernel u = Unknown('u', ldim=1) xi = Symbol('xi') xj = Symbol('xj') theta_1 = Constant('theta_1') alpha = Constant('alpha') def test_kernel_1d_1(): L = u # ... K = evaluate(L, u, Kernel('K'), xi) K = update_kernel(K, RBF, (xi, xj)) expected = theta_1*exp(-0.5*(xi - xj)**2) assert(K == expected) # ... # ... K = evaluate(L, u, Kernel('K'), xj)
from sympy import exp from sympy import simplify from symfe import dx, dy, Unknown, Constant from symgp.kernel import Kernel from symgp.kernel import RBF from symgp.kernel import evaluate from symgp.kernel import update_kernel u = Unknown('u', ldim=2) xi = Symbol('xi') yi = Symbol('yi') xj = Symbol('xj') yj = Symbol('yj') theta_1 = Constant('theta_1') theta_2 = Constant('theta_2') phi = Constant('phi') def test_kernel_2d_1(): L = u # ... K = evaluate(L, u, Kernel('K'), (Tuple(xi, yi))) K = update_kernel(K, RBF, ((xi, yi), (xj, yj))) expected = theta_1 * theta_2 * exp(-0.5 * (xi - xj)**2) * exp(-0.5 * (yi - yj)**2) assert (K == expected) # ...
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()