libopenturns-dev 1.7-3 / usr / include / openturns / swig / GeneralizedLinearModelResult_doc.i

%feature("docstring") OT::GeneralizedLinearModelResult
"Generalized linear model result.

Available constructors:
    GeneralizedLinearModelResult(*inputSample, outputSample, metaModel, residuals, relativeErrors, basis, trendCoefficients, covarianceModel*)

    GeneralizedLinearModelResult(*inputSample, outputSample, metaModel, residuals, relativeErrors, basis, trendCoefficients, covarianceModel, covarianceCholeskyFactor, covarianceHMatrix*)


Parameters
----------
inputSample, outputSample : :class:`~openturns.NumericalSample`
    The input and output samples of a model evaluated apart.
metaModel: :class:`~openturns.NumericalMathFunction`
    The surrogate model built thanks to :class:`~openturns.GeneralizedLinearModelAlgorithm`.
residuals: :class:`~openturns.NumericalPoint`
    The residual errors.
relativeErrors: :class:`~openturns.NumericalPoint`
    The relative errors.
basis : collection of :class:`~openturns.Basis`
    Its size should be equal to the output dimension or zero if no trend is estimated.
    The n-th basis is the functional basis (or the generalized linear model) for the n-th output marginal.
trendCoefficients : collection of :class:`~openturns.NumericalPoint`
    The trend coeffients associated to the generalized linear model.
covarianceModel : :class:`~openturns.CovarianceModel`
    Covariance function.
covarianceCholeskyFactor : :class:`~openturns.TriangularMatrix`
    The Cholesky factor of associated to the evaluation of the covariance function evaluated at the inputSample.
covarianceHMatrix :  :class:`~openturns.HMatrix`
    The *hmat* implementation of the Cholesky factor of the covariance matrix obtained by the discretization of the covariance function on the input sample.


Notes
-----
The structure is usually created by the method run() of a :class:`~openturns.GeneralizedLinearModelAlgorithm`, and obtained thanks to the *getResult()* method.
We use the notations used for the :class:`~openturns.GeneralizedLinearModelAlgorithm` class.
For a set :math:`(\\\\vect{X}, \\\\vect{Y})` such as:

.. math::
    \\\\vect{X} = \\\\left(
      \\\\begin{array}{l}
        \\\\vect{x}_1 \\\\\\\\
        \\\\dots \\\\\\\\
        \\\\vect{x}_n
       \\\\end{array}
     \\\\right) \\\\in \\\\mathcal{M}_{n, d}, \\\\quad
    \\\\vect{Y} = \\\\left(
      \\\\begin{array}{l}
        \\\\vect{y}_1 \\\\\\\\
        \\\\dots \\\\\\\\
        \\\\vect{y}_n
       \\\\end{array}
       \\\\right) \\\\in \\\\mathcal{M}_{n, p}

we recall the expression of the genrealized linear model:

.. math::
    \\\\vect{Y}(\\\\vect{x}) = \\\\vect{F}^t(\\\\vect{x}) \\\\vect{\\\\beta} + \\\\vect{Z}

where :math:`\\\\mat{F} \\\\in \\\\mathcal{M}_{np, M}(\\\\Rset)` and writes:

.. math::
    \\\\mat{F}(\\\\vect{x}) = \\\\left(
      \\\\begin{array}{lcl}
        \\\\vect{f}_1(\\\\vect{x}_1) & \\\\dots & \\\\vect{f}_M(\\\\vect{x}_1) \\\\\\\\
        \\\\dots & \\\\dots & \\\\\\\\
        \\\\vect{f}_1(\\\\vect{x}_n) & \\\\dots & \\\\vect{f}_M(\\\\vect{x}_n)
       \\\\end{array}
     \\\\right)

:math:`\\\\vect{\\\\beta} \\\\in \\\\mathcal{M}_{np, M}(\\\\Rset)` are the trend coefficients, estimated by a least-squares method.

Finally, :math:`\\\\vect{Z} \\\\sim \\\\mathcal{N}(0, \\\\mat{\\\\Sigma})` is a noise with:

