Noisy Simulated Annealing (NSA)

class pypop7.optimizers.sa.nsa.NSA(problem, options)

Noisy Simulated Annealing (NSA).

Note

This is a slightly modified version of discrete NSA for continuous optimization.

Parameters:

• problem (dict) –

  problem arguments with the following common settings (keys):

  • ’fitness_function’ - objective function to be minimized (func),

  • ’ndim_problem’ - number of dimensionality (int),

  • ’upper_boundary’ - upper boundary of search range (array_like),

  • ’lower_boundary’ - lower boundary of search range (array_like).

• options (dict) –

  optimizer options with the following common settings (keys):

  • ’max_function_evaluations’ - maximum of function evaluations (int, default: np.Inf),

  • ’max_runtime’ - maximal runtime to be allowed (float, default: np.Inf),

  • ’seed_rng’ - seed for random number generation needed to be explicitly set (int);

  and with the following particular settings (keys):

  • ’x’ - initial (starting) point (array_like),

  • ’sigma’ - initial global step-size (float),

  • ’is_noisy’ - whether or not to minimize a noisy cost function (bool, default: False),

  • ’schedule’ - schedule for sampling intensity (str, default: linear),

    • currently only two (linear or quadratic) schedules are supported for sampling intensity,

  • ’n_samples’ - number of samples (int),

  • ’rt’ - reducing factor of annealing temperature (float, default: 0.99).

Examples

Use the optimizer to minimize the well-known test function Rosenbrock:

>>> import numpy  # engine for numerical computing
>>> from pypop7.benchmarks.base_functions import rosenbrock  # function to be minimized
>>> from pypop7.optimizers.sa.nsa import NSA
>>> problem = {'fitness_function': rosenbrock,  # define problem arguments
...            'ndim_problem': 2,
...            'lower_boundary': -5*numpy.ones((2,)),
...            'upper_boundary': 5*numpy.ones((2,))}
>>> options = {'max_function_evaluations': 5000,  # set optimizer options
...            'seed_rng': 2022,
...            'x': 3*numpy.ones((2,)),
...            'sigma': 1.0,
...            'temperature': 100.0}
>>> nsa = NSA(problem, options)  # initialize the optimizer class
>>> results = nsa.optimize()  # run the optimization process
>>> # return the number of function evaluations and best-so-far fitness
>>> print(f"NSA: {results['n_function_evaluations']}, {results['best_so_far_y']}")
NSA: 5000, 0.006086567926462302

For its correctness checking of coding, the code-based repeatability report cannot be provided owing to the lack of some details of its experiments in the original paper.

is_noisy

whether or not to minimize a noisy cost function.

Type:

bool

n_samples

number of samples for each iteration.

Type:

int

rt

reducing factor of annealing temperature.

Type:

float

schedule

schedule for sampling intensity.

Type:

str

sigma

global step-size (fixed during optimization).

Type:

float

x

initial (starting) point.

Type:

array_like

References

Bouttier, C. and Gavra, I., 2019. Convergence rate of a simulated annealing algorithm with noisy observations. Journal of Machine Learning Research, 20(1), pp.127-171. https://www.jmlr.org/papers/v20/16-588.html