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 black-box optimizer NSA 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.

For its pytest based testing, please refer to this Python code.

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.