def test_KarhunenLoeveValidationMultidimensional(self):
# Create the KL result
numberOfVertices = 20
interval = ot.Interval(-1.0, 1.0)
mesh = ot.IntervalMesher([numberOfVertices - 1]).build(interval)
outputDimension = 2
univariateCovariance = ot.SquaredExponential()
covarianceCollection = [univariateCovariance] * outputDimension
multivariateCovariance = ot.TensorizedCovarianceModel(
covarianceCollection)
process = ot.GaussianProcess(multivariateCovariance, mesh)
sampleSize = 100
sampleSize = 10
processSample = process.getSample(sampleSize)
threshold = 1.0e-7
algo = ot.KarhunenLoeveSVDAlgorithm(processSample, threshold)
algo.run()
klresult = algo.getResult()
# Create the validation
validation = ot.KarhunenLoeveValidation(processSample, klresult)
# Check residuals
residualProcessSample = validation.computeResidual()
assert (type(residualProcessSample) is ot.ProcessSample)
# Check standard deviation
residualSigmaField = validation.computeResidualStandardDeviation()
zeroSample = ot.Sample(numberOfVertices, outputDimension)
ott.assert_almost_equal(residualSigmaField, zeroSample)
# Check graph
graph = validation.drawValidation()
if False:
from openturns.viewer import View
View(graph).save('validation2.png')
def test_NonZeroMean(self):
# Create the KL result
numberOfVertices = 10
interval = ot.Interval(-1.0, 1.0)
mesh = ot.IntervalMesher([numberOfVertices - 1]).build(interval)
covariance = ot.SquaredExponential()
zeroProcess = ot.GaussianProcess(covariance, mesh)
# Define a trend function
f = ot.SymbolicFunction(["t"], ["30 * t"])
fTrend = ot.TrendTransform(f, mesh)
# Add it to the process
process = ot.CompositeProcess(fTrend, zeroProcess)
# Sample
sampleSize = 100
processSample = process.getSample(sampleSize)
threshold = 0.0
algo = ot.KarhunenLoeveSVDAlgorithm(processSample, threshold)
algo.run()
klresult = algo.getResult()
# Create the KL reduction
meanField = processSample.computeMean()
klreduce = ot.KarhunenLoeveReduction(klresult)
# Generate a trajectory and reduce it
field = process.getRealization()
values = field.getValues()
reducedValues = klreduce(values)
ott.assert_almost_equal(values, reducedValues)
def run(self):
"""
Run high density region algorithm.
"""
# KL decomposition
threshold = 0.0
algo = ot.KarhunenLoeveSVDAlgorithm(self.processSample, threshold)
algo.setNbModes(self.numberOfComponents)
algo.run()
karhunenLoeveResult = algo.getResult()
self.reducedComponents = karhunenLoeveResult.project(
self.processSample)
numberOfComponents = self.reducedComponents.getDimension()
labels = ["C" + str(i) for i in range(numberOfComponents)]
self.reducedComponents.setDescription(labels)
def test_KarhunenLoeveValidation(self):
# Create the KL result
numberOfVertices = 20
interval = ot.Interval(-1.0, 1.0)
mesh = ot.IntervalMesher([numberOfVertices - 1]).build(interval)
covariance = ot.SquaredExponential()
process = ot.GaussianProcess(covariance, mesh)
sampleSize = 100
processSample = process.getSample(sampleSize)
threshold = 1.0e-7
algo = ot.KarhunenLoeveSVDAlgorithm(processSample, threshold)
algo.run()
klresult = algo.getResult()
# Create validation
validation = ot.KarhunenLoeveValidation(processSample, klresult)
# Check residuals
residualProcessSample = validation.computeResidual()
assert (type(residualProcessSample) is ot.ProcessSample)
# Check standard deviation
residualSigmaField = validation.computeResidualStandardDeviation()
exact = ot.Sample(numberOfVertices, 1)
#ott.assert_almost_equal(residualSigmaField, exact)
# Check mean
residualMean = validation.computeResidualMean()
exact = ot.Sample(numberOfVertices, 1)
#ott.assert_almost_equal(residualMean, exact)
# Check graph
graph0 = validation.drawValidation()
graph1 = residualProcessSample.drawMarginal(0)
graph2 = residualMean.drawMarginal(0)
graph3 = residualSigmaField.drawMarginal(0)
graph4 = validation.drawObservationWeight(0)
graph5 = validation.drawObservationQuality()
if 0:
from openturns.viewer import View
View(graph0).save('validation1.png')
View(graph1).save('validation1-residual.png')
View(graph2).save('validation1-residual-mean.png')
View(graph3).save('validation1-residual-stddev.png')
View(graph4).save('validation1-indiv-weight.png')
View(graph5).save('validation1-indiv-quality.png')
def test_ZeroMean(self):
# Create the KL result
numberOfVertices = 10
interval = ot.Interval(-1.0, 1.0)
mesh = ot.IntervalMesher([numberOfVertices - 1]).build(interval)
covariance = ot.SquaredExponential()
process = ot.GaussianProcess(covariance, mesh)
sampleSize = 10
processSample = process.getSample(sampleSize)
threshold = 0.0
algo = ot.KarhunenLoeveSVDAlgorithm(processSample, threshold)
algo.run()
klresult = algo.getResult()
# Create the KL reduction
meanField = processSample.computeMean()
klreduce = ot.KarhunenLoeveReduction(klresult)
# Generate a trajectory and reduce it
field = process.getRealization()
values = field.getValues()
reducedValues = klreduce(values)
ott.assert_almost_equal(values, reducedValues)
def test_trend(self):
N = 100
M = 1000
P = 10
mean = ot.SymbolicFunction("x", "sign(x)")
cov = ot.SquaredExponential([1.0], [0.1])
mesh = ot.IntervalMesher([N]).build(ot.Interval(-2.0, 2.0))
process = ot.GaussianProcess(ot.TrendTransform(mean, mesh), cov, mesh)
sample = process.getSample(M)
algo = ot.KarhunenLoeveSVDAlgorithm(sample, 1e-6)
algo.run()
result = algo.getResult()
trend = ot.TrendTransform(
ot.P1LagrangeEvaluation(sample.computeMean()), mesh)
sample2 = process.getSample(P)
sample2.setName('reduction of sign(x) w/o trend')
reduced1 = ot.KarhunenLoeveReduction(result)(sample2)
reduced2 = ot.KarhunenLoeveReduction(result, trend)(sample2)
g = sample2.drawMarginal(0)
g.setColors(["red"])
g1 = reduced1.drawMarginal(0)
g1.setColors(["blue"])
drs = g1.getDrawables()
for i, d in enumerate(drs):
d.setLineStyle("dashed")
drs[i] = d
g1.setDrawables(drs)
g.add(g1)
g2 = reduced2.drawMarginal(0)
g2.setColors(["green"])
drs = g2.getDrawables()
for i, d in enumerate(drs):
d.setLineStyle("dotted")
drs[i] = d
g2.setDrawables(drs)
g.add(g2)
if 0:
from openturns.viewer import View
View(g).save('reduction.png')
ot.Log.Show(ot.Log.NONE) # %% # Create a Gaussian process numberOfVertices = 20 interval = ot.Interval(-1.0, 1.0) mesh = ot.IntervalMesher([numberOfVertices - 1]).build(interval) covariance = ot.SquaredExponential() process = ot.GaussianProcess(covariance, mesh) # %% # decompose it using KL-SVD sampleSize = 100 processSample = process.getSample(sampleSize) threshold = 1.0e-7 algo = ot.KarhunenLoeveSVDAlgorithm(processSample, threshold) algo.run() klresult = algo.getResult() # %% # Instanciate the validation service validation = ot.KarhunenLoeveValidation(processSample, klresult) # %% # Plot the residual field residualProcessSample = validation.computeResidual() view = viewer.View(residualProcessSample.drawMarginal(0)) # %% # Plot the residual mean field residualMean = validation.computeResidualMean()
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])
sample = ot.GaussianProcess(model, mesh).getSample(100)
algo = ot.KarhunenLoeveSVDAlgorithm(sample, 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$")
fig = plt.figure(figsize=(6, 4))
plt.suptitle("SVD 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)
graph_ev.setLogScale(2)
bb = graph_ev.getBoundingBox()
lower = bb.getLowerBound()
lower[1] = 1.0e-7
bb = ot.Interval(lower, bb.getUpperBound())
graph_ev.setBoundingBox(bb)
return graph_modes, graph_ev
# %%
# We compute the Karhunen-Loeve decomposition of the model outputs.
# The underlying assumption is that these outputs are realizations of a
# stochastic process.
threshold = 0.0001
algoKL = ot.KarhunenLoeveSVDAlgorithm(outputFMUSample, threshold)
algoKL.run()
resultKL = algoKL.getResult()
# %%
# Let be curious and plot the Karhunen-Loeve modes:
phi_Y = resultKL.getScaledModesAsProcessSample()
lambda_Y = resultKL.getEigenvalues()
graph_modes_Y, graph_ev_Y = drawKL(phi_Y, lambda_Y, mesh, "Y")
view = viewer.View(graph_modes_Y)
view.ShowAll()
# %%
# Now that Karhunen-Loeve algorithm is trained, we can project them
# in the smaller-dimension space:
projectionSample = resultKL.project(outputFMUSample)
# %%
# Dynamical model: convolution wrt kernel p
print("Create the convolution function")
p = ot.SymbolicFunction("x", "exp(-(x/" + str(h) + ")^2)")
myConvolution = ot.FieldFunction(ConvolutionP1(p, mesh))
# %%
# Output database generation
print("Sample the output process")
sample_Y = myConvolution(sample_X)
# %%
# Karhunen-Loeve decomposition of the output process
print("Compute the decomposition of the output process")
algo_Y = ot.KarhunenLoeveSVDAlgorithm(sample_Y, threshold)
algo_Y.run()
result_Y = algo_Y.getResult()
phi_Y = result_Y.getScaledModesAsProcessSample()
lambda_Y = result_Y.getEigenvalues()
graph_modes_Y, graph_ev_Y = drawKL(phi_Y, lambda_Y, mesh, "Y")
view = viewer.View(graph_modes_Y)
# %%
# Compare eigenvalues of X and Y
graph_ev_X.add(graph_ev_Y)
graph_ev_X.setTitle("Input/output eigenvalues comparison")
graph_ev_X.setYTitle(r"$\lambda_X, \lambda_Y$")
graph_ev_X.setColors(["blue", "blue", "red", "red"])
graph_ev_X.setLegends([r"$\lambda_X$", "", r"$\lambda_Y$", ""])
graph_ev_X.setLegendPosition("topright")
#! /usr/bin/env python
from __future__ import print_function
import openturns as ot
ot.TESTPREAMBLE()
mesh = ot.IntervalMesher([9]).build(ot.Interval(-1.0, 1.0))
# 1D mesh, 1D covariance, uniform weight, automatic centering, more samples
# than vertices
cov1D = ot.AbsoluteExponential([1.0])
sample = ot.GaussianProcess(cov1D, mesh).getSample(16)
algo = ot.KarhunenLoeveSVDAlgorithm(sample, 0.0)
algo.run()
result = algo.getResult()
lambd = result.getEigenvalues()
KLModes = result.getModesAsProcessSample()
print("KL modes=", KLModes)
print("KL eigenvalues=", lambd)
coefficients = result.project(sample)
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]))
# 1D mesh, 1D covariance, uniform weight, automatic centering
sample = ot.GaussianProcess(cov1D, mesh).getSample(6)
algo = ot.KarhunenLoeveSVDAlgorithm(sample, 0.0)
algo.run()
result = algo.getResult()
lambd = result.getEigenvalues()
import openturns as ot
from openturns.viewer import View
N = 100
M = 1000
P = 10
mean = ot.SymbolicFunction("x", "sign(x)")
cov = ot.SquaredExponential([1.0], [0.1])
mesh = ot.IntervalMesher([N]).build(ot.Interval(-2.0, 2.0))
process = ot.GaussianProcess(ot.TrendTransform(mean, mesh), cov, mesh)
sample = process.getSample(M)
algo = ot.KarhunenLoeveSVDAlgorithm(sample, 1e-6)
algo.run()
result = algo.getResult()
trend = ot.TrendTransform(ot.P1LagrangeEvaluation(sample.computeMean()), mesh)
sample2 = process.getSample(P)
sample2.setName('reduction of sign(x) w/o trend')
reduced1 = ot.KarhunenLoeveReduction(result)(sample2)
reduced2 = ot.KarhunenLoeveReduction(result, trend)(sample2)
g = sample2.drawMarginal(0)
g.setColors(["red"])
g1 = reduced1.drawMarginal(0)
g1.setColors(["blue"])
drs = g1.getDrawables()
for i, d in enumerate(drs):
d.setLineStyle("dashed")
drs[i] = d
g1.setDrawables(drs)
g.add(g1)
g2 = reduced2.drawMarginal(0)
g2.setColors(["green"])
graphInf.setColors(["red"])
graphMoy.add(graphSup)
graphMoy.add(graphInf)
graphMoy.setTitle('Trajectoire')
graphMoy.setXTitle(parameterIndexName)
graphMoy.setYTitle(fieldName)
graphMoy.setLegends(["Moyenne","Quantile %.2f%%" % (100-alphaInf*100),"Quantile %.2f%%" % (alphaInf*100)])
graphMoy.setLegendPosition("topleft")
View(graphMoy)
# Compute the KL decomposition of the output
size = 100
inputSample = distX.getSample(size)
outputSample = maFonctionChamp(inputSample)
threshold = 1.e-5 # Seuil pour la troncature des valeurs propres
algo = ot.KarhunenLoeveSVDAlgorithm(outputSample, threshold)
algo.run()
KLResult = algo.getResult()
scaledModes = KLResult.getScaledModesAsProcessSample()
nbModes = scaledModes.getSize()
# Plot the KL decomposition
graph = scaledModes.drawMarginal(0)
graph.setTitle('%s, seuil=%.2e, %d modes de KL' % (modeleName,threshold,nbModes))
graph.setXTitle(parameterIndexName)
graph.setYTitle(fieldName)
modesStr = ["Mode "+str(i) for i in range(nbModes)]
graph.setLegends(modesStr)
graph.setLegendPosition("topleft")
View(graph)
# %%
# Compute a training sample.
# %%
size = 2000
ot.RandomGenerator.SetSeed(0)
inputSample = distribution.getSample(size)
outputSample = alti(inputSample)
# %%
# Compute the KL decomposition of the output
# ------------------------------------------
# %%
algo = ot.KarhunenLoeveSVDAlgorithm(outputSample, 1.0e-6)
algo.run()
KLResult = algo.getResult()
scaledModes = KLResult.getScaledModesAsProcessSample()
# %%
graph = scaledModes.drawMarginal(0)
graph.setTitle('KL modes')
graph.setXTitle(r'$t$')
graph.setYTitle(r'$z$')
view = viewer.View(graph)
# %%
# We create the `postProcessingKL` function which takes coefficients of the the K.-L. modes as inputs and returns the trajectories.
# %%
