Description Usage Arguments Details Value Author(s) References See Also Examples
Maximization of a fitness function using genetic algorithms (GAs). Local search using generalpurpose optimisation algorithms can be applied stochastically to exploit interesting regions. The algorithm can be run sequentially or in parallel using an explicit masterslave parallelisation.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27  ga(type = c("binary", "realvalued", "permutation"),
fitness, ...,
lower, upper, nBits,
population = gaControl(type)$population,
selection = gaControl(type)$selection,
crossover = gaControl(type)$crossover,
mutation = gaControl(type)$mutation,
popSize = 50,
pcrossover = 0.8,
pmutation = 0.1,
elitism = base::max(1, round(popSize*0.05)),
updatePop = FALSE,
postFitness = NULL,
maxiter = 100,
run = maxiter,
maxFitness = Inf,
names = NULL,
suggestions = NULL,
optim = FALSE,
optimArgs = list(method = "LBFGSB",
poptim = 0.05,
pressel = 0.5,
control = list(fnscale = 1, maxit = 100)),
keepBest = FALSE,
parallel = FALSE,
monitor = if(interactive()) gaMonitor else FALSE,
seed = NULL)

type 
the type of genetic algorithm to be run depending on the nature of decision variables. Possible values are:

fitness 
the fitness function, any allowable R function which takes as input an individual 
... 
additional arguments to be passed to the fitness function. This allows to write fitness functions that keep some variables fixed during the search. 
lower 
a vector of length equal to the decision variables providing the lower bounds of the search space in case of realvalued or permutation encoded optimizations. Formerly this argument was named 
upper 
a vector of length equal to the decision variables providing the upper bounds of the search space in case of realvalued or permutation encoded optimizations. Formerly this argument was named 
nBits 
a value specifying the number of bits to be used in binary encoded optimizations. 
population 
an R function for randomly generating an initial population. See 
selection 
an R function performing selection, i.e. a function which generates a new population of individuals from the current population probabilistically according to individual fitness. See 
crossover 
an R function performing crossover, i.e. a function which forms offsprings by combining part of the genetic information from their parents. See 
mutation 
an R function performing mutation, i.e. a function which randomly alters the values of some genes in a parent chromosome. See 
popSize 
the population size. 
updatePop 
a logical defaulting to 
postFitness 
a userdefined function which, if provided, receives the current 
pcrossover 
the probability of crossover between pairs of chromosomes. Typically this is a large value and by default is set to 0.8. 
pmutation 
the probability of mutation in a parent chromosome. Usually mutation occurs with a small probability, and by default is set to 0.1. 
elitism 
the number of best fitness individuals to survive at each generation. By default the top 5% individuals will survive at each iteration. 
maxiter 
the maximum number of iterations to run before the GA search is halted. 
run 
the number of consecutive generations without any improvement in the best fitness value before the GA is stopped. 
maxFitness 
the upper bound on the fitness function after that the GA search is interrupted. 
names 
a vector of character strings providing the names of decision variables. 
suggestions 
a matrix of solutions strings to be included in the initial population. If provided the number of columns must match the number of decision variables. 
optim 
a logical defaulting to 
optimArgs 
a list controlling the local search algorithm with the following components:

keepBest 
a logical argument specifying if best solutions at each iteration should be saved in a slot called 
parallel 
An optional argument which allows to specify if the Genetic Algorithm should be run sequentially or in parallel. For a single machine with multiple cores, possible values are:
In all the cases described above, at the end of the search the cluster is automatically stopped by shutting down the workers. If a cluster of multiple machines is available, evaluation of the fitness function can be executed in parallel using all, or a subset of, the cores available to the machines belonging to the cluster. However, this option requires more work from the user, who needs to set up and register a parallel back end.
In this case the cluster must be explicitly stopped with 
monitor 
a logical or an R function which takes as input the current state of the 
seed 
an integer value containing the random number generator state. This argument can be used to replicate the results of a GA search. Note that if parallel computing is required, the doRNG package must be installed. 
Genetic algorithms (GAs) are stochastic search algorithms inspired by the basic principles of biological evolution and natural selection. GAs simulate the evolution of living organisms, where the fittest individuals dominate over the weaker ones, by mimicking the biological mechanisms of evolution, such as selection, crossover and mutation.
The GA package is a collection of general purpose functions that provide a flexible set of tools for applying a wide range of genetic algorithm methods.
The ga
function enables the application of GAs to problems where the decision variables are encoded as "binary"
, "realvalued"
, or "permutation"
strings.
Default genetic operators are set via gaControl
. To retrieve the currently set operators:
1  gaControl("binary")

1  gaControl("realvalued")

1  gaControl("permutation")

