ConditionedGaussianProcess¶

class ConditionedGaussianProcess(*args)¶

Conditioned Gaussian process.

ConditionedGaussianProcess(krigingResult, mesh)

Parameters

krigingResultKrigingResult: Structure that contains all elements of kriging computations.
meshMesh: Mesh $\cM$ over which the domain $\cD$ is discretized.

Notes

ConditionedGaussianProcess helps to create Gaussian random fields, $X: \Omega \times\cD \mapsto \Rset^d$ where $\cD \in \Rset^n$ , with covariance function $\cC: \cD \times \cD \mapsto \cM_{d \times d}(\Rset)$ ( $\cC^{stat}: \cD \mapsto \cM_{d \times d}(\Rset)$ in the stationary case), conditionaly to some observations.

Let $X(\omega,x=x_1)=y_1,\cdots,X(\omega,x=x_n)=y_n$ be the observations of the Gaussian process. We assume the same Gaussian prior as in the KrigingAlgorithm:

$Y(\vect{x}) = \Tr{\vect{f}(\vect{x})} \vect{\beta} + Z(\vect{x})$

with $\Tr{\vect{f}(\vect{x})} \vect{\beta}$ a general linear model, $Z(\vect{x})$ a zero-mean Gaussian process with a stationary autocorrelation function $\cC^{stat}$ :

$\mathbb{E}[Z(\vect{x}), Z(\vect{\tilde{x}})] = \sigma^2 \cC^{stat}_{\theta}(\vect{x} - \vect{\tilde{x}})$

The ConditionedGaussianProcess generates realizations of the conditioned process. It focuses first on the KrigingAlgorithm to build such prior. Results are stored in a KrigingResult structure, which is given as input argument of the class. This last one, combined with the mesh argument, define both the prior $Y(\cM)$ and the covariance evaluation on the mesh vertices $\cC^{stat}_{\theta}(\cM)$ conditionnaly to the previous observations. It follows that the realizations are randomly generated from the Gaussian distribution $\cN ( Y(\cM), \cC^{stat}_{\theta}(\cM) )$ .

In practice, we do not store the Gaussian distribution as we need only the random realization method. For that purpose, we use the Cholesky method : we compute the Cholesky factor $\cL_{\theta}(\cM)$ of the covariance matrix $\cC^{stat}_{\theta}(\cM)$ such as $\cC^{stat}_{\theta}(\cM) = \cL_{\theta}(\cM) \Tr{\cL_{\theta}(\cM)}$ . It follows that the random realizations are obtained as following : $realization = Y(\cM) + \cL_{\theta}(\cM) W$ with $W$ a centered & reduced random Gaussian realization.

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> # Kriging use case
>>> # Learning data
>>> levels = [8.0, 5.0]
>>> box = ot.Box(levels)
>>> inputSample = box.generate()
>>> # Scale each direction
>>> inputSample *= 10
>>> # Define model
>>> model = ot.SymbolicFunction(['x', 'y'], ['cos(0.5*x) + sin(y)'])
>>> outputSample = model(inputSample)
>>> # Definition of exponential model
>>> inputDimension = 2
>>> covarianceModel = ot.SquaredExponential([1.988, 0.924], [3.153])
>>> # Basis definition
>>> basis = ot.ConstantBasisFactory(inputDimension).build()
>>> # Kriring algorithm
>>> algo = ot.KrigingAlgorithm(inputSample, outputSample, covarianceModel, basis)
>>> 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]]
>>> simplices = [[0, 1, 4], [1, 2, 4], [2, 3, 4], [3, 0, 4]]
>>> mesh2D = ot.Mesh(vertices, simplices)
>>> process = ot.ConditionedGaussianProcess(result, mesh2D)

Methods

`getClassName`(self)	Accessor to the object’s name.
`getContinuousRealization`(self)	Get a continuous realization.
`getCovarianceModel`(self)	Get the covariance model.
`getDescription`(self)	Get the description of the process.
`getFuture`(self, \*args)	Prediction of the $N$ future iterations of the process.
`getId`(self)	Accessor to the object’s id.
`getInputDimension`(self)	Get the dimension of the domain $\cD$ .
`getMarginal`(self, indices)	Get the $k^{th}$ marginal of the random process.
`getMesh`(self)	Get the mesh.
`getName`(self)	Accessor to the object’s name.
`getOutputDimension`(self)	Get the dimension of the domain $\cD$ .
`getRealization`(self)	Return a realization of the process.
`getSample`(self, size)	Get $n$ realizations of the process.
`getShadowedId`(self)	Accessor to the object’s shadowed id.
`getTimeGrid`(self)	Get the time grid of observation of the process.
`getTrend`(self)	Get the trend function.
`getVisibility`(self)	Accessor to the object’s visibility state.
`hasName`(self)	Test if the object is named.
`hasVisibleName`(self)	Test if the object has a distinguishable name.
`isComposite`(self)	Test whether the process is composite or not.
`isNormal`(self)	Test whether the process is normal or not.
`isStationary`(self)	Test whether the process is stationary or not.
`isTrendStationary`(self)	Tell if the process is trend stationary or not.
`setDescription`(self, description)	Set the description of the process.
`setMesh`(self, \*args)	Set the mesh.
`setName`(self, name)	Accessor to the object’s name.
`setSamplingMethod`(self, \*args)	Set the used method for getRealization.
`setShadowedId`(self, id)	Accessor to the object’s shadowed id.
`setTimeGrid`(self, \*args)	Set the time grid of observation of the process.
`setVisibility`(self, visible)	Accessor to the object’s visibility state.