.. math::
    \\\\mat{\\\\Sigma}_{i,j} =  C_{\\\\vect{\\\\sigma}, \\\\vect{\\\\theta}, \\\\vect{\\\\lambda}}(\\\\vect{x}_i,\\\\vect{x}_j) \\\\quad \\\\forall (i,j) \\\\in [1,n]


Examples
--------
Create the model :math:`\\\\cM: \\\\Rset \\\\mapsto \\\\Rset` and the samples:

>>> import openturns as ot
>>> f = ot.NumericalMathFunction(['x'],  ['x * sin(x)'])
>>> sampleX = [[1.0], [2.0], [3.0], [4.0], [5.0], [6.0]]
>>> sampleY = f(sampleX)

Create the algorithm:

>>> basis = ot.Basis([ot.NumericalMathFunction('x', 'x'), ot.NumericalMathFunction('x', 'x^2')])
>>> covarianceModel = ot.GeneralizedExponential(1, 2.0, 2.0)
>>> algo = ot.GeneralizedLinearModelAlgorithm(sampleX, sampleY, covarianceModel, basis)
>>> algo.run()

Get the result:

>>> result = algo.getResult()

Get the meta model:

>>> metaModel = result.getMetaModel()
>>> graph = metaModel.draw(0.0, 7.0)
>>> cloud = ot.Cloud(sampleX, sampleY)
>>> cloud.setPointStyle('fcircle')
>>> graph = ot.Graph()
>>> graph.add(cloud)
>>> graph.add(f.draw(0.0, 7.0))
>>> graph.setColors(['black', 'blue', 'red'])
"

// ---------------------------------------------------------------------

%feature("docstring") OT::GeneralizedLinearModelResult::getTrendCoefficients
"Accessor to the coefficients of the generalized linear model of the trend.

Returns
-------
trendCoef : collection of :class:`~openturns.NumericalPoint`
    For each output marginal *j*, the list of :math:`\\\\vect{\\\\beta}_j`.

    If a collection of basis has been fixed by the User, the vectors :math:`\\\\vect{\\\\beta}_j` don't have the same dimension according to the output marginal *j*.

Examples
--------
Create the model :math:`\\\\cM: \\\\Rset \\\\mapsto \\\\Rset` and the samples:

>>> import openturns as ot
>>> f = ot.NumericalMathFunction(['x'], ['x * sin(x)'])
>>> inputSample = ot.NumericalSample([[1.], [3.], [5.], [6.,], [7.], [8.]])
>>> outputSample = f(inputSample)

Create the algorithm:

>>> basis = ot.ConstantBasisFactory().build()
>>> covarianceModel = ot.SquaredExponential(1)
>>> algo = ot.GeneralizedLinearModelAlgorithm(inputSample, outputSample, covarianceModel, basis)
>>> algo.run()

Get the results:

>>> result = algo.getResult()

Get the trend coefficients:

>>> trendCoefficients = result.getTrendCoefficients()"

// ---------------------------------------------------------------------

%feature("docstring") OT::GeneralizedLinearModelResult::getCovarianceModel
"Accessor to the covariance model.

Returns
-------
covModel : :class:`~openturns.CovarianceModel`
    The covariance model of the Normal process *Z*, noted :math:`C_{\\\\vect{\\\\sigma}, \\\\vect{\\\\theta}, \\\\vect{\\\\lambda}}`.

    Its spatial dimension is *d* and its dimension is *p*.

Examples
--------
Create the model :math:`\\\\cM: \\\\Rset \\\\mapsto \\\\Rset` and the samples:

>>> import openturns as ot
>>> f = ot.NumericalMathFunction(['x'], ['x * sin(x)'])
>>> inputSample = ot.NumericalSample([[1.], [3.], [5.], [6.,], [7.], [8.]])
>>> outputSample = f(inputSample)

Create the algorithm:

>>> basis = ot.ConstantBasisFactory().build()
>>> covarianceModel = ot.SquaredExponential(1)
>>> algo = ot.GeneralizedLinearModelAlgorithm(inputSample, outputSample, covarianceModel, basis)
>>> algo.run()

Get the results:

>>> result = algo.getResult()
>>> # Get the covariance model

Get the covariance model:

>>> covariance = result.getCovarianceModel()"

// ---------------------------------------------------------------------