Returns an object of class gaclass
. See gaclass
for a description of available slots information.
Luca Scrucca luca.scrucca@unipg.it
Back T., Fogel D., Michalewicz Z. (2000). Evolutionary Computation 1: Basic Algorithms and Operators. IOP Publishing Ltd., Bristol and Philadelphia.
Back T., Fogel D., Michalewicz Z. (2000b). Evolutionary Computation 2: Advanced Algorithms and Operators. IOP Publishing Ltd., Bristol and Philadelphia.
Coley D. (1999). An Introduction to Genetic Algorithms for Scientists and Engineers. World Scientific Pub. Co. Inc., Singapore.
Eiben A., Smith J. (2003). Introduction to Evolutionary Computing. SpringerVerlag, Berlin Heidelberg.
Goldberg D. (1989). Genetic Algorithms in Search, Optimization, and Machine Learning. AddisonWesley Professional, Boston, MA.
Haupt R. L., Haupt S. E. (2004). Practical Genetic Algorithms. 2nd edition. John Wiley & Sons, New York.
Luke S. (2013) Essentials of Metaheuristics, 2nd edition. Lulu. Freely available at http://cs.gmu.edu/~sean/book/metaheuristics/.
Scrucca L. (2013). GA: A Package for Genetic Algorithms in R. Journal of Statistical Software, 53(4), 137, http://www.jstatsoft.org/v53/i04/.
Scrucca, L. (2017) On some extensions to GA package: hybrid optimisation, parallelisation and islands evolution. The R Journal, 9/1, 187206. https://journal.rproject.org/archive/2017/RJ2017008
Simon D. (2013) Evolutionary Optimization Algorithms. John Wiley & Sons.
Sivanandam S., Deepa S. (2007). Introduction to Genetic Algorithms. SpringerVerlag, Berlin Heidelberg.
Yu X., Gen M. (2010). Introduction to Evolutionary Algorithms. SpringerVerlag, Berlin Heidelberg.
summary,gamethod
,
plot,gamethod
,
gaclass
,
ga_Population
,
ga_Selection
,
ga_Crossover
,
ga_Mutation
,
gaControl
.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91  # 1) onedimensional function
f < function(x) abs(x)+cos(x)
curve(f, 20, 20)
fitness < function(x) f(x)
GA < ga(type = "realvalued", fitness = fitness, lower = 20, upper = 20)
summary(GA)
plot(GA)
curve(f, 20, 20)
abline(v = GA@solution, lty = 3)
# 2) onedimensional function
f < function(x) (x^2+x)*cos(x) # 10 < x < 10
curve(f, 10, 10)
# write your own tracing function
monitor < function(obj)
{
curve(f, 10, 10, main = paste("iteration =", obj@iter))
points(obj@population, obj@fitness, pch = 20, col = 2)
rug(obj@population, col = 2)
Sys.sleep(0.2)
}
## Not run:
GA < ga(type = "realvalued", fitness = f, lower = 10, upper = 10, monitor = monitor)
## End(Not run)
# or if you want to suppress the tracing
GA < ga(type = "realvalued", fitness = f, lower = 10, upper = 10, monitor = NULL)
summary(GA)
monitor(GA)
abline(v = GA@solution, lty = 3)
# 3) twodimensional Rastrigin function
Rastrigin < function(x1, x2)
{
20 + x1^2 + x2^2  10*(cos(2*pi*x1) + cos(2*pi*x2))
}
x1 < x2 < seq(5.12, 5.12, by = 0.1)
f < outer(x1, x2, Rastrigin)
persp3D(x1, x2, f, theta = 50, phi = 20, col.palette = bl2gr.colors)
filled.contour(x1, x2, f, color.palette = bl2gr.colors)
GA < ga(type = "realvalued", fitness = function(x) Rastrigin(x[1], x[2]),
lower = c(5.12, 5.12), upper = c(5.12, 5.12),
popSize = 50, maxiter = 100)
summary(GA)
plot(GA)
# 4) Parallel GA
# Simple example of an expensive fitness function obtained artificially by
# introducing a pause statement.
## Not run:
Rastrigin < function(x1, x2)
{
Sys.sleep(0.1)
20 + x1^2 + x2^2  10*(cos(2*pi*x1) + cos(2*pi*x2))
}
system.time(GA1 < ga(type = "realvalued",
fitness = function(x) Rastrigin(x[1], x[2]),
lower = c(5.12, 5.12), upper = c(5.12, 5.12),
popSize = 50, maxiter = 100, monitor = FALSE,
seed = 12345))
system.time(GA2 < ga(type = "realvalued",
fitness = function(x) Rastrigin(x[1], x[2]),
lower = c(5.12, 5.12), upper = c(5.12, 5.12),
popSize = 50, maxiter = 100, monitor = FALSE,
seed = 12345, parallel = TRUE))
## End(Not run)
# 5) Hybrid GA
# Example of GA with local search
Rastrigin < function(x1, x2)
{
20 + x1^2 + x2^2  10*(cos(2*pi*x1) + cos(2*pi*x2))
}
GA < ga(type = "realvalued",
fitness = function(x) Rastrigin(x[1], x[2]),
lower = c(5.12, 5.12), upper = c(5.12, 5.12),
popSize = 50, maxiter = 100,
optim = TRUE)
summary(GA)

Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.