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, 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
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 ComputeSparseLeastSquaresChaos(inputTrain, outputTrain, multivariateBasis,
totalDegree, myDistribution):
"""
Create a sparse polynomial chaos based on least squares.
* Uses the enumerate rule in multivariateBasis.
* Uses the LeastSquaresStrategy to compute the coefficients based on
least squares.
* Uses LeastSquaresMetaModelSelectionFactory to use the LARS selection method.
* Uses FixedStrategy in order to keep all the coefficients that the
LARS method selected.
Parameters
----------
inputTrain : ot.Sample
The input design of experiments.
outputTrain : ot.Sample
The output design of experiments.
multivariateBasis : ot.Basis
The multivariate chaos basis.
totalDegree : int
The total degree of the chaos polynomial.
myDistribution : ot.Distribution.
The distribution of the input variable.
Returns
-------
result : ot.PolynomialChaosResult
The estimated polynomial chaos.
"""
selectionAlgorithm = ot.LeastSquaresMetaModelSelectionFactory()
projectionStrategy = ot.LeastSquaresStrategy(inputTrain, outputTrain,
selectionAlgorithm)
enumfunc = multivariateBasis.getEnumerateFunction()
P = enumfunc.getStrataCumulatedCardinal(totalDegree)
adaptiveStrategy = ot.FixedStrategy(multivariateBasis, P)
chaosalgo = ot.FunctionalChaosAlgorithm(inputTrain, outputTrain,
myDistribution, adaptiveStrategy,
projectionStrategy)
chaosalgo.run()
result = chaosalgo.getResult()
return result
vectX = ot.RandomVector(myDistribution)
########################
### Chaos Polynomial ###
########################
polyColl = ot.PolynomialFamilyCollection(dim)
for i in range(dim):
polyColl[i] = ot.HermiteFactory()
enumerateFunction = ot.LinearEnumerateFunction(dim)
multivariateBasis = ot.OrthogonalProductPolynomialFactory(polyColl, enumerateFunction)
basisSequenceFactory = ot.LARS()
fittingAlgorithm = ot.CorrectedLeaveOneOut()
approximationAlgorithm = ot.LeastSquaresMetaModelSelectionFactory(basisSequenceFactory, fittingAlgorithm)
# Génération du plan d'expériences
N = 200
ot.RandomGenerator.SetSeed(77)
Liste_test = ot.LHSExperiment(myDistribution, N)
InputSample = Liste_test.generate()
# Ecriture du fichier de données d'entrées
fidResult=open('IT'+IT0+'/IT'+IT0+'_TIRAGE_200.txt',"a")
for i in range(N):
fidResult.write(
'{0:>8s}'.format(str('{0:.3f}'.format(InputSample[i,0])))+"\t"+
'{0:>8s}'.format(str('{0:.3f}'.format(InputSample[i,1])))+"\t"+
'{0:>8s}'.format(str('{0:.3f}'.format(InputSample[i,2])))+"\t"+
# 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
lhs_validation = ot.LHSExperiment(distribution_ishigami, 100)
input_validation = lhs_validation.generate()
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())
# 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
result = algo.getResult()
# %%
# Create a training sample
# %%
N = 100
inputTrain = im.distributionX.getSample(N)
outputTrain = im.model(inputTrain)
# %%
# Create the chaos.
# %%
multivariateBasis = ot.OrthogonalProductPolynomialFactory(
[im.X1, im.X2, im.X3])
selectionAlgorithm = ot.LeastSquaresMetaModelSelectionFactory()
projectionStrategy = ot.LeastSquaresStrategy(inputTrain, outputTrain,
selectionAlgorithm)
totalDegree = 8
enumfunc = multivariateBasis.getEnumerateFunction()
P = enumfunc.getStrataCumulatedCardinal(totalDegree)
adaptiveStrategy = ot.FixedStrategy(multivariateBasis, P)
chaosalgo = ot.FunctionalChaosAlgorithm(inputTrain, outputTrain,
im.distributionX, adaptiveStrategy,
projectionStrategy)
# %%
chaosalgo.run()
result = chaosalgo.getResult()
metamodel = result.getMetaModel()
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
output_sample = model(input_sample)
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)
ancova_sparse = ot.ANCOVA(chaos_sparse.getResult(), input_sample)
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()
