pymoo: Multi-Objective Optimization in Python

Warnings

• breaking The module organization was entirely changed in version 0.5.0. Many classes, especially algorithms, moved to nested submodules (e.g., `pymoo.algorithms.moo.nsga2.NSGA2`).
  Fix: Update import paths to reflect the new structure, e.g., `from pymoo.algorithms.moo.nsga2 import NSGA2` instead of `from pymoo.algorithms.nsga2 import NSGA2` (old paths are approximate).
• breaking Factory methods (`get_algorithm`, `get_problem`, `get_mutation`, etc.) were deprecated or deactivated in version 0.6.0 to improve clarity and reduce maintenance overhead.
  Fix: Directly import and instantiate classes (e.g., `NSGA2(pop_size=100)`) instead of using factory functions (e.g., `get_algorithm("nsga2", pop_size=100)`).
• breaking The termination criterion interface changed in version 0.6.0. Custom termination objects now need to return a floating-point number (0 for continue, 1 for terminate) instead of a boolean.
  Fix: Adjust custom termination logic to return a float, or use tuple-based termination criteria (e.g., `('n_gen', 200)`).
• breaking Versions prior to 0.6.1.3 are incompatible with NumPy 2.0.0 due to changes in how `autograd` interacts with NumPy's internal structure.
  Fix: Upgrade `pymoo` to version 0.6.1.3 or newer, or downgrade `numpy` to a version less than 2.0.0 (e.g., `numpy<2`). `autograd` is now optional in `pymoo >= 0.6.1.3`.
• gotcha Pymoo offers three ways to define an optimization problem: `Problem` (vectorized evaluation), `ElementwiseProblem` (single-solution evaluation), and `FunctionalProblem` (using functions). Choosing the wrong type can impact performance and parallelization.
  Fix: Understand the differences and select the appropriate problem definition for your use case. `Problem` is generally preferred for population-based algorithms due to vectorized evaluation efficiency, while `ElementwiseProblem` simplifies custom parallelization.

Install

• pip install -U pymoo Install stable version
• pip install -U pymoo[visualization] Install with visualization dependencies
• pip install -U pymoo[parallelization] Install with parallelization dependencies

Imports

• NSGA2

  from pymoo.algorithms.moo.nsga2 import NSGA2

  Module organization changed in 0.5.0; factory methods deprecated in 0.6.0.
• get_problem

  from pymoo.problems import get_problem

  Factory methods deprecated in 0.6.0. Use direct import or problem definition classes.
• minimize

  from pymoo.optimize import minimize

• Scatter

  from pymoo.visualization.scatter import Scatter

Quickstart

This quickstart defines a custom constrained multi-objective optimization problem, initializes the NSGA-II algorithm, sets a termination criterion based on the number of generations, runs the optimization, and visualizes the resulting Pareto front. Note that custom problems should now inherit from `pymoo.core.problem.Problem` or `ElementwiseProblem`.

import numpy as np
from pymoo.algorithms.moo.nsga2 import NSGA2
from pymoo.core.problem import Problem
from pymoo.optimize import minimize
from pymoo.visualization.scatter import Scatter

# Define your custom problem as an object
class MyProblem(Problem):
    def __init__(self):
        super().__init__(n_var=2, n_obj=2, n_constr=2, xl=np.array([-2.0, -2.0]), xu=np.array([2.0, 2.0]))

    def _evaluate(self, X, out, *args, **kwargs):
        f1 = X[:, 0]**2 + X[:, 1]**2
        f2 = (X[:, 0]-1)**2 + X[:, 1]**2

        g1 = 2 * (X[:, 0]-0.1) * (X[:, 0]-0.9)
        g2 = 20 * (X[:, 0]-0.4) * (X[:, 0]-0.6)

        out["F"] = np.column_stack([f1, f2])
        out["G"] = np.column_stack([g1, g2])

# Instantiate the problem
problem = MyProblem()

# Choose an algorithm
algorithm = NSGA2(pop_size=100)

# Define the termination criterion
termination = ('n_gen', 200)

# Optimize
res = minimize(problem, algorithm, termination, seed=1, verbose=False)

# Plot the results
plot = Scatter()
plot.add(res.F, color="red")
plot.show()