def _estimKrigingTheta(self, algoKriging, lowerBound, upperBound, size):
"""
Estimate the kriging theta values with an initial random search using
a Sobol sequence of size samples.
"""
if size > 0:
# create uniform distribution of the parameters bounds
dim = len(lowerBound)
distBoundCol = []
for i in range(dim):
distBoundCol += [ot.Uniform(lowerBound[i], upperBound[i])]
distBound = ot.ComposedDistribution(distBoundCol)
# set the bounds
searchInterval = ot.Interval(lowerBound, upperBound)
algoKriging.setOptimizationBounds(searchInterval)
# Generate starting points with a low discrepancy sequence
startingPoint = ot.LowDiscrepancyExperiment(
ot.SobolSequence(), distBound, size).generate()
algoKriging.setOptimizationAlgorithm(
ot.MultiStart(ot.TNC(), startingPoint))
else:
algoKriging.setOptimizeParameters(False)
return algoKriging
def build(self, dataX, dataY):
logLikelihood = ot.NumericalMathFunction(ReducedLogLikelihood(dataX, dataY))
xlb = np.linspace(self.lambdaMin_,self.lambdaMax_,num=500)
lambdax = [logLikelihood([x])[0] for x in xlb]
algo = ot.TNC(logLikelihood)
algo.setStartingPoint([xlb[np.array(lambdax).argmax()]])
algo.setBoundConstraints(ot.Interval(self.lambdaMin_, self.lambdaMax_))
algo.setOptimizationProblem(ot.BoundConstrainedAlgorithmImplementationResult.MAXIMIZATION)
algo.run()
optimalLambda = algo.getResult().getOptimizer()[0]
# graph
optimalLogLikelihood = algo.getResult().getOptimalValue()
graph = logLikelihood.draw(0.01 * optimalLambda, 10.0 * optimalLambda)
c = ot.Cloud([[optimalLambda, optimalLogLikelihood]])
c.setColor("red")
c.setPointStyle("circle")
graph.add(c)
return ot.BoxCoxTransform([optimalLambda]), graph
globalErrorCovariance = ot.CovarianceMatrix(2 * m)
for i in range(2 * m):
globalErrorCovariance[i, i] = 2.0 + (1.0 + i) * (1.0 + i)
for j in range(i):
globalErrorCovariance[i, j] = 1.0 / (1.0 + i + j)
bootstrapSizes = [0, 100]
for bootstrapSize in bootstrapSizes:
algo = ot.GaussianNonLinearCalibration(modelX, x, y, candidate,
priorCovariance, errorCovariance)
algo.setBootstrapSize(bootstrapSize)
algo.run()
# To avoid discrepance between the plaforms with or without CMinpack
print("result (Auto)=", algo.getResult().getParameterMAP())
algo.setOptimizationAlgorithm(
ot.MultiStart(
ot.TNC(),
ot.LowDiscrepancyExperiment(
ot.SobolSequence(),
ot.Normal(
candidate,
ot.CovarianceMatrix(ot.Point(candidate).getDimension())),
ot.ResourceMap.GetAsUnsignedInteger(
"GaussianNonLinearCalibration-MultiStartSize")).generate())
)
algo.run()
# To avoid discrepance between the plaforms with or without CMinpack
print("result (TNC)=", algo.getResult().getParameterMAP())
algo = ot.GaussianNonLinearCalibration(modelX, x, y, candidate,
priorCovariance,
globalErrorCovariance)
algo.setBootstrapSize(bootstrapSize)
# 2. covariance model
cov = ot.MaternModel([1.], [2.5], 1.5)
print(cov)
# 3. kriging algorithm
algokriging = ot.KrigingAlgorithm(x, y, cov, basis)
## error measure
#algokriging.setNoise([5*1e-1]*n_pt)
# 4. Optimization
# algokriging.setOptimizationAlgorithm(ot.NLopt('GN_DIRECT'))
lhsExperiment = ot.LHSExperiment(ot.Uniform(1e-1, 1e2), 50)
algokriging.setOptimizationAlgorithm(
ot.MultiStart(ot.TNC(), lhsExperiment.generate()))
algokriging.setOptimizationBounds(ot.Interval([0.1], [1e2]))
# if we choose not to optimize parameters
#algokriging.setOptimizeParameters(False)
# 5. run the algorithm
algokriging.run()
# %%
# Results
# -------
# %%
# get some results
krigingResult = algokriging.getResult()
def _estimKrigingTheta(self, algoKriging, lowerBound, upperBound, size):
"""
Estimate the kriging theta values with an initial random search using
a Sobol sequence of size samples.
"""
# get input parameters of the kriging algorithm
X = algoKriging.getInputSample()
Y = algoKriging.getOutputSample()
algoKriging.run()
krigingResult = algoKriging.getResult()
covarianceModel = krigingResult.getCovarianceModel()
basis = krigingResult.getBasisCollection()
if LooseVersion(ot.__version__) == '1.9':
llf = algoKriging.getReducedLogLikelihoodFunction()
else:
llf = algoKriging.getLogLikelihoodFunction()
# create uniform distribution of the parameters bounds
dim = len(lowerBound)
distBoundCol = []
for i in range(dim):
distBoundCol += [ot.Uniform(lowerBound[i], upperBound[i])]
distBound = ot.ComposedDistribution(distBoundCol)
if size > 0:
# Generate starting points with a low discrepancy sequence
thetaStart = ot.LowDiscrepancyExperiment(ot.SobolSequence(),
distBound,
size).generate()
# Get the best theta from the maximum llf value
llfValue = llf(thetaStart)
indexMax = int(np.argmax(llfValue))
bestTheta = thetaStart[indexMax]
# update theta after random search
if LooseVersion(ot.__version__) == '1.6':
covarianceModel.setScale(bestTheta)
elif LooseVersion(ot.__version__) > '1.6':
# optimize theta and sigma in ot 1.8
covarianceModel.setScale(bestTheta[:-1])
covarianceModel.setAmplitude([bestTheta[-1]])
# Now the KrigingAlgorithm is used to optimize the likelihood using a
# good starting point
if LooseVersion(ot.__version__) == "1.9":
algoKriging = ot.KrigingAlgorithm(X, Y, covarianceModel, basis)
else:
algoKriging = ot.KrigingAlgorithm(X, Y, basis, covarianceModel,
True)
# set TNC optim
searchInterval = ot.Interval(lowerBound, upperBound)
if LooseVersion(ot.__version__) == '1.6':
optimizer = ot.TNC()
optimizer.setBoundConstraints(searchInterval)
algoKriging.setOptimizer(optimizer)
elif LooseVersion(ot.__version__) in ['1.7', '1.8']:
optimizer = algoKriging.getOptimizationSolver()
problem = optimizer.getProblem()
problem.setBounds(searchInterval)
optimizer.setProblem(problem)
algoKriging.setOptimizationSolver(optimizer)
elif LooseVersion(ot.__version__) == '1.9':
algoKriging.setOptimizationBounds(searchInterval)
return algoKriging
ot.TESTPREAMBLE()
# ot.Log.Show(ot.Log.ALL)
dim = 2
# problem
model = ot.SymbolicFunction(['x', 'y'], [
'3*(1-x)^2*exp(-x^2-(y+1)^2)-10*(x/5-x^3-y^5)*exp(-x^2-y^2)-exp(-(x+1)^2-y^2)/3'
])
bounds = ot.Interval([-3.0] * dim, [3.0] * dim)
problem = ot.OptimizationProblem(model)
problem.setBounds(bounds)
# solver
solver = ot.TNC(problem)
# run locally
solver.setStartingPoint([0.0] * dim)
algo = solver
algo.run()
result = algo.getResult()
local_optimal_point = [0.296446, 0.320196]
local_optimal_value = [-0.0649359]
ott.assert_almost_equal(result.getOptimalPoint(), local_optimal_point, 1e-5,
0.0)
ott.assert_almost_equal(result.getOptimalValue(), local_optimal_value, 1e-5,
0.0)
# multistart
lower_bound = bounds.getLowerBound()
#! /usr/bin/env python
from __future__ import print_function
import openturns as ot
# linear
levelFunction = ot.NumericalMathFunction(["x1", "x2", "x3", "x4"], ["y1"],
["x1+2*x2-3*x3+4*x4"])
startingPoint = ot.NumericalPoint(4, 0.0)
bounds = ot.Interval(ot.NumericalPoint(4, -3.0), ot.NumericalPoint(4, 5.0))
algo = ot.TNC()
algo.setStartingPoint(startingPoint)
problem = ot.OptimizationProblem()
problem.setBounds(bounds)
problem.setObjective(levelFunction)
problem.setMinimization(True)
algo.setProblem(problem)
print('algo=', algo)
algo.run()
result = algo.getResult()
print('result=', result)
problem.setMinimization(False)
algo.setProblem(problem)
print('algo=', algo)
algo.run()
result = algo.getResult()
print('result=', result)
print(basis)
# 2. covariance model
cov = ot.MaternModel([1.], [2.5], 1.5)
print(cov)
# 3. kriging algorithm
algokriging = ot.KrigingAlgorithm(x, y, cov, basis)
## error measure
#algokriging.setNoise([5*1e-1]*n_pt)
# 4. Optimization
# algokriging.setOptimizationAlgorithm(ot.NLopt('GN_DIRECT'))
startingPoint = ot.LHSExperiment(ot.Uniform(1e-1, 1e2), 50).generate()
algokriging.setOptimizationAlgorithm(ot.MultiStart(ot.TNC(), startingPoint))
algokriging.setOptimizationBounds(ot.Interval([0.1], [1e2]))
# if we choose not to optimize parameters
#algokriging.setOptimizeParameters(False)
# 5. run the algorithm
algokriging.run()
# %%
# Results
# -------
# %%
# get some results
krigingResult = algokriging.getResult()
result = algo.getResult()
# print('1st pass result=', result)
print('iteration=', result.getIterationNumber())
assert result.getIterationNumber(
) > 3 and result.getIterationNumber() < 15, 'Too few/much iterations'
print(result.getInputSample())
print(result.getOutputSample())
# openturns.testing.assert_almost_equal(result.getOptimalPoint(), [0.5, 0.0], 1e-5, 1e-5)
# openturns.testing.assert_almost_equal(result.getOptimalValue(),
# [-0.802223], 1e-5, 1e-5)
# local refinement eventhough the model is noisy (we still want to check
# we're not too far from optimum)
problem.setObjective(model.getMarginal(0))
algo2 = ot.TNC(problem)
# we have to use getFinalPoints as our objective function is 2-d
algo2.setStartingPoint(result.getOptimalPoint())
algo2.run()
result = algo2.getResult()
# print(result)
# openturns.testing.assert_almost_equal(result.getOptimalPoint(), [0.542773, 0.151666], 1e-5, 1e-5)
# openturns.testing.assert_almost_equal(result.getOptimalPoint(),
# [0.123895, 0.818329], 1e-5, 1e-5)
openturns.testing.assert_almost_equal(
result.getOptimalPoint(), [0.961652, 0.165000], 1e-5, 1e-5)
openturns.testing.assert_almost_equal(
result.getOptimalValue(), [-0.979476], 1e-5, 1e-5)
#
import math as m
import sys
ot.TESTPREAMBLE()
ot.PlatformInfo.SetNumericalPrecision(3)
m = 10
x = [[0.5 + i] for i in range(m)]
#ot.ResourceMap.SetAsUnsignedInteger( "OptimizationAlgorithm-DefaultMaximumEvaluationNumber", 100)
inVars = ["a", "b", "c", "x"]
formulas = ["a + b * exp(c * x)", "(a * x^2 + b) / (c + x^2)"]
model = ot.SymbolicFunction(inVars, formulas)
p_ref = [2.8, 1.2, 0.5]
params = [0, 1, 2]
modelX = ot.ParametricFunction(model, params, p_ref)
y = modelX(x)
y += ot.Normal([0.0]*2, [0.05]*2, ot.IdentityMatrix(2)).getSample(m)
candidate = [1.0]*3
bootstrapSizes = [0, 100]
for bootstrapSize in bootstrapSizes:
algo = ot.NonLinearLeastSquaresCalibration(modelX, x, y, candidate)
algo.setBootstrapSize(bootstrapSize)
algo.run()
# To avoid discrepance between the plaforms with or without CMinpack
print("result (Auto)=", algo.getResult().getParameterMAP())
algo.setAlgorithm(ot.MultiStart(ot.TNC(), ot.LowDiscrepancyExperiment(ot.SobolSequence(), ot.Normal(candidate, ot.CovarianceMatrix(ot.Point(candidate).getDimension())), ot.ResourceMap.GetAsUnsignedInteger("NonLinearLeastSquaresCalibration-MultiStartSize")).generate()))
algo.run()
# To avoid discrepance between the plaforms with or without CMinpack
print("result (TNC)=", algo.getResult().getParameterMAP())
# %%
# Create the model
model = ot.SymbolicFunction(['E', 'F', 'L', 'I'], ['F*L^3/(3*E*I)'])
# %%
# Define the problems
minProblem = ot.OptimizationProblem(model)
minProblem.setBounds(bounds)
maxProblem = ot.OptimizationProblem(model)
maxProblem.setBounds(bounds)
maxProblem.setMinimization(False)
# %%
# Create a solver
solver = ot.TNC()
solver.setStartingPoint(distribution.getMean())
# %%
# Solve the problems
solver.setProblem(minProblem)
solver.run()
minResult = solver.getResult()
print('min: y=', minResult.getOptimalValue(), 'with x=',
minResult.getOptimalPoint())
solver.setProblem(maxProblem)
solver.run()
maxResult = solver.getResult()
print('max: y=', maxResult.getOptimalValue(), 'with x=',
maxResult.getOptimalPoint())
lowerBound = ot.NumericalPoint((-1.0, 1.0e-4))
upperBound = ot.NumericalPoint((3.0, 2.0))
finiteLowerBound = ot.BoolCollection((0, 1))
finiteUpperBound = ot.BoolCollection((0, 0))
bounds = ot.Interval(lowerBound, upperBound, finiteLowerBound,
finiteUpperBound)
# Create the starting point of the research
# For mu : the first point
# For sigma : a value evaluated from the two first data
startingPoint = ot.NumericalPoint(2)
startingPoint[0] = sample[0][0]
startingPoint[1] = m.sqrt(
(sample[1][0] - sample[0][0]) * (sample[1][0] - sample[0][0]))
# Create the optimization problem
problem = ot.OptimizationProblem(myLogLikelihoodOT, ot.NumericalMathFunction(),
ot.NumericalMathFunction(), bounds)
problem.setMinimization(False)
# Create the TNC algorithm
myAlgoTNC = ot.TNC(problem)
myAlgoTNC.setStartingPoint(startingPoint)
# Run the algorithm and extract results
myAlgoTNC.run()
resMLE = myAlgoTNC.getResult()
MLEparameters = resMLE.getOptimalPoint()
print("MLE of (mu, sigma) = (", MLEparameters[0], ", ", MLEparameters[1], ")")
# END_TEX
