Pymoo

Pymoo - Multi-Objective Optimization in Python

Overview

Pymoo is a comprehensive Python framework for optimization with emphasis on multi-objective problems. Solve single and multi-objective optimization using state-of-the-art algorithms (NSGA-II/III, MOEA/D), benchmark problems (ZDT, DTLZ), customizable genetic operators, and multi-criteria decision making methods. Excels at finding trade-off solutions (Pareto fronts) for problems with conflicting objectives.

When to Use This Skill

This skill should be used when:

• Solving optimization problems with one or multiple objectives
• Finding Pareto-optimal solutions and analyzing trade-offs
• Implementing evolutionary algorithms (GA, DE, PSO, NSGA-II/III)
• Working with constrained optimization problems
• Benchmarking algorithms on standard test problems (ZDT, DTLZ, WFG)
• Customizing genetic operators (crossover, mutation, selection)
• Visualizing high-dimensional optimization results
• Making decisions from multiple competing solutions
• Handling binary, discrete, continuous, or mixed-variable problems

Core Concepts

The Unified Interface

Pymoo uses a consistent minimize() function for all optimization tasks:

from pymoo.optimize import minimize
result = minimize(    problem,        # What to optimize    algorithm,      # How to optimize    termination,    # When to stop    seed=1,    verbose=True)

Result object contains:

• result.X: Decision variables of optimal solution(s)
• result.F: Objective values of optimal solution(s)
• result.G: Constraint violations (if constrained)
• result.algorithm: Algorithm object with history

Problem Types

Single-objective: One objective to minimize/maximize Multi-objective: 2-3 conflicting objectives → Pareto front Many-objective: 4+ objectives → High-dimensional Pareto front Constrained: Objectives + inequality/equality constraints Dynamic: Time-varying objectives or constraints

Quick Start Workflows

Workflow 1: Single-Objective Optimization

When: Optimizing one objective function

Steps:

1. Define or select problem
2. Choose single-objective algorithm (GA, DE, PSO, CMA-ES)
3. Configure termination criteria
4. Run optimization
5. Extract best solution

Example:

from pymoo.algorithms.soo.nonconvex.ga import GAfrom pymoo.problems import get_problemfrom pymoo.optimize import minimize
# Built-in problemproblem = get_problem("rastrigin", n_var=10)
# Configure Genetic Algorithmalgorithm = GA(    pop_size=100,    eliminate_duplicates=True)
# Optimizeresult = minimize(    problem,    algorithm,    ('n_gen', 200),    seed=1,    verbose=True)
print(f"Best solution: {result.X}")print(f"Best objective: {result.F[0]}")

See: scripts/single_objective_example.py for complete example

Workflow 2: Multi-Objective Optimization (2-3 objectives)

When: Optimizing 2-3 conflicting objectives, need Pareto front

Algorithm choice: NSGA-II (standard for bi/tri-objective)

Steps:

1. Define multi-objective problem
2. Configure NSGA-II
3. Run optimization to obtain Pareto front
4. Visualize trade-offs
5. Apply decision making (optional)

Example:

from pymoo.algorithms.moo.nsga2 import NSGA2from pymoo.problems import get_problemfrom pymoo.optimize import minimizefrom pymoo.visualization.scatter import Scatter
# Bi-objective benchmark problemproblem = get_problem("zdt1")
# NSGA-II algorithmalgorithm = NSGA2(pop_size=100)
# Optimizeresult = minimize(problem, algorithm, ('n_gen', 200), seed=1)
# Visualize Pareto frontplot = Scatter()plot.add(result.F, label="Obtained Front")plot.add(problem.pareto_front(), label="True Front", alpha=0.3)plot.show()
print(f"Found {len(result.F)} Pareto-optimal solutions")

See: scripts/multi_objective_example.py for complete example

Workflow 3: Many-Objective Optimization (4+ objectives)

When: Optimizing 4 or more objectives

Algorithm choice: NSGA-III (designed for many objectives)

Key difference: Must provide reference directions for population guidance

Steps:

1. Define many-objective problem
2. Generate reference directions
3. Configure NSGA-III with reference directions
4. Run optimization
5. Visualize using Parallel Coordinate Plot

Example:

from pymoo.algorithms.moo.nsga3 import NSGA3from pymoo.problems import get_problemfrom pymoo.optimize import minimizefrom pymoo.util.ref_dirs import get_reference_directionsfrom pymoo.visualization.pcp import PCP
# Many-objective problem (5 objectives)problem = get_problem("dtlz2", n_obj=5)
# Generate reference directions (required for NSGA-III)ref_dirs = get_reference_directions("das-dennis", n_dim=5, n_partitions=12)
# Configure NSGA-IIIalgorithm = NSGA3(ref_dirs=ref_dirs)
# Optimizeresult = minimize(problem, algorithm, ('n_gen', 300), seed=1)
# Visualize with Parallel Coordinatesplot = PCP(labels=[f"f{i+1}" for i in range(5)])plot.add(result.F, alpha=0.3)plot.show()

See: scripts/many_objective_example.py for complete example

Workflow 4: Custom Problem Definition

When: Solving domain-specific optimization problem

Steps:

1. Extend ElementwiseProblem class
2. Define __init__ with problem dimensions and bounds
3. Implement _evaluate method for objectives (and constraints)
4. Use with any algorithm

Unconstrained example:

from pymoo.core.problem import ElementwiseProblemimport numpy as np
class MyProblem(ElementwiseProblem):    def __init__(self):        super().__init__(            n_var=2,              # Number of variables            n_obj=2,              # Number of objectives            xl=np.array([0, 0]),  # Lower bounds            xu=np.array([5, 5])   # Upper bounds        )
    def _evaluate(self, x, out, *args, **kwargs):        # Define objectives        f1 = x[0]**2 + x[1]**2        f2 = (x[0]-1)**2 + (x[1]-1)**2
        out["F"] = [f1, f2]

Constrained example:

class ConstrainedProblem(ElementwiseProblem):    def __init__(self):        super().__init__(            n_var=2,            n_obj=2,            n_ieq_constr=2,        # Inequality constraints            n_eq_constr=1,         # Equality constraints            xl=np.array([0, 0]),            xu=np.array([5, 5])        )
    def _evaluate(self, x, out, *args, **kwargs):        # Objectives        out["F"] = [f1, f2]
        # Inequality constraints (g <= 0)        out["G"] = [g1, g2]
        # Equality constraints (h = 0)        out["H"] = [h1]

Constraint formulation rules:

• Inequality: Express as g(x) <= 0 (feasible when ≤ 0)
• Equality: Express as h(x) = 0 (feasible when = 0)
• Convert g(x) >= b to -(g(x) - b) <= 0

See: scripts/custom_problem_example.py for complete examples

Workflow 5: Constraint Handling

When: Problem has feasibility constraints

Approach options:

1. Feasibility First (Default - Recommended)

from pymoo.algorithms.moo.nsga2 import NSGA2
# Works automatically with constrained problemsalgorithm = NSGA2(pop_size=100)result = minimize(problem, algorithm, termination)
# Check feasibilityfeasible = result.CV[:, 0] == 0  # CV = constraint violationprint(f"Feasible solutions: {np.sum(feasible)}")

2. Penalty Method

from pymoo.constraints.as_penalty import ConstraintsAsPenalty
# Wrap problem to convert constraints to penaltiesproblem_penalized = ConstraintsAsPenalty(problem, penalty=1e6)

3. Constraint as Objective

from pymoo.constraints.as_obj import ConstraintsAsObjective
# Treat constraint violation as additional objectiveproblem_with_cv = ConstraintsAsObjective(problem)

4. Specialized Algorithms

from pymoo.algorithms.soo.nonconvex.sres import SRES
# SRES has built-in constraint handlingalgorithm = SRES()

See: references/constraints_mcdm.md for comprehensive constraint handling guide

Workflow 6: Decision Making from Pareto Front

When: Have Pareto front, need to select preferred solution(s)

Steps:

1. Run multi-objective optimization
2. Normalize objectives to [0, 1]
3. Define preference weights
4. Apply MCDM method
5. Visualize selected solution

Example using Pseudo-Weights:

from pymoo.mcdm.pseudo_weights import PseudoWeightsimport numpy as np
# After obtaining result from multi-objective optimization# Normalize objectivesF_norm = (result.F - result.F.min(axis=0)) / (result.F.max(axis=0) - result.F.min(axis=0))
# Define preferences (must sum to 1)weights = np.array([0.3, 0.7])  # 30% f1, 70% f2
# Apply decision makingdm = PseudoWeights(weights)selected_idx = dm.do(F_norm)
# Get selected solutionbest_solution = result.X[selected_idx]best_objectives = result.F[selected_idx]
print(f"Selected solution: {best_solution}")print(f"Objective values: {best_objectives}")

Other MCDM methods:

• Compromise Programming: Select closest to ideal point
• Knee Point: Find balanced trade-off solutions
• Hypervolume Contribution: Select most diverse subset

See:

• scripts/decision_making_example.py for complete example
• references/constraints_mcdm.md for detailed MCDM methods

Workflow 7: Visualization

Choose visualization based on number of objectives:

2 objectives: Scatter Plot

from pymoo.visualization.scatter import Scatter
plot = Scatter(title="Bi-objective Results")plot.add(result.F, color="blue", alpha=0.7)plot.show()

3 objectives: 3D Scatter

plot = Scatter(title="Tri-objective Results")plot.add(result.F)  # Automatically renders in 3Dplot.show()

4+ objectives: Parallel Coordinate Plot

from pymoo.visualization.pcp import PCP
plot = PCP(    labels=[f"f{i+1}" for i in range(n_obj)],    normalize_each_axis=True)plot.add(result.F, alpha=0.3)plot.show()

Solution comparison: Petal Diagram

from pymoo.visualization.petal import Petal
plot = Petal(    bounds=[result.F.min(axis=0), result.F.max(axis=0)],    labels=["Cost", "Weight", "Efficiency"])plot.add(solution_A, label="Design A")plot.add(solution_B, label="Design B")plot.show()

See: references/visualization.md for all visualization types and usage

Algorithm Selection Guide

Single-Objective Problems

Multi-Objective Problems (2-3 objectives)

Many-Objective Problems (4+ objectives)

Constrained Problems

See: references/algorithms.md for comprehensive algorithm reference

Benchmark Problems

Quick problem access:

from pymoo.problems import get_problem
# Single-objectiveproblem = get_problem("rastrigin", n_var=10)problem = get_problem("rosenbrock", n_var=10)
# Multi-objectiveproblem = get_problem("zdt1")        # Convex frontproblem = get_problem("zdt2")        # Non-convex frontproblem = get_problem("zdt3")        # Disconnected front
# Many-objectiveproblem = get_problem("dtlz2", n_obj=5, n_var=12)problem = get_problem("dtlz7", n_obj=4)

See: references/problems.md for complete test problem reference

Genetic Operator Customization

Standard operator configuration:

from pymoo.algorithms.soo.nonconvex.ga import GAfrom pymoo.operators.crossover.sbx import SBXfrom pymoo.operators.mutation.pm import PM
algorithm = GA(    pop_size=100,    crossover=SBX(prob=0.9, eta=15),    mutation=PM(eta=20),    eliminate_duplicates=True)

Operator selection by variable type:

Continuous variables:

• Crossover: SBX (Simulated Binary Crossover)
• Mutation: PM (Polynomial Mutation)

Binary variables:

• Crossover: TwoPointCrossover, UniformCrossover
• Mutation: BitflipMutation

Permutations (TSP, scheduling):

• Crossover: OrderCrossover (OX)
• Mutation: InversionMutation

See: references/operators.md for comprehensive operator reference

Performance and Troubleshooting

Common issues and solutions:

Problem: Algorithm not converging

• Increase population size
• Increase number of generations
• Check if problem is multimodal (try different algorithms)
• Verify constraints are correctly formulated

Problem: Poor Pareto front distribution

• For NSGA-III: Adjust reference directions
• Increase population size
• Check for duplicate elimination
• Verify problem scaling

Problem: Few feasible solutions

• Use constraint-as-objective approach
• Apply repair operators
• Try SRES/ISRES for constrained problems
• Check constraint formulation (should be g <= 0)

Problem: High computational cost

• Reduce population size
• Decrease number of generations
• Use simpler operators
• Enable parallelization (if problem supports)

Best practices:

1. Normalize objectives when scales differ significantly
2. Set random seed for reproducibility
3. Save history to analyze convergence: save_history=True
4. Visualize results to understand solution quality
5. Compare with true Pareto front when available
6. Use appropriate termination criteria (generations, evaluations, tolerance)
7. Tune operator parameters for problem characteristics

Resources

This skill includes comprehensive reference documentation and executable examples:

references/

Detailed documentation for in-depth understanding:

• algorithms.md: Complete algorithm reference with parameters, usage, and selection guidelines
• problems.md: Benchmark test problems (ZDT, DTLZ, WFG) with characteristics
• operators.md: Genetic operators (sampling, selection, crossover, mutation) with configuration
• visualization.md: All visualization types with examples and selection guide
• constraints_mcdm.md: Constraint handling techniques and multi-criteria decision making methods

Search patterns for references:

• Algorithm details: grep -r "NSGA-II\|NSGA-III\|MOEA/D" references/
• Constraint methods: grep -r "Feasibility First\|Penalty\|Repair" references/
• Visualization types: grep -r "Scatter\|PCP\|Petal" references/

scripts/

Executable examples demonstrating common workflows:

• single_objective_example.py: Basic single-objective optimization with GA
• multi_objective_example.py: Multi-objective optimization with NSGA-II, visualization
• many_objective_example.py: Many-objective optimization with NSGA-III, reference directions
• custom_problem_example.py: Defining custom problems (constrained and unconstrained)
• decision_making_example.py: Multi-criteria decision making with different preferences

Run examples:

python3 scripts/single_objective_example.pypython3 scripts/multi_objective_example.pypython3 scripts/many_objective_example.pypython3 scripts/custom_problem_example.pypython3 scripts/decision_making_example.py

Additional Notes

Installation:

uv pip install pymoo

Dependencies: NumPy, SciPy, matplotlib, autograd (optional for gradient-based)

Documentation: https://pymoo.org/

Version: This skill is based on pymoo 0.6.x

Common patterns:

• Always use ElementwiseProblem for custom problems
• Constraints formulated as g(x) <= 0 and h(x) = 0
• Reference directions required for NSGA-III
• Normalize objectives before MCDM
• Use appropriate termination: ('n_gen', N) or get_termination("f_tol", tol=0.001)