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)
# 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('initial design computed') # Response of the model print('sampling size = ', N) output_database = ishigami_model(input_database) # Learning input/output # Usual chaos meta model enumerate_function = ot.HyperbolicAnisotropicEnumerateFunction(dimension) orthogonal_basis = ot.OrthogonalProductPolynomialFactory( dimension * [ot.LegendreFactory()], enumerate_function) basis_size = 100 # Initial chaos algorithm adaptive_strategy = ot.FixedStrategy(orthogonal_basis, basis_size) # ProjectionStrategy ==> Sparse fitting_algorithm = ot.KFold() approximation_algorithm = ot.LeastSquaresMetaModelSelectionFactory( ot.LARS(), fitting_algorithm) projection_strategy = ot.LeastSquaresStrategy(input_database, output_database, approximation_algorithm) print('Surrogate model...') distribution_ishigami = ot.ComposedDistribution(dimension * [ot.Uniform(-pi, pi)]) algo_pc = ot.FunctionalChaosAlgorithm(input_database, output_database, distribution_ishigami, adaptive_strategy, projection_strategy) algo_pc.run() chaos_result = algo_pc.getResult() print('Surrogate model computed') # Validation
# 1) SPC algorithm # Create the orthogonal basis polynomialCollection = [ot.LegendreFactory()] * dimension enumerateFunction = ot.LinearEnumerateFunction(dimension) productBasis = ot.OrthogonalProductPolynomialFactory( polynomialCollection, enumerateFunction) # Create the adaptive strategy degree = 8 basisSize = enumerateFunction.getStrataCumulatedCardinal(degree) adaptiveStrategy = ot.FixedStrategy(productBasis, basisSize) # Select the fitting algorithm fittingAlgorithm = ot.KFold() leastSquaresFactory = ot.LeastSquaresMetaModelSelectionFactory( ot.LARS(), fittingAlgorithm) # Projection strategy projectionStrategy = ot.LeastSquaresStrategy( inputSample, outputSample, leastSquaresFactory) algo = ot.FunctionalChaosAlgorithm( inputSample, outputSample, distribution, adaptiveStrategy, projectionStrategy) # Reinitialize the RandomGenerator to see the effect of the sampling # method only ot.RandomGenerator.SetSeed(0) algo.run() # Get the results
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