def test_two_inputs_one_output():
# Kriging use case
inputDimension = 2
# Learning data
levels = [8, 5]
box = ot.Box(levels)
inputSample = box.generate()
# Scale each direction
inputSample *= 10.0
model = ot.SymbolicFunction(['x', 'y'], ['cos(0.5*x) + sin(y)'])
outputSample = model(inputSample)
# Validation
sampleSize = 10
inputValidSample = ot.ComposedDistribution(
2 * [ot.Uniform(0, 10.0)]).getSample(sampleSize)
outputValidSample = model(inputValidSample)
# 2) Definition of exponential model
# The parameters have been calibrated using TNC optimization
# and AbsoluteExponential models
scales = [5.33532, 2.61534]
amplitude = [1.61536]
covarianceModel = ot.SquaredExponential(scales, amplitude)
# 3) Basis definition
basis = ot.ConstantBasisFactory(inputDimension).build()
# 4) Kriging algorithm
algo = ot.KrigingAlgorithm(inputSample, outputSample, covarianceModel,
basis)
algo.run()
result = algo.getResult()
# Get meta model
metaModel = result.getMetaModel()
outData = metaModel(inputValidSample)
# 5) Errors
# Interpolation
ott.assert_almost_equal(outputSample, metaModel(inputSample), 3.0e-5,
3.0e-5)
# 6) Kriging variance is 0 on learning points
covariance = result.getConditionalCovariance(inputSample)
ott.assert_almost_equal(covariance, ot.SquareMatrix(len(inputSample)),
7e-7, 7e-7)
# Covariance per marginal & extract variance component
coll = result.getConditionalMarginalCovariance(inputSample)
var = [mat[0, 0] for mat in coll]
ott.assert_almost_equal(var, [0] * len(var), 0.0, 1e-13)
# Variance per marginal
var = result.getConditionalMarginalVariance(inputSample)
ott.assert_almost_equal(var, ot.Point(len(inputSample)), 0.0, 1e-13)
# Estimation
ott.assert_almost_equal(outputValidSample, outData, 1.e-1, 1e-1)
def _buildKrigingAlgo(self, inputSample, outputSample):
"""
Build the functional chaos algorithm without running it.
"""
if self._basis is None:
# create linear basis only for the defect parameter (1st parameter),
# constant otherwise
input = ['x' + str(i) for i in range(self._dim)]
functions = []
# constant
functions.append(ot.SymbolicFunction(input, ['1']))
# linear for the first parameter only
functions.append(ot.SymbolicFunction(input, [input[0]]))
self._basis = ot.Basis(functions)
if self._covarianceModel is None:
# anisotropic squared exponential covariance model
self._covarianceModel = ot.SquaredExponential([1] * self._dim)
# normalization
mean = inputSample.computeMean()
try:
stddev = inputSample.computeStandardDeviation()
except AttributeError:
stddev = inputSample.computeStandardDeviationPerComponent()
linear = ot.SquareMatrix(self._dim)
for j in range(self._dim):
linear[j, j] = 1.0 / stddev[j] if abs(stddev[j]) > 1e-12 else 1.0
zero = [0.0] * self._dim
transformation = ot.LinearFunction(mean, zero, linear)
algoKriging = ot.KrigingAlgorithm(transformation(inputSample),
outputSample, self._covarianceModel,
self._basis)
return algoKriging, transformation
def computeDurbinWatsonTest(x, residuals, hypothesis="Equal"):
# Parameters:
# hypothesis : string
# "Equal" : hypothesis is autocorrelation is 0
# "Less" : hypothesis is autocorrelation is less than 0
# "Greater" : hypothesis is autocorrelation is greater than 0
nx = x.getSize()
dim = x.getDimension()
residuals = np.array(residuals)
# statistic Durbin Watson
dw = np.sum(np.diff(np.hstack(residuals))**2) / np.sum(residuals**2)
# Normal approxiimation of DW to compute the pvalue
X = ot.Matrix(nx, dim + 1)
X[:, 0] = np.ones((nx, 1))
X[:, 1] = x
B = ot.Matrix(nx, dim + 1)
B[0, 1] = x[0][0] - x[1][0]
B[nx - 1, 1] = x[nx - 1][0] - x[nx - 2][0]
for i in range(nx - 2):
B[i + 1, 1] = -x[i][0] + 2 * x[i + 1][0] - x[i + 2][0]
XtX = X.computeGram()
XBQt = ot.SquareMatrix(XtX.solveLinearSystem(B.transpose() * X))
P = 2 * (nx - 1) - XBQt.computeTrace()
XBTrace = ot.SquareMatrix(XtX.solveLinearSystem(B.computeGram(),
False)).computeTrace()
Q = 2 * (3 * nx - 4) - 2 * XBTrace + ot.SquareMatrix(
XBQt * XBQt).computeTrace()
dmean = P / (nx - (dim + 1))
dvar = 2.0 / ((nx - (dim + 1)) * (nx - (dim + 1) + 2)) * (Q - P * dmean)
# compute the pvalue with respect to hypothesis
# Default pvalue is for hypothesis == "Equal"
# complementary CDF of standard normal distribution
pValue = 2 * ot.DistFunc.pNormal(np.abs(dw - dmean) / np.sqrt(dvar), True)
if hypothesis == "Less":
pValue = 1 - pValue / 2
elif hypothesis == "Greater":
pValue = pValue / 2
return pValue
def __init__(self, p, mesh):
# 1 = input dimension, the dimension of the input field
# 1 = output dimension, the dimension of the output field
# 1 = mesh dimension
super(ConvolutionP1, self).__init__(mesh, 1, mesh, 1)
# Here we define some constants and we set-up the invariant part of the execution
self.setInputDescription(["x"])
self.setOutputDescription(["y"])
vertices = mesh.getVertices()
size = vertices.getSize()
self.mat_W_ = ot.SquareMatrix(size)
for i in range(size):
x_minus_t = (vertices - vertices[i]) * (-1.0)
values_w = p(x_minus_t)
for j in range(size):
self.mat_W_[i, j] = values_w[j, 0]
G = mesh.computeP1Gram()
self.mat_W_ = self.mat_W_ * G
#
# The library proposes to model it through the object *DiscreteMarkovChain* defined thanks to the origin :math:`X_{t_0}` (which can be either deterministic or uncertain), the transition matrix :math:`\mathcal{M}` and the time grid.
# %%
import openturns as ot
import openturns.viewer as viewer
from matplotlib import pylab as plt
ot.Log.Show(ot.Log.NONE)
# %%
# Define the origin
origin = ot.Dirac(0.0)
# %%
# Define the transition matrix
transition = ot.SquareMatrix([[0.1, 0.3, 0.6], [0.7, 0.1, 0.2],
[0.5, 0.3, 0.2]])
# %%
# Define an 1-d mesh
tgrid = ot.RegularGrid(0.0, 1.0, 50)
# %%
# Markov chain definition and realization
process = ot.DiscreteMarkovChain(origin, transition, tgrid)
real = process.getRealization()
graph = real.drawMarginal(0)
graph.setTitle('Discrete Markov chain')
view = viewer.View(graph)
# %%
# Get several realizations
#!/usr/bin/env python
import openturns as ot
import os
ot.TESTPREAMBLE()
process = ot.DiscreteMarkovChain()
print("Default constructor : process = ")
print(process)
process = ot.DiscreteMarkovChain(0, ot.SquareMatrix([[1.0, 0.0], [0.0, 1.0]]))
print("Constructor from int and SquareMatrix: process = ")
print(process)
transitionMatrix = ot.SquareMatrix([[0.0, 0.5, 0.5], [0.7, 0.0, 0.3],
[0.8, 0.0, 0.2]])
print("transition matrix =")
print(transitionMatrix)
origin = 1
print("origin =")
print(origin)
process.setTransitionMatrix(transitionMatrix)
print("Transition matrix accessor : process = ")
print(process)
process.setOrigin(origin)
print("Origin accessor : process = ")
print(process)
# check Description typemap
sample.setDescription(('x0', 'x1', 'x2'))
print(sample.getDescription())
sample.setDescription(('y0', 'y1', 'y2'))
print(sample.getDescription())
sample.setDescription(np.array(('z0', 'z1', 'z2')))
print(sample.getDescription())
# Check Matrix tuple constructor
t0 = (1., 2., 3., 4.)
m0 = ot.Matrix(2, 2, t0)
print("tuple", t0, "=> Matrix", m0)
m0 = ot.SquareMatrix(2, t0)
print("tuple", t0, "=> SquareMatrix", m0)
m0 = ot.SymmetricMatrix(2, t0)
print("tuple", t0, "=> SymmetricMatrix", m0)
m0 = ot.Tensor(2, 2, 1, t0)
print("tuple", t0, "=> Tensor", m0)
m0 = ot.SymmetricTensor(2, 1, t0)
print("tuple", t0, "=> SymmetricTensor", m0)
m0 = ot.CorrelationMatrix(2, t0)
print("tuple", t0, "=> CorrelationMatrix", m0)
m0 = ot.CovarianceMatrix(2, t0)
# try to generate a sample
sampleSize = 1000
sample = sampler.getSample(sampleSize)
x_mu = sample.computeMean()
x_sigma = sample.computeStandardDeviation()
# compute covariance
x_cov = sample.computeCovariance()
P = ot.Matrix(obsSize, chainDim)
for i in range(obsSize):
for j in range(chainDim):
P[i, j] = p[i, j]
Qn = P.transpose() * P + Q0
Qn_inv = ot.SquareMatrix(chainDim)
for j in range(chainDim):
I_j = [0] * chainDim
I_j[j] = 1.0
Qn_inv_j = Qn.solveLinearSystem(I_j)
for i in range(chainDim):
Qn_inv[i, j] = Qn_inv_j[i]
sigma_exp = [0] * chainDim
for i in range(chainDim):
sigma_exp[i] = m.sqrt(Qn_inv[i, i])
y_vec = [0] * obsSize
for i in range(obsSize):
y_vec[i] = y_obs[i, 0]
x_emp = Qn.solveLinearSystem(P.transpose() * y_vec)
import openturns as ot
from matplotlib import pyplot as plt
from openturns.viewer import View
if ot.WhiteNoise().__class__.__name__ == 'Process':
# default to Gaussian for the interface class
process = ot.GaussianProcess()
elif ot.WhiteNoise().__class__.__name__ == 'DiscreteMarkovChain':
process = ot.WhiteNoise()
process.setTransitionMatrix(ot.SquareMatrix([[0.0,0.5,0.5],[0.7,0.0,0.3],[0.8,0.0,0.2]]))
origin = 0
process.setOrigin(origin)
else:
process = ot.WhiteNoise()
process.setTimeGrid(ot.RegularGrid(0.0, 0.02, 50))
process.setDescription(['$x$'])
sample = process.getSample(6)
sample_graph = sample.drawMarginal(0)
sample_graph.setTitle(str(process))
fig = plt.figure(figsize=(10, 4))
sample_axis = fig.add_subplot(111)
View(sample_graph, figure=fig, axes=[sample_axis], add_legend=False)
dt = 0.5
N = int((20.0 - t0) / dt)
mesh = ot.RegularGrid(t0, dt, N)
# Create the covariance function
def gamma(tau):
return 1.0 / (1.0 + tau * tau)
# Create the collection of HermitianMatrix
coll = ot.SquareMatrixCollection()
for k in range(N):
t = mesh.getValue(k)
matrix = ot.SquareMatrix([[gamma(t)]])
coll.add(matrix)
# %%
# Create the covariance model
covmodel = ot.UserDefinedStationaryCovarianceModel(mesh, coll)
# One vertex of the mesh
tau = 1.5
# Get the covariance function computed at the vertex tau
covmodel(tau)
# %%
# Graph of the spectral function
x = ot.Sample(N, 2)
#! /usr/bin/env python
import openturns as ot
ref_values = [[1.0, 0.0], [0.0, 0.5]]
mats = [ot.Matrix(ref_values),
ot.SquareMatrix(ref_values),
ot.TriangularMatrix(ref_values),
ot.SymmetricMatrix(ref_values),
ot.CovarianceMatrix(ref_values),
ot.CorrelationMatrix(ref_values)]
mats.extend([
ot.ComplexMatrix(ref_values),
ot.HermitianMatrix(ref_values),
ot.TriangularComplexMatrix(ref_values),
ot.SquareComplexMatrix(ref_values)])
for a in mats:
# try conversion
ref = ot.Matrix([[1.0, 0.0], [0.0, 0.5]])
iname = a.__class__.__name__
print('a=', a)
# try scalar mul
try:
s = 5.
ats = a * s
print('a*s=', ats)
sta = s * a
def test_model(myModel, test_partial_grad=True, x1=None, x2=None):
inputDimension = myModel.getInputDimension()
dimension = myModel.getOutputDimension()
if x1 is None and x2 is None:
x1 = ot.Point(inputDimension)
x2 = ot.Point(inputDimension)
for j in range(inputDimension):
x1[j] = -1.0 - j
x2[j] = 3.0 + 2.0 * j
else:
x1 = ot.Point(x1)
x2 = ot.Point(x2)
if myModel.isStationary():
ott.assert_almost_equal(myModel(x1 - x2), myModel(x1, x2), 1e-14,
1e-14)
ott.assert_almost_equal(myModel(x2 - x1), myModel(x1, x2), 1e-14,
1e-14)
eps = 1e-3
mesh = ot.IntervalMesher([9] * inputDimension).build(
ot.Interval([-10] * inputDimension, [10] * inputDimension))
C = myModel.discretize(mesh)
if dimension == 1:
# Check that discretize & computeAsScalar provide the
# same values
vertices = mesh.getVertices()
for j in range(len(vertices)):
for i in range(j, len(vertices)):
ott.assert_almost_equal(
C[i, j], myModel.computeAsScalar(vertices[i], vertices[j]),
1e-14, 1e-14)
else:
# Check that discretize & operator() provide the
# same values
vertices = mesh.getVertices()
localMatrix = ot.SquareMatrix(dimension)
for j in range(len(vertices)):
for i in range(j, len(vertices)):
for localJ in range(dimension):
for localI in range(dimension):
localMatrix[localI, localJ] = C[i * dimension + localI,
j * dimension + localJ]
ott.assert_almost_equal(localMatrix,
myModel(vertices[i], vertices[j]),
1e-14, 1e-14)
if test_partial_grad:
grad = myModel.partialGradient(x1, x2)
if (dimension == 1):
gradfd = ot.Matrix(inputDimension, 1)
for j in range(inputDimension):
x1_g = ot.Point(x1)
x1_d = ot.Point(x1)
x1_g[j] = x1_d[j] + eps
x1_d[j] = x1_d[j] - eps
gradfd[j, 0] = (myModel.computeAsScalar(x1_g, x2) -
myModel.computeAsScalar(x1_d, x2)) / (2 * eps)
else:
gradfd = ot.Matrix(inputDimension, dimension * dimension)
covarianceX1X2 = myModel(x1, x2)
centralValue = ot.Point(covarianceX1X2.getImplementation())
# Loop over the shifted points
for i in range(inputDimension):
currentPoint = ot.Point(x1)
currentPoint[i] += eps
localCovariance = myModel(currentPoint, x2)
currentValue = ot.Point(localCovariance.getImplementation())
for j in range(currentValue.getSize()):
gradfd[i, j] = (currentValue[j] - centralValue[j]) / eps
ott.assert_almost_equal(grad, gradfd, 1e-5, 1e-5,
"in " + myModel.getClassName() + " grad")
def C(tau):
return 1.0 / (1.0 + tau * tau)
t0 = 0.0
t1 = 20.0
N = 40
dt = (t1 - t0) / (N - 1)
myMesh = ot.RegularGrid(t0, dt, N)
myCovarianceCollection = ot.SquareMatrixCollection()
for k in range(N):
t = myMesh.getValue(k)
matrix = ot.SquareMatrix(1)
matrix[0, 0] = C(t)
myCovarianceCollection.add(matrix)
covarianceModel = ot.UserDefinedStationaryCovarianceModel(
myMesh, myCovarianceCollection)
def f(tau):
return [covarianceModel(tau)[0, 0]]
func = ot.PythonFunction(1, 1, f)
func.setDescription(['$t$', '$cov$'])
cov_graph = func.draw(0.0, 20.0, 512)
cov_graph.setTitle('User defined stationary covariance model')
q = 1 dim = 2 # Make a realization of an ARMA model # Tmin , Tmax and N points for TimeGrid dt = 1.0 size = 400 timeGrid = ot.RegularGrid(0.0, dt, size) # white noise cov = ot.CovarianceMatrix([[0.1, 0.0], [0.0, 0.2]]) whiteNoise = ot.WhiteNoise(ot.Normal([0.0] * dim, cov), timeGrid) # AR/MA coefficients ar = ot.ARMACoefficients(p, dim) ar[0] = ot.SquareMatrix([[-0.5, -0.1], [-0.4, -0.5]]) ar[1] = ot.SquareMatrix([[0.0, 0.0], [-0.25, 0.0]]) ma = ot.ARMACoefficients(q, dim) ma[0] = ot.SquareMatrix([[-0.4, 0.0], [0.0, -0.4]]) # ARMA model creation myARMA = ot.ARMA(ar, ma, whiteNoise) # Create a realization timeSeries = ot.TimeSeries(myARMA.getRealization()) cov[0, 0] += 0.01 * ot.DistFunc.rNormal() cov[1, 1] += 0.01 * ot.DistFunc.rNormal() alpha = ot.SquareMatrix(dim)
simplicies = [[]] * 6
simplicies[0] = [0, 1, 2, 4]
simplicies[1] = [3, 5, 6, 7]
simplicies[2] = [1, 2, 3, 6]
simplicies[3] = [1, 2, 4, 6]
simplicies[4] = [1, 3, 5, 6]
simplicies[5] = [1, 4, 5, 6]
mesh3D = ot.Mesh(vertices, simplicies)
tree = ot.KDTree(vertices)
print("3D mesh=", mesh3D)
print("volume=", "%.3f" % mesh3D.getVolume())
print("simplices volume=", mesh3D.computeSimplicesVolume())
point = [1.8] * 3
print("Nearest index(", point, ")=", tree.query(point))
points = [[-0.25] * 3, [2.25] * 3]
print("Nearest index(", points, ")=", tree.query(points))
print("P1 gram=\n", mesh3D.computeP1Gram())
rotation = ot.SquareMatrix(3)
rotation[0, 0] = m.cos(m.pi / 3.0)
rotation[0, 1] = m.sin(m.pi / 3.0)
rotation[1, 0] = -m.sin(m.pi / 3.0)
rotation[1, 1] = m.cos(m.pi / 3.0)
rotation[2, 2] = 1.0
# isregular bug
time_grid = ot.RegularGrid(0.0, 0.2, 40963)
mesh = ot.Mesh(time_grid)
print(mesh.isRegular())
print('Distribution Parameters ', distParam)
non_native = distParam.getValues()
desc = distParam.getDescription()
print('non-native=', non_native, desc)
native = distParam.evaluate()
print('native=', native)
non_native = distParam.inverse(native)
print('non-native=', non_native)
print('built dist=', distParam.getDistribution())
# derivative of the native parameters with regards the parameters of the
# distribution
print(distParam.gradient())
# by the finite difference technique
eps = 1e-5
dim = len(non_native)
nativeParamGrad = ot.SquareMatrix(ot.IdentityMatrix(dim))
for i in range(dim):
for j in range(dim):
xp = list(non_native)
xp[i] += eps
xm = list(non_native)
xm[i] -= eps
nativeParamGrad[i, j] = 0.5 * \
(distParam(xp)[j] - distParam(xm)[j]) / eps
print(nativeParamGrad)
import openturns as ot
from matplotlib import pyplot as plt
from openturns.viewer import View
if ot.SpectralGaussianProcess().__class__.__name__ == 'Process':
# default to Gaussian for the interface class
process = ot.GaussianProcess()
elif ot.SpectralGaussianProcess().__class__.__name__ == 'DiscreteMarkovChain':
process = ot.SpectralGaussianProcess()
process.setTransitionMatrix(
ot.SquareMatrix([[0.0, 0.5, 0.5], [0.7, 0.0, 0.3], [0.8, 0.0, 0.2]]))
origin = 0
process.setOrigin(origin)
else:
process = ot.SpectralGaussianProcess()
process.setTimeGrid(ot.RegularGrid(0.0, 0.02, 50))
process.setDescription(['$x$'])
sample = process.getSample(6)
sample_graph = sample.drawMarginal(0)
sample_graph.setTitle(str(process))
fig = plt.figure(figsize=(10, 4))
sample_axis = fig.add_subplot(111)
View(sample_graph, figure=fig, axes=[sample_axis], add_legend=False)
# Operator +|-
summation = ot.Sample(sample1 + sample2)
subtraction = ot.Sample(sample2 - sample1)
print('sample1 + sample2=', repr(summation))
print('sample2 - sample1=', repr(subtraction))
# Operator +=|-=
sample3 = ot.Sample(sample2)
sample4 = ot.Sample(sample2)
sample3 += sample1
sample4 -= sample1
print('sample3=', repr(sample3))
print('sample4=', repr(sample4))
sample5 = ot.Sample(sample2)
m = ot.SquareMatrix([[1, 2], [3, 5]])
v = ot.Point(2, 3.0)
t = ot.Point(2, 5.0)
print('sample5 =', sample5)
print('sample*2:', sample5 * 2.)
print('2*sample:', 2.0 * sample5)
print('sample/2:', sample5 / 2.)
print('sample*v:', sample5 * v)
print('sample/v:', sample5 / v)
# in-place
sample5 += t
print('sample+=t:', sample5)
sampleCollection[continuousDistributionNumber +
i] = discreteSampleCollection[i]
factoryCollection = ot.DistributionFactoryCollection(3)
factoryCollection[0] = ot.UniformFactory()
factoryCollection[1] = ot.BetaFactory()
factoryCollection[2] = ot.NormalFactory()
aSample = ot.Uniform(-1.5, 2.5).getSample(size)
model, best_bic = ot.FittingTest.BestModelBIC(aSample, factoryCollection)
print("best model BIC=", repr(model))
model, best_result = ot.FittingTest.BestModelKolmogorov(
aSample, factoryCollection)
print("best model Kolmogorov=", repr(model))
# BIC adequation
resultBIC = ot.SquareMatrix(distributionNumber)
for i in range(distributionNumber):
for j in range(distributionNumber):
value = ot.FittingTest.BIC(sampleCollection[i],
distributionCollection[j], 0)
resultBIC[i, j] = value
print("resultBIC=", repr(resultBIC))
# Kolmogorov test : case with estimated parameters
print("Kolmogorov test : case with estimated parameters")
distribution = ot.Normal()
sample = distribution.getSample(30)
factory = ot.NormalFactory()
ot.ResourceMap.SetAsUnsignedInteger('FittingTest-KolmogorovSamplingSize',
10000)
fitted_dist, test_result = ot.FittingTest.Kolmogorov(sample, factory)
graph.setGrid(True)
cloud = ot.Cloud(points)
cloud.setColor(color)
cloud.setPointStyle("dot")
graph.add(cloud)
return graph, s
# %%
# **Definition of some IFS**
# %%
# Spiral
rho1 = 0.9
theta1 = 137.5 * m.pi / 180.0
f1 = [[0.0]*2, ot.SquareMatrix(2, [rho1 * m.cos(theta1), -rho1 * m.sin(theta1), \
rho1 * m.sin(theta1), rho1 * m.cos(theta1)])]
rho2 = 0.15
f2 = [[1.0, 0.0], rho2 * ot.IdentityMatrix(2)]
f_i = [f1, f2]
graph, s = drawIFS(f_i, skip = 100, iterations = 100000, batch_size = 1, name="Spiral", color="blue")
print("Box counting dimension=%.3f" % s)
view = viewer.View(graph)
# %%
# Fern
f1 = [[0.0]*2, ot.SquareMatrix(2, [0.0, 0.0, 0.0, 0.16])]
f2 = [[0.0, 1.6], ot.SquareMatrix(2, [0.85, 0.04, -0.04, 0.85])]
f3 = [[0.0, 1.6], ot.SquareMatrix(2, [0.2, -0.26, 0.23, 0.22])]
f4 = [[0.0, 0.44], ot.SquareMatrix(2, [-0.15, 0.28, 0.26, 0.24])]
f_i = [f1, f2, f3, f4]
def test_model(myModel, test_partial_grad=True, x1=None, x2=None):
inputDimension = myModel.getInputDimension()
dimension = myModel.getOutputDimension()
if x1 is None and x2 is None:
x1 = ot.Point(inputDimension)
x2 = ot.Point(inputDimension)
for j in range(inputDimension):
x1[j] = -1.0 - j
x2[j] = 3.0 + 2.0 * j
else:
x1 = ot.Point(x1)
x2 = ot.Point(x2)
if myModel.isStationary():
ott.assert_almost_equal(myModel(x1 - x2), myModel(x1, x2), 1e-14,
1e-14)
ott.assert_almost_equal(myModel(x2 - x1), myModel(x1, x2), 1e-14,
1e-14)
eps = 1e-3
mesh = ot.IntervalMesher([7] * inputDimension).build(
ot.Interval([-10] * inputDimension, [10] * inputDimension))
C = myModel.discretize(mesh)
if dimension == 1:
# Check that discretize & computeAsScalar provide the
# same values
vertices = mesh.getVertices()
for j in range(len(vertices)):
for i in range(j, len(vertices)):
ott.assert_almost_equal(
C[i, j], myModel.computeAsScalar(vertices[i], vertices[j]),
1e-14, 1e-14)
else:
# Check that discretize & operator() provide the same values
vertices = mesh.getVertices()
localMatrix = ot.SquareMatrix(dimension)
for j in range(len(vertices)):
for i in range(j, len(vertices)):
for localJ in range(dimension):
for localI in range(dimension):
localMatrix[localI, localJ] = C[i * dimension + localI,
j * dimension + localJ]
ott.assert_almost_equal(localMatrix,
myModel(vertices[i], vertices[j]),
1e-14, 1e-14)
# Now we suppose that discretize is ok
# we look at crossCovariance of (vertices, vertices) which should return the same values
C.getImplementation().symmetrize()
crossCov = myModel.computeCrossCovariance(vertices, vertices)
ott.assert_almost_equal(
crossCov, C, 1e-14, 1e-14,
"in " + myModel.getClassName() + "::computeCrossCovariance")
# Now crossCovariance(sample, sample) is ok
# Let us validate crossCovariance(Sample, point) with 1st column(s) of previous calculations
crossCovSamplePoint = myModel.computeCrossCovariance(vertices, vertices[0])
crossCovCol = crossCov.reshape(crossCov.getNbRows(), dimension)
ott.assert_almost_equal(
crossCovSamplePoint, crossCovCol, 1e-14, 1e-14,
"in " + myModel.getClassName() + "::computeCrossCovarianceSamplePoint")
if test_partial_grad:
grad = myModel.partialGradient(x1, x2)
if (dimension == 1):
gradfd = ot.Matrix(inputDimension, 1)
for j in range(inputDimension):
x1_g = ot.Point(x1)
x1_d = ot.Point(x1)
x1_g[j] = x1_d[j] + eps
x1_d[j] = x1_d[j] - eps
gradfd[j, 0] = (myModel.computeAsScalar(x1_g, x2) -
myModel.computeAsScalar(x1_d, x2)) / (2 * eps)
else:
gradfd = ot.Matrix(inputDimension, dimension * dimension)
covarianceX1X2 = myModel(x1, x2)
centralValue = ot.Point(covarianceX1X2.getImplementation())
# Loop over the shifted points
for i in range(inputDimension):
currentPoint = ot.Point(x1)
currentPoint[i] += eps
localCovariance = myModel(currentPoint, x2)
currentValue = ot.Point(localCovariance.getImplementation())
for j in range(currentValue.getSize()):
gradfd[i, j] = (currentValue[j] - centralValue[j]) / eps
ott.assert_almost_equal(grad, gradfd, 1e-5, 1e-5,
"in " + myModel.getClassName() + " grad")
["X1", "X2", "X3"], ["sin(X1) + 5.0 * (sin(X2))^2 + 0.1 * X3^4 * sin(X1)"])
# Output
Y = modelIshigami(X)
# Using the same covariance model for each marginal
Cov1 = ot.SquaredExponential(1)
# Output covariance model
Cov2 = ot.SquaredExponential(1)
# Set output covariance scale
Cov2.setScale(Y.computeStandardDeviation())
# This is the GSA-type estimator: weight is 1.
W = ot.SquareMatrix(size)
for i in range(size):
W[i, i] = 1.0
# Using a biased estimator
estimatorTypeV = ot.HSICVStat()
# Loop over marginals
hsicIndexRef = [0.02331323, 0.00205350, 0.00791711]
for i in range(3):
test = X.getMarginal(i)
# Set input covariance scale
Cov1.setScale(test.computeStandardDeviation())
hsicIndex = estimatorTypeV.computeHSICIndex(test, Y, Cov1, Cov2, W)
ott.assert_almost_equal(hsicIndex, hsicIndexRef[i])
def run(self):
"""
Launch the algorithm and build the POD models.
Notes
-----
This method launches the iterative algorithm. First the censored data
are filtered if needed. The Box Cox transformation is performed if it is
enabled. Then the enrichment of the design of experiments is performed.
Once the algorithm stops, it builds the POD models : conditional samples are
simulated for each defect size, then the distributions of the probability
estimator (for MC simulation) are built. Eventually, a sample of this
distribution is used to compute the mean POD and the POD at the confidence
level.
"""
# Create an initial uniform distribution if not given
if self._distribution is None:
inputMin = self._input.getMin()
inputMin[0] = np.min(self._defectSizes)
inputMax = self._input.getMax()
inputMax[0] = np.max(self._defectSizes)
marginals = [ot.Uniform(inputMin[i], inputMax[i]) for i in range(self._dim)]
self._distribution = ot.ComposedDistribution(marginals)
# Create the design of experiments of the candidate points where the
# criterion is computed
if self._distribution.hasIndependentCopula():
# without copula use low discrepancy experiment as first doe
doeCandidate = ot.LowDiscrepancyExperiment(ot.SobolSequence(),
self._distribution, self._candidateSize).generate()
else:
# else simple Monte Carlo distribution
doeCandidate = self._distribution.getSample(self._candidateSize)
# build initial kriging model
# build the kriging model without optimization
algoKriging, transformation = self._buildKrigingAlgo(self._input, self._signals)
if self._verbose:
print('Building the kriging model')
print('Optimization of the covariance model parameters...')
llDim = algoKriging.getReducedLogLikelihoodFunction().getInputDimension()
lowerBound = [0.001] * llDim
upperBound = [50] * llDim
algoKriging = self._estimKrigingTheta(algoKriging,
lowerBound, upperBound,
self._initialStartSize)
algoKriging.run()
# Get kriging results
self._krigingResult = algoKriging.getResult()
self._covarianceModel = self._krigingResult.getCovarianceModel()
self._basis = self._krigingResult.getBasisCollection()
metamodel = ot.ComposedFunction(self._krigingResult.getMetaModel(), transformation)
self._Q2 = self._computeQ2(self._input, self._signals, self._krigingResult, transformation)
if self._verbose:
print('Kriging validation Q2 (>0.9): {:0.4f}\n'.format(self._Q2))
plt.ion()
# Start the improvment loop
iteration = 0
while iteration < self._nIteration:
iteration += 1
if self._verbose:
print('Iteration : {}/{}'.format(iteration, self._nIteration))
# compute POD (ptrue = pn-1) for bias reducing in the criterion
# Monte Carlo for all defect sizes in a vectorized way.
# get Sample for all parameters except the defect size
samplePred = self._distribution.getSample(self._samplingSize)[:,1:]
fullSamplePred = ot.Sample(self._samplingSize * self._defectNumber,
self._dim)
# Add the defect sizes as first value
for i, defect in enumerate(self._defectSizes):
fullSamplePred[self._samplingSize*i:self._samplingSize*(i+1), :] = \
self._mergeDefectInX(defect, samplePred)
meanPredictionSample = metamodel(fullSamplePred)
meanPredictionSample = np.reshape(meanPredictionSample, (self._samplingSize,
self._defectNumber), 'F')
# compute the POD for all defect sizes
currentPOD = np.mean(meanPredictionSample > self._detectionBoxCox, axis=0)
# Compute criterion for all candidate in the candidate doe
criterion = 1000000000
for icand, candidate in enumerate(doeCandidate):
# add the current candidate to the kriging doe
inputAugmented = self._input[:]
inputAugmented.add(candidate)
signalsAugmented = self._signals[:]
# predict the signal value of the candidate using the current
# kriging model
signalsAugmented.add(metamodel(candidate))
# create a temporary kriging model with the new doe and without
# updating the covariance model parameters
# normalization
mean = inputAugmented.computeMean()
try:
stddev = inputAugmented.computeStandardDeviation()
except AttributeError:
stddev = inputAugmented.computeStandardDeviationPerComponent()
linear = ot.SquareMatrix(self._dim)
for j in range(self._dim):
linear[j, j] = 1.0 / stddev[j] if abs(stddev[j]) > 1e-12 else 1.0
zero = [0.0] * self._dim
transformation = ot.LinearFunction(mean, zero, linear)
algoKrigingTemp = ot.KrigingAlgorithm(transformation(inputAugmented), signalsAugmented,
self._covarianceModel,
self._basis)
optimizer = algoKrigingTemp.getOptimizationAlgorithm()
optimizer.setMaximumIterationNumber(0)
algoKrigingTemp.setOptimizationAlgorithm(optimizer)
algoKrigingTemp.run()
krigingResultTemp = algoKrigingTemp.getResult()
# compute the criterion for all defect size
crit = []
# save results, used to compute the PODModel et PODCLModel
PODPerDefect = ot.Sample(self._simulationSize *
self._samplingSize, self._defectNumber)
for idef, defect in enumerate(self._defectSizes):
podSample = self._computePODSamplePerDefect(defect,
self._detectionBoxCox, krigingResultTemp, transformation,
self._distribution, self._simulationSize, self._samplingSize)
PODPerDefect[:, idef] = podSample
meanPOD = podSample.computeMean()[0]
varPOD = podSample.computeVariance()[0]
crit.append(varPOD + (meanPOD - currentPOD[idef])**2)
# compute the criterion aggregated for all defect sizes
newCriterion = np.sqrt(np.mean(crit))
# check if the result is better or not
if newCriterion < criterion:
self._PODPerDefect = PODPerDefect
criterion = newCriterion
indexOpt = icand
if self._verbose:
updateProgress(icand, int(doeCandidate.getSize()), 'Computing criterion')
# get the best candidate
candidateOpt = doeCandidate[indexOpt]
# add new point to DOE
self._input.add(candidateOpt)
# add the signal computed by the physical model
if self._boxCox:
self._signals.add(self._boxCoxTransform(self._physicalModel(candidateOpt) + [self._shift]))
else:
self._signals.add(self._physicalModel(candidateOpt))
# remove added candidate from the doeCandidate
doeCandidate.erase(indexOpt)
if self._verbose:
print('Criterion value : {:0.4f}'.format(criterion))
print('Added point : {}'.format(candidateOpt))
print('Update the kriging model')
# update the kriging model without optimization
algoKriging, transformation = self._buildKrigingAlgo(self._input, self._signals)
algoKriging.setOptimizeParameters(False)
algoKriging.run()
self._Q2 = self._computeQ2(self._input, self._signals, algoKriging.getResult(), transformation)
# Check the quality of the kriging model if it needs optimization
if self._Q2 < 0.95:
if self._verbose:
print('Optimization of the covariance model parameters...')
algoKriging.setOptimizeParameters(True)
algoKriging = self._estimKrigingTheta(algoKriging,
lowerBound, upperBound,
self._initialStartSize)
algoKriging.run()
# Get kriging results
self._krigingResult = algoKriging.getResult()
self._covarianceModel = self._krigingResult.getCovarianceModel()
self._basis = self._krigingResult.getBasisCollection()
self._Q2 = self._computeQ2(self._input, self._signals, self._krigingResult, transformation)
if self._verbose:
print('Kriging validation Q2 (>0.9): {:0.4f}'.format(self._Q2))
if self._graph:
# create the interpolate function of the POD model
meanPOD = self._PODPerDefect.computeMean()
interpModel = interp1d(self._defectSizes, np.array(meanPOD), kind='linear')
self._PODmodel = ot.PythonFunction(1, 1, interpModel)
# The POD at confidence level is built in getPODCLModel() directly
fig, ax = self.drawPOD(self._probabilityLevel, self._confidenceLevel)
plt.draw()
plt.pause(0.001)
plt.show()
if self._graphDirectory is not None:
if not os.path.exists(self._graphDirectory):
os.makedirs(self._graphDirectory)
fig.savefig(os.path.join(self._graphDirectory, 'AdaptiveSignalPOD_')+str(iteration),
bbox_inches='tight', transparent=True)
# Compute the final POD with the last updated kriging model
if self._verbose:
print('\nStart computing the POD with the last updated kriging model')
# compute the sample containing the POD values for all defect
self._PODPerDefect = ot.Sample(self._simulationSize *
self._samplingSize, self._defectNumber)
for i, defect in enumerate(self._defectSizes):
self._PODPerDefect[:, i] = self._computePODSamplePerDefect(defect,
self._detectionBoxCox, self._krigingResult, transformation,
self._distribution, self._simulationSize, self._samplingSize)
if self._verbose:
updateProgress(i, self._defectNumber, 'Computing POD per defect')
# compute the mean POD
meanPOD = self._PODPerDefect.computeMean()
# create the interpolate function of the POD model
interpModel = interp1d(self._defectSizes, np.array(meanPOD), kind='linear')
self._PODmodel = ot.PythonFunction(1, 1, interpModel)
# The POD at confidence level is built in getPODCLModel() directly
# remove the interactive plotting
plt.ioff()
