abc_optim {ABCoptim} R Documentation

Artificial Bee Colony Optimization

Description

Implements Karaboga (2005) Artificial Bee Colony (ABC) Optimization algorithm.

Usage

abc_optim(par, fn, ..., FoodNumber = 20, lb = rep(-Inf, length(par)),
ub = rep(+Inf, length(par)), limit = 100, maxCycle = 1000,
optiinteger = FALSE, criter = 50, parscale = rep(1, length(par)),
fnscale = 1)

## S3 method for class 'abc_answer'
print(x, ...)

abc_cpp(par, fn, ..., FoodNumber = 20, lb = rep(-Inf, length(par)),
ub = rep(+Inf, length(par)), limit = 100, maxCycle = 1000,
criter = 50, parscale = rep(1, length(par)), fnscale = 1)

## S3 method for class 'abc_answer'
plot(x, y = NULL,
main = "Trace of the Objective Function", xlab = "Number of iteration",
ylab = "Value of the objective Function", type = "l", ...)

Arguments

 par Initial values for the parameters to be optimized over fn A function to be minimized, with first argument of the vector of parameters over which minimization is to take place. It should return a scalar result. ... In the case of abc_*, further arguments to be passed to 'fn', otherwise, further arguments passed to the method. FoodNumber Number of food sources to exploit. Notice that the param NP has been deprecated. lb Lower bound of the parameters to be optimized. ub Upper bound of the parameters to be optimized. limit Limit of a food source. maxCycle Maximum number of iterations. optiinteger Whether to optimize binary parameters or not. criter Stop criteria (numer of unchanged results) until stopping parscale Numeric vector of length length(par). Scale applied to the parameters (see optim). fnscale Numeric scalar. Scale applied function. If fnscale < 0, then the problem becomes a maximization problem (see optim). x An object of class abc_answer. y Ignored main Passed to plot. xlab Passed to plot. ylab Passed to plot. type Passed to plot.

Details

This implementation of the ABC algorithm was developed based on the basic version written in C and published at the algorithm's official website (see references).

abc_optim and abc_cpp are two different implementations of the algorithm, the former using pure R code, and the later using C++, via the Rcpp package. Besides of the output, another important difference between the two implementations is speed, with abc_cpp showing between 50% and 100% faster performance.

Upper and Lower bounds (ub, lb) equal to infinite will be replaced by either .Machine\$double.xmax or -.Machine\$double.xmax.

If D (the number of parameters to be optimzed) is greater than one, then lb and ub can be either scalars (assuming that all the parameters share the same boundaries) or vectors (the parameters have different boundaries each other).

The plot method shows the trace of the objective function as the algorithm unfolds. The line is merely the result of the objective function evaluated at each point (row) of the hist matrix return by abc_optim/abc_cpp.

For now, the function will return with error if ... was passed to abc_optim/abc_cpp, since those argumens are not stored with the result.

Value

An list of class abc_answer, holding the following elements:

 Foods Numeric matrix. Last position of the bees. f Numeric vector. Value of the function evaluated at each set of Foods. fitness Numeric vector. Fitness of each Foods. trial Integer vector. Number of trials at each Foods. value Numeric scalar. Value of the function evaluated at the optimum. par Numeric vector. Optimum found. counts Integer scalar. Number of cycles. hist Numeric matrix. Trace of the global optimums.

Author(s)

George Vega Yon g.vegayon@gmail.com

References

D. Karaboga, An Idea based on Honey Bee Swarm for Numerical Optimization, tech. report TR06,Erciyes University, Engineering Faculty, Computer Engineering Department, 2005 http://mf.erciyes.edu.tr/abc/pub/tr06_2005.pdf

Artificial Bee Colony (ABC) Algorithm (website) http://mf.erciyes.edu.tr/abc/index.htm

Basic version of the algorithm implemented in C (ABC's official website) http://mf.erciyes.edu.tr/abc/form.aspx

Examples

# EXAMPLE 1: The minimum is at (pi,pi) --------------------------------------

fun <- function(x) {
-cos(x)*cos(x)*exp(-((x - pi)^2 + (x - pi)^2))
}

abc_optim(rep(0,2), fun, lb=-10, ub=10, criter=50)

# This should be equivalent
abc_cpp(rep(0,2), fun, lb=-10, ub=10, criter=50)

# We can also turn this into a maximization problem, and get the same
# results
fun <- function(x) {
# We've removed the '-' from the equation
cos(x)*cos(x)*exp(-((x - pi)^2 + (x - pi)^2))
}

abc_cpp(rep(0,2), fun, lb=-10, ub=10, criter=50, fnscale = -1)

# EXAMPLE 2: global minimum at about (-15.81515) ----------------------------

fw <- function (x)
10*sin(0.3*x)*sin(1.3*x^2) + 0.00001*x^4 + 0.2*x+80

ans <- abc_optim(50, fw, lb=-100, ub=100, criter=100)
ans[c("par", "counts", "value")]

# EXAMPLE 3: 5D sphere, global minimum at about (0,0,0,0,0) -----------------
fs <- function(x) sum(x^2)

ans <- abc_optim(rep(10,5), fs, lb=-100, ub=100, criter=200)
ans[c("par", "counts", "value")]

# EXAMPLE 4: An Ordinary Linear Regression ----------------------------------

set.seed(1231)
k <- 4
n <- 5e2

# Data generating process
w <- matrix(rnorm(k), ncol=1)     # This are the model parameters
X <- matrix(rnorm(k*n), ncol = k) # This are the controls
y <- X %*% w                      # This is the observed data

# Objective function
fun <- function(x) {
sum((y - X%*%x)^2)
}

# Running the regression
ans <- abc_optim(rep(0,k), fun, lb = -10000, ub=10000)

# Here are the outcomes: Both columns should be the same
cbind(ans\$par, w)
#             [,1]        [,2]
# [1,] -0.08051177 -0.08051177
# [2,]  0.69528553  0.69528553
# [3,] -1.75956316 -1.75956316
# [4,]  0.36156427  0.36156427

# This is just like OLS, with no constant
coef(lm(y~0+X))
#         X1          X2          X3          X4
#-0.08051177  0.69528553 -1.75956316  0.36156427

[Package ABCoptim version 0.15.0 Index]