def test_parameters_iso():
scale = []
amplitude = 1.0
extraParameter = []
# model 1
atom_ex = ot.IsotropicCovarianceModel(ot.MaternModel(), 2)
atom_ex.setScale([5])
atom_ex.setAmplitude([1.5])
scale.append(5)
amplitude *= 1.5
extraParameter.append(atom_ex.getKernel().getFullParameter()[-1])
# model2
m = ot.MaternModel()
m.setNu(2.5)
m.setScale([3])
m.setAmplitude([3])
scale.append(3)
amplitude *= 3
extraParameter.append(m.getNu())
# model 3
atom = ot.IsotropicCovarianceModel(ot.AbsoluteExponential(), 2)
atom.setScale([2])
atom.setAmplitude([2.5])
scale.append(2)
amplitude *= 2.5
model = ot.ProductCovarianceModel([atom_ex, m, atom])
ott.assert_almost_equal(model.getScale(), scale, 1e-16, 1e-16)
ott.assert_almost_equal(model.getAmplitude(), [amplitude], 1e-16, 1e-16)
ott.assert_almost_equal(model.getFullParameter(),
scale + [amplitude] + extraParameter, 1e-16, 1e-16)
# active parameter should be scale + amplitude
ott.assert_almost_equal(model.getActiveParameter(),
[0, 1, 2, 3], 1e-16, 1e-16)
# setting new parameters
extraParameter = [2.5, 0.5]
model.setFullParameter([6, 7, 8, 2] + extraParameter)
ott.assert_almost_equal(model.getCollection()[
0].getScale()[0], 6, 1e-16, 1e-16)
ott.assert_almost_equal(model.getCollection()[
1].getScale()[0], 7, 1e-16, 1e-16)
ott.assert_almost_equal(model.getCollection()[
2].getScale()[0], 8, 1e-16, 1e-16)
ott.assert_almost_equal(model.getAmplitude()[0], 2, 1e-16, 1e-16)
ott.assert_almost_equal(model.getCollection(
)[0].getFullParameter()[-1], extraParameter[0], 1e-16, 1e-16)
ott.assert_almost_equal(model.getCollection(
)[1].getFullParameter()[-1], extraParameter[1], 1e-16, 1e-16)
# checking active par setting
model.setActiveParameter([0, 1, 2, 3, 5])
ott.assert_almost_equal(model.getParameter(), [
6, 7, 8, 2, extraParameter[-1]], 1e-16, 1e-16)
import openturns as ot
from matplotlib import pyplot as plt
from openturns.viewer import View
from math import sqrt
mesh = ot.IntervalMesher([256]).build(ot.Interval(-1.0, 1.0))
threshold = 0.001
factory = ot.KarhunenLoeveP1Factory(mesh, threshold)
model = ot.AbsoluteExponential(1, 1.0)
ev = ot.NumericalPoint()
modes = factory.buildAsProcessSample(model, ev)
for i in range(modes.getSize()):
modes[i] = ot.Field(mesh, modes[i].getValues() * [sqrt(ev[i])])
g = modes.drawMarginal(0)
g.setXTitle("$t$")
g.setYTitle("$\sqrt{\lambda_n}\phi_n$")
fig = plt.figure(figsize=(6, 4))
plt.suptitle("P1 approx. of KL expansion for $C(s,t)=e^{-|s-t|}$")
axis = fig.add_subplot(111)
axis.set_xlim(auto=True)
View(g, figure=fig, axes=[axis], add_legend=False)
#! /usr/bin/env python
from __future__ import print_function
import openturns as ot
try:
mesh = ot.IntervalMesher([9]).build(ot.Interval(-1.0, 1.0))
cov1D = ot.AbsoluteExponential([1.0])
algo = ot.KarhunenLoeveP1Algorithm(mesh, cov1D, 0.0)
algo.run()
result = algo.getResult()
lambd = result.getEigenValues()
KLModes = result.getModesAsProcessSample()
print("KL modes=", KLModes)
print("KL eigenvalues=", lambd)
process = ot.TemporalNormalProcess(cov1D, KLModes.getMesh())
coefficients = result.project(process.getSample(10))
print("KL coefficients=", coefficients)
KLFunctions = result.getModes()
print("KL functions=", KLFunctions)
print("KL lift=", result.lift(coefficients[0]))
print("KL lift as field=", result.liftAsField(coefficients[0]))
R = ot.CorrelationMatrix(2)
R[0, 1] = 0.5
scale = [1.0]
amplitude = [1.0, 2.0]
cov2D = ot.ExponentialModel(scale, amplitude, R)
algo = ot.KarhunenLoeveP1Algorithm(mesh, cov2D, 0.0)
algo.run()
result = algo.getResult()
lambd = result.getEigenValues()
myDefautModel = ot.SquaredExponential([2.0], [3.0])
print('myDefautModel = ', myDefautModel)
test_model(myDefautModel)
myModel = ot.SquaredExponential([2.0] * inputDimension, [3.0])
test_model(myModel)
myDefautModel = ot.GeneralizedExponential([2.0], [3.0], 1.5)
print('myDefautModel = ', myDefautModel)
test_model(myDefautModel)
myModel = ot.GeneralizedExponential([2.0] * inputDimension, [3.0], 1.5)
test_model(myModel)
myDefautModel = ot.AbsoluteExponential([2.0], [3.0])
print('myDefautModel = ', myDefautModel)
test_model(myDefautModel)
myModel = ot.AbsoluteExponential([2.0] * inputDimension, [3.0])
test_model(myModel)
myDefautModel = ot.MaternModel([2.0], [3.0], 1.5)
print('myDefautModel = ', myDefautModel)
test_model(myDefautModel)
myModel = ot.MaternModel([2.0] * inputDimension, [3.0], 1.5)
test_model(myModel)
myDefautModel = ot.ExponentiallyDampedCosineModel([2.0], [3.0], 1.5)
print('myDefautModel = ', myDefautModel)
from __future__ import print_function import openturns as ot import openturns.viewer as viewer from matplotlib import pylab as plt ot.Log.Show(ot.Log.NONE) # %% # define a covariance model defaultDimension = 1 # Amplitude values amplitude = [1.0] * defaultDimension # Scale values scale = [1.0] * defaultDimension # Covariance model myModel = ot.AbsoluteExponential(scale, amplitude) # %% # define a mesh tmin = 0.0 step = 0.1 n = 11 myTimeGrid = ot.RegularGrid(tmin, step, n) # %% # create the process process = ot.GaussianProcess(myModel, myTimeGrid) print(process) # %% # draw a sample
myDefautModel = ot.SquaredExponential()
print("myDefautModel = ", myDefautModel)
myModel = ot.SquaredExponential(spatialDimension)
test_model(myModel)
myDefautModel = ot.GeneralizedExponential()
print("myDefautModel = ", myDefautModel)
myModel = ot.GeneralizedExponential(spatialDimension, 10.0, 1.5)
test_model(myModel)
myDefautModel = ot.AbsoluteExponential()
print("myDefautModel = ", myDefautModel)
myModel = ot.AbsoluteExponential(spatialDimension)
test_model(myModel)
myDefautModel = ot.MaternModel()
print("myDefautModel = ", myDefautModel)
myModel = ot.MaternModel(spatialDimension, 8.0, 2.0)
test_model(myModel)
myDefautModel = ot.ProductCovarianceModel()
print("myDefautModel = ", myDefautModel)
# Set Numerical precision to 4
ot.PlatformInfo.SetNumericalPrecision(4)
sampleSize = 40
spatialDimension = 1
# Create the function to estimate
model = ot.SymbolicFunction(["x0"], ["x0"])
X = ot.Sample(sampleSize, spatialDimension)
for i in range(sampleSize):
X[i, 0] = 3.0 + (8.0 * i) / sampleSize
Y = model(X)
# Add a small noise to data
Y += ot.GaussianProcess(ot.AbsoluteExponential(
[0.1], [0.2]), ot.Mesh(X)).getRealization().getValues()
basis = ot.LinearBasisFactory(spatialDimension).build()
# Case of a misspecified covariance model
covarianceModel = ot.DiracCovarianceModel(spatialDimension)
print("===================================================\n")
algo = ot.GeneralLinearModelAlgorithm(X, Y, covarianceModel, basis)
algo.run()
result = algo.getResult()
print("\ncovariance (dirac, optimized)=", result.getCovarianceModel())
print("trend (dirac, optimized)=", result.getTrendCoefficients())
print("===================================================\n")
# Now without estimating covariance parameters
basis = ot.LinearBasisFactory(spatialDimension).build()
covarianceModel = ot.DiracCovarianceModel(spatialDimension)
import openturns as ot
from matplotlib import pyplot as plt
from openturns.viewer import View
covarianceModel = ot.AbsoluteExponential()
if covarianceModel.getSpatialDimension() == 1:
scale = covarianceModel.getScale()[0]
if covarianceModel.isStationary():
def f(x):
return [covarianceModel(x)[0, 0]]
func = ot.PythonFunction(1, 1, f)
func.setDescription(['$tau$', '$cov$'])
cov_graph = func.draw(-3.0 * scale, 3.0 * scale, 129)
fig = plt.figure(figsize=(10, 4))
plt.suptitle(str(covarianceModel))
cov_axis = fig.add_subplot(111)
View(cov_graph, figure=fig, axes=[cov_axis], add_legend=False)
else:
def f(x):
return [covarianceModel([x[0]], [x[1]])[0, 0]]
func = ot.PythonFunction(2, 1, f)
func.setDescription(['$s$', '$t$', '$cov$'])
cov_graph = func.draw([-3.0 * scale] * 2, [3.0 * scale] * 2, [129] * 2)
fig = plt.figure(figsize=(10, 4))
plt.suptitle(str(covarianceModel))
cov_axis = fig.add_subplot(111)
View(cov_graph, figure=fig, axes=[cov_axis], add_legend=False)
#! /usr/bin/env python
from __future__ import print_function
import openturns as ot
try:
mesh = ot.IntervalMesher(ot.Indices(1, 9)).build(ot.Interval(-1.0, 1.0))
factory = ot.KarhunenLoeveP1Factory(mesh, 0.0)
eigenValues = ot.NumericalPoint()
KLModes = factory.buildAsProcessSample(ot.AbsoluteExponential([1.0]),
eigenValues)
print("KL modes=", KLModes)
print("KL eigenvalues=", eigenValues)
cov1D = ot.AbsoluteExponential([1.0])
KLFunctions = factory.build(cov1D, eigenValues)
print("KL functions=", KLFunctions)
print("KL eigenvalues=", eigenValues)
R = ot.CorrelationMatrix(2, [1.0, 0.5, 0.5, 1.0])
scale = [1.0]
amplitude = [1.0, 2.0]
cov2D = ot.ExponentialModel(scale, amplitude, R)
KLFunctions = factory.build(cov2D, eigenValues)
print("KL functions=", KLFunctions)
print("KL eigenvalues=", eigenValues)
except:
import sys
print("t_KarhunenLoeveP1Factory_std.py",
sys.exc_info()[0],
sys.exc_info()[1])
# %% from __future__ import print_function import openturns as ot import openturns.viewer as viewer from matplotlib import pylab as plt ot.Log.Show(ot.Log.NONE) # %% # Define the covariance model : # %% dimension = 1 amplitude = [1.0] * dimension scale = [10] * dimension covarianceModel = ot.AbsoluteExponential(scale, amplitude) # %% # Define the time grid on which we want to sample the gaussian process : # %% # define a mesh tmin = 0.0 step = 0.01 n = 10001 timeGrid = ot.RegularGrid(tmin, step, n) # %% # Finally define the gaussian process : # %%
import openturns as ot from matplotlib import pyplot as plt from openturns.viewer import View from math import sqrt mesh = ot.IntervalMesher([128]).build(ot.Interval(-1.0, 1.0)) threshold = 0.001 covariance = ot.AbsoluteExponential([1.0]) algo = ot.KarhunenLoeveP1Algorithm(mesh, covariance, threshold) algo.run() process = ot.GaussianProcess(covariance, mesh) sample = process.getSample(100) validation = ot.KarhunenLoeveValidation(sample, algo.getResult()) g = validation.drawValidation() fig = plt.figure(figsize=(6, 4)) axis = fig.add_subplot(111) axis.set_xlim(auto=True) View(g, figure=fig, axes=[axis], add_legend=False)
# Set Numerical precision to 4
ot.PlatformInfo.SetNumericalPrecision(4)
sampleSize = 40
spatialDimension = 1
# Create the function to estimate
model = ot.SymbolicFunction(["x0"], ["x0"])
X = ot.NumericalSample(sampleSize, spatialDimension)
for i in range(sampleSize):
X[i, 0] = 3.0 + (8.0 * i) / sampleSize
Y = model(X)
# Add a small noise to data
Y += ot.TemporalNormalProcess(ot.AbsoluteExponential([0.1], [0.2]),
ot.Mesh(X)).getRealization().getValues()
basis = ot.LinearBasisFactory(spatialDimension).build()
# Case of a misspecified covariance model
covarianceModel = ot.DiracCovarianceModel(spatialDimension)
print("===================================================\n")
algo = ot.GeneralizedLinearModelAlgorithm(X, Y, covarianceModel, basis)
algo.run()
result = algo.getResult()
print("\ncovariance (dirac, optimized)=", result.getCovarianceModel())
print("trend (dirac, optimized)=", result.getTrendCoefficients())
print("===================================================\n")
# Now without estimating covariance parameters
basis = ot.LinearBasisFactory(spatialDimension).build()
# 2) GeneralizedExponential myModel = ot.GeneralizedExponential([2.0], [3.0], 1.5) ott.assert_almost_equal(myModel.getScale(), [2], 0, 0) ott.assert_almost_equal(myModel.getAmplitude(), [3], 0, 0) ott.assert_almost_equal(myModel.getP(), 1.5, 0, 0) test_model(myModel) myModel = ot.GeneralizedExponential([2.0] * inputDimension, [3.0], 1.5) ott.assert_almost_equal(myModel.getScale(), [2, 2], 0, 0) ott.assert_almost_equal(myModel.getAmplitude(), [3], 0, 0) ott.assert_almost_equal(myModel.getP(), 1.5, 0, 0) test_model(myModel) # 3) AbsoluteExponential myModel = ot.AbsoluteExponential([2.0], [3.0]) ott.assert_almost_equal(myModel.getScale(), [2], 0, 0) ott.assert_almost_equal(myModel.getAmplitude(), [3], 0, 0) test_model(myModel) myModel = ot.AbsoluteExponential([2.0] * inputDimension, [3.0]) ott.assert_almost_equal(myModel.getScale(), [2, 2], 0, 0) ott.assert_almost_equal(myModel.getAmplitude(), [3], 0, 0) test_model(myModel) # 4) MaternModel myModel = ot.MaternModel([2.0], [3.0], 1.5) ott.assert_almost_equal(myModel.getScale(), [2], 0, 0) ott.assert_almost_equal(myModel.getAmplitude(), [3], 0, 0) ott.assert_almost_equal(myModel.getNu(), 1.5, 0, 0) test_model(myModel)
#! /usr/bin/env python
from __future__ import print_function
import openturns as ot
try:
mesh = ot.IntervalMesher(ot.Indices(1, 9)).build(ot.Interval(-1.0, 1.0))
factory = ot.KarhunenLoeveP1Factory(mesh, 0.0);
eigenValues = ot.NumericalPoint()
KLModes = factory.buildAsProcessSample(ot.AbsoluteExponential(1, 1.0), eigenValues)
print("KL modes=", KLModes)
print("KL eigenvalues=", eigenValues)
KLFunctions = factory.build(ot.AbsoluteExponential(1, 1.0), eigenValues)
print("KL functions=", KLFunctions)
print("KL eigenvalues=", eigenValues)
except:
import sys
print("t_KarhunenLoeveP1Factory_std.py", sys.exc_info()[0], sys.exc_info()[1])
import openturns as ot
from matplotlib import pyplot as plt
from openturns.viewer import View
from math import sqrt
mesh = ot.IntervalMesher([128]).build(ot.Interval(-1.0, 1.0))
threshold = 0.001
model = ot.AbsoluteExponential([1.0])
algo = ot.KarhunenLoeveP1Algorithm(mesh, model, threshold)
algo.run()
ev = algo.getResult().getEigenvalues()
modes = algo.getResult().getScaledModesAsProcessSample()
g = modes.drawMarginal(0)
g.setXTitle("$t$")
g.setYTitle("$\sqrt{\lambda_n}\phi_n$")
g.setTitle("P1 approx. of KL expansion for $C(s,t)=e^{-|s-t|}$")
fig = plt.figure(figsize=(6, 4))
axis = fig.add_subplot(111)
axis.set_xlim(auto=True)
View(g, figure=fig, axes=[axis], add_legend=False)
ot.Log.Show(ot.Log.NONE)
# %%
# Input model
print("Create the input process")
# Domain bound
a = 1
# Reference correlation length
b = 0.5
# Number of vertices in the mesh
N = 100
# Bandwidth of the smoothers
h = 0.05
mesh = ot.IntervalMesher([N - 1]).build(ot.Interval(-a, a))
covariance_X = ot.AbsoluteExponential([b])
process_X = ot.GaussianProcess(covariance_X, mesh)
# %%
# for some pretty graphs
def drawKL(scaledKL, KLev, mesh, title="Scaled KL modes"):
graph_modes = scaledKL.drawMarginal()
graph_modes.setTitle(title + " scaled KL modes")
graph_modes.setXTitle('$x$')
graph_modes.setYTitle(r'$\sqrt{\lambda_i}\phi_i$')
data_ev = [[i, KLev[i]] for i in range(scaledKL.getSize())]
graph_ev = ot.Graph()
graph_ev.add(ot.Curve(data_ev))
graph_ev.add(ot.Cloud(data_ev))
graph_ev.setTitle(title + " KL eigenvalues")
# Set Numerical precision to 4
ot.PlatformInfo.SetNumericalPrecision(4)
sampleSize = 40
inputDimension = 1
# Create the function to estimate
model = ot.SymbolicFunction(["x0"], ["x0"])
X = ot.Sample(sampleSize, inputDimension)
for i in range(sampleSize):
X[i, 0] = 3.0 + (8.0 * i) / sampleSize
Y = model(X)
# Add a small noise to data
Y += ot.GaussianProcess(ot.AbsoluteExponential([0.1], [0.2]),
ot.Mesh(X)).getRealization().getValues()
basis = ot.LinearBasisFactory(inputDimension).build()
# Case of a misspecified covariance model
covarianceModel = ot.DiracCovarianceModel(inputDimension)
print("===================================================\n")
algo = ot.GeneralLinearModelAlgorithm(X, Y, covarianceModel, basis)
algo.run()
result = algo.getResult()
print("\ncovariance (dirac, optimized)=", result.getCovarianceModel())
print("trend (dirac, optimized)=", result.getTrendCoefficients())
print("===================================================\n")
# Now without estimating covariance parameters
import openturns as ot
from matplotlib import pyplot as plt
from openturns.viewer import View
if ot.AbsoluteExponential().__class__.__name__ == 'ExponentialModel':
covarianceModel = ot.ExponentialModel([0.5], [5.0])
elif ot.AbsoluteExponential().__class__.__name__ == 'GeneralizedExponential':
covarianceModel = ot.GeneralizedExponential([2.0], [3.0], 1.5)
elif ot.AbsoluteExponential().__class__.__name__ == 'ProductCovarianceModel':
amplitude = [1.0]
scale1 = [4.0]
scale2 = [4.0]
cov1 = ot.ExponentialModel(scale1, amplitude)
cov2 = ot.ExponentialModel(scale2, amplitude)
covarianceModel = ot.ProductCovarianceModel([cov1, cov2])
elif ot.AbsoluteExponential().__class__.__name__ == 'RankMCovarianceModel':
variance = [1.0, 2.0]
basis = ot.LinearBasisFactory().build()
covarianceModel = ot.RankMCovarianceModel(variance, basis)
else:
covarianceModel = ot.AbsoluteExponential()
title = str(covarianceModel)[:100]
if covarianceModel.getInputDimension() == 1:
scale = covarianceModel.getScale()[0]
if covarianceModel.isStationary():
def f(x):
return [covarianceModel(x)[0, 0]]
func = ot.PythonFunction(1, 1, f)
func.setDescription(['$tau$', '$cov$'])
cov_graph = func.draw(-3.0 * scale, 3.0 * scale, 129)