def test_pseudospectral_approximation_tensor(self): def expfun(x): return np.exp(x[0] + x[1]) + 0.5 * np.cos(x[0] * 2 * np.pi) # Compare actual function with polynomial approximation s = Parameter(lower=-1, upper=1, points=6) T = IndexSet('Tensor grid', [5, 5]) uq = Polynomial([s, s], T) num_elements = 10 coefficients, index_set, evaled_pts = uq.getPolynomialCoefficients( expfun) pts, x1, x2 = meshgrid(-1.0, 1.0, num_elements, num_elements) Approx = uq.getPolynomialApproximation(expfun, pts, coefficients) A = np.reshape(Approx, (num_elements, num_elements)) fun = evalfunction(pts, expfun) # Now plot this surface fig = plt.figure() ax = fig.gca(projection='3d') surf = ax.plot_surface(x1, x2, A, rstride=1, cstride=1, cmap=cm.winter, linewidth=0, antialiased=False, alpha=0.5) ax.scatter(x1, x2, fun, 'ko') ax.set_zlim(0, 10) ax.set_xlabel('x1') ax.set_ylabel('x2') ax.set_zlabel('Response') fig.colorbar(surf, shrink=0.5, aspect=5)
def gradients_univariate(): # Parameters! pt = 8 x1 = Parameter(param_type="Uniform", lower=-1.0, upper=1.0, points=pt, derivative_flag=1) x2 = Parameter(param_type="Uniform", lower=-1.0, upper=1.0, points=pt, derivative_flag=1) parameters = [x1, x2] dims = len(parameters) # Basis selection! hyperbolic_cross = IndexSet("Total order", orders=[pt-1,pt-1]) esq = EffectiveSubsampling(parameters, hyperbolic_cross) A , p, w = esq.getAmatrix() C = esq.getCmatrix() # Matrix sizes m, n = A.shape print m, n print '*****************' m, n = C.shape print m, n # Now perform least squares! W = np.mat(np.diag(np.sqrt(w))) b = W.T * evalfunction(p, fun) d = evalgradients(p, fungrad, 'vector') x = qr.solveLSQ(np.vstack([A, C]), np.vstack([b, d]) ) print x
def gradients_univariate_subsampled(): # Parameters! pt = 8 x1 = Parameter(param_type="Uniform", lower=-1.0, upper=1.0, points=pt, derivative_flag=1) parameters = [x1] dims = len(parameters) # Basis selection! basis = IndexSet("Total order", orders=[pt-1]) esq = EffectiveSubsampling(parameters, basis) A , p, w = esq.getAmatrix() C = esq.getCmatrix() # QR column pivotings P = qr.mgs_pivoting(A.T) # Now perform least squares! basis_terms_required = basis.getCardinality() minimum_points = np.int( (basis_terms_required + dims)/(dims + 1.) ) nodes = P[0:minimum_points] A = getRows(A, nodes) C = getRows(C, nodes) #print 'Size of subsampled matrices!' #m, n = A.shape #print m , n #m, n = C.shape #print m, n # Subselection! w = w[nodes] p = p[nodes,:] W = np.mat(np.diag(np.sqrt(w))) b = W.T * evalfunction(p, fun) d = evalgradients(p, fungrad, 'vector') R = np.vstack([A, C]) # Stacked least squares problem! #x = qr.solveLSQ(np.vstack([A, C]), np.vstack([b, d]) ) #print '\n' #print 'Final Solution!' #print x #print A #print C #print b #print d # Direct Elimination least squares! x = qr.solveCLSQ(A, b, C, d)
def nogradients_univariate(): # Parameters! pt = 6 x1 = Parameter(param_type="Uniform", lower=-1.0, upper=1.0, points=pt) parameters = [x1, x1] # Effective subsampling object! esq = EffectiveSubsampling(parameters) # Solve the least squares problem A, p, w = esq.getAmatrix() # Is this always square?? W = np.mat(np.diag(np.sqrt(w) ) ) b = W.T * evalfunction(p, fun) x = qr.solveLSQ(A,b) print x
def gradients_multivariate_subsampled(): # Parameters! pt = 3 x1 = Parameter(param_type="Uniform", lower=-1.0, upper=1.0, points=pt, derivative_flag=1) x2 = Parameter(param_type="Uniform", lower=-1.0, upper=1.0, points=pt, derivative_flag=1) parameters = [x1, x2] dims = len(parameters) # Basis selection! basis = IndexSet("Total order", orders=[pt-1,pt-1]) esq = EffectiveSubsampling(parameters, basis) A , p, w = esq.getAmatrix() C = esq.getCmatrix() # QR column pivotings P = qr.mgs_pivoting(A.T) # Now perform least squares! basis_terms_required = basis.getCardinality() minimum_points = np.int( (basis_terms_required + dims)/(dims + 1.) ) + 5 nodes = P[0:minimum_points] A = getRows(A, nodes) C = getRowsC(C, nodes, dims) m, n = A.shape #print m , n m, n = C.shape #print m, n w = w[nodes] p = p[nodes,:] #print p, w W = np.mat(np.diag(np.sqrt(w))) b = W.T * evalfunction(p, fun) d = evalgradients(p, fungrad, 'vector') R = np.vstack([A, C]) print np.linalg.cond(R) print R print np.vstack([b, d]) x = qr.solveLSQ(np.vstack([A, C]), np.vstack([b, d]) ) print '\n' print x """
def run(value): def fun(x): return np.exp(x[0] + 0.5*x[1]) def fungrad(x): return [ np.exp(x[0] + 0.5*x[1]), 0.5*np.exp(x[0] + 0.5*x[1]) ] ############################################################################################### # Tensor grid solution! ################################################################################################ value_large = 80 x1 = Parameter(param_type="Uniform", lower=-1, upper=1, points=value_large) x2 = Parameter(param_type="Uniform", lower=-1, upper=1, points=value_large) uq = Polynomial([x1,x2]) all_coefficients, all_indices, evaled_pts = uq.getPolynomialCoefficients(fun) """ x,y,z, max_order = twoDgrid(all_coefficients, all_indices) z = np.log10(np.abs(z)) Zm = np.ma.masked_where(np.isnan(z),z) plt.pcolor(y,x, Zm, cmap='jet', vmin=-16, vmax=0) plt.title('SPAM coefficients') plt.xlabel('i1') plt.ylabel('i2') plt.colorbar() plt.xlim(0,max_order) plt.ylim(0,max_order) plt.show() sys.exit() """ ################################################################################ # Now with gradients and reducing the number of basis terms ################################################################################ x1 = Parameter(param_type="Uniform", lower=-1, upper=1, points=value, derivative_flag=1) x2 = Parameter(param_type="Uniform", lower=-1, upper=1, points=value, derivative_flag=1) parameters = [x1, x2] hyperbolic_cross = IndexSet("Hyperbolic basis", orders=[value-1,value-1], q=1.0) esq = EffectiveSubsampling(parameters, hyperbolic_cross) # 1. Determine least number of subsamples required! minimum_subsamples = esq.least_no_of_subsamples_reqd() esq.set_no_of_evals(minimum_subsamples) # 2. Store function & gradient values! fun_values = evalfunction(esq.subsampled_quadrature_points, fun) grad_values = evalgradients(esq.subsampled_quadrature_points, fungrad, 'matrix') # 3. Compute coefficients & errors using the two techniques! #print esq.no_of_basis_terms #esq.prune(np.rint( 0.2 * esq.no_of_basis_terms)) #print esq.no_of_basis_terms #print '\n' x , cond = esq.computeCoefficients(fun_values, grad_values, 'weighted') x_DE, cond_DE = esq.computeCoefficients(fun_values, grad_values, 'constrainedDE') x_NS, cond_NS = esq.computeCoefficients(fun_values, grad_values, 'constrainedNS') error , notused = compute_errors(all_coefficients, all_indices, x, esq.index_set.getIndexSet() ) error_DE, notused = compute_errors(all_coefficients, all_indices, x_DE, esq.index_set.getIndexSet() ) error_NS, notused = compute_errors(all_coefficients, all_indices, x_NS, esq.index_set.getIndexSet() ) return error, error_DE, error_NS, cond, cond_DE, cond_NS, esq.no_of_basis_terms, minimum_subsamples
def run(value): def fun(x): return np.exp(x[0] + 0.5*x[1]) def fungrad(x): # 0 mean error with a standard deviation of 1e-5 return [ np.exp(x[0] + 0.5*x[1])+ 0.00001 * np.random.rand(1) , 0.5*np.exp(x[0] + 0.5*x[1]) + 0.00001 * np.random.rand(1) ] ############################################################################################### # Tensor grid solution! ################################################################################################ value_large = 80 x1 = Parameter(param_type="Uniform", lower=-1, upper=1, points=value_large) x2 = Parameter(param_type="Uniform", lower=-1, upper=1, points=value_large) uq = Polynomial([x1,x2]) all_coefficients, all_indices, evaled_pts = uq.getPolynomialCoefficients(fun) """ x,y,z, max_order = twoDgrid(all_coefficients, all_indices) z = np.log10(np.abs(z)) Zm = np.ma.masked_where(np.isnan(z),z) plt.pcolor(y,x, Zm, cmap='jet', vmin=-16, vmax=0) plt.title('SPAM coefficients') plt.xlabel('i1') plt.ylabel('i2') plt.colorbar() plt.xlim(0,max_order) plt.ylim(0,max_order) plt.show() sys.exit() """ ################################################################################ # Now with gradients and reducing the number of basis terms ################################################################################ x1 = Parameter(param_type="Uniform", lower=-1, upper=1, points=value, derivative_flag=1) x2 = Parameter(param_type="Uniform", lower=-1, upper=1, points=value, derivative_flag=1) parameters = [x1, x2] hyperbolic_cross = IndexSet("Hyperbolic basis", orders=[value-1,value-1], q=1.0) esq = EffectiveSubsampling(parameters, hyperbolic_cross) # 1. Determine least number of subsamples required! minimum_subsamples = esq.least_no_of_subsamples_reqd() esq.set_no_of_evals(minimum_subsamples) # 2. Store function & gradient values! error_store = 0 error_DE_store = 0 error_NS_store = 0 for k in range(0, 25): fun_values = evalfunction(esq.subsampled_quadrature_points, fun) grad_values = evalgradients(esq.subsampled_quadrature_points, fungrad, 'matrix') x , cond = esq.computeCoefficients(fun_values, grad_values, 'weighted') x_DE, cond_DE = esq.computeCoefficients(fun_values, grad_values, 'constrainedDE') x_NS, cond_NS = esq.computeCoefficients(fun_values, grad_values, 'constrainedNS') error, error_vec = compute_errors(all_coefficients, all_indices, x, esq.index_set.getIndexSet() ) error_DE, error_vecDE = compute_errors(all_coefficients, all_indices, x_DE, esq.index_set.getIndexSet() ) error_NS, error_vecNS = compute_errors(all_coefficients, all_indices, x_NS, esq.index_set.getIndexSet() ) error_store = error_store + error error_DE_store = error_DE_store + error_DE error_NS_store = error_NS_store + error_NS #plt.semilogy(x, 'kx', markersize=15, linewidth=3, label='Weighted') #plt.semilogy(x_DE, 'bo', markersize=14, linewidth=3, label='Constrained-DE', alpha=0.5) #plt.semilogy(x_NS, 'gs', markersize=10, linewidth=3, label='Constrained-NS', alpha=0.4) plt.semilogy(error_vec, 'kx', markersize=15, linewidth=3, label='Weighted') plt.semilogy(error_vecDE, 'bo', markersize=14, linewidth=3, label='Constrained-DE', alpha=0.5) plt.semilogy(error_vecNS, 'gs', markersize=10, linewidth=3, label='Constrained-NS', alpha=0.4) plt.xlabel(r'Basis terms', fontsize=16) plt.ylabel(r'Coefficient errors', fontsize=16) plt.savefig('Errors.eps', format='eps', dpi=200, bbox_inches='tight') print error_store / 50.0 print error_DE_store / 50.0 print error_NS_store / 50.0 #fig = plt.figure() #ax = plt.subplot(111) #plt.semilogy(error_vec, 'r<', markersize=15, linewidth=3, label='Weighted') #plt.semilogy(error_vecDE, 'bo', markersize=14, linewidth=3, label='Constrained-DE', alpha=0.5) #plt.semilogy(error_vecNS, 'gs', markersize=10, linewidth=3, label='Constrained-NS', alpha=0.4) #plt.xlabel(r'Basis terms', fontsize=16) #plt.ylabel(r'Coefficient error', fontsize=16) #plt.legend(loc=1) #plt.savefig('Errors.eps', format='eps', dpi=600, bbox_inches='tight') return error, error_DE, error_NS, cond, cond_DE, cond_NS, esq.no_of_basis_terms, minimum_subsamples