def test_two_inputs_one_output():
# Kriging use case
inputDimension = 2
# Learning data
levels = [8, 5]
box = ot.Box(levels)
inputSample = box.generate()
# Scale each direction
inputSample *= 10.0
model = ot.SymbolicFunction(['x', 'y'], ['cos(0.5*x) + sin(y)'])
outputSample = model(inputSample)
# Validation
sampleSize = 10
inputValidSample = ot.ComposedDistribution(
2 * [ot.Uniform(0, 10.0)]).getSample(sampleSize)
outputValidSample = model(inputValidSample)
# 2) Definition of exponential model
# The parameters have been calibrated using TNC optimization
# and AbsoluteExponential models
scales = [5.33532, 2.61534]
amplitude = [1.61536]
covarianceModel = ot.SquaredExponential(scales, amplitude)
# 3) Basis definition
basis = ot.ConstantBasisFactory(inputDimension).build()
# 4) Kriging algorithm
algo = ot.KrigingAlgorithm(inputSample, outputSample, covarianceModel,
basis)
algo.run()
result = algo.getResult()
# Get meta model
metaModel = result.getMetaModel()
outData = metaModel(inputValidSample)
# 5) Errors
# Interpolation
ott.assert_almost_equal(outputSample, metaModel(inputSample), 3.0e-5,
3.0e-5)
# 6) Kriging variance is 0 on learning points
covariance = result.getConditionalCovariance(inputSample)
ott.assert_almost_equal(covariance, ot.SquareMatrix(len(inputSample)),
7e-7, 7e-7)
# Covariance per marginal & extract variance component
coll = result.getConditionalMarginalCovariance(inputSample)
var = [mat[0, 0] for mat in coll]
ott.assert_almost_equal(var, [0] * len(var), 0.0, 1e-13)
# Variance per marginal
var = result.getConditionalMarginalVariance(inputSample)
ott.assert_almost_equal(var, ot.Point(len(inputSample)), 0.0, 1e-13)
# Estimation
ott.assert_almost_equal(outputValidSample, outData, 1.e-1, 1e-1)
def createMyBasicKriging(X, Y):
'''
Create a kriging from a pair of X and Y samples.
We use a 3/2 Matérn covariance model and a constant trend.
'''
basis = ot.ConstantBasisFactory(dimension).build()
covarianceModel = ot.MaternModel([1.0], 1.5)
algo = ot.KrigingAlgorithm(X, Y, covarianceModel, basis)
algo.run()
krigResult = algo.getResult()
return krigResult
def fitKriging(covarianceModel):
'''
Fit the parameters of a kriging metamodel.
'''
coordinates = ot.Sample([[1.0,1.0],[5.0,1.0],[9.0,1.0], \
[1.0,3.5],[5.0,3.5],[9.0,3.5], \
[1.0,6.0],[5.0,6.0],[9.0,6.0]])
observations = ot.Sample([[25.0], [25.0], [10.0], [20.0], [25.0], [20.0],
[15.0], [25.0], [25.0]])
basis = ot.ConstantBasisFactory(2).build()
algo = ot.KrigingAlgorithm(coordinates, observations, covarianceModel,
basis)
algo.run()
krigingResult = algo.getResult()
return krigingResult
def test_one_input_one_output():
sampleSize = 6
dimension = 1
f = ot.SymbolicFunction(['x0'], ['x0 * sin(x0)'])
X = ot.Sample(sampleSize, dimension)
X2 = ot.Sample(sampleSize, dimension)
for i in range(sampleSize):
X[i, 0] = 3.0 + i
X2[i, 0] = 2.5 + i
X[0, 0] = 1.0
X[1, 0] = 3.0
X2[0, 0] = 2.0
X2[1, 0] = 4.0
Y = f(X)
Y2 = f(X2)
# create algorithm
basis = ot.ConstantBasisFactory(dimension).build()
covarianceModel = ot.SquaredExponential([1e-02], [4.50736])
algo = ot.KrigingAlgorithm(X, Y, covarianceModel, basis)
algo.run()
# perform an evaluation
result = algo.getResult()
ott.assert_almost_equal(result.getMetaModel()(X), Y)
ott.assert_almost_equal(result.getResiduals(), [1.32804e-07], 1e-3, 1e-3)
ott.assert_almost_equal(result.getRelativeErrors(), [5.20873e-21])
# Kriging variance is 0 on learning points
covariance = result.getConditionalCovariance(X)
covariancePoint = ot.Point(covariance.getImplementation())
theoricalVariance = ot.Point(sampleSize * sampleSize)
ott.assert_almost_equal(covariance,
ot.Matrix(sampleSize, sampleSize),
8.95e-7, 8.95e-7)
# Covariance per marginal & extract variance component
coll = result.getConditionalMarginalCovariance(X)
var = [mat[0, 0] for mat in coll]
ott.assert_almost_equal(var, [0]*sampleSize, 1e-14, 1e-14)
# Variance per marginal
var = result.getConditionalMarginalVariance(X)
ott.assert_almost_equal(var, ot.Point(sampleSize), 1e-14, 1e-14)
def set_mean(self, mean):
'''
This function constructs the mean function
takes the following argument:
-> mean_type
'''
if mean.mean_type == 'Linear':
self.mean_function = ot.LinearBasisFactory(self.input_dim).build()
elif mean.mean_type == 'Constant':
self.mean_function = ot.ConstantBasisFactory(
self.input_dim).build()
elif mean.mean_type == 'Quadratic':
self.mean_function = ot.QuadraticBasisFactory(
self.input_dim).build()
elif mean.mean_type == 'Zero':
self.mean_function = ot.Basis()
else:
self.mean_function = "This library does not support the specified mean function"
# %%
# We rely on `H-Matrix` approximation for accelerating the evaluation.
# We change default parameters (compression, recompression) to higher values. The model is less accurate but very fast to build & evaluate.
# %%
ot.ResourceMap.SetAsString("KrigingAlgorithm-LinearAlgebra", "HMAT")
ot.ResourceMap.SetAsScalar("HMatrix-AssemblyEpsilon", 1e-5)
ot.ResourceMap.SetAsScalar("HMatrix-RecompressionEpsilon", 1e-4)
# %%
# In order to create the Kriging metamodel, we first select a constant trend with the `ConstantBasisFactory` class. Then we use a squared exponential covariance kernel.
# The `SquaredExponential` kernel has one amplitude coefficient and 4 scale coefficients. This is because this covariance kernel is anisotropic : each of the 4 input variables is associated with its own scale coefficient.
# %%
basis = ot.ConstantBasisFactory(dim).build()
covarianceModel = ot.SquaredExponential(dim)
# %%
# Typically, the optimization algorithm is quite good at setting sensible optimization bounds.
# In this case, however, the range of the input domain is extreme.
# %%
print("Lower and upper bounds of X_train:")
print(X_train.getMin(), X_train.getMax())
# %%
# We need to manually define sensible optimization bounds.
# Note that since the amplitude parameter is computed analytically (this is possible when the output dimension is 1), we only need to set bounds on the scale parameter.
# %%
def test_one_input_one_output():
sampleSize = 6
dimension = 1
f = ot.SymbolicFunction(['x0'], ['x0 * sin(x0)'])
X = ot.Sample(sampleSize, dimension)
X2 = ot.Sample(sampleSize, dimension)
for i in range(sampleSize):
X[i, 0] = 3.0 + i
X2[i, 0] = 2.5 + i
X[0, 0] = 1.0
X[1, 0] = 3.0
X2[0, 0] = 2.0
X2[1, 0] = 4.0
Y = f(X)
Y2 = f(X2)
# create covariance model
basis = ot.ConstantBasisFactory(dimension).build()
covarianceModel = ot.SquaredExponential()
# create algorithm
algo = ot.KrigingAlgorithm(X, Y, covarianceModel, basis)
# set sensible optimization bounds and estimate hyperparameters
algo.setOptimizationBounds(ot.Interval(X.getMin(), X.getMax()))
algo.run()
# perform an evaluation
result = algo.getResult()
ott.assert_almost_equal(result.getMetaModel()(X), Y)
ott.assert_almost_equal(result.getResiduals(), [1.32804e-07], 1e-3, 1e-3)
ott.assert_almost_equal(result.getRelativeErrors(), [5.20873e-21])
# Kriging variance is 0 on learning points
covariance = result.getConditionalCovariance(X)
nullMatrix = ot.Matrix(sampleSize, sampleSize)
ott.assert_almost_equal(covariance, nullMatrix, 0.0, 1e-13)
# Kriging variance is non-null on validation points
validCovariance = result.getConditionalCovariance(X2)
values = ot.Matrix([[
0.81942182, -0.35599947, -0.17488593, 0.04622401, -0.03143555,
0.04054783
],
[
-0.35599947, 0.20874735, 0.10943841, -0.03236419,
0.02397483, -0.03269184
],
[
-0.17488593, 0.10943841, 0.05832917, -0.01779918,
0.01355719, -0.01891618
],
[
0.04622401, -0.03236419, -0.01779918, 0.00578327,
-0.00467674, 0.00688697
],
[
-0.03143555, 0.02397483, 0.01355719, -0.00467674,
0.0040267, -0.00631173
],
[
0.04054783, -0.03269184, -0.01891618, 0.00688697,
-0.00631173, 0.01059488
]])
ott.assert_almost_equal(validCovariance - values, nullMatrix, 0.0, 1e-7)
# Covariance per marginal & extract variance component
coll = result.getConditionalMarginalCovariance(X)
var = [mat[0, 0] for mat in coll]
ott.assert_almost_equal(var, [0] * sampleSize, 1e-14, 1e-13)
# Variance per marginal
var = result.getConditionalMarginalVariance(X)
ott.assert_almost_equal(var, ot.Sample(sampleSize, 1), 1e-14, 1e-13)
# Prediction accuracy
ott.assert_almost_equal(Y2, result.getMetaModel()(X2), 0.3, 0.0)
# %%
sampleSize_train = 10
X_train = myDistribution.getSample(sampleSize_train)
Y_train = model(X_train)
# %%
# Create the metamodel
# --------------------
# %%
# In order to create the Kriging metamodel, we first select a constant trend with the `ConstantBasisFactory` class. Then we use a squared exponential covariance kernel.
# The `SquaredExponential` kernel has one amplitude coefficient and 4 scale coefficients. This is because this covariance kernel is anisotropic : each of the 4 input variables is associated with its own scale coefficient.
# %%
basis = ot.ConstantBasisFactory(dimension).build()
covarianceModel = ot.SquaredExponential(dimension)
# %%
# Typically, the optimization algorithm is quite good at setting sensible optimization bounds.
# In this case, however, the range of the input domain is extreme.
# %%
print("Lower and upper bounds of X_train:")
print(X_train.getMin(), X_train.getMax())
# %%
# We need to manually define sensible optimization bounds.
# Note that since the amplitude parameter is computed analytically (this is possible when the output dimension is 1), we only need to set bounds on the scale parameter.
# %%
box = ot.Box(levels)
inputSample = box.generate()
# Scale each direction
inputSample *= 10
# Define model
model = ot.Function(['x', 'y'], ['z'], ['cos(0.5*x) + sin(y)'])
outputSample = model(inputSample)
# 2) Definition of exponential model
covarianceModel = ot.SquaredExponential([1.988, 0.924], [3.153])
# 3) Basis definition
basisCollection = ot.BasisCollection(
1,
ot.ConstantBasisFactory(spatialDimension).build())
# Kriring algorithm
algo = ot.KrigingAlgorithm(inputSample, outputSample, covarianceModel,
basisCollection)
algo.run()
result = algo.getResult()
vertices = [[1.0, 0.0], [2.0, 0.0], [2.0, 1.0], [1.0, 1.0], [1.5, 0.5]]
simplicies = [[0, 1, 4], [1, 2, 4], [2, 3, 4], [3, 0, 4]]
mesh2D = ot.Mesh(vertices, simplicies)
process = ot.ConditionedGaussianProcess(result, mesh2D)
# Get a realization of the process
realization = process.getRealization()
model = ot.SymbolicFunction(['x', 'y'], ['cos(0.5*x) + sin(y)'])
outputSample = model(inputSample)
# Validation data
sampleSize = 10
inputValidSample = ot.ComposedDistribution(
2 * [ot.Uniform(0, 10.0)]).getSample(sampleSize)
outputValidSample = model(inputValidSample)
# 2) Definition of exponential model
# The parameters have been calibrated using TNC optimization
# and AbsoluteExponential models
covarianceModel = ot.SquaredExponential([7.63, 2.11], [7.38])
# 3) Basis definition
basis = ot.ConstantBasisFactory(inputDimension).build()
# Kriging algorithm
algo = ot.KrigingAlgorithm(inputSample, outputSample, covarianceModel, basis)
algo.setOptimizeParameters(False) # do not optimize hyper-parameters
algo.run()
result = algo.getResult()
vertices = [[1.0, 0.0], [2.0, 0.0], [2.0, 1.0], [1.0, 1.0], [1.5, 0.5]]
simplicies = [[0, 1, 4], [1, 2, 4], [2, 3, 4], [3, 0, 4]]
mesh2D = ot.Mesh(vertices, simplicies)
process = ot.ConditionedGaussianProcess(result, mesh2D)
# Get a realization of the process
realization = process.getRealization()
[4.35455857e+00, 1.23814619e-02, 1.01810539e+00, 1.10769534e+01]])
signals = ot.NumericalSample(
[[37.305445], [35.466919], [43.187991], [45.305165], [40.121222],
[44.609524], [45.14552], [44.80595], [35.414039], [39.851778],
[42.046049], [34.73469], [39.339349], [40.384559], [38.718623],
[46.189709], [36.155737], [31.768369], [35.384313], [47.914584],
[46.758537], [46.564428], [39.698493], [45.636588], [40.643948]])
# Select point as initial DOE
inputDOE = inputSample[:10]
outputDOE = signals[:10]
# simulate the true physical model
basis = ot.ConstantBasisFactory(4).build()
basis = ot.ConstantBasisFactory(4).build()
if ot.__version__ == '1.6':
covColl = ot.CovarianceModelCollection(4)
scale = [5.03148, 13.9442, 20, 20]
for i in range(4):
c = ot.SquaredExponential(1, scale[i])
c.setAmplitude([15.1697])
covColl[i] = c
covarianceModel = ot.ProductCovarianceModel(covColl)
elif ot.__version__ > '1.6':
covarianceModel = ot.SquaredExponential([5.03148, 13.9442, 20, 20],
[15.1697])
if ot.__version__ == '1.9':
krigingModel = ot.KrigingAlgorithm(inputSample, signals, covarianceModel, basis)
#! /usr/bin/env python
from __future__ import print_function
import openturns as ot
ot.TESTPREAMBLE()
dim = 2
x = [2.0 + i for i in range(dim)]
print("x=", x)
factory = ot.ConstantBasisFactory(dim)
print("factory=", factory)
basis = factory.build()
print("basis=", basis)
f = ot.AggregatedFunction(basis)
y = f(x)
print("y=", y)
factory = ot.LinearBasisFactory(dim)
print("factory=", factory)
basis = factory.build()
print("basis=", basis)
f = ot.AggregatedFunction(basis)
y = f(x)
print("y=", y)
metaModel_0.run()
print(metaModel_0.getResult())
# deterministic/kriging
X0 = persalys.Input('X0', 0, '')
X1 = persalys.Input('X1', 0, '')
X2 = persalys.Input('X2', 0, '')
X3 = persalys.Input('X3', 0, '')
Y0 = persalys.Output('Y0', '')
inputs = [X0, X1, X2, X3]
outputs = [Y0]
formulas = ['X0+X1+X2+X3']
SymbolicModel_0 = persalys.SymbolicPhysicalModel('SymbolicModel_0', inputs, outputs, formulas)
values = [[0],
[0],
[-0.1, 0.1],
[-0.1, 0.1]]
design_0 = persalys.GridDesignOfExperiment('design_0', SymbolicModel_0, values)
design_0.setBlockSize(1)
interestVariables = ['Y0']
design_0.setInterestVariables(interestVariables)
design_0.run()
metaModel_0 = persalys.KrigingAnalysis('metaModel_0', design_0)
metaModel_0.setBasis(ot.ConstantBasisFactory(2).build())
metaModel_0.setCovarianceModel(ot.SquaredExponential(2))
metaModel_0.setAnalyticalValidation(True)
metaModel_0.setTestSampleValidation(False)
metaModel_0.setKFoldValidation(False)
metaModel_0.run()
print(metaModel_0.getResult())