__init__(self, \*args)¶: Initialize self. See help(type(self)) for accurate signature.

getClassName(self)¶

Accessor to the object’s name.

Returns

class_namestr: The object class name (object.__class__.__name__).

getContinuousRealization(self)¶

Get a continuous realization.

Returns

realizationFunction

According to the process, the continuous realizations are built:

either using a dedicated functional model if it exists: e.g. a functional basis process.
or using an interpolation from a discrete realization of the process on $\cM$ : in dimension $d=1$ , a linear interpolation and in dimension $d \geq 2$ , a piecewise constant function (the value at a given position is equal to the value at the nearest vertex of the mesh of the process).

getCovarianceModel(self)¶

Get the covariance model.

Returns

covarianceModelCovarianceModel: Temporal covariance model $C$ .

getDescription(self)¶

Get the description of the process.

Returns

descriptionDescription: Description of the process.

getFuture(self, \*args)¶

Prediction of the $N$ future iterations of the process.

Parameters

stepNumberint, $N \geq 0$: Number of future steps.
sizeint, $size \geq 0$ , optional: Number of futures needed. Default is 1.

Returns

predictionProcessSample or TimeSeries: $N$ future iterations of the process. If $size = 1$ , prediction is a TimeSeries. Otherwise, it is a ProcessSample.

getId(self)¶

Accessor to the object’s id.

Returns

idint: Internal unique identifier.

getInputDimension(self)¶

Get the dimension of the domain $\cD$ .

Returns

nint: Dimension of the domain $\cD$ : $n$ .

getMarginal(self, indices)¶

Get the $k^{th}$ marginal of the random process.

Parameters

kint or list of ints $0 \leq k < d$: Index of the marginal(s) needed.

Returns

marginalsProcess: Process defined with marginal(s) of the random process.

getMesh(self)¶

Get the mesh.

Returns

meshMesh: Mesh over which the domain $\cD$ is discretized.

getName(self)¶

Accessor to the object’s name.

Returns

namestr: The name of the object.

getOutputDimension(self)¶

Get the dimension of the domain $\cD$ .

Returns

dint: Dimension of the domain $\cD$ .

getRealization(self)¶

Return a realization of the process.

Returns

realizationField: A realization of the process.

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> # Kriging use case
>>> # Learning data
>>> levels = [8.0, 5.0]
>>> box = ot.Box(levels)
>>> inputSample = box.generate()
>>> # Scale each direction
>>> inputSample *= 10
>>> # Define model
>>> model = ot.SymbolicFunction(['x', 'y'], ['cos(0.5*x) + sin(y)'])
>>> outputSample = model(inputSample)
>>> # Definition of exponential model
>>> inputDimension = 2
>>> covarianceModel = ot.SquaredExponential(inputDimension *[0.95])
>>> # Basis definition
>>> basis = ot.ConstantBasisFactory(inputDimension).build()
>>> # Kriring algorithm
>>> algo = ot.KrigingAlgorithm(inputSample, outputSample, covarianceModel, basis)
>>> 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]]
>>> simplices = [[0, 1, 4], [1, 2, 4], [2, 3, 4], [3, 0, 4]]
>>> mesh2D = ot.Mesh(vertices, simplices)
>>> process = ot.ConditionedGaussianProcess(result, mesh2D)
>>> # Get a realization of the process
>>> realization = process.getRealization()

getSample(self, size)¶

Get $n$ realizations of the process.

Parameters

nint, $n \geq 0$: Number of realizations of the process needed.

Returns

processSampleProcessSample: $n$ realizations of the random process. A process sample is a collection of fields which share the same mesh $\cM \in \Rset^n$ .

getShadowedId(self)¶

Accessor to the object’s shadowed id.

Returns

idint: Internal unique identifier.

getTimeGrid(self)¶

Get the time grid of observation of the process.

Returns

timeGridRegularGrid: Time grid of a process when the mesh associated to the process can be interpreted as a RegularGrid. We check if the vertices of the mesh are scalar and are regularly spaced in $\Rset$ but we don’t check if the connectivity of the mesh is conform to the one of a regular grid (without any hole and composed of ordered instants).

