surrogateopt - Surrogate optimization for global minimization of time-consuming objective

        functions - MATLAB ([original](https://in.mathworks.com/help/gads/surrogateopt.html)) ([raw](?raw))

Surrogate optimization for global minimization of time-consuming objective functions

Syntax

Description

surrogateopt is a global solver for time-consuming objective functions.

surrogateopt attempts to solve problems of the form

The solver searches for the global minimum of a real-valued objective function in multiple dimensions, subject to bounds, optional linear constraints, optional integer constraints, and optional nonlinear inequality constraints.surrogateopt is best suited to objective functions that take a long time to evaluate. The objective function can be nonsmooth. The solver requires finite bounds on all variables. The solver can optionally maintain a checkpoint file to enable recovery from crashes or partial execution, or optimization continuation after meeting a stopping condition. The objective function_f_(x) can be empty ([]), in which case surrogateopt attempts to find a point satisfying all the constraints.

[x](#mw%5Feedaab90-3a2f-4dad-bc9a-f1945f16e2ab) = surrogateopt([objconstr](#mw%5F61b86098-d547-4563-afb7-af5c91912fd6),[lb](#mw%5Fdbf50a47-efee-476b-86c5-0d2c0d0e27b3),[ub](#mw%5F5048c1ef-7a27-436e-a0e4-18608813187f)) searches for a global minimum of objconstr(x) in the regionlb <= x <= ub. If objconstr(x) returns a structure, then surrogateopt searches for a minimum of objconstr(x).Fval, subject toobjconstr(x).Ineq <= 0.

example

[x](#mw%5Feedaab90-3a2f-4dad-bc9a-f1945f16e2ab) = surrogateopt([objconstr](#mw%5F61b86098-d547-4563-afb7-af5c91912fd6),[lb](#mw%5Fdbf50a47-efee-476b-86c5-0d2c0d0e27b3),[ub](#mw%5F5048c1ef-7a27-436e-a0e4-18608813187f),[intcon](#mw%5F27e51e6e-15cf-408c-aecc-06d507185d40)) requires that the variables listed in intcon take integer values.

example

[x](#mw%5Feedaab90-3a2f-4dad-bc9a-f1945f16e2ab) = surrogateopt([objconstr](#mw%5F61b86098-d547-4563-afb7-af5c91912fd6),[lb](#mw%5Fdbf50a47-efee-476b-86c5-0d2c0d0e27b3),[ub](#mw%5F5048c1ef-7a27-436e-a0e4-18608813187f),[intcon](#mw%5F27e51e6e-15cf-408c-aecc-06d507185d40),[A](#d126e72756),[b](#mw%5F9bfd5d1d-859b-4c72-b98a-43c8cdffa088%5Fsep%5Fbuxdit7-b),[Aeq](#d126e72915),[beq](#mw%5F9bfd5d1d-859b-4c72-b98a-43c8cdffa088%5Fsep%5Fbuxdit7-beq)) requires that the solution x satisfy the inequalitiesA*x <= b and the equalities Aeq*x = beq. If no inequalities exist, set A = [] andb = []. Similarly, if no equalities exist, setAeq = [] and beq = [].

example

[x](#mw%5Feedaab90-3a2f-4dad-bc9a-f1945f16e2ab) = surrogateopt(___,[options](#mw%5Ffa3519af-f062-41df-af65-c65ea7a54eb6)) modifies the search procedure using the options in options. Specify options following any input argument combination in the previous syntaxes.

example

[x](#mw%5Feedaab90-3a2f-4dad-bc9a-f1945f16e2ab) = surrogateopt([problem](#mw%5F02738a3c-d151-4c26-a11c-f28fc45334a0)) searches for a minimum for problem, a structure described inproblem.

example

[x](#mw%5Feedaab90-3a2f-4dad-bc9a-f1945f16e2ab) = surrogateopt([checkpointFile](#mw%5F18ead528-cf4a-40a3-bc8a-8c026f2c93b8),[opts](#mw%5F5a1bdfbf-632e-485a-a9a7-2f58f8d2febb)) continues running the optimization from the state in a saved checkpoint file, and replaces options in checkpointFile with those inopts. See Checkpoint File.

example

[[x](#mw%5Feedaab90-3a2f-4dad-bc9a-f1945f16e2ab),[fval](#mw%5F9bdf44db-8ff0-4cdb-a58a-0a298cb479be)] = surrogateopt(___) also returns the best (smallest) value of the objective function found by the solver, using any of the input argument combinations in the previous syntaxes.

example

[[x](#mw%5Feedaab90-3a2f-4dad-bc9a-f1945f16e2ab),[fval](#mw%5F9bdf44db-8ff0-4cdb-a58a-0a298cb479be),[exitflag](#mw%5Fbda07112-0768-4281-806e-5aef112e870c),[output](#mw%5Ffaa18963-4146-488f-b88b-cacc98b213cd)] = surrogateopt(___) also returns exitflag, an integer describing the reason the solver stopped, and output, a structure describing the optimization procedure.

example

[[x](#mw%5Feedaab90-3a2f-4dad-bc9a-f1945f16e2ab),[fval](#mw%5F9bdf44db-8ff0-4cdb-a58a-0a298cb479be),[exitflag](#mw%5Fbda07112-0768-4281-806e-5aef112e870c),[output](#mw%5Ffaa18963-4146-488f-b88b-cacc98b213cd),[trials](#mw%5Fa0e6c0e6-9ae3-48c8-9dd2-47063b473dc7)] = surrogateopt(___) also returns a structure containing all of the evaluated points and the objective function values at those points.

example

Examples

collapse all

Search for a minimum of the six-hump camel back function in the region -2.1 <= x(i) <= 2.1. This function has two global minima with the objective function value -1.0316284... and four local minima with higher objective function values.

rng default % For reproducibility objconstr = @(x)(4x(:,1).^2 - 2.1x(:,1).^4 + x(:,1).^6/3 ... + x(:,1).x(:,2) - 4x(:,2).^2 + 4*x(:,2).^4); lb = [-2.1,-2.1]; ub = -lb; x = surrogateopt(objconstr,lb,ub)

surrogateopt stopped because it exceeded the function evaluation limit set by 'options.MaxFunctionEvaluations'.

Find the minimum of Rosenbrock's function

100(x(2)-x(1)2)2+(1-x(1))2

subject to the nonlinear constraint that the solution lies in a disk of radius 1/3 around the point [1/3,1/3]:

(x(1)-1/3)2+(x(2)-1/3)2≤(1/3)2.

To do so, write a function objconstr(x) that returns the value of Rosenbrock's function in a structure field Fval, and returns the nonlinear constraint value in the form c(x)≤0 in the structure field Ineq.

function f = objconstr(x) f.Fval = 100*(x(2) - x(1)^2)^2 + (1 - x(1))^2; f.Ineq = (x(1)-1/3)^2 + (x(2)-1/3)^2 - (1/3)^2;

Call surrogateopt using lower bounds of 0 and upper bounds of 2/3 on each component.

lb = [0,0]; ub = [2/3,2/3]; [x,fval,exitflag] = surrogateopt(@objconstr,lb,ub)

surrogateopt stopped because it exceeded the function evaluation limit set by 'options.MaxFunctionEvaluations'.

Check the value of the nonlinear constraint at the solution.

The constraint function value is near zero, indicating that the constraint is active at the solution.

Find the minimum of the ps_example function for a two-dimensional variable x whose first component is restricted to integer values, and all components are between –5 and 5.

intcon = 1; rng default % For reproducibility objconstr = @ps_example; lb = [-5,-5]; ub = [5,5]; x = surrogateopt(objconstr,lb,ub,intcon)

surrogateopt stopped because it exceeded the function evaluation limit set by 'options.MaxFunctionEvaluations'.

Minimize the six-hump camel back function in the region -2.1 <= x(i) <= 2.1. This function has two global minima with the objective function value -1.0316284... and four local minima with higher objective function values.

To search the region systematically, use a regular grid of starting points. Set 120 as the maximum number of function evaluations. Use the 'surrogateoptplot' plot function. To understand the 'surrogateoptplot' plot, see Interpret surrogateoptplot.

rng default % For reproducibility objconstr = @(x)(4x(:,1).^2 - 2.1x(:,1).^4 + x(:,1).^6/3 ... + x(:,1).x(:,2) - 4x(:,2).^2 + 4*x(:,2).^4); lb = [-2.1,-2.1]; ub = -lb; [Xpts,Ypts] = meshgrid(-3:3); startpts = [Xpts(:),Ypts(:)]; options = optimoptions('surrogateopt','PlotFcn','surrogateoptplot',... 'InitialPoints',startpts,'MaxFunctionEvaluations',120); x = surrogateopt(objconstr,lb,ub,options)

surrogateopt stopped because it exceeded the function evaluation limit set by 'options.MaxFunctionEvaluations'.

Minimize a nonlinear objective function subject to linear inequality constraints. Minimize for 200 function evaluations.

objconstr = @multirosenbrock; nvar = 6; lb = -2*ones(nvar,1); ub = -lb; intcon = []; A = ones(1,nvar); b = 3; Aeq = []; beq = []; options = optimoptions('surrogateopt','MaxFunctionEvaluations',200); [sol,fval,exitflag,output] = ... surrogateopt(objconstr,lb,ub,intcon,A,b,Aeq,beq,options)

surrogateopt stopped because it exceeded the function evaluation limit set by 'options.MaxFunctionEvaluations'.

sol = 1×6

0.2072    0.0437    0.1360    0.0066    0.1196   -0.0002

output = struct with fields: elapsedtime: 30.3115 funccount: 200 constrviolation: 0 ineq: [1×0 double] rngstate: [1×1 struct] message: 'surrogateopt stopped because it exceeded the function evaluation limit set by ↵'options.MaxFunctionEvaluations'.'

Create a problem structure representing the six-hump camel back function in the region -2.1 <= x(i) <= 2.1. Set 120 as the maximum number of function evaluations.

rng default % For reproducibility objconstr = @(x)(4x(:,1).^2 - 2.1x(:,1).^4 + x(:,1).^6/3 ... + x(:,1).x(:,2) - 4x(:,2).^2 + 4*x(:,2).^4); options = optimoptions('surrogateopt','MaxFunctionEvaluations',120); problem = struct('objective',objconstr,... 'lb',[-2.1,-2.1],... 'ub',[2.1,2.1],... 'options',options,... 'solver','surrogateopt'); x = surrogateopt(problem)

surrogateopt stopped because it exceeded the function evaluation limit set by 'options.MaxFunctionEvaluations'.

Minimize the six-hump camel back function and return both the minimizing point and the objective function value. Set options to suppress all other display.

rng default % For reproducibility objconstr = @(x)(4x(:,1).^2 - 2.1x(:,1).^4 + x(:,1).^6/3 ... + x(:,1).x(:,2) - 4x(:,2).^2 + 4*x(:,2).^4); lb = [-2.1,-2.1]; ub = -lb; options = optimoptions('surrogateopt','Display','off','PlotFcn',[]); [x,fval] = surrogateopt(objconstr,lb,ub,options)

Monitor the surrogate optimization process by requesting that surrogateopt return more outputs. Use the 'surrogateoptplot' plot function. To understand the 'surrogateoptplot' plot, see Interpret surrogateoptplot.

rng default % For reproducibility objconstr = @(x)(4x(:,1).^2 - 2.1x(:,1).^4 + x(:,1).^6/3 ... + x(:,1).x(:,2) - 4x(:,2).^2 + 4*x(:,2).^4); lb = [-2.1,-2.1]; ub = -lb; options = optimoptions('surrogateopt','PlotFcn','surrogateoptplot'); [x,fval,exitflag,output] = surrogateopt(objconstr,lb,ub,options)

surrogateopt stopped because it exceeded the function evaluation limit set by 'options.MaxFunctionEvaluations'.

output = struct with fields: elapsedtime: 13.2674 funccount: 200 constrviolation: 0 ineq: [1×0 double] rngstate: [1×1 struct] message: 'surrogateopt stopped because it exceeded the function evaluation limit set by ↵'options.MaxFunctionEvaluations'.'

Conclude a surrogate optimization quickly by setting a small maximum number of function evaluations. To prepare for the possibility of restarting the optimization, request all solver outputs.

rng default % For reproducibility objconstr = @(x)(4x(:,1).^2 - 2.1x(:,1).^4 + x(:,1).^6/3 ... + x(:,1).x(:,2) - 4x(:,2).^2 + 4*x(:,2).^4); lb = [-2.1,-2.1]; ub = -lb; options = optimoptions('surrogateopt','MaxFunctionEvaluations',20); [x,fval,exitflag,output,trials] = surrogateopt(objconstr,lb,ub,options);

surrogateopt stopped because it exceeded the function evaluation limit set by 'options.MaxFunctionEvaluations'.

Optimize for another 20 function evaluations, starting from the previously evaluated points.

options.InitialPoints = trials; [x,fval,exitflag,output,trials] = surrogateopt(objconstr,lb,ub,options);

surrogateopt stopped because it exceeded the function evaluation limit set by 'options.MaxFunctionEvaluations'.

By comparing the plots of these 40 function evaluations to those in Search for Global Minimum, you see that restarting surrogate optimization is not the same as having the solver run continuously.

To enable restarting surrogate optimization due to a crash or any other reason, set a checkpoint file name.

opts = optimoptions('surrogateopt','CheckpointFile','checkfile.mat');

Create an optimization problem and set a small number of function evaluations.

rng default % For reproducibility objconstr = @(x)(4x(:,1).^2 - 2.1x(:,1).^4 + x(:,1).^6/3 ... + x(:,1).x(:,2) - 4x(:,2).^2 + 4*x(:,2).^4); lb = [-2.1,-2.1]; ub = -lb; opts.MaxFunctionEvaluations = 30; [x,fval,exitflag,output] = surrogateopt(objconstr,lb,ub,opts)

Surrogateopt stopped because it exceeded the function evaluation limit set by 'options.MaxFunctionEvaluations'.

output = struct with fields: elapsedtime: 28.7221 funccount: 30 constrviolation: 0 ineq: [1×0 double] rngstate: [1×1 struct] message: 'Surrogateopt stopped because it exceeded the function evaluation limit set by ↵'options.MaxFunctionEvaluations'.'

Set options to use 100 function evaluations (which means 70 more than already done) and restart the optimization.

opts.MaxFunctionEvaluations = 100; [x2,fval2,exitflag2,output2] = surrogateopt('checkfile.mat',opts)

Surrogateopt stopped because it exceeded the function evaluation limit set by 'options.MaxFunctionEvaluations'.

output2 = struct with fields: elapsedtime: 159.2411 funccount: 100 constrviolation: 0 ineq: [1×0 double] rngstate: [1×1 struct] message: 'Surrogateopt stopped because it exceeded the function evaluation limit set by ↵'options.MaxFunctionEvaluations'.'

Input Arguments

collapse all

Objective function and nonlinear constraint, specified as a function handle or function name. objconstr accepts a single argument x, where x is typically a row vector. However, when the Vectorized option istrue, x is a matrix containingoptions.BatchUpdateInterval rows; each row represents one point to evaluate. objconstr returns one of the following:

• Real scalar fval = objconstr(x).
• Structure. If the structure contains the fieldFval, then surrogateopt attempts to minimize objconstr(x).Fval. If the structure contains the field Ineq, thensurrogateopt attempts to make all components of that field nonpositive: objconstr(x).Ineq <= 0 for all entries. objconstr(x) must include either the Fval orIneq fields, or both.surrogateopt ignores other fields. If you have no constraint, do not set anobjconstr(x).Ineq field, or setobjconstr(x).Ineq to [], not NaN.

When the Vectorized option is true and the BatchUpdateInterval is greater than one,objconstr operates on each row ofx and returns one of the following:

• Real vector fval = objconstr(x).fval is a column vector withoptions.BatchUpdateInterval entries (or fewer for the last function evaluation whenBatchUpdateInterval does not evenly divideMaxFunctionEvaluations).
• Structure with vector entries. If the structure contains the fieldFval, then surrogateopt attempts to minimize objconstr(x).Fval, andobjconstr(x).Fval is a vector of lengthBatchUpdateInterval (or less). If the structure contains the field Ineq, thensurrogateopt attempts to make all components of that field nonpositive: objconstr(x).Ineq <= 0 for all entries, andobjconstr(x).Ineq contains up toBatchUpdateInterval entries.

The objective function objconstr.Fval can be empty ([]), in which case surrogateopt attempts to find a point satisfying all the constraints. See Solve Feasibility Problem.

For examples using a nonlinear constraint, see Solve Problem with Nonlinear Constraints, Surrogate Optimization with Nonlinear Constraint, and Solve Feasibility Problem. For information on converting between the surrogateopt structure syntax and other solvers, see packfcn and Convert Nonlinear Constraints Between surrogateopt Form and Other Solver Forms For an example using vectorized batch evaluations, see Optimize Simulink Model in Parallel.

Data Types: function_handle | char | string

Lower bounds, specified as a finite real vector. lb represents the lower bounds element-wise inlb ≤x≤ ub. The lengths of lb and ub must be equal to the number of variables that objconstr accepts.

Caution

Although lb is optional for most solvers,lb is a required input forsurrogateopt.

Note

surrogateopt allows equal entries in lb andub. For each i in intcon, you must have ceil(lb(i)) <= floor(ub(i)). See Construct Surrogate Details.

Example: lb = [0;-20;4] means x(1) ≥ 0, x(2) ≥ -20, x(3) ≥ 4.

Data Types: double

Upper bounds, specified as a finite real vector. ub represents the upper bounds element-wise inlb ≤x≤ ub. The lengths of lb and ub must be equal to the number of variables that objconstr accepts.

Caution

Although ub is optional for most solvers,ub is a required input forsurrogateopt.

Note

surrogateopt allows equal entries in lb andub. For each i in intcon, you must have ceil(lb(i)) <= floor(ub(i)). See Construct Surrogate Details.

Example: ub = [10;-20;4] means x(1) ≤ 10, x(2) ≤ -20, x(3) ≤ 4.

Data Types: double

Integer variables, specified as a vector of positive integers with values from 1 to the number of problem variables. Each value inintcon represents an x component that is integer-valued.

Example: To specify that the even entries in x are integer-valued, set intcon to2:2:nvars.

Data Types: double

Linear inequality constraints, specified as a real matrix. A is an M-by-nvars matrix, where M is the number of inequalities.

A encodes the M linear inequalities

A*x <= b,

where x is the column vector of nvars variables x(:), and b is a column vector with M elements.

For example, to specify

_x_1 + 2_x_2 ≤ 10
3_x_1 + 4_x_2 ≤ 20
5_x_1 + 6_x_2 ≤ 30,

give these constraints:

A = [1,2;3,4;5,6]; b = [10;20;30];

Example: To specify that the control variables sum to 1 or less, give the constraintsA = ones(1,N) and b = 1.

Data Types: double

Linear inequality constraints, specified as a real vector. b is an M-element vector related to the A matrix. If you pass b as a row vector, solvers internally convert b to the column vector b(:).

b encodes the M linear inequalities

A*x <= b,

where x is the column vector of N variables x(:), and A is a matrix of size M-by-N.

For example, to specify

_x_1 + 2_x_2 ≤ 10
3_x_1 + 4_x_2 ≤ 20
5_x_1 + 6_x_2 ≤ 30,

give these constraints:

A = [1,2;3,4;5,6]; b = [10;20;30];

Example: To specify that the control variables sum to 1 or less, give the constraintsA = ones(1,N) and b = 1.

Data Types: double

Linear equality constraints, specified as a real matrix. Aeq is an Me-by-nvars matrix, where Me is the number of equalities.

Aeq encodes the Me linear equalities

Aeq*x = beq,

where x is the column vector of N variables x(:), and beq is a column vector with Me elements.

For example, to specify

_x_1 + 2_x_2 + 3_x_3 = 10
2_x_1 + 4_x_2 +_x_3 = 20,

give these constraints:

Aeq = [1,2,3;2,4,1]; beq = [10;20];

Example: To specify that the control variables sum to 1, give the constraints Aeq = ones(1,N) and beq = 1.

Data Types: double

Linear equality constraints, specified as a real vector. beq is an Me-element vector related to the Aeq matrix. If you pass beq as a row vector, solvers internally convert beq to the column vector beq(:).

beq encodes the Me linear equalities

Aeq*x = beq,

where x is the column vector of N variables x(:), and Aeq is a matrix of size Meq-by-N.

For example, to specify

_x_1 + 2_x_2 + 3_x_3 = 10
2_x_1 + 4_x_2 +_x_3 = 20,

give these constraints:

Aeq = [1,2,3;2,4,1]; beq = [10;20];

Example: To specify that the control variables sum to 1, give the constraints Aeq = ones(1,N) and beq = 1.

Data Types: double

Options, specified as the output ofoptimoptions.

For more information, see Surrogate Optimization Options.

Example: options = optimoptions('surrogateopt','Display','iter','UseParallel',true)

Problem structure, specified as a structure with these fields:

• objective — Objective function, which can include nonlinear constraints, specified as a function name or function handle
• lb — Lower bounds forx
• ub — Upper bounds forx
• solver —'surrogateopt'
• Aineq — Matrix for linear inequality constraints (optional)
• bineq — Vector for linear inequality constraints (optional)
• Aeq — Matrix for linear equality constraints (optional)
• beq — Vector for linear equality constraints (optional)
• options — Options created with optimoptions
• rngstate — Field to reset the state of the random number generator (optional)
• intcon — Field specifying integer-valuedx components (optional)

Note

These problem fields are required:objective, lb,ub, solver, andoptions.

Data Types: struct

Path to a checkpoint file, specified as a string or character vector. A checkpoint file has the .mat extension. If you specify a file name without a path, surrogateopt uses a checkpoint file in the current folder.

A checkpoint file stores the state of an optimization for resuming the optimization. surrogateopt updates the checkpoint file at each function evaluation, so you can resume the optimization even whensurrogateopt halts prematurely. For an example, seeRestart Surrogate Optimization from Checkpoint File.

surrogateopt creates a checkpoint file when it has a valid CheckpointFile option.

You can change some options when resuming from a checkpoint file. Seeopts.

The data in a checkpoint file is in .mat format. To avoid errors or other unexpected results, do not modify the data before calling surrogateopt.

Warning

Do not resume surrogateopt from a checkpoint file created with a different MATLAB® version. surrogateopt can throw an error or give inconsistent results.

Example: 'checkfile.mat'

Example: "C:\Program Files\MATLAB\docs\checkpointNov2019.mat"

Data Types: char | string

Options for resuming optimization from the checkpoint file, specified asoptimoptions options (from a restricted set) that you can change from the original options. The options you can change are:

• BatchUpdateInterval
• CheckpointFile
• Display
• MaxFunctionEvaluations
• MaxTime
• MinSurrogatePoints
• ObjectiveLimit
• OutputFcn
• PlotFcn
• UseParallel
• UseVectorized

Example: opts = optimoptions(options,'MaxFunctionEvaluations',400);

Output Arguments

collapse all

Solution, returned as a real vector. x has the same length as lb and ub.

Objective function value at the solution, returned as a real number.

• When objconstr returns a scalar,fval is the scalarobjconstr(x).
• When objconstr returns a structure,fval is the valueobjconstr(x).Fval, the objective function value at x (if this value exists).

Reason surrogateopt stopped, returned as one of the integer values described in this table.

Information about the optimization process, returned as a structure with these fields:

• funccount — Total number of function evaluations.
• elapsedtime — Time spent running the solver in seconds, as measured by tic/toc.
• message — Reason why the algorithm stopped.
• constrviolation — Maximum nonlinear constraint violation, if any. constrviolation = max(output.ineq).
• ineq — Nonlinear inequality constraint value at the solution x. Ifobjconstr returns a structure, thenineq = objconstr(x).Ineq. Otherwise, ineq is empty.
• rngstate — State of the MATLAB random number generator just before the algorithm starts. Use this field to reproduce your results. See Reproduce Results, which discusses using rngstate forga.

Points evaluated, returned as a structure with these fields:

• X — Matrix with nvars columns, where nvars is the length oflb or ub. Each row ofX represents one point evaluated bysurrogateopt.
• Fval — Column vector, where each entry is the objective function value of the corresponding row ofX.
• Ineq — Matrix with each row representing the constraint function values of the corresponding row ofX.

The trials structure has the same form as theoptions.InitialPoints structure. So, you can continue an optimization by passing the trials structure as theInitialPoints option.

Algorithms

surrogateopt repeatedly performs these steps:

1. Create a set of trial points by sampling MinSurrogatePoints random points within the bounds, and evaluate the objective function at the trial points.
2. Create a surrogate model of the objective function by interpolating a radial basis function through all of the random trial points.
3. Create a merit function that gives some weight to the surrogate and some weight to the distance from the trial points. Locate a small value of the merit function by randomly sampling the merit function in a region around the incumbent point (best point found since the last surrogate reset). Use this point, called the adaptive point, as a new trial point.
4. Evaluate the objective at the adaptive point, and update the surrogate based on this point and its value. Count a "success" if the objective function value is sufficiently lower than the previous best (lowest) value observed, and count a "failure" otherwise.
5. Update the dispersion of the sample distribution upwards if three successes occur before max(nvar,5) failures, wherenvar is the number of dimensions. Update the dispersion downwards if max(nvar,5) failures occur before three successes.
6. Continue from step 3 until all trial points are withinMinSampleDistance of the evaluated points. At that time, reset the surrogate by discarding all adaptive points from the surrogate, reset the scale, and go back to step 1 to create MinSurrogatePoints new random trial points for evaluation.

For details, see Surrogate Optimization Algorithm.

Alternative Functionality

App

The Optimize Live Editor task provides a visual interface for surrogateopt.

Extended Capabilities

Version History

Introduced in R2018b

expand all

surrogateopt has updated internal routines that increase its efficiency, especially for integer-constrained problems. Also, for problems with fast objective and nonlinear constraint functions, checkpointing is more efficient than before: surrogateopt writes checkpoint files no more than once in 10 seconds. For details, see Surrogate Optimization Algorithm and Checkpoint File.