PyPop7

PyPop7 provides a wide range of Black-Box Optimization (BBO) algorithms for continuous optimization problems, categorized into several major families:

• Evolutionary Programming (EP): Includes Lévy distribution based EP (LEP), Fast EP (FEP), and Classical EP (CEP).
• Direct Search (DS): Includes Powell's search method (POWELL), Generalized Pattern Search (GPS), Nelder-Mead simplex method (NM), Hooke-Jeeves direct search method (HJ), and Coordinate/Compass Search (CS).
• Random (stochastic) Search (RS): Includes Bernoulli Smoothing (BES), Gaussian Smoothing (GS), Simple Random Search (SRS), Annealed Random Hill Climber (ARHC), Random Hill Climber (RHC), and Pure Random Search (PRS).
• Evolution Strategies (ES): A large collection of variants including LMCMA, LMCMAES, R1ES, OPOA2015, OPOA2010, CCMAES2009, OPOC2009, OPOC2006, MAES, DDCMA, SAMAES, SAES, CSAES, DSAES, SSAES, and RES.
• Natural ES (NES): Includes Separable NES (SNES), Original NES (ONES), and Search Gradient ES (SGES).
• Estimation of Distribution Algorithms (EDA): Includes Adaptive Estimation of Multivariate Normal Algorithm (AEMNA) and EMNA.
• Cross-Entropy Method (CEM): Includes Model Reference Adaptive Search (MRAS).

The following Python libraries are recommended for various black-box optimization tasks:

Active & Well-Maintained

• pygmo: A well-designed library for parallel optimization. Supports algorithms like de, sade, de1220, pso, pso_gen, sea, sga, simulated_annealing, cmaes, and xnes.
• pycma: Implementation of CMA-ES.
• optuna: Used for hyperparameter optimization and supports CMA-ES.
• evosax: A JAX-based library for Evolutionary Algorithms (EAs) and NeuroEvolution (NE) that runs on GPU.
• EvoJAX: A scalable, hardware-accelerated neuroevolution toolkit based on JAX.
• pymoo: Focuses on multi-objective black-box optimization (supports cmaes, de, es, ga, g3pcx, isres, nelder, pattern, pso, sres).
• BayesianOptimization: For Bayesian Optimization (BO).
• hyperopt: For Random Search (RS).
• vizier: For Hyperparameter Optimization and AutoML.
• deephyper: For Bayesian Optimization (BO).
• evotorch: Neuroevolution toolkit.

Specialized Tools

• FairEMOL: For mitigating unfairness via Evolutionary Multiobjective Optimisation Learning.
• IOHanalyzer: A performance analyzer for Iterative Optimization Heuristics (IOHs).

To create a new black-box optimizer in PyPop7, you must subclass the Optimizer base class. A complete implementation requires overriding specific lifecycle methods that the Optimizer.optimize() method calls.

Required Lifecycle Methods

• initialize(self): Handles the population initialization stage. It should return the initial point(s) or population.
• iterate(self): Handles the iteration stage (generating new candidates/individuals).
• _collect(self, fitness, y=None): Collects necessary output information and metadata (like the number of generations) to be returned by the optimize() method.

Implementation Pattern

The Optimizer.optimize() method follows a standard lifecycle:

1. initialize() is called to set up the starting state.
2. The initial fitness is evaluated.
3. A loop runs calling iterate() and evaluating fitness until _check_terminations() returns true.
4. _collect() is called to package the results.

from pypop7.optimizers.core.optimizer import Optimizer

class MyCustomOptimizer(Optimizer):
    def initialize(self):
        # Return initial population/point
        return ...

    def iterate(self):
        # Return next candidate/population
        return ...

    def _collect(self, fitness, y=None):
        # Package results
        results = super()._collect(fitness, y)
        results['my_custom_metric'] = ...
        return results

Black-Box Optimization (BBO) refers to optimization problems where the only accessible information is obtained through sampling evaluations. In these scenarios, the algorithm does not have access to the internal mathematical model or gradient information of the objective function.

Common characteristics of black-box problems that PyPop is designed to handle include:

• Unavailability of gradients: Due to complex modeling, legacy code, or noisy evaluations.
• Lack of precise mathematical models: Often caused by complex simulations.
• Non-differentiability: Where automatic differentiation is impossible or non-informative.
• Non-linearity and Non-convexity: Including multi-modal landscapes.
• Ill-conditioning and Discontinuity: Difficult mathematical landscapes.
• Noisiness/Stochasticity: Function evaluations that are not deterministic.
• Needle-in-a-haystack: Extremely sparse optimal regions.

PyPop provides various algorithms (also known as Zeroth-Order, Derivative-Free, or Gradient-Free Optimization) to navigate these landscapes using only function samples.

If your fitness function requires arguments other than the sampling point x, use one of these two methods:

1. Class Wrapper

Create a class with an __init__ method to store the extra arguments and a __call__ method to perform the evaluation.

2. Unified API Interface

Use the unified API provided by PyPop7 optimizers. When calling optimizer.optimize(args=...), the args passed to optimize will be forwarded to your fitness_function as the second argument.

# Method 1: Class Wrapper
class Rosenbrock(object):
    def __init__(self, arg):
        self.arg = arg
    def __call__(self, x):
        return rosenbrock(x, self.arg)

problem = {'fitness_function': Rosenbrock(100.0), ...}

# Method 2: Unified API
def rosenbrock(x, args):
    return args*np.sum(np.square(x[1:] - np.square(x[:-1]))) + np.sum(np.square(x[:-1] - 1.0))

problem = {'fitness_function': rosenbrock, ...}
from pypop7.optimizers.es.maes import MAES
maes = MAES(problem, options)
results = maes.optimize(args=100.0)  # args are passed to rosenbrock