python-multiobjective-optimization

Files (1)

• SKILL.md

SKILL.md (first lines)

# Python Multiobjective Optimization

## Overview

Master multiobjective optimization where you must simultaneously optimize multiple conflicting objectives. Unlike single-objective optimization that finds one optimal solution, multiobjective optimization discovers a **Pareto front** - a set of trade-off solutions where improving one objective worsens another.

**Core value:** Find optimal trade-offs between competing objectives (cost vs. performance, risk vs. return, speed vs. accuracy) and enable informed decision-making across the Pareto frontier.

## When to Use

Use multiobjective optimization when:

- Optimizing multiple conflicting objectives simultaneously
- Need trade-off analysis between competing goals
- Decision-makers must choose from Pareto-optimal alternatives
- No single "best" solution exists without preference information

**Examples:**

- Portfolio optimization: maximize return, minimize risk
- Engineering design: minimize cost, maximize performance, minimize weight
- Manufacturing: maximize throughput, minimize defects, minimize energy
- Drug design: maximize efficacy, minimize toxicity, maximize bioavailability
- Vehicle routing: minimize distance, minimize time, minimize vehicles

**Don't use when:**

- Only one objective exists (use single-objective optimization)
- Objectives can be combined into single metric with known weights
- One objective is vastly more important than others

## Key Concepts

### Pareto Dominance

Solution **x** dominates solution **y** if:

1. **x** is no worse than **y** in all objectives
2. **x** is strictly better than **y** in at least one objective

```python
def dominates(obj_x, obj_y, minimize=True):
    """
    Check if obj_x dominates obj_y (for minimization).

    Returns True if obj_x dominates obj_y.
    """
    if minimize:
        # For minimization: x dominates y if all x_i <= y_i and at least one x_i < y_i
        better_or_equal = all(x <= y for x, y in zip(obj_x, obj_y))
        strictly_better = any(x < y for x, y in zip(obj_x, obj_y))
    else:
        # For maximization: x dominates y if all x_i >= y_i and at least one x_i > y_i
        better_or_equal = all(x >= y for x, y in zip(obj_x, obj_y))
        strictly_better = any(x > y for x, y in zip(obj_x, obj_y))

    return better_or_equal and strictly_better
```

### Pareto Front (Pareto Frontier)

The **Pareto front** is the set of all non-dominated solutions - solutions where you cannot improve one objective without worsening another.

**Properties:**

- All points on the Pareto front are equally "optimal" from mathematical perspective
- Choosing among Pareto solutions requires preference information
- Moving along the front trades one objective for another

### Utopia and Nadir Points

- **Utopia point**: Best possible value for each objective (usually infeasible)
- **Nadir point**: Worst value among Pareto-optimal solutions for each objective

## Methods Overview

### Scalarization Approaches

Convert multiobjective problem to series of single-objective problems.

#### 1. Weighted Sum

- Combine objectives with weights: minimize w₁f₁(x) + w₂f₂(x)
- Pros: Simple, uses any single-objective solver
- Cons: Cannot find non-convex Pareto fronts, sensitive to scaling

#### 2. Weighted Metrics (Lp-norm)

- Minimize ||f(x) - ideal||ₚ with weights
- Pros: Can find non-convex fronts (p=∞)
- Cons: Requires ideal point estimation

#### 3. ε-Constraint Method

- Minimize one objective, constrain others: min f₁(x) s.t. f₂(x) ≤ ε
- Pros: Finds entire Pareto front including non-convex regions
- Cons: Many single-objective solves, requires constraint bounds

#### 4. Goal Programming

- Minimize deviation from target goals
- Pros: Intuitive when targets known
- Cons: Requires setting goals

### Evolutionary Algorithms

Population-based metaheuristics that evolve Pareto front approximations.

#### 1. NSGA-II (Non-dominated Sorting Genetic Algorithm II)

- Most popular multiobjective evolutionary algorithm
- Fast non-dominated sorting + crowding distance
- Pros: Robust, well-tested, handles 2-3 objectives well
- Cons: Degrades with many objectives (>3)

#### 2. NSGA-III

- Extension of NSGA-II for many objectives (4+)
- Reference point-based selection

From woernfl/ai-lab, MIT.

More from woernfl/ai-lab