pygmo Documentation

pygmo is a scientific Python library designed for massively parallel optimization. It provides a unified interface to various optimization algorithms and problems, facilitating easy deployment in parallel environments.

Key features include:

• Algorithm Diversity: Combines bio-inspired and evolutionary algorithms with state-of-the-art methods like Simplex, SQP, and interior point methods.
• Algorithmic Cooperation: Supports building 'super-algorithms' using the asynchronous, generalized island model to exploit cooperation between different algorithms.
• Problem Versatility: Capable of solving constrained, unconstrained, single-objective, multi-objective, continuous, integer, stochastic, and deterministic optimization problems.
• Research-Oriented: Designed for comparing novel algorithms against established state-of-the-art implementations.

Note: pygmo is built upon the pagmo C++ library.

pygmo is a comprehensive optimization library that supports a wide variety of problem types and parallelization strategies:

Supported Problem Types

• Continuous and Integer programming
• Single and Multi-objective optimization
• Constrained and Unconstrained problems
• Stochastic problems
• With or without derivatives

Parallelization Models

• Coarse-grained parallelization: Uses the generalised island model, where multiple optimization instances run in parallel (potentially on different machines) and exchange information to improve time-to-solution.
• Fine-grained parallelization: Supports batch fitness evaluation for selected algorithms, allowing single optimizations to be sped up via multithreading, GPUs, SIMD vectorization, or high-performance clusters.

Utilities and Testing

• Includes a library of ready-to-use problems (e.g., Rosenbrock, Rastrigin, Lennard-Jones) for testing.
• Provides utilities for hypervolume computation, non-dominated sorting, and plotting.

The pygmo.island class is the fundamental unit of parallelization in pagmo. An island is a computational unit that can be offloaded to a separate thread, process, or remote machine.

By using an island, you can call island.evolve() to run an optimization task asynchronously, allowing your main Python script to continue executing other tasks in the meantime.

An island's execution model is determined by its UDI (User Defined Island). The UDI defines how the evolution is offloaded (e.g., to a thread, a process, or a remote cluster).

Key relationships:

• An island evolves a population using a UDA (User Defined Algorithm).
• A problem computes fitness using a UDP (User Defined Problem).
• A collection of island objects forms an archipelago.

Note: While you can manually manage multiple islands, it is generally recommended to use a pygmo.archipelago for parallelization tasks instead of manual island scripting.

import pygmo as pg
# Example of creating a thread-based island
isl = pg.island(algo = pg.de(10), prob = pg.ackley(5), size=20, udi=pg.thread_island())

The pygmo.hypervolume class is used to compute the hypervolume indicator (Lebesgue Measure or S-Metric) and hypervolume contributions for multi-objective optimization. You can construct it in two ways:

1. From a pygmo.population: This uses the fitness values of the individuals in the population. Note that if the population's fitness values change, you must reconstruct the hypervolume object, as it copies the point set upon construction.
2. From explicit coordinates: You can pass a NumPy array or a list of lists representing the coordinates of the point set. This is useful for analyzing specific geometries independently of a problem's objective function.

Requirements/Assumptions:

• Minimization: The implementation assumes minimization in every dimension. The reference point must be numerically larger than or equal to the points in each objective, and strictly larger in at least one objective.
• Dimensionality: The input data and the reference point must have at least 2 dimensions.

import pygmo as pg
from numpy import array

# Method 1: From a population
udp = pg.problem(pg.dtlz(prob_id=2, dim=10, fdim=3))
pop = pg.population(udp, 50)
hv = pg.hypervolume(pop)

# Method 2: From explicit coordinates (NumPy array or list)
hv = pg.hypervolume(array([[1,0],[0.5,0.5],[0,1]]))
hv_from_list = pg.hypervolume([[1,0],[0.5,0.5],[0,1]])