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