pymoo

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.

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

The Unified Interface

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

```python

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

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:

```python

from pymoo.algorithms.soo.nonconvex.ga import GA

from pymoo.problems import get_problem

from pymoo.optimize import minimize

# Built-in problem

problem = get_problem("rastrigin", n_var=10)

# Configure Genetic Algorithm

algorithm = GA(

pop_size=100,

eliminate_duplicates=True

)

# Optimize

result = 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:

```python

from pymoo.algorithms.moo.nsga2 import NSGA2

from pymoo.problems import get_problem

from pymoo.optimize import minimize

from pymoo.visualization.scatter import Scatter

# Bi-objective benchmark problem

problem = get_problem("zdt1")

# NSGA-II algorithm

algorithm = NSGA2(pop_size=100)

# Optimize

result = minimize(problem, algorithm, ('n_gen', 200), seed=1)

# Visualize Pareto front

plot = 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:

```python

from pymoo.algorithms.moo.nsga3 import NSGA3

from pymoo.problems import get_problem

from pymoo.optimize import minimize

from pymoo.util.ref_dirs import get_reference_directions

from 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-III

algorithm = NSGA3(ref_dirs=ref_dirs)

# Optimize

result = minimize(problem, algorithm, ('n_gen', 300), seed=1)

# Visualize with Parallel Coordinates

plot = 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:

```python

from pymoo.core.problem import ElementwiseProblem

import 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:

```python

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)

```python

from pymoo.algorithms.moo.nsga2 import NSGA2

# Works automatically with constrained problems

algorithm = NSGA2(pop_size=100)

result = minimize(problem, algorithm, termination)

# Check feasibility

feasible = result.CV[:, 0] == 0 # CV = constraint violation

print(f"Feasible solutions: {np.sum(feasible)}")

```

2. Penalty Method

```python

from pymoo.constraints.as_penalty import ConstraintsAsPenalty

# Wrap problem to convert constraints to penalties

problem_penalized = ConstraintsAsPenalty(problem, penalty=1e6)

```

3. Constraint as Objective

```python

from pymoo.constraints.as_obj import ConstraintsAsObjective

# Treat constraint violation as additional objective

problem_with_cv = ConstraintsAsObjective(problem)

```

4. Specialized Algorithms

```python

from pymoo.algorithms.soo.nonconvex.sres import SRES

# SRES has built-in constraint handling

algorithm = 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:

```python

from pymoo.mcdm.pseudo_weights import PseudoWeights

import numpy as np

# After obtaining result from multi-objective optimization

# Normalize objectives

F_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 making

dm = PseudoWeights(weights)

selected_idx = dm.do(F_norm)

# Get selected solution

best_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

```python

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

```python

plot = Scatter(title="Tri-objective Results")

plot.add(result.F) # Automatically renders in 3D

plot.show()

```

4+ objectives: Parallel Coordinate Plot

```python

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

```python

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

Single-Objective Problems

| Algorithm | Best For | Key Features |

|-----------|----------|--------------|

| GA | General-purpose | Flexible, customizable operators |

| DE | Continuous optimization | Good global search |

| PSO | Smooth landscapes | Fast convergence |

| CMA-ES | Difficult/noisy problems | Self-adapting |

Multi-Objective Problems (2-3 objectives)

| Algorithm | Best For | Key Features |

|-----------|----------|--------------|

| NSGA-II | Standard benchmark | Fast, reliable, well-tested |

| R-NSGA-II | Preference regions | Reference point guidance |

| MOEA/D | Decomposable problems | Scalarization approach |

Many-Objective Problems (4+ objectives)

| Algorithm | Best For | Key Features |

|-----------|----------|--------------|

| NSGA-III | 4-15 objectives | Reference direction-based |

| RVEA | Adaptive search | Reference vector evolution |

| AGE-MOEA | Complex landscapes | Adaptive geometry |

Constrained Problems

| Approach | Algorithm | When to Use |

|----------|-----------|-------------|

| Feasibility-first | Any algorithm | Large feasible region |

| Specialized | SRES, ISRES | Heavy constraints |

| Penalty | GA + penalty | Algorithm compatibility |

See: references/algorithms.md for comprehensive algorithm reference

Quick problem access:

```python

from pymoo.problems import get_problem

# Single-objective

problem = get_problem("rastrigin", n_var=10)

problem = get_problem("rosenbrock", n_var=10)

# Multi-objective

problem = get_problem("zdt1") # Convex front

problem = get_problem("zdt2") # Non-convex front

problem = get_problem("zdt3") # Disconnected front

# Many-objective

problem = 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

Standard operator configuration:

```python

from pymoo.algorithms.soo.nonconvex.ga import GA

from pymoo.operators.crossover.sbx import SBX

from 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

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

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:

```bash

python3 scripts/single_objective_example.py

python3 scripts/multi_objective_example.py

python3 scripts/many_objective_example.py

python3 scripts/custom_problem_example.py

python3 scripts/decision_making_example.py

```

Installation:

```bash

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)