# findLocallyEfficientPoint: Find locally efficient point. In kerschke/mogsa: A Multi-Objective Optimization Algorithm Based on Multi-Objective Gradients

## 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.