def optimizeLambda(self, marginal, deltaRHS): """ Compute the lambda values Parameters ---------- marginal : int The indice of the perturbed marginal. deltaRHS : sequence of float of dim 2 The values of the mean and variance + mean^2 """ # define the optimization function which the Lagrange function # and using the gradient and the hessian optimFunc = ot.PythonFunction(2, 1, lambda lamb: [self.H(marginal, lamb, deltaRHS)], gradient=lambda lamb: self.gradH(marginal, lamb, deltaRHS), hessian=lambda lamb: self.hessianH(marginal, lamb)) # define the optimization problem optimPb = ot.OptimizationProblem(optimFunc, ot.NumericalMathFunction(), ot.NumericalMathFunction(), ot.Interval()) # solve the problem using SLSQP from NLopt optim = ot.NLopt(optimPb, 'LD_SLSQP') optim.setStartingPoint([0, 0]) optim.run() # return the lambda values, solution of the problem return optim.getResult().getOptimalPoint()
# %% # Solving the problem with NLopt # ------------------------------ # # We see that the `Cobyla` algorithm required lots of function evaluations. This is why we now use the `NLopt` class with the LBFGS algorithm. However, the algorithm may use input points which are far away from the input domain we used so far. This is why we had bounds to the problem, so that the algorithm never goes to far away from the valley. # %% bounds = ot.Interval(lowerbound, upperbound) # %% problem = ot.OptimizationProblem(rosenbrock) problem.setBounds(bounds) # %% algo = ot.NLopt(problem, 'LD_LBFGS') algo.setStartingPoint(x0) algo.run() # %% result = algo.getResult() # %% xoptim = result.getOptimalPoint() xoptim # %% delta = xexact - xoptim absoluteError = delta.norm() absoluteError
# Calibration of default optimizer ot.ResourceMap.SetAsScalar( 'GeneralLinearModelAlgorithm-DefaultOptimizationLowerBound', 1.0e-5) ot.ResourceMap.SetAsScalar( 'GeneralLinearModelAlgorithm-DefaultOptimizationUpperBound', 100) # Data & estimation inputDimension = 1 X = ot.Normal().getSample(100) X = X.sortAccordingToAComponent(0) covarianceModel = ot.SquaredExponential([1.0], [1.0]) model = ot.SymbolicFunction(["x"], ["x - 0.6 * cos(x/3)"]) Y = model(X) basis = ot.QuadraticBasisFactory(inputDimension).build() algo = ot.GeneralLinearModelAlgorithm(X, Y, covarianceModel, basis, True) algo.setOptimizationAlgorithm(ot.NLopt('LN_NELDERMEAD')) algo.run() # perform an evaluation result = algo.getResult() metaModel = result.getMetaModel() conditionalCovariance = result.getCovarianceModel() residual = metaModel(X) - Y ott.assert_almost_equal(residual.computeCenteredMoment(2), [1.06e-05], 1e-5, 1e-5) ott.assert_almost_equal(conditionalCovariance.getParameter(), [0.619144, 0.000937], 5e-3, 1e-3) likelihood = algo.getObjectiveFunction() assert likelihood.getInputDimension() == 1, "likelihood dim" print("ok")
startingPoint = [0.0] * dim bounds = ot.Interval([-3.] * dim, [5.] * dim) algoNames = ot.NLopt.GetAlgorithmNames() for algoName in algoNames: # STOGO might not be enabled # NEWUOA nan/-nan # COBYLA crashes on squeeze # ESCH not same results with 2.4.1 if 'STOGO' in algoName or 'NEWUOA' in algoName or 'COBYLA' in algoName or 'ESCH' in algoName: print('-- Skipped: algo=', algoName) continue algo = ot.NLopt(algoName) for minimization in [True, False]: for inequality in [True, False]: for equality in [True, False]: problem = ot.OptimizationProblem( linear, ot.NumericalMathFunction(), ot.NumericalMathFunction(), bounds) problem.setMinimization(minimization) if inequality: # x3 <= x1 problem.setInequalityConstraint(ot.NumericalMathFunction( ['x1', 'x2', 'x3', 'x4'], ['ineq'], ['x1-x3'])) if equality: # x4 = 2 problem.setEqualityConstraint(ot.NumericalMathFunction( ['x1', 'x2', 'x3', 'x4'], ['eq'], ['x4-2']))
for algoName in algoNames: # STOGO/AGS might not be enabled if 'STOGO' in algoName or 'AGS' in algoName: continue # NEWUOA nan/-nan # COBYLA crashes on squeeze # ESCH not same results with 2.4.1 # AUGLAG_EQ raises a roundoff-limited exception on i386 # LD_SLSQP/LD_CCSAQ not same point on i386 if 'NEWUOA' in algoName or 'COBYLA' in algoName or 'ESCH' in algoName or 'AUGLAG_EQ' in algoName or 'LD_SLSQP' in algoName or 'LD_CCSAQ' in algoName: print('-- Skipped: algo=', algoName) continue algo = ot.NLopt(algoName) for minimization in [True, False]: for inequality in [True, False]: for equality in [True, False]: for bound in [True, False]: if not bound and 'LN_BOBYQA' in algoName: continue print('algo=', algoName, 'minimization=', minimization, 'bounds=', bound, 'inequality=', inequality, 'equality=', equality) problem = ot.OptimizationProblem(f) problem.setMinimization(minimization) if inequality:
ot.ResourceMap.SetAsNumericalScalar( 'GeneralizedLinearModelAlgorithm-DefaultOptimizationLowerBound', 1.0e-5) ot.ResourceMap.SetAsNumericalScalar( 'GeneralizedLinearModelAlgorithm-DefaultOptimizationUpperBound', 100) # Data & estimation spatialDimension = 1 X = ot.Normal().getSample(100) X = X.sortAccordingToAComponent(0) covarianceModel = ot.SquaredExponential([1.0], [1.0]) model = ot.NumericalMathFunction(["x"], ["x - 0.6 * cos(x/3)"]) Y = model(X) basis = ot.QuadraticBasisFactory(spatialDimension).build() algo = ot.GeneralizedLinearModelAlgorithm(X, Y, covarianceModel, basis, True) algo.setOptimizationSolver(ot.NLopt('LN_NELDERMEAD')) algo.run() # perform an evaluation result = algo.getResult() metaModel = result.getMetaModel() conditionalCovariance = result.getCovarianceModel() residual = metaModel(X) - Y assert_almost_equal(residual.computeCenteredMoment(2), [1.06e-05], 1e-5, 1e-5) assert_almost_equal(conditionalCovariance.getParameter(), [0.702138, 0.00137], 5e-3, 1e-3) print("Test Ok") except: import sys
print('OK') except: print('no') # check that hmat library was found print('7: HMatrix (hmat-oss)'.ljust(width), end=' ') if ot.HMatrixFactory.IsAvailable(): print('OK') else: print('no') # check that nlopt library was found print('8: optimization (NLopt)'.ljust(width), end=' ') try: problem = ot.OptimizationProblem() algo = ot.NLopt('LD_SLSQP') algo.setProblem(problem) print('OK') except: print('no') # check that TBB library was found print('9: multithreading (TBB)'.ljust(width), end=' ') if ot.TBB.IsAvailable(): print('OK') else: print('no') except: import os import traceback
['x1', 'x2'], ['(x1 - 0.5)^2 + x2^2 - 4.0', '(x1 + 0.5)^2 + x2^2 - 4.0']) # This is the perturbation function noise = ot.SymbolicFunction(['x1', 'x2', 'xi1', 'xi2'], ['x1 + xi1', 'x2 + xi2']) # This is capital J: J(x,xi) = calJ(x+xi), the parametric objective function JFull = ot.ComposedFunction(calJ, noise) J = ot.ParametricFunction(JFull, [2, 3], [0.0] * 2) # This is g, the parametric constraints gFull = ot.ComposedFunction(calG, noise) g = ot.ParametricFunction(gFull, [2, 3], [0.0] * 2) bounds = ot.Interval([-3.0] * 2, [3.0] * 2) solver = ot.NLopt('LD_SLSQP') solver.setMaximumIterationNumber(100) for sigma_xi in [0.1, 0.2, 0.3, 0.4, 0.5]: thetaDist = ot.Normal([0.0] * 2, [sigma_xi] * 2, ot.IdentityMatrix(2)) robustnessMeasure = otrobopt.MeanMeasure(J, thetaDist) reliabilityMeasure = otrobopt.JointChanceMeasure(g, thetaDist, ot.Less(), 0.9) problem = otrobopt.RobustOptimizationProblem(robustnessMeasure, reliabilityMeasure) problem.setBounds(bounds) algo = otrobopt.SequentialMonteCarloRobustAlgorithm(problem, solver) algo.setMaximumIterationNumber(11) algo.setMaximumAbsoluteError(1e-6)
printCovarianceParameterChange(covarianceModel, notUpdatedCovarianceModel) # %% # We see that the parameters did not change *at all*: disabling the optimization allows one to keep a constant covariance model. In a practical algorithm, we may, for example, add a block of 10 new points before updating the parameters of the covariance model. At this point, we may reuse the previous covariance model so that the optimization starts from a better point, compared to the parameters default values. This will reduce the cost of the optimization. # %% # Configure the local optimization solver # --------------------------------------- # %% # The following example shows how to set the local optimization solver. # We choose the SLSQP algorithm from NLOPT. # %% problem = solver.getProblem() local_solver = ot.NLopt(problem, "LD_SLSQP") covarianceModel = ot.SquaredExponential([1.0] * dimension, [1.0]) covarianceModel.setScale(maximum_scale_bounds) # Trick A algo = ot.KrigingAlgorithm(X_train, Y_train, covarianceModel, basis) algo.setOptimizationBounds(scaleOptimizationBounds) # Trick B algo.setOptimizationAlgorithm(local_solver) algo.run() # %% finetune_covariance_model = result.getCovarianceModel() print(finetune_covariance_model) # %% printCovarianceParameterChange(finetune_covariance_model, basic_covariance_model)