Stoppers¶
Abstract Base Stopper¶

class
BaseStopper
[source]¶ Base stopper from which all stoppers must inherit to be compatible with GloMPO.
 Attributes
 loggerlogging.Logger
logging.Logger
instance into which status messages may be added.

abstract
__call__
(log, best_opt_id, tested_opt_id)[source]¶ Compares two optimizers and returns if one should be terminated according to some condition. When called, this method may check any values within the logs of both the best and the tested optimizer.
 Parameters
 log
Instance of
BaseLogger
that contains the iteration history of every optimizer. best_opt_id
ID number of the optimizer which has found the lowest function value.
 tested_opt_id
ID number of the optimizer which the Stopper is testing to stop or not.
 Returns
 bool
True
if the condition in the method is met,False
otherwise.
 Notes
For proper functionality, the result of this method must be saved to
last_result
before returning.

__iter__
()¶ Provides a (flattened) iteration through all the bases which comprise the combined stopper/exitcondition

__str__
()¶ Produces a string of the stopper/exit condition’s name and configuration.

property
last_result
¶ The result of the last
__call__()
.

reset
()¶ Clears previous evaluation result to avoid misleading printing. Resets
last_result
toNone
. Given that stoppers and exitconditions are evaluated lazily, it is possible for misleading results to be returned bystr_with_result()
indicating a stopper/exit condition has been evaluated when it has not. Bases are thus reset before__call__()
to prevent this.

str_with_result
()¶ String representation of the object with its result.
Combining Base Stoppers¶
BaseStopper
is based on the same structure as BaseExitCondition
. Thus, simple conditions can also be combined into more sophisticated termination conditions. See Combining Base ExitConditions.
Included Stoppers¶
For convenience, GloMPO comes bundled with several simple stoppers already included.

class
BestFunctionValueUnmoving
(calls, tol=0)[source]¶ Bases:
scm.glompo.stoppers.basestopper.BaseStopper
Considers the lowest function value seen by the optimizer thus far. Returns
True
if the tested optimizer’s best value has not changed significantly in a given amount of time. Parameters
 calls
Number of function evaluations between comparison points.
 tol
Tolerance fraction between 0 and 1.
 Returns
 bool
True
if:abs(latest_f_value  f_value_calls_ago) <= abs(f_value_calls_ago * self.tol)

class
CurrentFunctionValueUnmoving
(calls, tol=0)[source]¶ Bases:
scm.glompo.stoppers.basestopper.BaseStopper
Considers function values the optimizers are currently exploring. Used to terminate an optimizer when its function evaluations are unchanging, usually indicating that it is approaching some convergence. Best used with a stopper which monitors step size to ensure a widely exploring optimizer is not stopped.
 Parameters
 calls
Number of function evaluations between comparison points.
 tol
Tolerance fraction between 0 and 1.
 Returns
 bool
Returns
True
if the standard deviation of the lastcalls
function evaluations is belowtol * abs(latest_f_eval)
.

class
MaxFunctionCalls
(min_pts)[source]¶ Bases:
scm.glompo.stoppers.basestopper.BaseStopper
Keeps an optimizer alive for a minimum number of function evaluations.
 Parameters
 min_pts
Minimum number of points for which an optimizer should be kept alive.
 Returns
 bool
Returns
True
after the function has been evaluated at leastmin_pts
times.

class
MaxInteroptimizerDistance
(bounds, relative_distance, test_all=False)[source]¶ Bases:
scm.glompo.stoppers.basestopper.BaseStopper
Terminates optimizers which are too close in parameter space.
 Parameters
 bounds
Bounds of each parameter.
 relative_distance
Fraction (between 0 and 1) of the maximum distance in the space (from the point at all lower bounds to the point at all upper bounds) below which the optimizers are deemed too close and the tested optimizer will be stopped.
 test_all
If
True
the distance between the tested optimizer and all other optimizers is tested, else only the best and tested optimizers are compared.
 Returns
 bool
Returns
True
if optimizers are calculated to be too close together.
 Notes
Calculates the maximum Euclidean distance in parameter space between the point of lower bounds and the point of upper bounds (
max_distance
). Calculates the Euclidean distance between the final iterations of the best and tested optimizers (inter_optimizer_distance
). ReturnsTrue
if:inter_optimizer_distance <= max_distance * relative_distance
Caution
Use this stopper with care and only in problems where the parameters have been standardised so that every parameter is dimensionless and on the same order of magnitude.

