ExpertMixture

class ExpertMixture(*args)

Expert mixture defining a piecewise function according to a classifier.

This implements an expert mixture which is a piecewise function f defined by the collection of functions (f_i)_{i=1, \ldots, N} given in basis and according to a classifier:

f(\vect{x}) &= f_1(\vect{x}) \hspace{1em} \forall \vect{z} \in \text{Class} 1 \\
            &= f_k(\vect{x}) \hspace{1em} \forall \vect{z} \in \text{Class} k \\
            &= f_N(\vect{x}) \hspace{1em} \forall \vect{z} \in \text{Class} N

where the N classes are defined by the classifier.

In supervised mode the classifier partitions the input and output space at once:

\vect{z} = (\vect{x}, f(\vect{x}))

whereas in non-supervised mode only the input space is partitioned:

\vect{z} = \vect{x}

Parameters:
basissequence of Function

A basis

classifierClassifier

A classifier

supervisedbool (default=True)

In supervised mode, the classifier partitions the space of (\vect(x), f(\vect(x))) whereas in non-supervised mode the classifier only partitions the input space.

Notes

The number of experts must match the number of classes of the classifier.

Examples

>>> import openturns as ot
>>> R = ot.CorrelationMatrix(2)
>>> R[0, 1] = -0.99
>>> d1 = ot.Normal([-1.0, 1.0], [1.0, 1.0], R)
>>> R[0, 1] = 0.99
>>> d2 = ot.Normal([1.0, 1.0], [1.0, 1.0], R)
>>> distribution = ot.Mixture([d1, d2], [1.0]*2)
>>> classifier = ot.MixtureClassifier(distribution)
>>> f1 = ot.SymbolicFunction(['x'], ['-x'])
>>> f2 = ot.SymbolicFunction(['x'], ['x'])
>>> experts = [f1, f2]
>>> evaluation = ot.ExpertMixture(experts, classifier)
>>> moe = ot.Function(evaluation)
>>> print(moe([-0.3]))
[0.3]
>>> print(moe([0.1]))
[0.1]
Attributes:
thisown

The membership flag

Methods

__call__(*args) Call self as a function.
draw(*args) Draw the output of function as a Graph.
getCallsNumber() Accessor to the number of times the function has been called.
getClassName() Accessor to the object’s name.
getClassifier() Accessor the classifier.
getDescription() Accessor to the description of the inputs and outputs.
getExperts() Accessor the basis.
getId() Accessor to the object’s id.
getInputDescription() Accessor to the description of the inputs.
getInputDimension() Accessor to the number of the inputs.
getMarginal(*args) Accessor to marginal.
getName() Accessor to the object’s name.
getOutputDescription() Accessor to the description of the outputs.
getOutputDimension() Accessor to the number of the outputs.
getParameter() Accessor to the parameter values.
getParameterDescription() Accessor to the parameter description.
getParameterDimension() Accessor to the dimension of the parameter.
getShadowedId() Accessor to the object’s shadowed id.
getVisibility() Accessor to the object’s visibility state.
hasName() Test if the object is named.
hasVisibleName() Test if the object has a distinguishable name.
isActualImplementation() Accessor to the validity flag.
parameterGradient(inP) Gradient against the parameters.
setClassifier(classifier) Accessor the classifier.
setDescription(description) Accessor to the description of the inputs and outputs.
setExperts(experts) Accessor the basis.
setInputDescription(inputDescription) Accessor to the description of the inputs.
setName(name) Accessor to the object’s name.
setOutputDescription(outputDescription) Accessor to the description of the outputs.
setParameter(parameters) Accessor to the parameter values.
setParameterDescription(description) Accessor to the parameter description.
setShadowedId(id) Accessor to the object’s shadowed id.
setVisibility(visible) Accessor to the object’s visibility state.
__init__(*args)

Initialize self. See help(type(self)) for accurate signature.

draw(*args)

Draw the output of function as a Graph.

Available usages:

draw(inputMarg, outputMarg, CP, xiMin, xiMax, ptNb)

