/pymoo

name: pymoo
description: Multi-objective optimization framework. NSGA-II, NSGA-III, MOEA/D, Pareto fronts, constraint handling, benchmarks (ZDT, DTLZ), for engineering design and optimization problems.
license: Apache-2.0 license
metadata:
    skill-author: K-Dense Inc.

Pymoo - Multi-Objective Optimization in Python

Routing Boundary

Use this skill only for pymoo, NSGA-II/NSGA, Pareto-front analysis, multi-objective optimization, constrained optimization, and pymoo algorithm implementation. Do not use it for generic optimization planning, experiment design, gradient descent, Bayesian modeling, PyMC, or causal analysis.

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

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

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

**Unc