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
# Create the problem and set the optimization algorithm # ----------------------------------------------------- # %% problem = ot.OptimizationProblem(rastrigin) # %% # We use the :class:`~openturns.Cobyla` algorithm and run it from multiple starting points selected by a :class:`~openturns.LowDiscrepancyExperiment`. # %% size = 64 distribution = ot.ComposedDistribution( [ot.Uniform(lowerbound[0], upperbound[0])] * dim) experiment = ot.LowDiscrepancyExperiment( ot.SobolSequence(), distribution, size) solver = ot.MultiStart(ot.Cobyla(problem), experiment.generate()) # %% # Visualize the starting points of the optimization algorithm # ----------------------------------------------------------- # %% startingPoints = solver.getStartingSample() graph = rastrigin.draw(lowerbound, upperbound, [100]*dim) graph.setTitle("Rastrigin function") cloud = ot.Cloud(startingPoints) cloud.setPointStyle("bullet") cloud.setColor("black") graph.add(cloud) graph.setLegends([""]) # sphinx_gallery_thumbnail_number = 2
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) algo.run() print("result (Global)=", algo.getResult().getParameterMAP())
# 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()
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() upper_bound = bounds.getUpperBound() dist_collection = [] for i in range(dim): dist_collection.append(ot.Uniform(lower_bound[i], upper_bound[i])) distribution = ot.ComposedDistribution(dist_collection) size = 20 experiment = ot.LHSExperiment(distribution, size) startingSample = experiment.generate() algo = ot.MultiStart(solver, startingSample) algo.setMaximumEvaluationNumber(2000) algo.run() result = algo.getResult() true_optimal_point = [0.228279, -1.62553] true_optimal_value = [-6.55113] ott.assert_almost_equal(result.getOptimalPoint(), true_optimal_point, 1e-5, 0.0) ott.assert_almost_equal(result.getOptimalValue(), true_optimal_value, 1e-5, 0.0) n_local_results = algo.getResultCollection().getSize() assert n_local_results == 13, "n_local_results is wrong" algo.setKeepResults(False) algo.run() n_local_results_nokeep = algo.getResultCollection().getSize() assert n_local_results_nokeep == 0, "n_local_results_nokeep is wrong"
# %% # We can check that the minimum and maximum in the sample correspond to the bounds of the design of experiment. # %% lbounds, ubounds # %% starting_points.getMin(), starting_points.getMax() # %% # Then we create a `MultiStart` algorithm based on the LHS starting points. # %% solver.setMaximumIterationNumber(10000) multiStartSolver = ot.MultiStart(solver, starting_points) # %% # Finally, we configure the optimization algorithm so as to use the `MultiStart` algorithm. # %% algo = ot.KrigingAlgorithm(X_train, Y_train, covarianceModel, basis) algo.setOptimizationAlgorithm(multiStartSolver) algo.run() # %% finetune_covariance_model = result.getCovarianceModel() finetune_covariance_model # %% printCovarianceParameterChange(finetune_covariance_model,basic_covariance_model)
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()
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() print('-- local search x*=', result.getOptimalPoint(), 'f(x*)=', result.getOptimalValue()) # multistart distribution = ot.Normal([0.0] * dim, [2.0] * dim, ot.CorrelationMatrix(dim)) size = 20 experiment = ot.LHSExperiment(distribution, size) startingPoints = experiment.generate() algo = ot.MultiStart(solver, startingPoints) algo.setMaximumEvaluationNumber(2000) algo.run() result = algo.getResult() print('-- multistart x*=', result.getOptimalPoint(), 'f(x*)=', result.getOptimalValue()) print('n_local_results=', len(algo.getResultCollection())) algo.setKeepResults(False) algo.run() print('n_local_results (no keep)=', len(algo.getResultCollection()))
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.setOptimizationAlgorithm(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())