runMOGSA: Run MOGSA.

Description Usage Arguments Value Note Examples

View source: R/runMOGSA.R

Description

Starting from a specific point ind in the search space, MOGSA will perform multiple iterations of (a) multi-objective gradient descent towards a local efficient point, and (b) exploration of the efficient set to which the recently found efficient point belongs. These two phases are alternatively executed until the maximum number of visited basins (max.no.basins) was reached or the algorithm has found a global efficient set (or at least a multi-objective trap).

Usage

1
2
3
4
5
6
runMOGSA(ind, fn = NULL, fn1 = NULL, fn2 = NULL,
  max.no.basins = 15L, max.no.steps.ls = 600L,
  max.no.steps.exploration = 100L, scale.step = 0.5,
  exploration.step = 0.2, 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.

fn

[function]
Bi-objective problem to be optimized. Note that this function will only be considered, if its single objectives (fn1 and/or fn2) are not provided.

fn1

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

fn2

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

max.no.basins

[integer(1L)]
Maximum number of basins allowed to visit on the way to the optimum. The default is 50L.

max.no.steps.ls

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

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

scale.step

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

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.

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

[matrix]
Returns MOGSA's optimization path, consisting of the visited individuals (x1 and x2) and the visited basins (basin). Furthermore the sequential iterations performed per basin and phase of the algorithm (start, local search, exploration and external points), as well as the actual phases (type) are provided. The external points result from evaluations during the exploration phase, in which the algorithm actually evaluated a point outside of the 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
## Example 1:
# (i) Define two single-objective test problems (fn1, fn2) and a starting point (ind):
fn1 = function(x) sum((x - c(2, 0))^2)
fn2 = function(x) sum((x - c(0, 1))^2)
ind = c(1, 1)

# (ii) Visualize locally efficient set, i.e., the "area" (here: line), of globally
# non-dominated points:
plot(c(2, 0), c(0, 1), type = "o", pch = 19, lty = 2,
  xlim = c(-0.2, 2.2), ylim = c(-0.1, 1.1),
  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)

# (iii) Run MOGSA:
mogsa.result = runMOGSA(ind = ind, fn1 = fn1, fn2 = fn2)

# (iv) Visualize the optimization path of MOGSA:
points(mogsa.result[, c("x1", "x2")],
  col = as.integer(mogsa.result$type) + 1L,
  pch = as.integer(mogsa.result$type) + 14L)
legend("topright", pch = 15:18, col = 2:5, legend = levels(mogsa.result$type))

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