draw(firstInputMarg, secondInputMarg, outputMarg, CP, xiMin_xjMin, xiMax_xjMax, ptNbs)

draw(xiMin, xiMax, ptNb)

draw(xiMin_xjMin, xiMax_xjMax, ptNbs)

Parameters:
outputMarg, inputMargint, outputMarg, inputMarg \geq 0

outputMarg is the index of the marginal to draw as a function of the marginal with index inputMarg.

firstInputMarg, secondInputMargint, firstInputMarg, secondInputMarg \geq 0

In the 2D case, the marginal outputMarg is drawn as a function of the two marginals with indexes firstInputMarg and secondInputMarg.

CPsequence of float

Central point.

xiMin, xiMaxfloat

Define the interval where the curve is plotted.

xiMin_xjMin, xiMax_xjMaxsequence of float of dimension 2.

In the 2D case, define the intervals where the curves are plotted.

ptNbint ptNb > 0 or list of ints of dimension 2 ptNb_k > 0, k=1,2

The number of points to draw the curves.

Notes

We note f: \Rset^n \rightarrow \Rset^p where \vect{x} = (x_1, \dots, x_n) and f(\vect{x}) = (f_1(\vect{x}), \dots,f_p(\vect{x})), with n\geq 1 and p\geq 1.

  • In the first usage:

Draws graph of the given 1D outputMarg marginal f_k: \Rset^n \rightarrow \Rset as a function of the given 1D inputMarg marginal with respect to the variation of x_i in the interval [x_i^{min}, x_i^{max}], when all the other components of \vect{x} are fixed to the corresponding ones of the central point CP. Then it draws the graph: t\in [x_i^{min}, x_i^{max}] \mapsto f_k(CP_1, \dots, CP_{i-1}, t,  CP_{i+1} \dots, CP_n).

  • In the second usage:

Draws the iso-curves of the given outputMarg marginal f_k as a function of the given 2D firstInputMarg and secondInputMarg marginals with respect to the variation of (x_i, x_j) in the interval [x_i^{min}, x_i^{max}] \times [x_j^{min}, x_j^{max}], when all the other components of \vect{x} are fixed to the corresponding ones of the central point CP. Then it draws the graph: (t,u) \in [x_i^{min}, x_i^{max}] \times [x_j^{min}, x_j^{max}] \mapsto f_k(CP_1, \dots, CP_{i-1}, t, CP_{i+1}, \dots, CP_{j-1}, u,  CP_{j+1} \dots, CP_n).

  • In the third usage:

The same as the first usage but only for function f: \Rset \rightarrow \Rset.

  • In the fourth usage:

The same as the second usage but only for function f: \Rset^2 \rightarrow \Rset.

Examples

>>> import openturns as ot
>>> from openturns.viewer import View
>>> f = ot.SymbolicFunction(['x'], ['sin(2*pi_*x)*exp(-x^2/2)'])
>>> graph = f.draw(-1.2, 1.2, 100)
>>> View(graph).show()
getCallsNumber()

Accessor to the number of times the function has been called.

Returns:
calls_numberint

Integer that counts the number of times the function has been called since its creation.

getClassName()

Accessor to the object’s name.

Returns:
class_namestr

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

getClassifier()

Accessor the classifier.

Returns:
classifierClassifier

The classifier.

getDescription()

Accessor to the description of the inputs and outputs.

Returns:
descriptionDescription

Description of the inputs and the outputs.

Examples

>>> import openturns as ot
>>> f = ot.SymbolicFunction(['x1', 'x2'],
...                         ['2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6'])
>>> print(f.getDescription())
[x1,x2,y0]
getExperts()

Accessor the basis.

Returns:
basiscollection of Function

The collection of functions (f_i)_{i=1, \ldots, N}.

getId()

Accessor to the object’s id.

Returns:
idint

Internal unique identifier.

getInputDescription()

Accessor to the description of the inputs.

Returns:
descriptionDescription

Description of the inputs.

