scipy.optimize._shgo:shgo

Parameters

func : callable

The objective function to be minimized. Must be in the form f(x, *args), where x is the argument in the form of a 1-D array and args is a tuple of any additional fixed parameters needed to completely specify the function.

bounds : sequence or `Bounds`

Bounds for variables. There are two ways to specify the bounds:

• Instance of Bounds class.

• Sequence of (min, max) pairs for each element in x.

args : tuple, optional

Any additional fixed parameters needed to completely specify the objective function.

constraints : {Constraint, dict} or List of {Constraint, dict}, optional

Constraints definition. Only for COBYLA, COBYQA, SLSQP and trust-constr. See the tutorial ^[5] for further details on specifying constraints.

n : int, optional

Number of sampling points used in the construction of the simplicial complex. For the default simplicial sampling method 2**dim + 1 sampling points are generated instead of the default n=100. For all other specified values n sampling points are generated. For sobol, halton and other arbitrary sampling_methods n=100 or another specified number of sampling points are generated.

iters : int, optional

Number of iterations used in the construction of the simplicial complex. Default is 1.

callback : callable, optional

Called after each iteration, as callback(xk), where xk is the current parameter vector.

minimizer_kwargs : dict, optional

Extra keyword arguments to be passed to the minimizer scipy.optimize.minimize. Some important options could be:

method

The minimization method. If not given, chosen to be one of BFGS, L-BFGS-B, SLSQP, depending on whether or not the problem has constraints or bounds.

args

Extra arguments passed to the objective function (func) and its derivatives (Jacobian, Hessian).

options

Note that by default the tolerance is specified as {ftol: 1e-12}

options : dict, optional

A dictionary of solver options. Many of the options specified for the global routine are also passed to the scipy.optimize.minimize routine. The options that are also passed to the local routine are marked with "(L)".

Stopping criteria, the algorithm will terminate if any of the specified criteria are met. However, the default algorithm does not require any to be specified:

maxfev

Maximum number of function evaluations in the feasible domain. (Note only methods that support this option will terminate the routine at precisely exact specified value. Otherwise the criterion will only terminate during a global iteration)

f_min

Specify the minimum objective function value, if it is known.

f_tol

Precision goal for the value of f in the stopping criterion. Note that the global routine will also terminate if a sampling point in the global routine is within this tolerance.

maxiter

Maximum number of iterations to perform.

maxev

Maximum number of sampling evaluations to perform (includes searching in infeasible points).

maxtime

Maximum processing runtime allowed

minhgrd

Minimum homology group rank differential. The homology group of the objective function is calculated (approximately) during every iteration. The rank of this group has a one-to-one correspondence with the number of locally convex subdomains in the objective function (after adequate sampling points each of these subdomains contain a unique global minimum). If the difference in the hgr is 0 between iterations for maxhgrd specified iterations the algorithm will terminate.

Objective function knowledge:

symmetry

Specify if the objective function contains symmetric variables. The search space (and therefore performance) is decreased by up to O(n!) times in the fully symmetric case. If True is specified then all variables will be set symmetric to the first variable. Default is set to False.

E.g. f(x) = (x_1 + x_2 + x_3) + (x_4)**2 + (x_5)**2 + (x_6)**2

In this equation x_2 and x_3 are symmetric to x_1, while x_5 and x_6 are symmetric to x_4, this can be specified to the solver as

symmetry = [0,  # Variable 1
            0,  # symmetric to variable 1
            0,  # symmetric to variable 1
            3,  # Variable 4
            3,  # symmetric to variable 4
            3,  # symmetric to variable 4
            ]

jac

Jacobian (gradient) of objective function. Only for CG, BFGS, Newton-CG, L-BFGS-B, TNC, SLSQP, dogleg, trust-ncg. If jac is a boolean and is True, fun is assumed to return the gradient along with the objective function. If False, the gradient will be estimated numerically. jac can also be a callable returning the gradient of the objective. In this case, it must accept the same arguments as fun. (Passed to scipy.optimize.minimize automatically)

hess,hessp

Hessian (matrix of second-order derivatives) of objective function or Hessian of objective function times an arbitrary vector p. Only for Newton-CG, dogleg, trust-ncg. Only one of hessp or hess needs to be given. If hess is provided, then hessp will be ignored. If neither hess nor hessp is provided, then the Hessian product will be approximated using finite differences on jac. hessp must compute the Hessian times an arbitrary vector. (Passed to scipy.optimize.minimize automatically)

Algorithm settings:

minimize_every_iter

If True then promising global sampling points will be passed to a local minimization routine every iteration. If False then only the final minimizer pool will be run. Defaults to True.

local_iter

Only evaluate a few of the best minimizer pool candidates every iteration. If False all potential points are passed to the local minimization routine.

infty_constraints

If True then any sampling points generated which are outside will the feasible domain will be saved and given an objective function value of inf. If False then these points will be discarded. Using this functionality could lead to higher performance with respect to function evaluations before the global minimum is found, specifying False will use less memory at the cost of a slight decrease in performance. Defaults to True.

Feedback:

disp

Set to True to print convergence messages.

sampling_method : str or function, optional

Current built in sampling method options are halton, sobol and simplicial. The default simplicial provides the theoretical guarantee of convergence to the global minimum in finite time. halton and sobol method are faster in terms of sampling point generation at the cost of the loss of guaranteed convergence. It is more appropriate for most "easier" problems where the convergence is relatively fast. User defined sampling functions must accept two arguments of n sampling points of dimension dim per call and output an array of sampling points with shape n x dim.

workers : int or map-like callable, optional

Sample and run the local serial minimizations in parallel. Supply -1 to use all available CPU cores, or an int to use that many Processes (uses multiprocessing.Pool <multiprocessing>).

Alternatively supply a map-like callable, such as multiprocessing.Pool.map for parallel evaluation. This evaluation is carried out as workers(func, iterable). Requires that func be pickleable.