def fit(self, sample, data): """Create the predictor. The result of the Polynomial Chaos is stored as :attr:`pc_result` and the surrogate is stored as :attr:`pc`. It exposes :attr:`self.weights`, :attr:`self.coefficients` and Sobol' indices :attr:`self.s_first` and :attr:`self.s_total`. :param array_like sample: The sample used to generate the data (n_samples, n_features). :param array_like data: The observed data (n_samples, [n_features]). """ trunc_strategy = ot.FixedStrategy(self.basis, self.n_basis) if self.strategy == 'LS': # least-squares method proj_strategy = ot.LeastSquaresStrategy(sample, data) _, self.weights = proj_strategy.getExperiment().generateWithWeights() elif self.strategy == 'SparseLS': app = ot.LeastSquaresMetaModelSelectionFactory(ot.LARS(), ot.CorrectedLeaveOneOut()) proj_strategy = ot.LeastSquaresStrategy(sample, data, app) _, self.weights = proj_strategy.getExperiment().generateWithWeights() max_considered_terms = self.sparse_param.get('max_considered_terms', 120) most_significant = self.sparse_param.get('most_significant', 30) significance_factor = self.sparse_param.get('significance_factor', 1e-3) trunc_strategy = ot.CleaningStrategy(ot.OrthogonalBasis(self.basis), max_considered_terms, most_significant, significance_factor, True) else: proj_strategy = self.proj_strategy sample_ = np.zeros_like(self.sample) sample_[:len(sample)] = sample sample_arg = np.all(np.isin(sample_, self.sample), axis=1) self.weights = np.array(self.weights)[sample_arg] # PC fitting pc_algo = ot.FunctionalChaosAlgorithm(sample, self.weights, data, self.dist, trunc_strategy) pc_algo.setProjectionStrategy(proj_strategy) ot.Log.Show(ot.Log.ERROR) pc_algo.run() # Accessors self.pc_result = pc_algo.getResult() self.pc = self.pc_result.getMetaModel() self.coefficients = self.pc_result.getCoefficients() # sensitivity indices sobol = ot.FunctionalChaosSobolIndices(self.pc_result) self.s_first, self.s_total = [], [] for i, j in product(range(self.in_dim), range(np.array(data).shape[1])): self.s_first.append(sobol.getSobolIndex(i, j)) self.s_total.append(sobol.getSobolTotalIndex(i, j)) self.s_first = np.array(self.s_first).reshape(self.in_dim, -1).T self.s_total = np.array(self.s_total).reshape(self.in_dim, -1).T
# Add the trend to the initial process myYProcess = ot.CompositeProcess(fTemp, myXProcess) # Get a field from myYtProcess myYField = myYProcess.getRealization() # %% # CASE 1 : we estimate the trend from the field # Define the regression stategy using the LAR method myBasisSequenceFactory = ot.LARS() # Define the fitting algorithm using the # Corrected Leave One Out or KFold algorithms myFittingAlgorithm = ot.CorrectedLeaveOneOut() myFittingAlgorithm_2 = ot.KFold() # Define the basis function # For example composed of 5 functions myFunctionBasis = list(map(lambda fst: ot.SymbolicFunction( ['t', 's'], [fst]), ['1', 't', 's', 't^2', 's^2'])) # Define the trend function factory algorithm myTrendFactory = ot.TrendFactory(myBasisSequenceFactory, myFittingAlgorithm) # Create the trend transformation of type TrendTransform myTrendTransform = myTrendFactory.build(myYField, ot.Basis(myFunctionBasis)) # Check the estimated trend function print('Trend function = ', myTrendTransform)
print("project sample_Y") sample_xi_Y = result_Y.project(sample_Y) print("Compute PCE between coefficients") degree = 1 dimension_xi_X = sample_xi_X.getDimension() dimension_xi_Y = sample_xi_Y.getDimension() enumerateFunction = ot.LinearEnumerateFunction(dimension_xi_X) basis = ot.OrthogonalProductPolynomialFactory( [ot.HermiteFactory()] * dimension_xi_X, enumerateFunction) basisSize = enumerateFunction.getStrataCumulatedCardinal(degree) adaptive = ot.FixedStrategy(basis, basisSize) projection = ot.LeastSquaresStrategy( ot.LeastSquaresMetaModelSelectionFactory(ot.LARS(), ot.CorrectedLeaveOneOut())) ot.ResourceMap.SetAsScalar("LeastSquaresMetaModelSelection-ErrorThreshold", 1.0e-7) algo_chaos = ot.FunctionalChaosAlgorithm(sample_xi_X, sample_xi_Y, basis.getMeasure(), adaptive, projection) algo_chaos.run() result_chaos = algo_chaos.getResult() meta_model = result_chaos.getMetaModel() print("myConvolution=", myConvolution.getInputDimension(), "->", myConvolution.getOutputDimension()) preprocessing = ot.KarhunenLoeveProjection(result_X) print("preprocessing=", preprocessing.getInputDimension(), "->", preprocessing.getOutputDimension()) print("meta_model=", meta_model.getInputDimension(), "->", meta_model.getOutputDimension())
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 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
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()
dim = 3 enumerateFunction = ot.LinearEnumerateFunction(dim) polyCol = [0.] * dim for i in range(dim): polyCol[i] = ot.StandardDistributionPolynomialFactory( distribution.getMarginal(i)) ####### Chaos definition ###### multivariateBasis = ot.OrthogonalProductPolynomialFactory( polyCol, enumerateFunction) indexMax = enumerateFunction.getStrataCumulatedCardinal(1) strategy = ot.FixedStrategy(multivariateBasis, indexMax) approximation_algorithm = ot.LeastSquaresMetaModelSelectionFactory( ot.LARS(), ot.CorrectedLeaveOneOut()) evaluationStrategy_sparse = ot.LeastSquaresStrategy(approximation_algorithm) evaluationStrategy = ot.LeastSquaresStrategy() # sparse and not sparse chaos = ot.FunctionalChaosAlgorithm(input_sample, output_sample, distribution, strategy, evaluationStrategy) chaos.run() chaos_sparse = ot.FunctionalChaosAlgorithm(input_sample, output_sample, distribution, strategy, evaluationStrategy_sparse) chaos_sparse.run() print('indices/full=', chaos.getResult().getIndices()) print('indices/sparse=', chaos_sparse.getResult().getIndices()) ancova = ot.ANCOVA(chaos.getResult(), input_sample)
sample_xi_X = result_X.project(sample_X) print("project sample_Y") sample_xi_Y = result_Y.project(sample_Y) print("Compute PCE between coefficients") degree = 1 dimension_xi_X = sample_xi_X.getDimension() dimension_xi_Y = sample_xi_Y.getDimension() enumerateFunction = ot.LinearEnumerateFunction(dimension_xi_X) basis = ot.OrthogonalProductPolynomialFactory( [ot.HermiteFactory()] * dimension_xi_X, enumerateFunction) basisSize = enumerateFunction.getStrataCumulatedCardinal(degree) adaptive = ot.FixedStrategy(basis, basisSize) projection = ot.LeastSquaresStrategy( ot.LeastSquaresMetaModelSelectionFactory(ot.LARS(), ot.CorrectedLeaveOneOut())) ot.ResourceMap.SetAsScalar( "LeastSquaresMetaModelSelection-ErrorThreshold", 1.0e-7) algo_chaos = ot.FunctionalChaosAlgorithm( sample_xi_X, sample_xi_Y, basis.getMeasure(), adaptive, projection) algo_chaos.run() result_chaos = algo_chaos.getResult() meta_model = result_chaos.getMetaModel() print("myConvolution=", myConvolution.getInputDimension(), "->", myConvolution.getOutputDimension()) preprocessing = ot.KarhunenLoeveProjection(result_X) print("preprocessing=", preprocessing.getInputDimension(), "->", preprocessing.getOutputDimension()) print("meta_model=", meta_model.getInputDimension(), "->", meta_model.getOutputDimension()) postprocessing = ot.KarhunenLoeveLifting(result_Y)