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
# %% # Generate an training sample of size N with MC simulation. # %% N = 50 # size of the experimental design inputTrain = myDistribution.getSample(N) outputTrain = g(inputTrain) # %% # We select the `FixedStrategy` truncation rule, which corresponds to using the first `P` polynomials of the polynomial basis. In this case, we select `P` using the `getStrataCumulatedCardinal` method, so that all polynomials with total degree lower or equal to 5 are used. # %% totalDegree = 5 enumfunc = multivariateBasis.getEnumerateFunction() P = enumfunc.getStrataCumulatedCardinal(totalDegree) adaptiveStrategy = ot.FixedStrategy(multivariateBasis, P) adaptiveStrategy # %% # We see that the number of polynomials is equal to 126. This will lead to the computation of 126 coefficients. # %% # We now set the method used to compute the coefficients; we select the integration method. # # We begin by getting the standard measure associated with the multivariate polynomial basis. We see that the range of the `Beta` distribution has been standardized into the [-1,1] interval. This is the same for the `Uniform` distribution and the second `Beta` distribution. # %% distributionMu = multivariateBasis.getMeasure() distributionMu # %%
Y = myModel(X)
dimension = X.getDimension()
# %%
# build the orthogonal basis
coll = [
ot.StandardDistributionPolynomialFactory(distribution.getMarginal(i))
for i in range(dimension)
]
enumerateFunction = ot.LinearEnumerateFunction(dimension)
productBasis = ot.OrthogonalProductPolynomialFactory(coll, enumerateFunction)
# %%
# create the algorithm
degree = 6
adaptiveStrategy = ot.FixedStrategy(
productBasis, enumerateFunction.getStrataCumulatedCardinal(degree))
projectionStrategy = ot.LeastSquaresStrategy()
algo = ot.FunctionalChaosAlgorithm(X, Y, distribution, adaptiveStrategy,
projectionStrategy)
algo.run()
# %%
# get the metamodel function
result = algo.getResult()
metamodel = result.getMetaModel()
# %%
# Print residuals
result.getResiduals()
result = algo.getResult()
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')
# Polynomial chaos between KL coefficients
print("project sample_X")
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(), "->",
validationSize = 10
inputValidation = distribution.getSample(validationSize)
outputValidation = model(inputValidation)
# 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)
# that total degree. Then the number of functions up to that layer is computed
# with the :meth:`~openturns.EnumerateFunction.getStrataCumulatedCardinal` method.
# %%
dimension = im.distributionX.getDimension()
multivariateBasis = ot.OrthogonalProductPolynomialFactory(
[im.distributionX.getMarginal(i) for i in range(dimension)])
totalDegree = 5 # Polynomial degree
enumerate_function = multivariateBasis.getEnumerateFunction()
strataIndex = enumerate_function.getMaximumDegreeStrataIndex(totalDegree)
print("strataIndex = ", strataIndex)
number_of_terms_in_basis = enumerate_function.getStrataCumulatedCardinal(
strataIndex)
print("number_of_terms_in_basis = ", number_of_terms_in_basis)
adaptiveStrategy = ot.FixedStrategy(multivariateBasis,
number_of_terms_in_basis)
print(adaptiveStrategy)
# %%
#
# We compute the coefficients using a multivariate tensor product Gaussian
# quadrature rule. Since the coefficients are computed in the standardized
# space, we first use the `getMeasure` method of the multivariate basis in
# order to get that standardized distribution. Then we use the
# :class:`~openturns.GaussProductExperiment` class to create the quadrature,
# using 6 nodes on each
# of the dimensions.
# %%
standard_distribution = multivariateBasis.getMeasure()
print(standard_distribution)
model = ot.Function(F)
dim = model.getInputDimension()
print("dim=", dim)
size = dim + 1
distribution = ot.ComposedDistribution([ot.Normal()] * dim)
weightedExperiment = ot.MonteCarloExperiment(distribution, size)
inSample, weights = weightedExperiment.generateWithWeights()
print("Sample model")
t0 = time()
outSample = model(inSample)
t1 = time()
print("t=", t1 - t0, "s, speed=", inSample.getSize() / (t1 - t0), "evals/s")
basis = ot.OrthogonalProductPolynomialFactory([ot.HermiteFactory()] * dim)
adaptive = ot.FixedStrategy(basis, dim + 1)
projection = ot.LeastSquaresStrategy(weightedExperiment)
algo = ot.FunctionalChaosAlgorithm(inSample, outSample, distribution, adaptive,
projection)
algo.run()
vector = ot.FunctionalChaosRandomVector(algo.getResult())
# Field of Sobol indices
#for i in range(dim):
for i in range(15, 16):
print("i=", i)
sobol = [
vector.getSobolIndex(i, j) for j in range(mesh.getVerticesNumber())
]
field = ot.Field(mesh, [[x] for x in sobol])
graph = field.draw()
# Get the measure mu associated to the multivariate basis.
# %%
distributionMu = multivariateBasis.getMeasure()
distributionMu
# %%
# STEP 2: Truncature strategy of the multivariate orthonormal basis
# -----------------------------------------------------------------
# %%
# FixedStrategy : all the polynomials af degree lower or equal to 2 which corresponds to the 15 first ones.
# %%
p = 15
truncatureBasisStrategy = ot.FixedStrategy(multivariateBasis, p)
# %%
# SequentialStrategy : among the maximumCardinalBasis = 100 first polynomials of the multivariate basis those verfying the convergence criterion.
# %%
maximumCardinalBasis = 100
truncatureBasisStrategy_1 = ot.SequentialStrategy(
multivariateBasis, maximumCardinalBasis)
# %%
# CleaningStrategy : among the maximumConsideredTerms = 500 first polynomials, those which have the mostSignificant = 50 most significant contributions with significance criterion significanceFactor equal to :math:`10^{-4}`
# The `True` boolean indicates if we are interested in the online monitoring of the current basis update (removed or added coefficients).
# %%
maximumConsideredTerms = 500
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
# Correlated input distribution
S = ot.CorrelationMatrix(inputDimension)
S[1, 0] = 0.3
R = ot.NormalCopula().GetCorrelationFromSpearmanCorrelation(S)
myCopula = ot.NormalCopula(R)
myCorrelatedInputDistribution = ot.ComposedDistribution(
[ot.Normal()] * inputDimension, myCopula)
sample = myCorrelatedInputDistribution.getSample(2000)
# Orthogonal basis
enumerateFunction = ot.LinearEnumerateFunction(inputDimension)
productBasis = ot.OrthogonalProductPolynomialFactory(
[ot.HermiteFactory()] * inputDimension, enumerateFunction)
# Adaptive strategy
adaptiveStrategy = ot.FixedStrategy(
productBasis, enumerateFunction.getStrataCumulatedCardinal(4))
# Projection strategy
samplingSize = 250
projectionStrategy = ot.LeastSquaresStrategy(
ot.MonteCarloExperiment(samplingSize))
# Polynomial chaos algorithm
algo = ot.FunctionalChaosAlgorithm(
model, distribution, adaptiveStrategy, projectionStrategy)
algo.run()
# Post-process the results
result = ot.FunctionalChaosResult(algo.getResult())
ancova = ot.ANCOVA(result, sample)
indices = ancova.getIndices()
uncorrelatedIndices = ancova.getUncorrelatedIndices()
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()
graph.setColors(['red'])
graph2 = metaModel(validationInputSample).drawMarginal(0)
graph2.setColors(['blue'])
graph.add(graph2)
graph.setTitle('Comparaison modele/meta-modele')
graph.setXTitle(r'$t$')
graph.setYTitle(r'$z$')
otv.View(graph)
# Second, using a more evolved interface
basis = ot.OrthogonalProductPolynomialFactory([
ot.StandardDistributionPolynomialFactory(distX.getMarginal(i))
for i in range(distX.getDimension())
])
adaptiveStrategy = ot.FixedStrategy(
basis,
ot.EnumerateFunction(distX.getDimension()).getStrataCumulatedCardinal(6))
projectionStrategy = ot.LeastSquaresStrategy(
ot.LeastSquaresMetaModelSelectionFactory(ot.LARS(),
ot.CorrectedLeaveOneOut()))
algo = ot.FunctionalChaosAlgorithm(inputSample, outputSampleChaos, distX,
adaptiveStrategy, projectionStrategy)
algo.run()
metaModel = ot.PointToFieldConnection(postProcessing,
algo.getResult().getMetaModel())
graph = validationOutputSample.drawMarginal(0)
graph.setColors(['red'])
graph2 = metaModel(validationInputSample).drawMarginal(0)
graph2.setColors(['blue'])
graph.add(graph2)
