def fit(self, X, y, **fit_params): input_dimension = X.shape[1] if self.distribution is None: self.distribution = BuildDistribution(X) if self.enumerate == 'linear': enumerateFunction = ot.LinearEnumerateFunction(input_dimension) elif self.enumerate == 'hyperbolic': enumerateFunction = ot.HyperbolicAnisotropicEnumerateFunction(input_dimension, self.q) else: raise ValueError('enumerate should be "linear" or "hyperbolic"') polynomials = [ot.StandardDistributionPolynomialFactory(self.distribution.getMarginal(i)) for i in range(input_dimension)] productBasis = ot.OrthogonalProductPolynomialFactory(polynomials, enumerateFunction) adaptiveStrategy = ot.FixedStrategy(productBasis, enumerateFunction.getStrataCumulatedCardinal(self.degree)) if self.sparse: projectionStrategy = ot.LeastSquaresStrategy(ot.LeastSquaresMetaModelSelectionFactory(ot.LARS(), ot.CorrectedLeaveOneOut())) else: projectionStrategy = ot.LeastSquaresStrategy(X, y.reshape(-1, 1)) algo = ot.FunctionalChaosAlgorithm(X, y.reshape(-1, 1), self.distribution, adaptiveStrategy, projectionStrategy) algo.run() self._result = algo.getResult() output_dimension = self._result.getMetaModel().getOutputDimension() # sensitivity si = ot.FunctionalChaosSobolIndices(self._result) if output_dimension == 1: self.feature_importances_ = [si.getSobolIndex(i) for i in range(input_dimension)] else: self.feature_importances_ = [[0.0] * input_dimension] * output_dimension for k in range(output_dimension): for i in range(input_dimension): self.feature_importances_[k][i] = si.getSobolIndex(i, k) self.feature_importances_ = np.array(self.feature_importances_) return self
def __init__(self, beta_coeff, idx_set, jpdf): self.beta_coeff = beta_coeff self.idx_set = idx_set self.jpdf = jpdf self.N = jpdf.getDimension() # get the distribution type of each random variable dist_types = [] for i in range(self.N): dist_type = self.jpdf.getMarginal(i).getName() dist_types.append(dist_type) # create orthogonal univariate bases poly_collection = ot.PolynomialFamilyCollection(self.N) for i in range(self.N): pdf = jpdf.getDistributionCollection()[i] algo = ot.AdaptiveStieltjesAlgorithm(pdf) poly_collection[i] = ot.StandardDistributionPolynomialFactory(algo) # create multivariate basis multivariate_basis = ot.OrthogonalProductPolynomialFactory( poly_collection, ot.EnumerateFunction(self.N)) # get enumerate function (multi-index handling) enum_func = multivariate_basis.getEnumerateFunction() # get epansion self.expansion = multivariate_basis.getSubBasis( transform_multi_index_set(idx_set, enum_func)) # create openturns surrogate model sur_model = ot.FunctionCollection() for i in range(len(self.expansion)): multi = str(beta_coeff[i]) + '*x' help_function = ot.SymbolicFunction(['x'], [multi]) sur_model.add(ot.ComposedFunction(help_function, self.expansion[i])) self.surrogate_model = np.sum(sur_model)
def _buildChaosAlgo(self, inputSample, outputSample): """ Build the functional chaos algorithm without running it. """ if self._distribution is None: # create default distribution : Uniform between min and max of the # input sample inputSample = ot.NumericalSample(inputSample) inputMin = inputSample.getMin() inputMin[0] = np.min(self._defectSizes) inputMax = inputSample.getMax() inputMax[0] = np.max(self._defectSizes) marginals = [ ot.Uniform(inputMin[i], inputMax[i]) for i in range(self._dim) ] self._distribution = ot.ComposedDistribution(marginals) # put description of the inputSample into decription of the distribution self._distribution.setDescription(inputSample.getDescription()) if self._adaptiveStrategy is None: # Create the adaptive strategy : default is fixed strategy of degree 5 # with linear enumerate function polyCol = [0.] * self._dim for i in range(self._dim): polyCol[i] = ot.StandardDistributionPolynomialFactory( self._distribution.getMarginal(i)) enumerateFunction = ot.EnumerateFunction(self._dim) multivariateBasis = ot.OrthogonalProductPolynomialFactory( polyCol, enumerateFunction) # default degree is 3 (in __init__) indexMax = enumerateFunction.getStrataCumulatedCardinal( self._degree) self._adaptiveStrategy = ot.FixedStrategy(multivariateBasis, indexMax) if self._projectionStrategy is None: # sparse polynomial chaos basis_sequence_factory = ot.LAR() fitting_algorithm = ot.KFold() approximation_algorithm = ot.LeastSquaresMetaModelSelectionFactory( basis_sequence_factory, fitting_algorithm) self._projectionStrategy = ot.LeastSquaresStrategy( inputSample, outputSample, approximation_algorithm) return ot.FunctionalChaosAlgorithm(inputSample, outputSample, \ self._distribution, self._adaptiveStrategy, self._projectionStrategy)
def fit(self, X, y, **fit_params): """Fit Tensor regression model. Parameters ---------- X : array-like, shape = (n_samples, n_features) Training data. y : array-like, shape = (n_samples, [n_output_dims]) Target values. Returns ------- self : returns an instance of self. """ if len(X) == 0: raise ValueError( "Can not perform a tensor approximation with empty sample") # check data type is accurate if (len(np.shape(X)) != 2): raise ValueError("X has incorrect shape.") input_dimension = len(X[1]) if (len(np.shape(y)) != 2): raise ValueError("y has incorrect shape.") if self.distribution is None: self.distribution = BuildDistribution(X) factoryCollection = [ ot.OrthogonalUniVariateFunctionFamily( ot.OrthogonalUniVariatePolynomialFunctionFactory( ot.StandardDistributionPolynomialFactory( self.distribution.getMarginal(i)))) for i in range(input_dimension) ] functionFactory = ot.OrthogonalProductFunctionFactory( factoryCollection) algo = ot.TensorApproximationAlgorithm(X, y, self.distribution, functionFactory, [self.nk] * input_dimension, self.max_rank) algo.run() self.result_ = algo.getResult() return self
# Create a distribution of dimension n # for example n=3 with indpendent components distribution = ot.ComposedDistribution( [ot.Normal(), ot.Uniform(), ot.Gamma(2.75, 1.0), ot.Beta(2.5, 1.0, -1.0, 2.0)]) # %% # Prepare the input/output samples sampleSize = 250 X = distribution.getSample(sampleSize) Y = myModel(X) dimension = X.getDimension() # %% # build the orthogonal basis coll = [ot.StandardDistributionPolynomialFactory(distribution.getMarginal(i)) for i in range(dimension)] enumerateFunction = ot.LinearEnumerateFunction(dimension) productBasis = ot.OrthogonalProductPolynomialFactory(coll, enumerateFunction) # %% # create the algorithm degree = 6 adaptiveStrategy = ot.FixedStrategy( productBasis, enumerateFunction.getStrataCumulatedCardinal(degree)) projectionStrategy = ot.LeastSquaresStrategy() algo = ot.FunctionalChaosAlgorithm(X, Y, distribution, adaptiveStrategy, projectionStrategy) algo.run() # %% # get the metamodel function result = algo.getResult()
import openturns as ot from openturns.viewer import View dim = 1 f = ot.SymbolicFunction(['x'], ['x*sin(x)']) uniform = ot.Uniform(0.0, 10.0) distribution = ot.ComposedDistribution([uniform] * dim) factoryCollection = [ ot.OrthogonalUniVariateFunctionFamily( ot.OrthogonalUniVariatePolynomialFunctionFactory( ot.StandardDistributionPolynomialFactory(uniform))) ] * dim functionFactory = ot.OrthogonalProductFunctionFactory(factoryCollection) size = 10 sampleX = [[1.0], [2.0], [3.0], [4.0], [5.0], [6.0], [7.0], [8.0]] sampleY = f(sampleX) nk = [5] * dim maxRank = 1 algo = ot.TensorApproximationAlgorithm(sampleX, sampleY, distribution, functionFactory, nk, maxRank) algo.run() result = algo.getResult() metamodel = result.getMetaModel() graph = f.draw(0.0, 10.0) graph.add(metamodel.draw(0.0, 10.0)) graph.add(ot.Cloud(sampleX, sampleY)) graph.setColors(['blue', 'red', 'black']) graph.setLegends(['model', 'meta model', 'sample']) graph.setLegendPosition('topleft') graph.setTitle('y(x)=x*sin(x)')
# borehole # dim = 8 # model = ot.SymbolicFunction(['rw', 'r', 'Tu', 'Hu', 'Tl', 'Hl', 'L', 'Kw'], #['(2*_pi*Tu*(Hu-Hl))/(ln(r/rw)*(1+(2*L*Tu)/(ln(r/rw)*rw^2*Kw)+Tu/Tl))']) # coll = [ot.Normal(0.1, 0.0161812), # ot.LogNormal(7.71, 1.0056), # ot.Uniform(63070.0, 115600.0), # ot.Uniform(990.0, 1110.0), # ot.Uniform(63.1, 116.0), # ot.Uniform(700.0, 820.0), # ot.Uniform(1120.0, 1680.0), # ot.Uniform(9855.0, 12045.0)] distribution = ot.ComposedDistribution(coll) factoryCollection = [ot.OrthogonalUniVariateFunctionFamily( ot.OrthogonalUniVariatePolynomialFunctionFactory(ot.StandardDistributionPolynomialFactory(dist))) for dist in coll] functionFactory = ot.OrthogonalProductFunctionFactory(factoryCollection) size = 1000 X = distribution.getSample(size) Y = model(X) # ot.ResourceMap.Set('TensorApproximationAlgorithm-Method', 'RankM') # n-d nk = [10] * dim maxRank = 5 algo = ot.TensorApproximationAlgorithm(
# with: # # .. math:: # v_j^{(i)} (x_j) = \sum_{k=1}^{n_j} \beta_{j,k}^{(i)} \phi_{j,k} (x_j) # # We should define : # # - The family of univariate functions :math:`\phi_j`. We choose the orthogonal basis with respect to the marginal distribution measures. # - The maximal rank :math:`m`. Here value is set to 5 # - The marginal degrees :math:`n_j`. Here we set the degrees to [4, 15, 3, 2] # # %% factoryCollection = [ ot.OrthogonalUniVariatePolynomialFunctionFactory( ot.StandardDistributionPolynomialFactory(_)) for _ in [E, F, L, I] ] functionFactory = ot.OrthogonalProductFunctionFactory(factoryCollection) nk = [4, 15, 3, 2] maxRank = 1 # %% # Finally we might launch the algorithm: # %% algo = ot.TensorApproximationAlgorithm(X_train, Y_train, myDistribution, functionFactory, nk, maxRank) algo.run() result = algo.getResult() metamodel = result.getMetaModel()
def alsace(func, N, jpdf, tol=1e-22, sample_type='R', limit_cond=5, max_fcalls=1000, seed=123, ed_file=None, ed_fevals_file=None, verbose=True, pce_dict={}): """ ALSACE - Approximations via Lower-Set and Least-Squares-based Adaptive Chaos Expansions func: function to be approximated. N: number of parameters. jpdf: joint probability density function. limit_cond: maximum allowed condition number of tr(inv(D.T*D)) sample_type: 'R'-random, 'L'-LHS seed: sampling seed tol, max_fcalls: exit criteria, self-explanatory. ed_file, ed_fevals_file: experimental design and corresponding evaluations 'act': activated, i.e. already part of the approximation. 'adm': admissible, i.e. candidates for the approximation's expansion. """ if not pce_dict: # if pce_dict is empty --> cold-start idx_act = [] idx_act.append([0] * N) # start with 0 multi-index idx_adm = [] # set seed ot.RandomGenerator.SetSeed(seed) ed_size = 2 * N # initial number of samples # initial experimental design and coresponding evaluations ed, ed_fevals = get_ed(func, jpdf, ed_size, sample_type=sample_type, knots=[], values=[], ed_file=ed_file, ed_fevals_file=ed_fevals_file) global_error_indicator = 1.0 # give arbitrary sufficiently large value # get the distribution type of each random variable dist_types = [] for i in range(N): dist_type = jpdf.getMarginal(i).getName() dist_types.append(dist_type) # create orthogonal univariate bases poly_collection = ot.PolynomialFamilyCollection(N) for i in range(N): pdf = jpdf.getDistributionCollection()[i] algo = ot.AdaptiveStieltjesAlgorithm(pdf) poly_collection[i] = ot.StandardDistributionPolynomialFactory(algo) # create multivariate basis mv_basis = ot.OrthogonalProductPolynomialFactory( poly_collection, ot.EnumerateFunction(N)) # get enumerate function (multi-index handling) enum_func = mv_basis.getEnumerateFunction() else: # get data from dictionary idx_act = pce_dict['idx_act'] idx_adm = pce_dict['idx_adm'] pce_coeff_act = pce_dict['pce_coeff_act'] pce_coeff_adm = pce_dict['pce_coeff_adm'] ed = pce_dict['ed'] ed_fevals = pce_dict['ed_fevals'] ed_size = len(ed_fevals) # compute local and global error indicators global_error_indicator = np.sum(np.array(pce_coeff_adm)**2) enum_func = pce_dict['enum_func'] mv_basis = pce_dict['mv_basis'] # while ed_size < max_fcalls and global_error_indicator > tol: # the index added last to the activated set is the one to be refined last_act_idx = idx_act[-1][:] # get admissible neighbors of the lastly added index adm_neighbors = admissible_neighbors(last_act_idx, idx_act) # update admissible indices idx_adm = idx_adm + adm_neighbors # get polynomial basis for the LS problem idx_ls = idx_act + idx_adm idx_ls_single = transform_multi_index_set(idx_ls, enum_func) ls_basis = mv_basis.getSubBasis(idx_ls_single) ls_basis_size = len(ls_basis) # construct the design matrix D and compute its QR decomposition D = get_design_matrix(ls_basis, ed) Q, R = sp.qr(D, mode='economic') # construct information matrix A= D^T*D A = np.matmul(D.T, D) / ed_size trAinv_test = np.sum(1. / np.linalg.eig(A)[0]) trAinv = np.trace(np.linalg.inv(A)) print('new trace ', trAinv_test) print('old trace ', trAinv) # If tr(A) becomes too large, enrich the ED until tr(A) becomes # acceptable or until ed_size reaches max_fcalls while (trAinv > limit_cond and ed_size < max_fcalls) or ed_size < ls_basis_size: # inform user if verbose: print('WARNING: tr(inv(A)) = ', trAinv) print('WARNING: cond(D) = ', np.linalg.cond(D)) print("") # select new size for the ED if ls_basis_size > ed_size: ed_size = ls_basis_size + N elif ed_size + N > max_fcalls: ed_size = max_fcalls else: ed_size = ed_size + N # expand ED ed, ed_fevals = get_ed(func, jpdf, ed_size, sample_type=sample_type, knots=ed, values=ed_fevals, ed_file=ed_file, ed_fevals_file=ed_fevals_file) # construct the design matrix D and compute its QR decomposition D = get_design_matrix(ls_basis, ed) Q, R = sp.qr(D, mode='economic') # construct information matrix A= D^T*D A = np.matmul(D.T, D) / ed_size trAinv = np.trace(np.linalg.inv(A)) # solve LS problem c = Q.T.dot(ed_fevals) pce_coeff_ls = sp.solve_triangular(R, c) # find the multi-index with the largest contribution, add it to idx_act # and delete it from idx_adm pce_coeff_act = pce_coeff_ls[:len(idx_act)].tolist() pce_coeff_adm = pce_coeff_ls[-len(idx_adm):].tolist() help_idx = np.argmax(np.abs(pce_coeff_adm)) idx_add = idx_adm.pop(help_idx) pce_coeff_add = pce_coeff_adm.pop(help_idx) idx_act.append(idx_add) pce_coeff_act.append(pce_coeff_add) # store expansion data in dictionary pce_dict = {} pce_dict['idx_act'] = idx_act pce_dict['idx_adm'] = idx_adm pce_dict['pce_coeff_act'] = pce_coeff_act pce_dict['pce_coeff_adm'] = pce_coeff_adm pce_dict['ed'] = ed pce_dict['ed_fevals'] = ed_fevals pce_dict['enum_func'] = enum_func pce_dict['mv_basis'] = mv_basis return pce_dict
ot.Rayleigh(1.0), ot.Student(22.0), ot.Triangular(-1.0, 0.3, 1.0), ot.Uniform(-1.0, 1.0), ot.Uniform(-1.0, 3.0), ot.Weibull(1.0, 3.0), ot.Beta(1.0, 3.0, -1.0, 1.0), ot.Beta(0.5, 1.0, -1.0, 1.0), ot.Beta(0.5, 1.0, -2.0, 3.0), ot.Gamma(1.0, 3.0), ot.Arcsine() ] for n in range(len(distributionCollection)): distribution = distributionCollection[n] name = distribution.getClassName() polynomialFactory = ot.StandardDistributionPolynomialFactory( ot.AdaptiveStieltjesAlgorithm(distribution)) print("polynomialFactory(", name, "=", polynomialFactory, ")") for i in range(iMax): print(name, " polynomial(", i, ")=", clean(polynomialFactory.build(i))) roots = polynomialFactory.getRoots(iMax - 1) print(name, " polynomial(", iMax - 1, ") roots=", roots) nodes, weights = polynomialFactory.getNodesAndWeights(iMax - 1) print(name, " polynomial(", iMax - 1, ") nodes=", nodes, " and weights=", weights) M = ot.SymmetricMatrix(iMax) for i in range(iMax): pI = polynomialFactory.build(i) for j in range(i + 1): pJ = polynomialFactory.build(j) def kernel(x):
if dist_types[i] == 'Uniform': poly_collection[i] = ot.OrthogonalUniVariatePolynomialFamily( ot.LegendreFactory()) elif dist_types[i] == 'Normal': poly_collection[i] = ot.OrthogonalUniVariatePolynomialFamily( ot.HermiteFactory()) elif dist_types[i] == 'Beta': poly_collection[i] = ot.OrthogonalUniVariatePolynomialFamily( ot.JacobiFactory()) elif dist_types[i] == 'Gamma': poly_collection[i] = ot.OrthogonalUniVariatePolynomialFamily( ot.LaguerreFactory()) else: pdf = jpdf_ot.getDistributionCollection()[i] algo = ot.AdaptiveStieltjesAlgorithm(pdf) poly_collection[i] = ot.StandardDistributionPolynomialFactory(algo) # create multivariate basis mv_basis = ot.OrthogonalProductPolynomialFactory(poly_collection, ot.EnumerateFunction(N)) # get enumerate function (multi-index handling) enum_func = mv_basis.getEnumerateFunction() max_fcalls = np.linspace(100, 1000, 10).tolist() meanz = [] varz = [] cv_errz_rms = [] cv_errz_max = [] fcallz = [] # cross validation sample np.random.seed(42)
def fit(self, X, y, **fit_params): """Fit PC regression model. Parameters ---------- X : array-like, shape = (n_samples, n_features) Training data. y : array-like, shape = (n_samples, [n_output_dims]) Target values. Returns ------- self : returns an instance of self. """ if len(X) == 0: raise ValueError( "Can not perform chaos expansion with empty sample") # check data type is accurate if (len(np.shape(X)) != 2): raise ValueError("X has incorrect shape.") input_dimension = len(X[1]) if (len(np.shape(y)) != 2): raise ValueError("y has incorrect shape.") if self.distribution is None: self.distribution = ot.MetaModelAlgorithm.BuildDistribution(X) if self.enumeratef == 'linear': enumerateFunction = ot.LinearEnumerateFunction(input_dimension) elif self.enumeratef == 'hyperbolic': enumerateFunction = ot.HyperbolicAnisotropicEnumerateFunction( input_dimension, self.q) else: raise ValueError('enumeratef should be "linear" or "hyperbolic"') polynomials = [ ot.StandardDistributionPolynomialFactory( self.distribution.getMarginal(i)) for i in range(input_dimension) ] productBasis = ot.OrthogonalProductPolynomialFactory( polynomials, enumerateFunction) adaptiveStrategy = ot.FixedStrategy( productBasis, enumerateFunction.getStrataCumulatedCardinal(self.degree)) if self.sparse: # Filter according to the sparse_fitting_algorithm key if self.sparse_fitting_algorithm == "cloo": fitting_algorithm = ot.CorrectedLeaveOneOut() else: fitting_algorithm = ot.KFold() # Define the correspondinding projection strategy projectionStrategy = ot.LeastSquaresStrategy( ot.LeastSquaresMetaModelSelectionFactory( ot.LARS(), fitting_algorithm)) else: projectionStrategy = ot.LeastSquaresStrategy(X, y) algo = ot.FunctionalChaosAlgorithm(X, y, self.distribution, adaptiveStrategy, projectionStrategy) algo.run() self.result_ = algo.getResult() output_dimension = self.result_.getMetaModel().getOutputDimension() # sensitivity si = ot.FunctionalChaosSobolIndices(self.result_) if output_dimension == 1: self.feature_importances_ = [ si.getSobolIndex(i) for i in range(input_dimension) ] else: self.feature_importances_ = [[0.0] * input_dimension ] * output_dimension for k in range(output_dimension): for i in range(input_dimension): self.feature_importances_[k][i] = si.getSobolIndex(i, k) self.feature_importances_ = np.array(self.feature_importances_) return self
# f(X_1, \dots, X_d) = \sum_{i=1}^m \prod_{j=1}^d v_j^{(i)} (x_j), \forall x \in \mathbb{R}^d # # with: # # .. math:: # v_j^{(i)} (x_j) = \sum_{k=1}^{n_j} \beta_{j,k}^{(i)} \phi_{j,k} (x_j) # # We should define : # # - The family of univariate functions :math:`\phi_j`. We choose the orthogonal basis with respect to the marginal distribution measures. # - The maximal rank :math:`m`. Here value is set to 5 # - The marginal degrees :math:`n_j`. Here we set the degrees to [4, 15, 3, 2] # # %% factoryCollection = [ot.OrthogonalUniVariatePolynomialFunctionFactory(ot.StandardDistributionPolynomialFactory(_)) for _ in [E,F,L,I]] functionFactory = ot.OrthogonalProductFunctionFactory(factoryCollection) nk = [4, 15, 3, 2] maxRank = 1 # %% # Finally we might launch the algorithm: # %% algo = ot.TensorApproximationAlgorithm(X_train, Y_train, myDistribution, functionFactory, nk, maxRank) algo.run() result = algo.getResult() metamodel = result.getMetaModel() # %% # The `run` method has optimized the hyperparameters of the metamodel (:math:`\beta` coefficients).
def train(self): self.input_dim = self.training_points[None][0][0].shape[1] x_train = ot.Sample(self.training_points[None][0][0]) y_train = ot.Sample(self.training_points[None][0][1]) # Distribution choice of the inputs to Create the input distribution distributions = [] dist_specs = self.options["uncertainty_specs"] if dist_specs: if len(dist_specs) != self.input_dim: raise SurrogateOpenturnsException( "Number of distributions should be equal to input \ dimensions. Should be {}, got {}".format( self.input_dim, len(dist_specs) ) ) for ds in dist_specs: dist_klass = getattr(sys.modules["openturns"], ds["name"]) args = [ds["kwargs"][name] for name in DISTRIBUTION_SIGNATURES[ds["name"]]] distributions.append(dist_klass(*args)) else: for i in range(self.input_dim): mean = np.mean(x_train[:, i]) lower, upper = 0.95 * mean, 1.05 * mean if mean < 0: lower, upper = upper, lower distributions.append(ot.Uniform(lower, upper)) distribution = ot.ComposedDistribution(distributions) # Polynomial basis # step 1 - Construction of the multivariate orthonormal basis: # Build orthonormal or orthogonal univariate polynomial families # (associated to associated input distribution) polynoms = [0.0] * self.input_dim for i in range(distribution.getDimension()): polynoms[i] = ot.StandardDistributionPolynomialFactory( distribution.getMarginal(i) ) enumerateFunction = ot.LinearEnumerateFunction(self.input_dim) productBasis = ot.OrthogonalProductPolynomialFactory( polynoms, enumerateFunction ) # step 2 - Truncation strategy of the multivariate orthonormal basis: # a strategy must be chosen for the selection of the different terms # of the multivariate basis. # Truncature strategy of the multivariate orthonormal basis # We choose all the polynomials of degree <= degree degree = self.options["pce_degree"] index_max = enumerateFunction.getStrataCumulatedCardinal(degree) adaptive_strategy = ot.FixedStrategy(productBasis, index_max) basis_sequenceFactory = ot.LARS() fitting_algorithm = ot.CorrectedLeaveOneOut() approximation_algorithm = ot.LeastSquaresMetaModelSelectionFactory( basis_sequenceFactory, fitting_algorithm ) projection_strategy = ot.LeastSquaresStrategy( x_train, y_train, approximation_algorithm ) algo = ot.FunctionalChaosAlgorithm( x_train, y_train, distribution, adaptive_strategy, projection_strategy ) # algo = ot.FunctionalChaosAlgorithm(X_train_NS, Y_train_NS) algo.run() self._pce_result = algo.getResult()
# model = ot.SymbolicFunction(['rw', 'r', 'Tu', 'Hu', 'Tl', 'Hl', 'L', 'Kw'], # ['(2*pi_*Tu*(Hu-Hl))/(ln(r/rw)*(1+(2*L*Tu)/(ln(r/rw)*rw^2*Kw)+Tu/Tl))']) # coll = [ot.Normal(0.1, 0.0161812), # ot.LogNormal(7.71, 1.0056), # ot.Uniform(63070.0, 115600.0), # ot.Uniform(990.0, 1110.0), # ot.Uniform(63.1, 116.0), # ot.Uniform(700.0, 820.0), # ot.Uniform(1120.0, 1680.0), # ot.Uniform(9855.0, 12045.0)] distribution = ot.ComposedDistribution(coll) factoryCollection = [ ot.OrthogonalUniVariateFunctionFamily( ot.OrthogonalUniVariatePolynomialFunctionFactory( ot.StandardDistributionPolynomialFactory(dist))) for dist in coll ] functionFactory = ot.OrthogonalProductFunctionFactory(factoryCollection) size = 1000 X = distribution.getSample(size) Y = model(X) # ot.ResourceMap.Set('TensorApproximationAlgorithm-Method', 'RankM') # n-d nk = [10] * dim maxRank = 5 algo = ot.TensorApproximationAlgorithm(X, Y, distribution, functionFactory, nk, maxRank)
def __init__(self, strategy, degree, distributions, N_quad=None, sample=None, stieltjes=True, sparse_param={}): """Generate truncature and projection strategies. Allong with the strategies the sample is storred as an attribute. :attr:`sample` as well as corresponding weights: :attr:`weights`. :param str strategy: Least square or Quadrature ['LS', 'Quad', 'SparseLS']. :param int degree: Polynomial degree. :param distributions: Distributions of each input parameter. :type distributions: lst(:class:`openturns.Distribution`) :param array_like sample: Samples for least square (n_samples, n_features). :param bool stieltjes: Wether to use Stieltjes algorithm for the basis. :param dict sparse_param: Parameters for the Sparse Cleaning Truncation Strategy and/or hyperbolic truncation of the initial basis. - **max_considered_terms** (int) -- Maximum Considered Terms, - **most_significant** (int), Most Siginificant number to retain, - **significance_factor** (float), Significance Factor, - **hyper_factor** (float), factor for hyperbolic truncation strategy. """ # distributions self.in_dim = len(distributions) self.dist = ot.ComposedDistribution(distributions) self.sparse_param = sparse_param if 'hyper_factor' in self.sparse_param: enumerateFunction = ot.EnumerateFunction(self.in_dim, self.sparse_param['hyper_factor']) else: enumerateFunction = ot.EnumerateFunction(self.in_dim) if stieltjes: # Tend to result in performance issue self.basis = ot.OrthogonalProductPolynomialFactory( [ot.StandardDistributionPolynomialFactory( ot.AdaptiveStieltjesAlgorithm(marginal)) for marginal in distributions], enumerateFunction) else: self.basis = ot.OrthogonalProductPolynomialFactory( [ot.StandardDistributionPolynomialFactory(margin) for margin in distributions], enumerateFunction) self.n_basis = enumerateFunction.getStrataCumulatedCardinal(degree) # Strategy choice for expansion coefficient determination self.strategy = strategy if self.strategy == 'LS' or self.strategy == 'SparseLS': # least-squares method self.sample = sample else: # integration method # redefinition of sample size # n_samples = (degree + 1) ** self.in_dim # marginal degree definition # by default: the marginal degree for each input random # variable is set to the total polynomial degree 'degree'+1 measure = self.basis.getMeasure() if N_quad is not None: degrees = [int(N_quad ** 0.25)] * self.in_dim else: degrees = [degree + 1] * self.in_dim self.proj_strategy = ot.IntegrationStrategy( ot.GaussProductExperiment(measure, degrees)) self.sample, self.weights = self.proj_strategy.getExperiment().generateWithWeights() if not stieltjes: transformation = ot.Function(ot.MarginalTransformationEvaluation( [measure.getMarginal(i) for i in range(self.in_dim)], distributions, False)) self.sample = transformation(self.sample) self.pc = None self.pc_result = None
def fit(self, X, y, **fit_params): input_dimension = X.shape[1] if self.distribution is None: self.distribution = BuildDistribution(X) factoryCollection = [ot.OrthogonalUniVariateFunctionFamily( ot.OrthogonalUniVariatePolynomialFunctionFactory(ot.StandardDistributionPolynomialFactory(self.distribution.getMarginal(i)))) for i in range(input_dimension)] functionFactory = ot.OrthogonalProductFunctionFactory(factoryCollection) algo = ot.TensorApproximationAlgorithm(X, y.reshape(-1, 1), self.distribution, functionFactory, [self.nk]*input_dimension, self.max_rank) algo.run() self._result = algo.getResult() return self
def dali_pce(func, N, jpdf_cp, jpdf_ot, tol=1e-12, max_fcalls=1000, verbose=True, interp_dict={}): if not interp_dict: # if dictionary is empty --> cold-start idx_act = [] # M_activated x N idx_adm = [] # M_admissible x N fevals_act = [] # M_activated x 1 fevals_adm = [] # M_admissible x 1 coeff_act = [] # M_activated x 1 coeff_adm = [] # M_admissible x 1 # start with 0 multi-index knot0 = [] for n in range(N): # get knots per dimension based on maximum index kk, ww = seq_lj_1d(order=0, dist=jpdf_cp[n]) knot0.append(kk[0]) feval = func(knot0) # update activated sets idx_act.append([0] * N) coeff_act.append(feval) fevals_act.append(feval) # local error indicators local_error_indicators = np.abs(coeff_act) # get the OT distribution type of each random variable dist_types = [] for i in range(N): dist_type = jpdf_ot.getMarginal(i).getName() dist_types.append(dist_type) # create orthogonal univariate bases poly_collection = ot.PolynomialFamilyCollection(N) for i in range(N): if dist_types[i] == 'Uniform': poly_collection[i] = ot.OrthogonalUniVariatePolynomialFamily( ot.LegendreFactory()) elif dist_types[i] == 'Normal': poly_collection[i] = ot.OrthogonalUniVariatePolynomialFamily( ot.HermiteFactory()) elif dist_types[i] == 'Beta': poly_collection[i] = ot.OrthogonalUniVariatePolynomialFamily( ot.JacobiFactory()) elif dist_types[i] == 'Gamma': poly_collection[i] = ot.OrthogonalUniVariatePolynomialFamily( ot.LaguerreFactory()) else: pdf = jpdf_ot.getDistributionCollection()[i] algo = ot.AdaptiveStieltjesAlgorithm(pdf) poly_collection[i] = ot.StandardDistributionPolynomialFactory( algo) # create multivariate basis mv_basis = ot.OrthogonalProductPolynomialFactory( poly_collection, ot.EnumerateFunction(N)) # get enumerate function (multi-index handling) enum_func = mv_basis.getEnumerateFunction() else: idx_act = interp_dict['idx_act'] idx_adm = interp_dict['idx_adm'] coeff_act = interp_dict['coeff_act'] coeff_adm = interp_dict['coeff_adm'] fevals_act = interp_dict['fevals_act'] fevals_adm = interp_dict['fevals_adm'] mv_basis = interp_dict['mv_basis'] enum_func = interp_dict['enum_func'] # local error indicators local_error_indicators = np.abs(coeff_adm) # compute global error indicator global_error_indicator = local_error_indicators.sum() # max or sum # fcalls / M approx. terms up to now fcalls = len(idx_act) + len(idx_adm) # fcalls = M --> approx. terms # maximum index per dimension max_idx_per_dim = np.max(idx_act + idx_adm, axis=0) # univariate knots and polynomials per dimension knots_per_dim = {} for n in range(N): kk, ww = seq_lj_1d(order=max_idx_per_dim[n], dist=jpdf_cp[n]) knots_per_dim[n] = kk # start iterations while global_error_indicator > tol and fcalls < max_fcalls: if verbose: print(fcalls) print(global_error_indicator) # the index added last to the activated set is the one to be refined last_act_idx = idx_act[-1][:] # compute the knot corresponding to the lastly added index last_knot = [ knots_per_dim[n][i] for n, i in zip(range(N), last_act_idx) ] # get admissible neighbors of the lastly added index adm_neighbors = admissible_neighbors(last_act_idx, idx_act) for an in adm_neighbors: # update admissible index set idx_adm.append(an) # find which parameter/direction n (n=1,2,...,N) gets refined n_ref = np.argmin( [idx1 == idx2 for idx1, idx2 in zip(an, last_act_idx)]) # sequence of 1d Leja nodes/weights for the given refinement knots_n, weights_n = seq_lj_1d(an[n_ref], jpdf_cp[int(n_ref)]) # update max_idx_per_dim, knots_per_dim, if necessary if an[n_ref] > max_idx_per_dim[n_ref]: max_idx_per_dim[n_ref] = an[n_ref] knots_per_dim[n_ref] = knots_n # find new_knot and compute function on new_knot new_knot = last_knot[:] new_knot[n_ref] = knots_n[-1] feval = func(new_knot) fevals_adm.append(feval) fcalls += 1 # update function calls # create PCE basis idx_system = idx_act + idx_adm idx_system_single = transform_multi_index_set(idx_system, enum_func) system_basis = mv_basis.getSubBasis(idx_system_single) # get corresponding evaluations fevals_system = fevals_act + fevals_adm # multi-dimensional knots M = len(idx_system) # equations terms knots_md = [[knots_per_dim[n][idx_system[m][n]] for m in range(M)] for n in range(N)] knots_md = np.array(knots_md).T # design matrix D = get_design_matrix(system_basis, knots_md) # solve system of equaations Q, R = scl.qr(D, mode='economic') c = Q.T.dot(fevals_system) coeff_system = scl.solve_triangular(R, c) # find the multi-index with the largest contribution, add it to idx_act # and delete it from idx_adm coeff_act = coeff_system[:len(idx_act)].tolist() coeff_adm = coeff_system[-len(idx_adm):].tolist() help_idx = np.argmax(np.abs(coeff_adm)) idx_add = idx_adm.pop(help_idx) pce_coeff_add = coeff_adm.pop(help_idx) fevals_add = fevals_adm.pop(help_idx) idx_act.append(idx_add) coeff_act.append(pce_coeff_add) fevals_act.append(fevals_add) # re-compute coefficients of admissible multi-indices # local error indicators local_error_indicators = np.abs(coeff_adm) # compute global error indicator global_error_indicator = local_error_indicators.sum() # max or sum # store expansion data in dictionary interp_dict = {} interp_dict['idx_act'] = idx_act interp_dict['idx_adm'] = idx_adm interp_dict['coeff_act'] = coeff_act interp_dict['coeff_adm'] = coeff_adm interp_dict['fevals_act'] = fevals_act interp_dict['fevals_adm'] = fevals_adm interp_dict['enum_func'] = enum_func interp_dict['mv_basis'] = mv_basis return interp_dict
polyColl = ot.PolynomialFamilyCollection(inputDimension) # %% # We could use the Krawtchouk and Charlier families (for discrete distributions). # %% polyColl[0] = ot.KrawtchoukFactory() polyColl[1] = ot.CharlierFactory() # %% # We could also use the automatic selection of the polynomial which corresponds to the distribution: this is done with the `StandardDistributionPolynomialFactory` class. # %% for i in range(inputDimension): marginal = distribution.getMarginal(i) polyColl[i] = ot.StandardDistributionPolynomialFactory(marginal) # %% # In our specific case, we use specific polynomial factories. # %% polyColl[0] = ot.HermiteFactory() polyColl[1] = ot.LegendreFactory() polyColl[2] = ot.LaguerreFactory(2.75) # Parameter for the Jacobi factory : 'Probabilty' encoded with 1 polyColl[3] = ot.JacobiFactory(2.5, 3.5, 1) # %% # Create the enumeration function. # %%
ot.Uniform(), ot.Gamma(2.75, 1.0), ot.Beta(2.5, 1.0, -1.0, 2.0) ]) # %% # Prepare the input/output samples sampleSize = 250 X = distribution.getSample(sampleSize) Y = myModel(X) dimension = X.getDimension() # %% # build the orthogonal basis coll = [ ot.StandardDistributionPolynomialFactory(distribution.getMarginal(i)) for i in range(dimension) ] enumerateFunction = ot.LinearEnumerateFunction(dimension) productBasis = ot.OrthogonalProductPolynomialFactory(coll, enumerateFunction) # %% # create the algorithm degree = 6 adaptiveStrategy = ot.FixedStrategy( productBasis, enumerateFunction.getStrataCumulatedCardinal(degree)) projectionStrategy = ot.LeastSquaresStrategy() algo = ot.FunctionalChaosAlgorithm(X, Y, distribution, adaptiveStrategy, projectionStrategy) algo.run()
#['(2*_pi*Tu*(Hu-Hl))/(ln(r/rw)*(1+(2*L*Tu)/(ln(r/rw)*rw^2*Kw)+Tu/Tl))']) # coll = [ot.Normal(0.1, 0.0161812), # ot.LogNormal(7.71, 1.0056), # ot.Uniform(63070.0, 115600.0), # ot.Uniform(990.0, 1110.0), # ot.Uniform(63.1, 116.0), # ot.Uniform(700.0, 820.0), # ot.Uniform(1120.0, 1680.0), # ot.Uniform(9855.0, 12045.0)] distribution = ot.ComposedDistribution(coll) factoryCollection = list( map( lambda dist: ot.OrthogonalUniVariateFunctionFamily( ot.OrthogonalUniVariatePolynomialFunctionFactory( ot.StandardDistributionPolynomialFactory(dist))), coll)) functionFactory = ot.OrthogonalProductFunctionFactory(factoryCollection) size = 1000 X = distribution.getSample(size) Y = model(X) # ot.ResourceMap.Set('TensorApproximationAlgorithm-Method', 'RankM') # n-d nk = [10] * dim maxRank = 5 algo = ot.TensorApproximationAlgorithm(X, Y, distribution, functionFactory, nk, maxRank) algo.run()