getTrend(self)¶

Get the trend function.

Returns

trendTrendTransform: Trend function.

getVisibility(self)¶

Accessor to the object’s visibility state.

Returns

visiblebool: Visibility flag.

hasName(self)¶

Test if the object is named.

Returns

hasNamebool: True if the name is not empty.

hasVisibleName(self)¶

Test if the object has a distinguishable name.

Returns

hasVisibleNamebool: True if the name is not empty and not the default one.

isComposite(self)¶

Test whether the process is composite or not.

Returns

isCompositebool: True if the process is composite (built upon a function and a process).

isNormal(self)¶

Test whether the process is normal or not.

Returns

isNormalbool: True if the process is normal.

Notes

A stochastic process is normal if all its finite dimensional joint distributions are normal, which means that for all $k \in \Nset$ and $I_k \in \Nset^*$ , with $cardI_k=k$ , there is $\vect{m}_1, \dots, \vect{m}_k \in \Rset^d$ and $\mat{C}_{1,\dots,k}\in\mathcal{M}_{kd,kd}(\Rset)$ such that:

$\Expect{\exp\left\{i\Tr{\vect{X}}_{I_k} \vect{U}_{k} \right\}} = \exp{\left\{i\Tr{\vect{U}}_{k}\vect{M}_{k}-\frac{1}{2}\Tr{\vect{U}}_{k}\mat{C}_{1,\dots,k}\vect{U}_{k}\right\}}$

where $\Tr{\vect{X}}_{I_k} = (\Tr{X}_{\vect{t}_1}, \hdots, \Tr{X}_{\vect{t}_k})$ , $\\Tr{vect{U}}_{k} = (\Tr{\vect{u}}_{1}, \hdots, \Tr{\vect{u}}_{k})$ and $\Tr{\vect{M}}_{k} = (\Tr{\vect{m}}_{1}, \hdots, \Tr{\vect{m}}_{k})$ and $\mat{C}_{1,\dots,k}$ is the symmetric matrix:

$\mat{C}_{1,\dots,k} = \left( \begin{array}{cccc} C(\vect{t}_1, \vect{t}_1) &C(\vect{t}_1, \vect{t}_2) & \hdots & C(\vect{t}_1, \vect{t}_{k}) \\ \hdots & C(\vect{t}_2, \vect{t}_2) & \hdots & C(\vect{t}_2, \vect{t}_{k}) \\ \hdots & \hdots & \hdots & \hdots \\ \hdots & \hdots & \hdots & C(\vect{t}_{k}, \vect{t}_{k}) \end{array} \right)$

A Gaussian process is entirely defined by its mean function $m$ and its covariance function $C$ (or correlation function $R$ ).

isStationary(self)¶

Test whether the process is stationary or not.

Returns

isStationarybool: True if the process is stationary.

Notes

A process $X$ is stationary if its distribution is invariant by translation: $\forall k \in \Nset$ , $\forall (\vect{t}_1, \dots, \vect{t}_k) \in \cD$ , $\forall \vect{h}\in \Rset^n$ , we have:

$(X_{\vect{t}_1}, \dots, X_{\vect{t}_k}) \stackrel{\mathcal{D}}{=} (X_{\vect{t}_1+\vect{h}}, \dots, X_{\vect{t}_k+\vect{h}})$

isTrendStationary(self)¶

Tell if the process is trend stationary or not.

Returns

isTrendStationarybool: True if the process is trend stationary.

setDescription(self, description)¶

Set the description of the process.

Parameters

descriptionsequence of str: Description of the process.

setMesh(self, \*args)¶

Set the mesh.

Parameters

meshMesh: Mesh over which the domain $\cD$ is discretized.

setName(self, name)¶

Accessor to the object’s name.

Parameters

namestr: The name of the object.

setSamplingMethod(self, \*args)¶

Set the used method for getRealization.

Available parameters are :

0 : Cholesky factor sampling (default method)

1 : H-Matrix method (if H-Mat available)

2 : Gibbs method (in dimension 1 only)

Parameters

samplingMethodint: Fix a method for sampling.

setShadowedId(self, id)¶

Accessor to the object’s shadowed id.

Parameters

idint: Internal unique identifier.

setTimeGrid(self, \*args)¶

Set the time grid of observation of the process.

Returns

timeGridRegularGrid: Time grid of observation of the process when the mesh associated to the process can be interpreted as a RegularGrid. We check if the vertices of the mesh are scalar and are regularly spaced in $\Rset$ but we don’t check if the connectivity of the mesh is conform to the one of a regular grid (without any hole and composed of ordered instants).

setVisibility(self, visible)¶

Accessor to the object’s visibility state.

Parameters

visiblebool: Visibility flag.

OpenTURNS

An Open source initiative for the Treatment of Uncertainties, Risks'N Statistics

Previous topic

Next topic

This Page

ConditionedGaussianProcess¶