def __init__(self, b, d, dim=1, X=None, Y=None): ''' Constructor for the class Tensorizer. If dim == 1, defines a map t from [0,1] to {0,...,b-1}^d x [0,1] t(x) = (i_1, ..., i_d, y) with y in [0,1] and i_k in {0, ..., b-1} such that x = (i + y)b^(-d) with i in {0, ..., b^d-1} having the following representation in base b: i = sum_{k=1}^d i_k b^(d-k) in [0,b^d-1]. If dim != 1, defines a map t from [0,1]^dim to {{0, ..., b-1}^d}^dim x [0,1]^dim if property orderingType == 1, or from [0,1]^dim to {{0, ..., b-1}^dim}^d x [0,1]^dim if property orderingType == 2. Parameters ---------- b : int The base of the map. d : int The resolution of the map. dim : int, optional The input dimension of the function to be tensorized. The default is 1. X : tensap.RandomVector, optional Random vector used for the map. The default is None a uniform random vector on [0, 1]^dim. Y : tensap.RandomVector, optional Random vector used for the map. The default is None a uniform random vector on [0, 1]^dim. ordering_type : int Integer specifying the ordering type of the variables. The default is 1. Returns ------- None. ''' self.dim = dim self.b = b self.d = d self.ordering_type = 1 if X is not None: if isinstance(X, tensap.RandomVariable): X = tensap.RandomVector(X, self.dim) self.X = X else: self.X = tensap.RandomVector(tensap.UniformRandomVariable(0, 1), self.dim) if Y is not None: if isinstance(Y, tensap.RandomVariable): Y = tensap.RandomVector(Y, self.dim) self.Y = Y else: self.Y = tensap.RandomVector(tensap.UniformRandomVariable(0, 1), self.dim)
def lhs_random(self, n, p=1): ''' Latin Hypercube Sampling of the random variable self of n points in dimension p. Requires the package pyDOE. Parameters ---------- n : int Number of points. p : int, optional The dimension. The default is 1. Returns ------- numpy.ndarray The coordinates of the Latin Hypercube Sampling in each dimension. ''' from pyDOE import lhs A = lhs(p, samples=n) U = tensap.UniformRandomVariable(0, 1) A = [U.transfer(self, A[:, i]) for i in range(A.shape[1])] return np.transpose(np.array(A))
def shift(self, bias, scaling): ''' Shift the uniform random variable using the provided bias and scaling factor. The lower bound inf becomes scaling*inf + bias, and the upper bound sup becomes scaling*sup + bias. Parameters ---------- bias : float The bias. scaling : float The scaling factor. Returns ------- shifted_rv : tensap.UniformRandomVariable The shifted uniform random variable. ''' shifted_rv = tensap.UniformRandomVariable(self.inf, self.sup) shifted_rv.inf = scaling * shifted_rv.inf + bias shifted_rv.sup = scaling * shifted_rv.sup + bias return shifted_rv
def get_standard_random_variable(): ''' Return the standard uniform random variable on [-1, 1]. Returns ------- tensap.UniformRandomVariable The standard uniform random variable. ''' return tensap.UniformRandomVariable()
def __init__(self, n=50): ''' Constructor for the class LegendrePolynomials. Parameters ---------- n : int, optional The highest degree for which a polynomial can be computed with the stored recurrence coefficients. The default is 50. Returns ------- None. ''' self.measure = tensap.UniformRandomVariable(-1, 1) self._recurrence_coefficients, self._orthogonal_polynomials_norms = \ self._recurrence(n)
def gauss_integration_rule(self, nb_pts): ''' Return the nb_pts-points gauss integration rule associated with the measure of self, using Golub-Welsch algorithm. Parameters ---------- nb_pts : int The number of integration points. Returns ------- tensap.IntegrationRule The integration rule associated with the measure of self. ''' RV = tensap.UniformRandomVariable(self.a, self.b) I = RV.gauss_integration_rule(nb_pts) I.weights = I.weights * self.mass() return I
def lhs_random(self, n): ''' Latin Hypercube Sampling of the RandomVector of n points. Requires the package pyDOE. Parameters ---------- n : int Number of points. Returns ------- list List containing the coordinates of the Latin Hypercube Sampling in each dimension. ''' from pyDOE import lhs A = lhs(self.size, samples=n) A = RandomVector(tensap.UniformRandomVariable(0, 1), self.size).transfer(self, A) return [A[:, k] for k in range(self.size)]
import sys import numpy as np import matplotlib.pyplot as plt sys.path.insert(0, './../../../') import tensap # %% Interpolation on a polynomial space using Chebyshev Points def FUN(x): # Function to approximate return np.cos(10*x) FUN = tensap.UserDefinedFunction(FUN, 1) FUN.evaluation_at_multiple_points = True X = tensap.UniformRandomVariable(-1, 1) # Interpolation basis and points P = 30 H = tensap.PolynomialFunctionalBasis(X.orthonormal_polynomials(), range(P+1)) X_CP = tensap.chebyshev_points(H.cardinal(), [-1, 1]) # Interpolation of the function F = H.interpolate(FUN, X_CP) # Displays and error print('Interpolation on a polynomial space using Chebyshev Points') plt.figure() X_PLOT = np.linspace(-1, 1, 100) plt.plot(X_PLOT, FUN(X_PLOT)) plt.plot(X_PLOT, F(X_PLOT))
''' import sys from time import time import numpy as np import matplotlib.pyplot as plt sys.path.insert(0, './../../../') import tensap # %% Function to approximate: identification of a function f(x) with a function # g(i1,...,id,y) (see also tutorial_TensorizedFunction) R = 4 # Resolution B = 5 # Scaling factor ORDER = R + 1 X = tensap.UniformRandomVariable(0, 1) Y = tensap.UniformRandomVariable(0, 1) CHOICE = 1 if CHOICE == 1: def FUN(x): return np.sin(10 * np.pi * (2 * x + 0.5)) / (4 * x + 1) + (2 * x - 0.5)**4 elif CHOICE == 2: def FUN(x): return (np.sin(4*np.pi*x) + 0.2*np.cos(16*np.pi*x))**(x < 0.5) + \ (2*x-1)*(x >= 0.5) else: raise ValueError('Bad function choice.')
''' from time import time import numpy as np from scipy.stats import multivariate_normal import tensap # %% Function to approximate: multivariate gaussian distribution ORDER = 6 # Covariance matrix S = np.array([[2, 0, 0.5, 1, 0, 0.5], [0, 1, 0, 0, 0.5, 0], [0.5, 0, 2, 0, 0, 1], [1, 0, 0, 3, 0, 0], [0, 0.5, 0, 0, 1, 0], [0.5, 0, 1, 0, 0, 2]]) # Reference measure REF = tensap.RandomVector( [tensap.UniformRandomVariable(-x, x) for x in 5 * np.diag(S)]) # Density, defined with respect to the reference measure def U(x): return multivariate_normal.pdf(x, np.zeros(ORDER), S) * \ np.prod(2*5*np.diag(S)) # %% Training and test samples NUM_TRAIN = 1e5 # Training sample size X_TRAIN = multivariate_normal.rvs(np.zeros(ORDER), S, int(NUM_TRAIN)) NUM_TEST = 1e4 # Test sample size X_TEST = multivariate_normal.rvs(np.zeros(ORDER), S, int(NUM_TEST))
# %% Choice of the function to approximate CHOICE = 2 if CHOICE == 1: print('Henon-Heiles') D = 5 FUN, X = tensap.multivariate_functions_benchmark('henon_heiles', D) DEGREE = 4 BASES = [tensap.PolynomialFunctionalBasis(x.orthonormal_polynomials(), range(DEGREE+1)) for x in X.random_variables] elif CHOICE == 2: print('Anisotropic function') D = 6 X = tensap.RandomVector(tensap.UniformRandomVariable(-1, 1), D) def FUN(x): return 1/(10 + 2*x[:, 0] + x[:, 2] + 2*x[:, 3] - x[:, 4])**2 DEGREE = 13 BASES = [tensap.PolynomialFunctionalBasis(x.orthonormal_polynomials(), range(DEGREE+1)) for x in X.random_variables] elif CHOICE == 3: print('Sinus of a sum') D = 10 X = tensap.RandomVector(tensap.UniformRandomVariable(-1, 1), D) def FUN(x):
G1 = np.linspace(DOM[0], DOM[1], 100) G = tensap.FullTensorGrid(G1, D).array() else: G1 = np.linspace(DOM[0], DOM[1], 1000) M1 = P1.magic_points(G1)[0] G = tensap.FullTensorGrid(np.ravel(M1), D).array() MAGIC_POINTS, IND, OUTPUT = P.magic_points(G) if D == 2: plt.figure() plt.plot(G[:, 0], G[:, 1], 'k.', markersize=1) plt.plot(MAGIC_POINTS[:, 0], MAGIC_POINTS[:, 1], 'ro', fillstyle='none') plt.show() # %% Interpolation of a function using magic points D = 2 def F(x): return np.cos(x[:, 0]) + x[:, 1]**6 + x[:, 0]**2*x[:, 1] IF = P.interpolate(F, MAGIC_POINTS) X = tensap.RandomVector(tensap.UniformRandomVariable(), D) N_TEST = 1000 X_TEST = X.random(N_TEST) ERR = np.linalg.norm(IF(X_TEST) - F(X_TEST)) / np.linalg.norm(F(X_TEST)) print('Test error = %2.5e' % ERR)
NotImplementedError If the function is not implemented. Returns ------- function The asked function. tensap.RandomVector Input random variables. ''' if case == 'borehole': X = np.empty(8, dtype=object) X[0] = tensap.NormalRandomVariable(0.1, 0.0161812) X[1] = tensap.NormalRandomVariable(0, 1) X[2] = tensap.UniformRandomVariable(63070, 115600) X[3] = tensap.UniformRandomVariable(990, 1110) X[4] = tensap.UniformRandomVariable(63.1, 116) X[5] = tensap.UniformRandomVariable(700, 820) X[6] = tensap.UniformRandomVariable(1120, 1680) X[7] = tensap.UniformRandomVariable(9855, 12045) X = tensap.RandomVector(X) def fun(x): return 2 * np.pi * x[:, 2] * (x[:, 3] - x[:, 5]) / \ (np.log(np.exp(7.71 + 1.0056*x[:, 1]) / x[:, 0]) * (1 + 2 * x[:, 6] * x[:, 2] / np.log(np.exp(7.71 + 1.0056 * x[:, 1]) / x[:, 0]) / x[:, 0]**2 / x[:, 7] + x[:, 2] / x[:, 4])) elif case == 'ishigami':