Optimization

Scalarization Methods

Reduce a multi-objective problem to a single objective by combining goals, then vary the combination to trace the Pareto front.

One objective at a time

Scalarization converts a vector of objectives into a single scalar objective that a standard optimizer can handle. Solving the scalarized problem yields one Pareto-optimal point; sweeping the scalarization parameters produces a set of points that approximate the Pareto front. This reuses the full toolbox of single-objective optimization.

Weighted sum

The simplest scalarization minimizes a weighted sum sum_i w_i f_i(x) with nonnegative weights summing to one. Each weight vector yields a Pareto point. Its major limitation is that it can only find points on convex parts of the front; solutions in concave regions are never optimal for any weighting, so parts of the front are missed.

Epsilon-constraint

Optimize one objective while constraining the others to be no worse than chosen bounds (epsilon values).
Varying the bounds sweeps out the front, including concave regions the weighted sum misses.
Requires choosing sensible bounds and can produce infeasible subproblems if bounds are too tight.

Chebyshev and achievement scalarization

The weighted Chebyshev method minimizes the maximum weighted deviation from an ideal point: max_i w_i |f_i(x) - z_i*|. Unlike the weighted sum, it can reach every Pareto point, including concave regions, though it may also return weakly dominated points. Augmented versions add a small sum term to avoid that.

Choosing a scalarization

Weighted sum is easy but incomplete; epsilon-constraint and Chebyshev cover the whole front at more cost. Scalarization is efficient when a few trade-off points suffice, but tracing a dense front requires many solves. Population-based methods produce a whole front in one run and are preferred when a dense, complete front is needed.

python

# weighted-sum sweep
fronts = []
for w in weight_grid:
    x = minimize(lambda x: sum(w[i]*f[i](x) for i in range(k)))
    fronts.append([f[i](x) for i in range(k)])

Scalarization lets a proven single-objective solver map the trade-off frontier of a multi-goal engineering design.