Note: This page has been translated by MathWorks. Please click here

To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

You might need to formulate problems with more than one objective, since a single objective with several constraints may not adequately represent the problem being faced. If so, there is a vector of objectives,

*F*(*x*)
= [*F*_{1}(*x*), *F*_{2}(*x*),...,*F*_{m}(*x*)],

Multiobjective optimization is concerned with the minimization
of a vector of objectives *F*(*x*)
that can be the subject of a number of constraints or bounds:

$$\begin{array}{l}\underset{x\in {\mathbb{R}}^{n}}{\mathrm{min}}F(x),\text{subjectto}\\ {G}_{i}(x)=0,\text{}i=1,\mathrm{...},{k}_{e};\text{}{G}_{i}(x)\le 0,\text{}i={k}_{e}+1,\mathrm{...},k;\text{}l\le x\le u.\end{array}$$

Note that because *F*(*x*)
is a vector, if any of the components of *F*(*x*)
are competing, there is no unique solution to this problem. Instead,
the concept of noninferiority in Zadeh [4] (also
called Pareto optimality in Censor [1] and
Da Cunha and Polak [2]) must be used
to characterize the objectives. A noninferior solution is one in which
an improvement in one objective requires a degradation of another.
To define this concept more precisely, consider a feasible region,
Ω, in the parameter space. *x* is an element
of the *n*-dimensional real numbers $$x\in {\mathbb{R}}^{n}$$ that satisfies all the constraints,
i.e.,

$$\Omega =\left\{x\in {\mathbb{R}}^{n}\right\},$$

$$\begin{array}{l}{G}_{i}(x)=0,\text{}i=1,\mathrm{...},{k}_{e},\\ {G}_{i}(x)\le 0,\text{}i={k}_{e}+1,\mathrm{...},k,\\ l\le x\le u.\end{array}$$

$$\Lambda =\left\{y\in {\mathbb{R}}^{m}:y=F(x),x\in \Omega \right\}.$$

**Figure 8-1, Mapping from Parameter Space into Objective
Function Space**

A noninferior solution point can now be defined.

**Definition:** Point $$x*\in \Omega $$ is a noninferior solution if for some neighborhood
of *x** there does not exist a Δ*x* such
that $$\left(x*+\Delta x\right)\in \Omega $$ and

$$\begin{array}{l}{F}_{i}\left(x*+\Delta x\right)\le {F}_{i}(x*),\text{}i=1,\mathrm{...},m,\text{and}\\ {F}_{j}\left(x*+\Delta x\right){F}_{j}(x*)\text{foratleastone}j.\end{array}$$

In the two-dimensional representation of the figure Figure 8-2, Set of Noninferior Solutions, the set
of noninferior solutions lies on the curve between *C* and *D*.
Points *A* and *B* represent
specific noninferior points.

**Figure 8-2, Set of Noninferior Solutions**

*A* and *B* are clearly
noninferior solution points because an improvement in one objective, *F*_{1},
requires a degradation in the other objective, *F*_{2},
i.e., *F*_{1B} < *F*_{1A}, *F*_{2B} > *F*_{2A}.

Since any point in Ω that is an inferior point represents a point in which improvement can be attained in all the objectives, it is clear that such a point is of no value. Multiobjective optimization is, therefore, concerned with the generation and selection of noninferior solution points.

Noninferior solutions are also called *Pareto optima*.
A general goal in multiobjective optimization is constructing the
Pareto optima. The algorithm used in `gamultiobj`

is
described in Deb [3].

`gamultiobj`

The `gamultiobj`

solver attempts to create
a set of Pareto optima for a multiobjective minimization. You may
optionally set bounds or other constraints on variables. `gamultiobj`

uses
the genetic algorithm for finding local Pareto optima. As in the `ga`

function,
you may specify an initial population, or have the solver generate
one automatically.

The fitness function for use in `gamultiobj`

should
return a vector of type `double`

. The population
may be of type `double`

, a bit string vector, or
can be a custom-typed vector. As in `ga`

, if you
use a custom population type, you must write your own creation, mutation,
and crossover functions that accept inputs of that population type,
and specify these functions in the following fields, respectively:

**Creation function**(`CreationFcn`

)**Mutation function**(`MutationFcn`

)**Crossover function**(`CrossoverFcn`

)

You can set the initial population in a variety of ways. Suppose
that you choose a population of size *m*. (The default
population size is 50 when the number of variables is less than 6,
and is 200 otherwise.) You can set the population:

As an

*m*-by-*n*matrix, where the rows represent*m*individuals.As a

*k*-by-*n*matrix, where*k*<*m*. The remaining*m*–*k*individuals are generated by a creation function.The entire population can be created by a creation function.

Was this topic helpful?