exploreEfficientSet: Explore locally efficient set.

Description Usage Arguments Value Note Examples

View source: R/exploreEfficientSet.R

Description

Explores a locally efficient set separately along the gradients of the two objectives fn1 and fn2. Both explorations initially start in point ind. Such explorations obviously are only reasonable, if ind is a locally efficient point. See findLocallyEfficientPoint for further details.

Usage

1
2
3
4
exploreEfficientSet(ind, fn1, fn2, gradient.list = list(g1 = NULL, g2 =
  NULL), max.no.steps.exploration = 400L, exploration.step = 0.2,
  prec.grad = 1e-06, prec.norm = 1e-06, prec.angle = 1e-04, lower,
  upper, check.data = TRUE, show.info = TRUE)

Arguments

ind

[numeric(d)]
d-dimensional individual.

fn1

[function]
The first objective used for computing the multi-objective gradient.

fn2

[function]
The second objective used for computing the multi-objective gradient.

gradient.list

[list(p)]
A list with the single-objective gradients of the p objectives. Per default each of the p elements of this list is NULL, implying that the respective gradients will be approximated using estimateGradientBothDirections.

max.no.steps.exploration

[integer(1L)]
Maximum number of steps performed (per objective) when exploring the local efficient set. The only purpose of this value is to avoid infinite loops and thus can be set higher than the default value (400L).

exploration.step

[numeric(1L)]
Scaling factor for the step size, when exploring a local efficient set. The default is 0.2.

prec.grad

[numeric(1L)]
Precision value (= step size) used for approximating the gradient. The default is 1e-6.

prec.norm

[numeric(1L)]
Precision threshold when normalizing a vector. That is, every element of the vector, whose absolute value is below this threshold, will be replaced by 0. The default is 1e-6.

prec.angle

[numeric(1L)]
Precision threshold used for comparing whether the angle (in degree) between two vectors is zero. The default is 1e-4.

lower

[numeric(d)]
Vector of lower bounds.

upper

[numeric(d)]
Vector of upper bounds.

check.data

[logical(1L)]
Should sanity checks be performed? The default is TRUE. Note that the checks should only be turned off (e.g., for a slight speed up), if you are sure that you provide the input data in the correct format.

show.info

[logical(1L)]
Should the called method provide further information on the console? The default is TRUE.

Value

[list(4)]
Returns a list with four elements. The first one provides the points that were found to be part of the efficient set.
The second element lists the corresponding number of performed function evaluations.
The third and fourth elements are lists, containing information on the edges of the efficient set. This information consists of a logical indicating whether it could be confirmed that the found efficient set definitely is only a local efficient set. Important note: a value of FALSE does not imply that the found efficient set has to be globally efficient, as it could also be a multi-objective trap. In addition those two sublists also contain the actual positions of the evaluated points outside the efficient set, their single-objective gradients as well as the number of function evaluations (per objective) performed to compute these gradients.
Note that these (up to two) points (end1$external and end2$external) are reasonable starting points for a gradient descent towards a better efficient set.

Note

ATTENTION: Only turn off the sanity checks (check.data = FALSE), if you can ensure that all input parameters are provided in the correct format.

Examples

1
2
3
4
5
6
# Define two single-objective test problems:
fn1 = function(x) sum((x - c(0.2, 1))^2)
fn2 = function(x) 2 * x[1]^2 - x[1] * x[2] + 0.3 * x[2]^2

# c(0.2, 1) is obviously a local optimum of fn1, so let's explore the efficient set from there:
exploreEfficientSet(c(0.2, 1), fn1, fn2, max.no.steps.exploration = 50L, exploration.step = 0.05)

kerschke/mogsa documentation built on Oct. 27, 2018, 12:13 a.m.