Examples

>>> import openturns as ot
>>> f = ot.SymbolicFunction(['x1', 'x2'],
...                         ['2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6'])
>>> print(f.getInputDescription())
[x1,x2]
getInputDimension()

Accessor to the number of the inputs.

Returns:
number_inputsint

Number of inputs.

Examples

>>> import openturns as ot
>>> f = ot.SymbolicFunction(['x1', 'x2'],
...                         ['2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6'])
>>> print(f.getInputDimension())
2
getMarginal(*args)

Accessor to marginal.

Parameters:
indicesint or list of ints

Set of indices for which the marginal is extracted.

Returns:
marginalFunction

Function corresponding to either f_i or (f_i)_{i \in indices}, with f:\Rset^n \rightarrow \Rset^p and f=(f_0 , \dots, f_{p-1}).

getName()

Accessor to the object’s name.

Returns:
namestr

The name of the object.

getOutputDescription()

Accessor to the description of the outputs.

Returns:
descriptionDescription

Description of the outputs.

Examples

>>> import openturns as ot
>>> f = ot.SymbolicFunction(['x1', 'x2'],
...                         ['2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6'])
>>> print(f.getOutputDescription())
[y0]
getOutputDimension()

Accessor to the number of the outputs.

Returns:
number_outputsint

Number of outputs.

Examples

>>> import openturns as ot
>>> f = ot.SymbolicFunction(['x1', 'x2'],
...                         ['2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6'])
>>> print(f.getOutputDimension())
1
getParameter()

Accessor to the parameter values.

Returns:
parameterPoint

The parameter values.

getParameterDescription()

Accessor to the parameter description.

Returns:
parameterDescription

The parameter description.

getParameterDimension()

Accessor to the dimension of the parameter.

Returns:
parameter_dimensionint

Dimension of the parameter.

getShadowedId()

Accessor to the object’s shadowed id.

Returns:
idint

Internal unique identifier.

getVisibility()

Accessor to the object’s visibility state.

Returns:
visiblebool

Visibility flag.

hasName()

Test if the object is named.

Returns:
hasNamebool

True if the name is not empty.

hasVisibleName()

Test if the object has a distinguishable name.

Returns:
hasVisibleNamebool

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

isActualImplementation()

Accessor to the validity flag.

Returns:
is_implbool

Whether the implementation is valid.

parameterGradient(inP)

Gradient against the parameters.

Parameters:
xsequence of float

Input point

Returns:
parameter_gradientMatrix

The parameters gradient computed at x.

setClassifier(classifier)

Accessor the classifier.

Parameters:
classifierClassifier

The classifier.

setDescription(description)

Accessor to the description of the inputs and outputs.

Parameters:
descriptionsequence of str

Description of the inputs and the outputs.

Examples

>>> import openturns as ot
>>> f = ot.SymbolicFunction(['x1', 'x2'],
...                         ['2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6'])
>>> print(f.getDescription())
[x1,x2,y0]
>>> f.setDescription(['a','b','y'])
>>> print(f.getDescription())
[a,b,y]
setExperts(experts)

Accessor the basis.

Parameters:
basisBasis

The collection of functions (f_i)_{i=1, \ldots, N}.

setInputDescription(inputDescription)

Accessor to the description of the inputs.

Returns:
descriptionDescription

Description of the inputs.

setName(name)

Accessor to the object’s name.

Parameters:
namestr

The name of the object.

setOutputDescription(outputDescription)

Accessor to the description of the outputs.

Returns:
descriptionDescription

Description of the outputs.

setParameter(parameters)

Accessor to the parameter values.

Parameters:
parametersequence of float

The parameter values.

setParameterDescription(description)

Accessor to the parameter description.

Parameters:
parameterDescription

The parameter description.

setShadowedId(id)

Accessor to the object’s shadowed id.

Parameters:
idint

Internal unique identifier.

setVisibility(visible)

Accessor to the object’s visibility state.

Parameters:
visiblebool

Visibility flag.

thisown

The membership flag