# %%
marginalDegrees = [4] * dim_input
experiment = ot.GaussProductExperiment(distributionMu, marginalDegrees)
# %%
# We can see the size of the associated design of experiments.
# %%
experiment.generate().getSize()
# %%
# The choice of the `GaussProductExperiment` rule leads to 256 evaluations of the model.
# %%
projectionStrategy = ot.IntegrationStrategy(experiment)
# %%
# We can now create the functional chaos.
# %%
chaosalgo = ot.FunctionalChaosAlgorithm(g, myDistribution, adaptiveStrategy,
projectionStrategy)
chaosalgo.run()
# %%
# Get the result
#
# %%
result = chaosalgo.getResult()
# This algorithm estimates the empirical error on each sub-basis using Leave One Out strategy.
# %%
fittingAlgorithm = ot.CorrectedLeaveOneOut()
# Finally the metamodel selection algorithm embbeded in LeastSquaresStrategy
approximationAlgorithm = ot.LeastSquaresMetaModelSelectionFactory(
basisSequenceFactory, fittingAlgorithm)
evaluationCoeffStrategy_2 = ot.LeastSquaresStrategy(
ot.MonteCarloExperiment(sampleSize), approximationAlgorithm)
# %%
# Try integration.
# %%
marginalDegrees = [2] * inputDimension
evaluationCoeffStrategy_3 = ot.IntegrationStrategy(
ot.GaussProductExperiment(distributionMu, marginalDegrees))
# %%
# STEP 4: Creation of the Functional Chaos Algorithm
# --------------------------------------------------
#
# The `FunctionalChaosAlgorithm` class combines
#
# * the model : `model`
# * the distribution of the input random vector : `distribution`
# * the truncature strategy of the multivariate basis
# * and the evaluation strategy of the coefficients
# %%
polynomialChaosAlgorithm = ot.FunctionalChaosAlgorithm(
model, distribution, truncatureBasisStrategy, evaluationCoeffStrategy)
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
# This algorithm estimates the empirical error on each sub-basis using Leave One Out strategy.
# %%
fittingAlgorithm = ot.CorrectedLeaveOneOut()
# Finally the metamodel selection algorithm embbeded in LeastSquaresStrategy
approximationAlgorithm = ot.LeastSquaresMetaModelSelectionFactory(
basisSequenceFactory, fittingAlgorithm)
evaluationCoeffStrategy_2 = ot.LeastSquaresStrategy(
ot.MonteCarloExperiment(sampleSize), approximationAlgorithm)
# %%
# Try integration.
# %%
marginalSizes = [2] * inputDimension
evaluationCoeffStrategy_3 = ot.IntegrationStrategy(
ot.GaussProductExperiment(distributionStandard, marginalSizes))
# %%
# STEP 4: Creation of the Functional Chaos Algorithm
# --------------------------------------------------
#
# The `FunctionalChaosAlgorithm` class combines
#
# * the model : `model`
# * the distribution of the input random vector : `distribution`
# * the truncature strategy of the multivariate basis
# * and the evaluation strategy of the coefficients
# %%
polynomialChaosAlgorithm = ot.FunctionalChaosAlgorithm(
model, distribution, truncatureBasisStrategy, evaluationCoeffStrategy)