findLocallyEfficientPoint: Find locally efficient point.

Description Usage Arguments Value Note Examples

View source: R/findLocallyEfficientPoint.R

Description

Performs sequential downhill steps in the direction of the multi-objective gradient until a locally efficient point was found. The latter possess a multi-objective gradient of length zero (see performGradientStep for details) as the normalized gradients of its objectives cancel each other out.
Note that once the local search detects that it crossed the optimum (i.e., the multi-objective gradients of succeeding iterations show in opposite directions), it will perform a weighted bisection optimization to find a local efficient point. See performWeightedBisectionOptimization for further details on the latter.

Usage

1
2
3
4
5
findLocallyEfficientPoint(ind, fn1, fn2, gradient.list = list(g1 = NULL,
  g2 = NULL), max.no.steps.ls = 500L, scale.step = 0.5,
  prec.grad = 1e-06, prec.norm = 1e-06, prec.angle = 1e-04,
  ls.method = "both", lower, upper, check.data = TRUE,
  show.info = TRUE, allow.restarts = 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.ls

[integer(1L)]
Maximum number of steps performed to find a locally efficient point. The default is 500L.

scale.step

[numeric(1L)]
Scaling factor for the step size in the direction of the multi-objective gradient. The default is 0.5.

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.

ls.method

[character(1L)]
Select between two possible local search methods: weighted bisection ("bisection"), multi-objective local search ("mo-ls") or "both" (sequentially). The default is "both".

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.

allow.restarts

[logical(1L)]
Should the algorithm be allowed to perform restarts? The default is TRUE.

Value

[list(3L)]
Returns a list, whose first element (opt.path) provides the matrix of the optimization path, which has been evaluated on the way to a locally efficient point. As the 1st row represents the initial individual (ind), the i-th row corresponds to the (i-1)-th individual.
The second element of the list (fn.evals) contains a matrix with the corresponding number of function evaluations per objective. As a result, this matrix consists of p columns and as many rows as opt.path.
The final list element (gradient.list) provides another list, whose p elements provide the single-objective gradients of the last individual from opt.path. This information might be used to safe function evaluations when proceeding with that particular individual (e.g., when exploring a potential existing 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
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
# Define two single-objective test problems:
fn1 = function(x) sum((x - c(2, 0))^2)
fn2 = function(x) sum((x - c(0, 1))^2)

# Visualize locally efficient set, i.e., the "area" where we ideally want to find a point:
plot(c(2, 0), c(0, 1), type = "o", pch = 19,
  xlab = expression(x[1]), ylab = expression(x[2]), las = 1, asp = 1)
text(2, 0, "Optimum of fn1", pos = 2, offset = 1.5)
text(0, 1, "Optimum of fn2", pos = 4, offset = 1.5)

# Place two points x1 and x2 on opposite sides of the bi-objective optimum:
x.start = c(0.3, 0.5)
points(rbind(x.start), pch = 19, type = "o", lty = "dotted")
text(rbind(x.start), labels = c("start"), pos = 2)

# Visualize path of bisection search in blue
res.bisection = findLocallyEfficientPoint(c(0.3, 0.5), fn1, fn2, ls.method = "bisection")
points(res.bisection$opt.path, pch = 20, lty = 2, type = "o", col = "blue")

# Visualize path of multi-objective local search in red
res.mo.ls = findLocallyEfficientPoint(c(0.3, 0.5), fn1, fn2, ls.method = "mo-ls")
points(res.mo.ls$opt.path, pch = 20, lty = 2, type = "o", col = "red")

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