class
MaxSequentialInvalidPoints
(n_iters=1)[source]¶ Bases:
scm.glompo.stoppers.basestopper.BaseStopper
Checks for nonnumerical solutions. Some pathological functions may have undefined regions within them or combinations of parameters which return nonfinite results.
 Parameters
 n_iters
Number of allowed invalid function evaluations.
 Returns
 bool
Returns
True
if the optimizer fails to find a valid function evaluation in the lastn_iters
function evaluations.

class
MinStepSize
(bounds, calls, relative_tol=0.05)[source]¶ Bases:
scm.glompo.stoppers.basestopper.BaseStopper
Monitors distance in parameter space between function evaluations. This stopper will stop an optimizer that is excessively focused on one area of parameter space.
 Parameters
 bounds
Bounds of each parameter.
 calls
Number of function evaluations over which to perform the averaging.
 relative_tol
Fraction (between 0 and 1) of the maximum distance in the space (from the point at all lower bounds to the point at all upper bounds) below which the optimizers are deemed too close and the tested optimizer will be stopped.
 Returns
 bool
True
if the tested optimizer’s average step size over the lastcalls
function evaluations is less than:relative_tol * maximum_parameter_space_distance

class
OptimizerType
(opt_to_stop)[source]¶ Bases:
scm.glompo.stoppers.basestopper.BaseStopper
Stops an optimizer based on its class. Intended for use with other stoppers to allow for specific stopping conditions based on the type of optimizer.
 Parameters
 opt_to_stop
BaseOptimizer
class which is targeted.
 Returns
 bool
True
if the tested optimizer is an instance ofopt_to_stop
.
 Examples
>>> OptimizerType(CMAOptimizer) & StopperA()  OptimizerType(Nevergrad) & StopperB()
In this case
StopperA
will only stopCMAOptimizer
s andStopperB
will only stopscm.glompo.optimizers.nevergrad.Nevergrad
optimizers. This is useful in cases where exploratory optimizers should be stopped quickly but late stage optimizers encouraged to converge and iterate for longer periods.

class
TimeAnnealing
(crit_ratio=1)[source]¶ Bases:
scm.glompo.stoppers.basestopper.BaseStopper
Keeps optimizers alive based on how long they have been alive. Randomly keeps optimizers alive based on how long (in function evaluations) they have been active. The newer an optimizer is, the more likely it will pass the test and be kept alive. Used to temper very strict termination conditions.
 Parameters
 crit_ratio
Critical ratio of function calls between best and tested optimizers above which the tested optimizer is guaranteed to survive. Values lower than one are looser and allow the tested optimizer to survive even if it has been in operation longer than the best optimizer. Values higher than one are stricter and may stop the tested optimizer even if it has iterated fewer times than the best optimizer.
 Returns
 bool
True
if an optimizer has been alive long enough and fails a comparison test with a uniformly randomly generated number.
 Notes
This condition calculates the quotient (
num_bet_fcalls / num_tested_fcalls
). A random number is then generated between zero andcrit_ratio
. Only if the quotient is larger than this number does the tested optimizer remains alive.

class
ValidationWorsening
(calls=1, tol=0)[source]¶ Bases:
scm.glompo.stoppers.basestopper.BaseStopper
Considers loss function values of the validation set. Triggers if the value of the last evaluation of the validation set cost function is worse than the average of the last several calls.
 Parameters
 calls
Number of function evaluations between comparison points. Increase this number to capture longterm increases in the loss value change rather than sudden spurious fluctuations.
 tol
Tolerance fraction applied to the loss values made
calls
prior. The loss value (f) is modified by: f * (1 +tol
). This can also be used to ignore the effects of mild fluctuations.
 Returns
 bool
Returns
True
if the loss value of the last validation set evaluation is worse than the average of thecalls
evaluations before.

class
ValueAnnealing
(crit_stop_chance=0.5)[source]¶ Bases:
scm.glompo.stoppers.basestopper.BaseStopper
Keeps optimizers alive based on the function values they are exploring. This condition is unlikely to stop a tested optimizer which is very near the best (in terms of function value) but the probability of stopping increases with the difference between them. This condition can be applied in combination with others to prevent ‘competitive’ optimizers for being stopped while still terminating poorly performing ones.
The decision criteria follows an exponential distribution which corresponds to the probability of survival. Control of the probability can be achieved through the
crit_stop_chance
initialisation criteria. Parameters
 crit_stop_chance: float
The probability of stopping a tested optimizer which is twice as large as the best optimizer in absolute value. The default is 50%.
 Returns
 bool
True
if the difference between the explored function values of the best and tested optimizer fails a comparison test with a uniformly randomly generated number.