def _exec(self, X):
y0 = X[0]
a = X[1]
b = X[2]
phi_ab = ot.ParametricFunction(self.phi_, [2, 3], [a, b])
phi_t = ot.ParametricFunction(phi_ab, [0], [0.0])
solver = ot.RungeKutta(phi_t)
initialState = [y0]
values = solver.solve(initialState, self.ticks_)
return values * [1.0e-6]
def buildFunction(beta, nu, N, t0):
'''
Build the transition function of the SIR model given the values of
beta and nu
'''
f = ot.SymbolicFunction(['t', 'S', 'I', 'R'], [
str(-beta / N) + '*S*I',
str(beta / N) + 'S*I-' + str(nu) + '*I',
str(nu) + '*I'
])
phi = ot.ParametricFunction(f, [0], [t0])
return phi
def __init__(self, simulateur, annee, S, D):
"""
Crée un modèle de pension probabiliste.
Paramètres :
simulateur : un SimulateurRetraite
annee : un flottant, l'année de calcul de P
S : un flottant, le solde financier en part de PIB
D : un flottant positif, le montant des dépenses de retraites
en part de PIB
Description :
Crée un modèle de pension probabiliste pour le
ratio (pension moyenne) / (salaire moyen).
Les entrées du modèle sont "As", "F", "TauC"
et la sortie est "P".
Les paramètres S et D sont fixés par le constructeur
de la classe au moment de la création de l'objet.
* S : le solde financier du système de retraites (% PIB)
* D : le montant des dépenses (% PIB)
* As : l'âge moyen de départ à la retraite défini par l'utilisateur
* F : facteur d'élasticité de report de l'âge de départ
(par exemple F=0.5)
* TauC : le taux de chômage (par exemple TauC = 4.5)
Les distributions des variables sont ot.Uniform
et indépendantes.
Exemple :
S = 0.0
D = 0.14
annee = 2050
modele = ModelePensionProbabiliste(simulateur, annee, S, D)
fonction = modele.getFonction()
inputDistribution = modele.getInputDistribution()
"""
# Crée le modèle de pension complet : entrées = (S, D, As, F, TauC)
modelePension = ot.Function(FonctionPension(simulateur, annee))
# Crée le modèle réduit à partir du modèle complet : entrées = (As, F, TauC)
indices = ot.Indices([0, 1])
referencePoint = ot.Point([S, D])
self.fonction = ot.ParametricFunction(modelePension, indices, referencePoint)
# Distribution
As = ot.Uniform(62.0, 66.0)
F = ot.Uniform(0.25, 0.75)
TauC = ot.Uniform(4.5, 10.0)
self.inputDistribution = ot.ComposedDistribution([As, F, TauC])
self.inputDistribution.setDescription(["As", "F", "TauC"])
return
def __init__(self):
# dimension
self.dim = 3
# Fixed parameters for the Ishigami function
self.a = 7.0
self.b = 0.1
# First marginal : X1
self.X1 = ot.Uniform(-m.pi, m.pi)
self.X1.setName("X1")
# Second marginal : X2
self.X2 = ot.Uniform(-m.pi, m.pi)
self.X2.setName("X2")
# Third marginal : X3
self.X3 = ot.Uniform(-m.pi, m.pi)
self.X3.setName("X1")
# Input distribution
self.distributionX = ot.ComposedDistribution(
[self.X1, self.X2, self.X3])
self.distributionX.setDescription(['X1', 'X2', 'X3'])
self.ishigami = ot.SymbolicFunction(
['X1', 'X2', 'X3', 'a', 'b'],
['sin(X1) + a * sin(X2)^2 + b * X3^4 * sin(X1)'])
# The Ishigami model
self.model = ot.ParametricFunction(self.ishigami, [3, 4],
[self.a, self.b])
self.expectation = self.a / 2.0
self.variance = 1.0/2 + self.a**2/8.0 + \
self.b*m.pi**4/5.0 + self.b**2*m.pi**8/18.0
self.S1 = (1.0 / 2.0 + self.b * m.pi**4 / 5.0 +
self.b**2 * m.pi**8 / 50.0) / self.variance
self.S2 = (self.a**2 / 8.0) / self.variance
self.S3 = 0.0
self.S12 = 0.0
self.S13 = self.b**2 * m.pi**8 / 2.0 * (1.0 / 9.0 -
1.0 / 25.0) / self.variance
self.S23 = 0.0
self.S123 = 0.0
self.ST1 = self.S1 + self.S13
self.ST2 = self.S2
self.ST3 = self.S3 + self.S13
def functionCrue4VarsStochastic(X):
Q, Ks, Zv, Zm = X
# 1. Creation of the problem function
f8v = ot.PythonFunction(8, 1, functionCrue8vars)
g = ot.ParametricFunction(f8v, [0, 1, 2, 3], X)
# 2. Random vector definition
Hd = ot.Uniform(4.,14.)
Zb = ot.Uniform(50.,60.)
L = ot.Uniform(1000.,10000.)
B = ot.Uniform(50.,500.)
inputvector = ot.ComposedDistribution([Hd, Zb, L, B])
inputRV = ot.RandomVector(inputvector)
S = ot.CompositeRandomVector(g, inputRV)
# 3. Sample output
sampleSize = 10
outputSample = S.getSample(sampleSize)
Smean = outputSample.computeMean()[0]
return [Smean]
def _runMonteCarlo(self, defect):
# set a parametric function where the first parameter = given defect
g = ot.ParametricFunction(self._metamodel, [0], [defect])
g = ot.MemoizeFunction(g)
g.enableHistory()
g.clearHistory()
g.clearCache()
output = ot.CompositeRandomVector(g,
ot.RandomVector(self._distribution))
event = ot.ThresholdEvent(output, ot.Greater(), self._detectionBoxCox)
##### Monte Carlo ########
algo_MC = ot.ProbabilitySimulationAlgorithm(event)
algo_MC.setMaximumOuterSampling(self._samplingSize)
# set negative coef of variation to be sure the stopping criterion is the sampling size
algo_MC.setMaximumCoefficientOfVariation(-1)
algo_MC.run()
return algo_MC.getResult()
def __init__(self, a=7.0, b=0.1):
"""
Create a Ishigami sensitivity problem.
Parameters
----------
a : float
The first parameter.
b : float
The second parameter.
Example
-------
problem = IshigamiSensitivityBenchmarkProblem()
"""
# Define the function
formula = ["sin(X1) + a * sin(X2)^2 + b * X3^4 * sin(X1)"]
input_names = ["X1", "X2", "X3", "a", "b"]
fullFunction = ot.SymbolicFunction(input_names, formula)
indices = [3, 4]
referencePoint = [a, b]
function = ot.ParametricFunction(fullFunction, indices, referencePoint)
# Define the distribution
inputDimension = 3
distributionList = [ot.Uniform(-np.pi, np.pi)] * inputDimension
distribution = ot.ComposedDistribution(distributionList)
name = "Ishigami"
# Compute exact indices
exact = self.ComputeIndices(a, b)
firstOrderIndices = ot.Point([exact["S1"], exact["S2"], exact["S3"]])
totalOrderIndices = ot.Point([exact["T1"], exact["T2"], exact["T3"]])
super(IshigamiSensitivityBenchmarkProblem, self).__init__(
name, distribution, function, firstOrderIndices, totalOrderIndices
)
return None
def buildCrossCutFunction(self, i, j):
"""
Create the cross-cut parametric function for projection (i,j).
The parametric function is the event function where the
only free variables are (X[i], X[j]) and other variables
are set to the mean point.
We must have i < j, otherwise the function
would be evaluated at the wrong input X.
Parameters
----------
i : int
The index of the first marginal of the cross-cut.
j : int
The index of the second marginal of the cross-cut.
Returns
-------
crosscutFunction : ot.Function
The cross-cut function.
"""
if j < i:
raise ValueError("i=%d > j=%d." % (i, j))
inputVector = self.event.getAntecedent()
distribution = inputVector.getDistribution()
mean = distribution.getMean()
indices = []
point = []
for k in range(self.inputDimension):
if k != i and k != j:
indices.append(k)
point.append(mean[k])
crosscutFunction = ot.ParametricFunction(self.g, indices, point)
return crosscutFunction
# .. math::
# f : \underline{X} \mapsto \underline{\underline{A}} ( \underline{X} - \underline{b} ) + \underline{c} + \frac{1}{2} \underline{X}^T \times \underline{\underline{\underline{M}}} \times \underline{X}
#
# %%
import openturns as ot
import openturns.viewer as viewer
from matplotlib import pylab as plt
import math as m
ot.Log.Show(ot.Log.NONE)
# %%
# create a quadratic function
inputDimension = 3
outputDimension = 2
center = [1.0] * inputDimension
constant = [-1.0, 2.0] # c
linear = ot.Matrix(inputDimension, outputDimension) # A
quadratic = ot.SymmetricTensor(inputDimension, outputDimension) # M
quadratic[0, 0, 1] = 3.0
function = ot.QuadraticFunction(center, constant, linear, quadratic)
x = [7.0, 8.0, 9.0]
print(function(x))
# %%
# draw y1 with x1=2.0, x2=1.0, x0 in [0, 2]
graph = ot.ParametricFunction(
function, [1, 2], [2.0, 1.0]).getMarginal(1).draw(0.0, 2.0)
view = viewer.View(graph)
plt.show()
# %%
algo = ot.FunctionalChaosAlgorithm(inputSample, outputSample)
algo.run()
result = algo.getResult()
metamodel = result.getMetaModel()
# %%
# Plot the second output of our model depending on :math:`x_2` with :math:`x_1=0.5`. In order to do this, we create a `ParametricFunction` and set the value of :math:`x_1`. Then we use the `getMarginal` method to extract the second output (which index is equal to 1).
# %%
x1index = 0
x1value = 0.5
x2min = -3.
x2max = 3.
outputIndex = 1
metamodelParametric = ot.ParametricFunction(metamodel, [x1index], [x1value])
graph = metamodelParametric.getMarginal(outputIndex).draw(x2min, x2max)
graph.setLegends(["Metamodel"])
modelParametric = ot.ParametricFunction(model, [x1index], [x1value])
curve = modelParametric.getMarginal(outputIndex).draw(x2min, x2max).getDrawable(0)
curve.setColor('red')
curve.setLegend("Model")
graph.add(curve)
graph.setLegendPosition("bottomright")
graph.setXTitle("X2")
graph.setTitle("Metamodel Validation, output #%d" % (outputIndex))
view = viewer.View(graph)
# %%
# We see that the metamodel fits approximately to the model, except perhaps for extreme values of :math:`x_2`. However, there is a better way of globally validating the metamodel, using the `MetaModelValidation` on a validation design of experiment.
y_obs[5, 0] = 0.661725805623086
y_obs[6, 0] = -1.57581204592385
y_obs[7, 0] = -2.95308465670895
y_obs[8, 0] = -8.8878164296758
y_obs[9, 0] = -13.0812290405651
print('y_obs=', y_obs)
p = ot.Sample(obsSize, chainDim)
for i in range(obsSize):
for j in range(chainDim):
p[i, j] = (-2 + 5. * i / 9.)**j
print('p=', p)
fullModel = ot.SymbolicFunction(['p1', 'p2', 'p3', 'x1', 'x2', 'x3'],
['p1*x1+p2*x2+p3*x3', '1.0'])
linkFunction = ot.ParametricFunction(fullModel, range(chainDim),
[0.0] * chainDim)
# instrumental distribution
instrumental = ot.Uniform(-1., 1.)
# prior distribution
sigma0 = [10.0] * chainDim
Q0 = ot.CorrelationMatrix(chainDim) # precision matrix
Q0_inv = ot.CorrelationMatrix(chainDim) # variance matrix
for i in range(chainDim):
Q0_inv[i, i] = sigma0[i] * sigma0[i]
Q0[i, i] = 1.0 / Q0_inv[i, i]
print('Q0=', Q0)
mu0 = [0.0] * chainDim
prior = ot.Normal(mu0, Q0_inv) # x0 ~ N(mu0, sigma0)
view = otv.View(graph)
# %%
# A common pre-processing step is to apply a transform on the input data before performing the kriging.
# To do so we write a linear transform of our input data : we make it unit centered at its mean. Then we fix the mean and the standard deviation to their values with the `ParametricFunction`. We build the inverse transform as well.
#
# We first compute the mean and standard deviation of the input data :
mean = Xtrain.computeMean()[0]
stdDev = Xtrain.computeStandardDeviation()[0]
print("Xtrain, mean : %.3f" % mean)
print("Xtrain, standard deviation : %.3f" % stdDev)
# %%
tf = ot.SymbolicFunction(['mu', 'sigma', 'x'], ['(x-mu)/sigma'])
itf = ot.SymbolicFunction(['mu', 'sigma', 'x'], ['sigma*x+mu'])
myInverseTransform = ot.ParametricFunction(itf, [0, 1], [mean, stdDev])
myTransform = ot.ParametricFunction(tf, [0, 1], [mean, stdDev])
# %%
# A constant basis
# ----------------
#
# In this paragraph we choose a basis constant for the kriging. There is only one unknown which is the
# value of the constant. The basis is built with the :class:`~openturns.ConstantBasisFactory` class.
basis = ot.ConstantBasisFactory(dimension).build()
# %%
# We build the kriging algorithm by giving it the transformed data, the output data, the covariance
# model and the basis.
algo = ot.KrigingAlgorithm(myTransform(Xtrain), Ytrain, covarianceModel, basis)
# Generate design of experiment
# -----------------------------
#
# We create training samples from the function :math:`x\sin(x)`. We can change their number and distribution in the :math:`[0; 10]` range.
# If the `with_error` boolean is `True`, then the data is computed by adding a gaussian noise to the function values.
# %%
dim = 1
xmin = 0
xmax = 10
n_pt = 20 # number of initial points
with_error = True # whether to use generation with error
# %%
ref_func_with_error = ot.SymbolicFunction(['x', 'eps'], ['x * sin(x) + eps'])
ref_func = ot.ParametricFunction(ref_func_with_error, [1], [0.0])
x = np.vstack(np.linspace(xmin, xmax, n_pt))
ot.RandomGenerator.SetSeed(1235)
eps = ot.Normal(0, 1.5).getSample(n_pt)
X = ot.Sample(n_pt, 2)
X[:, 0] = x
X[:, 1] = eps
if with_error:
y = np.array(ref_func_with_error(X))
else:
y = np.array(ref_func(x))
# %%
graph = ref_func.draw(xmin, xmax, 200)
cloud = ot.Cloud(x, y)
cloud.setColor('red')
criticalDomain = ot.Interval(5, float('inf'))
# %%
# We have access to the distance to this domain thanks to the
# :class:`~openturns.DistanceToDomainFunction` class.
dist2criticalDomain = ot.DistanceToDomainFunction(criticalDomain)
# %%
# We define the parameters in our function from the output sample
s = 0.1 * Y.computeStandardDeviation()[0]
# %%
# We now define our filter function by composition of the parametrized function and
# the distance function.
f = ot.SymbolicFunction(["x", "s"], ["exp(-x/s)"])
phi = ot.ParametricFunction(f, [1], [s])
filterFunction = ot.ComposedFunction(phi, dist2criticalDomain)
# %%
# We choose an unbiased estimator
estimatorType = ot.HSICUStat()
# %%
# and build the HSIC estimator
targetHSIC = ot.HSICEstimatorTargetSensitivity(covarianceModelCollection, X, Y,
estimatorType, filterFunction)
# %%
# We get the R2-HSIC indices:
R2HSICIndices = targetHSIC.getR2HSICIndices()
print("\n Target HSIC analysis")
#!/usr/bin/env python
from __future__ import print_function
import openturns as ot
import openturns.testing as ott
import math as m
f = ot.SymbolicFunction(
['tau', 'alpha'], ['cos(4*tau)*cosh((tau-pi_)/alpha)/cosh(pi_/alpha)'])
alpha = 1.36
rho = ot.ParametricFunction(f, [1], [alpha])
cov = ot.StationaryFunctionalCovarianceModel([1.0], [1.0], rho)
print(cov)
tau = 0.1
c = cov([tau])[0, 0]
print("tau=", tau)
print("c=", c)
c_ref = m.cos(4*tau)*m.cosh((tau-m.pi)/alpha)/m.cosh(m.pi/alpha)
ott.assert_almost_equal(c, c_ref)
assert len(cov.getFullParameter()) == 3, "wrong full parameter"
assert len(cov.getFullParameterDescription()
) == 3, "wrong full parameter description"
print(cov.getFullParameter())
print(cov.getFullParameterDescription())
assert len(cov.getActiveParameter()) == 2, "wrong active parameter"
quantile = beta*(-np.log1p(-p))**(1/alpha)
return [quantile]
# %%
quantileFunction = ot.PythonFunction(3, 1, weibullQ)
# %%
# We define the parameters of the Weibull distribution and create the parametric function.
# %%
alpha = 10.0
beta = 1.0
# %%
quantile = ot.ParametricFunction(quantileFunction,[1,2], [alpha,beta])
quantile
# %%
# In the library, the uniform distribution is by default over the :math:`[-1,1]` interval. To obtain a uniform distribution over :math:`[0,1]`, we need to set the bounds explicitly.
# %%
U = ot.Uniform(0.,1.)
# %%
# Then we generate a sample of size 1000 from the uniform distribution.
# %%
n = 1000
uniformSample = U.getSample(n)
import openturns as ot
from matplotlib import pyplot as plt
from openturns.viewer import View
def flow(X):
Y0 = X[0]
Y1 = X[1]
t = X[2]
dY0 = Y0 * (2.0 - Y1)
dY1 = Y1 * (Y0 - 1.0)
return [dY0, dY1]
f = ot.PythonFunction(3, 2, flow)
phi = ot.ParametricFunction(f, [2], [0.0])
solver = ot.RungeKutta(phi)
initialState = [2.0, 2.0]
nt = 47
dt = 0.1
timeGrid = ot.RegularGrid(0.0, dt, nt)
result = solver.solve(initialState, timeGrid)
xMin = result.getMin()
xMax = result.getMax()
delta = 0.2 * (xMax - xMin)
mesh = ot.IntervalMesher([12] * 2).build(
ot.Interval(xMin - delta, xMax + delta))
field = ot.Field(mesh, phi(mesh.getVertices()))
ot.ResourceMap.SetAsScalar("Field-ArrowScaling", 0.1)
graph = field.draw()
covarianceModelCollection.add(Cov2)
# We choose an estimator type :
# - unbiased: HSICUStat;
# - biased: HSICVStat.
#
estimatorType = ot.HSICUStat()
# We define a distance function for the weights
# For the TSA, the critical domain is [5,+inf].
interval = ot.Interval(5, float('inf'))
g = ot.DistanceToDomainFunction(interval)
stdDev = Y.computeStandardDeviation()[0]
foo = ot.SymbolicFunction(["x", "s"], ["exp(-x/s)"])
g2 = ot.ParametricFunction(foo, [1], [0.1 * stdDev])
# The filter function
filterFunction = ot.ComposedFunction(g2, g)
# We eventually build the HSIC object!
TSA = ot.HSICEstimatorTargetSensitivity(covarianceModelCollection, X, Y,
estimatorType, filterFunction)
# We get the R2-HSIC
R2HSIC = TSA.getR2HSICIndices()
ott.assert_almost_equal(R2HSIC, [0.26863688, 0.00468423, 0.00339962])
# and the HSIC indices
HSICIndices = TSA.getHSICIndices()
ott.assert_almost_equal(HSICIndices, [0.00107494, 0.00001868, 0.00001411])
# the second output of the model, is the standard deviation.
# %%
fullModel = ot.SymbolicFunction(["x", "theta1", "theta2", "theta3"],
["theta1+theta2*x+theta3*x^2", "1.0"])
# %%
# To differentiate between the two classes of inputs (:math:`x` and :math:`\vect\theta`),
# we define a :class:`~openturns.ParametricFunction` from `fullModel`
# and make the first input (the observations :math:`x`) its *parameter*:
# :math:`f_x(\vect \theta) := f(x, \vect \theta)`.
# We set :math:`x = 1` as a placeholder,
# but :math:`x` will actually take the values :math:`x_i` of the observations
# when we sample :math:`\vect\theta`.
linkFunction = ot.ParametricFunction(fullModel, [0], [1.0])
print(linkFunction)
# %%
# Define the observation noise :math:`\varepsilon {\sim} \mathcal N(0, 1)` and create a sample from it.
# %%
ot.RandomGenerator.SetSeed(0)
noiseStandardDeviation = 1.0
noise = ot.Normal(0, noiseStandardDeviation)
noiseSample = noise.getSample(obsSize)
# %%
# Define the vector of observations :math:`y_i`,
# here sampled using the "true" value of :math:`\vect \theta`: :math:`\vect \theta_{true}`.
import openturns as ot
import otrobopt
from matplotlib import pyplot as plt
from openturns.viewer import View
thetaDist = ot.Normal(2.0, 0.1)
if 'WorstCaseMeasure' == 'WorstCaseMeasure':
thetaDist = ot.Uniform(-1.0, 4.0)
elif 'ChanceMeasure' in 'WorstCaseMeasure':
thetaDist = ot.Normal(1.0, 1.0)
f_base = ot.SymbolicFunction(['x', 'theta'], ['x*theta'])
f = ot.ParametricFunction(f_base, [1], thetaDist.getMean())
if 'WorstCaseMeasure' == 'JointChanceMeasure':
measure = otrobopt.JointChanceMeasure(f, thetaDist, ot.GreaterOrEqual(),
0.95)
elif 'WorstCaseMeasure' == 'IndividualChanceMeasure':
measure = otrobopt.IndividualChanceMeasure(f, thetaDist,
ot.GreaterOrEqual(), [0.95])
elif 'WorstCaseMeasure' == 'MeanStandardDeviationTradeoffMeasure':
measure = otrobopt.MeanStandardDeviationTradeoffMeasure(
f, thetaDist, [0.8])
elif 'WorstCaseMeasure' == 'QuantileMeasure':
measure = otrobopt.QuantileMeasure(f, thetaDist, 0.99)
else:
measure = otrobopt.WorstCaseMeasure(f, thetaDist)
N = 10
experiment = ot.LHSExperiment(N)
factory = otrobopt.MeasureFactory(experiment)
ot.Uniform(63070.0, 115600.0),
ot.Uniform(990.0, 1110.0),
ot.Uniform(63.1, 116.0),
ot.Uniform(700.0, 820.0),
ot.Uniform(1120.0, 1680.0),
ot.Uniform(9855.0, 12045.0)
]
distribution = ot.ComposedDistribution(coll)
distribution.setDescription(input_names)
# %%
# Freeze r, Tu, Tl from model to go faster
selection = [1, 2, 4]
complement = ot.Indices(selection).complement(dimension)
distribution = distribution.getMarginal(complement)
model = ot.ParametricFunction(model, selection,
distribution.getMarginal(selection).getMean())
input_names_copy = list(input_names)
input_names = itemgetter(*complement)(input_names)
dimension = len(complement)
# %%
# design of experiment
size = 1000
X = distribution.getSample(size)
Y = model(X)
# %%
# create a functional chaos model
algo = ot.FunctionalChaosAlgorithm(X, Y)
algo.run()
result = algo.getResult()
#! /usr/bin/env python
import openturns as ot
ot.TESTPREAMBLE()
ot.PlatformInfo.SetNumericalPrecision(5)
m = 10
x = [[0.5 + i] for i in range(m)]
inVars = ["a", "b", "c", "x"]
formulas = ["a + b * exp(c * x)", "(a * x^2 + b) / (c + x^2)"]
g = ot.SymbolicFunction(inVars, formulas)
trueParameter = [2.8, 1.2, 0.5]
params = [0, 1, 2]
model = ot.ParametricFunction(g, params, trueParameter)
y = model(x)
y += ot.Normal([0.0] * 2, [0.05] * 2, ot.IdentityMatrix(2)).getSample(m)
candidate = [1.0] * 3
methods = ["SVD", "QR", "Cholesky"]
for method in methods:
print("method=", method)
algo = ot.LinearLeastSquaresCalibration(model, x, y, candidate, method)
algo.run()
print("result=", algo.getResult())
import openturns.testing as ott
import math as m
import sys
ot.TESTPREAMBLE()
ot.PlatformInfo.SetNumericalPrecision(3)
m = 10
x = [[0.5 + i] for i in range(m)]
inVars = ["a", "b", "c", "x"]
formulas = ["a + b * exp(c * x)", "(a * x^2 + b) / (c + x^2)"]
model = ot.SymbolicFunction(inVars, formulas)
p_ref = [2.8, 1.2, 0.5]
params = [0, 1, 2]
modelX = ot.ParametricFunction(model, params, p_ref)
y = modelX(x)
y += ot.Normal([0.0] * 2, [0.05] * 2, ot.IdentityMatrix(2)).getSample(m)
candidate = [1.0] * 3
priorCovariance = ot.CovarianceMatrix(3)
for i in range(3):
priorCovariance[i, i] = 3.0 + (1.0 + i) * (1.0 + i)
for j in range(i):
priorCovariance[i, j] = 1.0 / (1.0 + i + j)
errorCovariance = ot.CovarianceMatrix(2)
for i in range(2):
errorCovariance[i, i] = 2.0 + (1.0 + i) * (1.0 + i)
for j in range(i):
errorCovariance[i, j] = 1.0 / (1.0 + i + j)
globalErrorCovariance = ot.CovarianceMatrix(2 * m)
for i in range(2 * m):
# Then we create a kriging metamodel, using a constant trend and a squared exponential covariance model.
# %%
basis = ot.ConstantBasisFactory(dimension).build()
covarianceModel = ot.SquaredExponential([0.1]*dimension, [1.0])
algo = ot.KrigingAlgorithm(x, y, covarianceModel, basis)
algo.run()
result = algo.getResult()
metamodel = result.getMetaModel()
# %%
# It is not so easy to visualize a bidimensional function. In order to simplify the graphics, we consider the value of the function at the input :math:`x_{1,ref}=0.5`. This amounts to create a `ParametricFunction` where the first variable :math:`x_1` (at input index 0) is set to :math:`0.5`.
# %%
x1ref = 0.5
metamodelAtXref = ot.ParametricFunction(metamodel, [0], [x1ref])
modelAtXref = ot.ParametricFunction(model, [0], [x1ref])
# %%
# For this given value of :math:`x_1`, we plot the model and the metamodel with :math:`x_2` from its 1% up to its 99% quantile. We configure the X title to "X2" because the default setting would state that this axis is the first value of the parametric function, which default name is "X0".
# %%
x2min = ot.Normal().computeQuantile(0.01)[0]
x2max = ot.Normal().computeQuantile(0.99)[0]
graph = metamodelAtXref.draw(x2min, x2max)
graph.setLegends(["Kriging"])
curve = modelAtXref.draw(x2min, x2max)
curve.setLegends(["Model"])
curve.setColors(['red'])
graph.add(curve)
graph.setLegendPosition("topright")
# center of the approximation
x0 = [-0.4, -0.4]
# drawing bounds
a=-0.4
b=0.0
# %%
# create a linear (first order) Taylor approximation
algo = ot.LinearTaylor(x0, model)
algo.run()
responseSurface = algo.getMetaModel()
# %%
# plot 2nd output of our model with x1=x0_1
graph = ot.ParametricFunction(responseSurface, [0], [x0[1]]).getMarginal(1).draw(a, b)
graph.setLegends(['taylor'])
curve = ot.ParametricFunction(model, [0], [x0[1]]).getMarginal(1).draw(a, b).getDrawable(0)
curve.setColor('red')
curve.setLegend('model')
graph.add(curve)
graph.setLegendPosition('topright')
view = viewer.View(graph)
# %%
# Here is the decomposition at the second order:
#
# .. math::\underline{y} \, \approx \, \widehat{h}(\underline{x}) \, = \,
# h(\underline{x}_0) \, + \, \sum_{i=1}^{n_{X}} \;
# \frac{\partial h}{\partial x_i}(\underline{x}_0).\left(x_i - x_{0,i} \right) \, +
# \, \frac{1}{2} \; \sum_{i,j=1}^{n_X} \;
def residualFunctionNoise(params):
modelx = ot.ParametricFunction(model, [0, 1, 2], params)
return [modelx(x[i])[0] - ynoise[i, 0] for i in range(m)]
#!/usr/bin/env python
import openturns as ot
import math as m
f = ot.SymbolicFunction(ot.Description.BuildDefault(5, 'x'), [
'sin(x0) + x1 * cos(x2) / exp(x3)', '-2.0 * x0 + x1 * x2^2 + cos(x3)',
'x0 / (abs(x1) * x2^2 + x3 + 1.0)'
])
pset = [3, 1] # x3, x1
parametersSet = True
x = [1.0, 2.0, 0.0] # x0, x2, x4
# with reference point
referencePoint = [0.85] * 2 # x3, x1
g2 = ot.ParametricFunction(f, pset, referencePoint, parametersSet)
print('g2=', g2)
print('g2(x)=', g2(x))
# with complementary parameter set
referencePoint = [1.0, 2.0, 0.0] # x0, x2, x4
x = [0.85] * 2 # x3, x1
parametersSet = False
g3 = ot.ParametricFunction(f, pset, referencePoint, parametersSet)
print('g3=', g3)
print('g3(x)=', g3(x))
# From ticket #1092
modelFunc = ot.SymbolicFunction(["s", "r", "c"], ["r + c"])
s = [1.]
r = 1e9
result = algo.getResult()
x_star = result.getOptimalPoint()
if minimization and algoName != 'STEEPEST_DESCENT':
ott.assert_almost_equal(x_star, p_ref, 5e-2)
print(result)
# least-squares optimization
n = 3
m = 10
x = [[0.5 + i] for i in range(m)]
model = ot.SymbolicFunction(['a', 'b', 'c', 'x'],
['a + b * exp(min(500, c * x))'])
p_ref = [2.8, 1.2, 0.5] # a, b, c
modelx = ot.ParametricFunction(model, [0, 1, 2], p_ref)
y = modelx(x)
def residualFunction_py(p):
modelx = ot.ParametricFunction(model, [0, 1, 2], p)
return [modelx(x[i])[0] - y[i, 0] for i in range(m)]
residualFunction = ot.PythonFunction(n, m, residualFunction_py)
bounds = ot.Interval([0, 0, 0], [2.5, 8.0, 19])
for algoName in algoNames:
line_search = not (algoName in ['LEVENBERG_MARQUARDT', 'DOGLEG'])
for bound in [True, False]:
# %% # Define the value of the reference values of the :math:`\theta` parameter. In the bayesian framework, this is called the mean of the *prior* normal distribution. In the data assimilation framework, this is called the *background*. # %% KsInitial = 20. ZvInitial = 49. ZmInitial = 51. thetaPrior = [KsInitial, ZvInitial, ZmInitial] # %% # The following statement create the calibrated function from the model. The calibrated parameters :math:`K_s`, :math:`Z_v`, :math:`Z_m` are at indices 1, 2, 3 in the inputs arguments of the model. # %% calibratedIndices = [1,2,3] mycf = ot.ParametricFunction(g, calibratedIndices, thetaPrior) # %% # Calibration with linear least squares # ------------------------------------- # %% # The `LinearLeastSquaresCalibration` class performs the linear least squares calibration by linearizing the model in the neighbourhood of the reference point. # %% algo = ot.LinearLeastSquaresCalibration(mycf, Qobs, Hobs, thetaPrior, "SVD") # %% # The `run` method computes the solution of the problem. # %%
def residualFunction_py(p):
modelx = ot.ParametricFunction(model, [0, 1, 2], p)
return [modelx(x[i])[0] - y[i, 0] for i in range(m)]