%feature("docstring") OT::GeneralizedLinearModelResult::getBasisCollection
"Accessor to the multivariate basis of the generalized linear model.

Returns
-------
basisCollection : collection of :class:`~openturns.Basis`
    Each element of this class is a :class:`~openturns.Basis` which is the functional basis (or the generalized linear model).

Notes
-----
If the trend is not estimated, the collection is empty. Otherwise, it contains a number of basis equal to the output dimension *p*.

Examples
--------
Create the model :math:`\\\\cM: \\\\Rset \\\\mapsto \\\\Rset` and the samples:

>>> import openturns as ot
>>> f = ot.NumericalMathFunction(['x'], ['x * sin(x)'])
>>> inputSample = ot.NumericalSample([[1.], [3.], [5.], [6.,], [7.], [8.]])
>>> outputSample = f(inputSample)

Create the algorithm:

>>> basis = ot.ConstantBasisFactory().build()
>>> covarianceModel = ot.SquaredExponential(1)
>>> algo = ot.GeneralizedLinearModelAlgorithm(inputSample, outputSample, covarianceModel, basis)
>>> algo.run()

Get the results:

>>> result = algo.getResult()
>>> # Get the basis collection

Get the basis collection:

>>> basisCollection = result.getBasisCollection()"

// ---------------------------------------------------------------------

%feature("docstring") OT::GeneralizedLinearModelResult::getMetaModel
"Accessor to the metamodel.

Returns
-------
metaModel : :class:`~openturns.NumericalMathFunction`

Examples
--------
>>> import openturns as ot
>>> f = ot.NumericalMathFunction(['x0'], ['f0'], ['x0 * sin(x0)'])
>>> inputSample = ot.NumericalSample([[1.], [3.], [5.], [6.,], [7.], [8.]])
>>> outputSample = f(inputSample)
>>> # Create the algorithm
>>> basis = ot.ConstantBasisFactory().build()
>>> covarianceModel = ot.SquaredExponential(1)
>>> algo = ot.GeneralizedLinearModelAlgorithm(inputSample, outputSample, covarianceModel, basis)
>>> algo.run()
>>> # Get the results
>>> result = algo.getResult()
>>> # The metamodel
>>> metaModel = result.getMetaModel()"

// ---------------------------------------------------------------------

%feature("docstring") OT::GeneralizedLinearModelResult::getTransformation
"Accessor to the transformation applied to normalize the input sample.

Returns
-------
transformation : :class:`~openturns.NumericalMathFunction`
    The transformation that isused to normalize the input sample.
"

// ---------------------------------------------------------------------

%feature("docstring") OT::GeneralizedLinearModelResult::setTransformation
"Set accessor to the transformation applied to normalize the input sample.

Parameters
----------
transformation : :class:`~openturns.NumericalMathFunction`
    The transformation that should be applied to normalize the input sample.
"

// ---------------------------------------------------------------------

%feature("docstring") OT::GeneralizedLinearModelResult::getNoise
"Accessor to the underlying noise process.

Returns
-------
process : :class:`~openturns.Process`
    Returns the underlying process modeling the noise.

Notes
-----
The noise process writes:

.. math::
    \\\\cY \\\\sim \\\\cN\\\\left(0 , C_{\\\\vect{\\\\sigma}, \\\\vect{\\\\theta}, \\\\vect{\\\\lambda}} \\\\right)


Examples
--------
Create the model :math:`\\\\cM: \\\\Rset \\\\mapsto \\\\Rset` and the samples:

>>> import openturns as ot
>>> f = ot.NumericalMathFunction(['x'], ['x * sin(x)'])
>>> inputSample = ot.NumericalSample([[1.], [3.], [5.], [6.,], [7.], [8.]])
>>> outputSample = f(inputSample)

Create the algorithm:

>>> basis = ot.ConstantBasisFactory().build()
>>> covarianceModel = ot.SquaredExponential(1)
>>> algo = ot.GeneralizedLinearModelAlgorithm(inputSample, outputSample, covarianceModel, basis)
>>> algo.run()

Get the results:

>>> result = algo.getResult()

Get the noise process:

>>> noise_process = result.getNoise()
"

// ---------------------------------------------------------------------