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. 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: Define or select problem Choose single-objective algorithm (GA, DE, PSO, CMA-ES) Configure termination criteria Run optimization 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: Define multi-objective problem Configure NSGA-II Run optimization to obtain Pareto front Visualize trade-offs 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: Define many-objective problem Generate reference directions Configure NSGA-III with reference directions Run optimization 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: Extend ElementwiseProblem class Define __init__ with problem dimensions and bounds Implement _evaluate method for objectives (and constraints) Use with any algorithm Unconstrained example: 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: 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 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 from pymoo.constraints.as_penalty import ConstraintsAsPenalty # Wrap problem to convert constraints to penalties problem_penalized = ConstraintsAsPenalty(problem, penalty= 1e6 ) 3. Constraint as Objective from pymoo.constraints.as_obj import ConstraintsAsObjective # Treat constraint violation as additional objective problem_with_cv = ConstraintsAsObjective(problem) 4. Specialized Algorithms 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: Run multi-objective optimization Normalize objectives to [0, 1] Define preference weights Apply MCDM method Visualize selected solution Example using Pseudo-Weights: 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 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 3D plot.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 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 |