Learn R Programming

MOEADr package


Felipe Campelo Department of Computer Science
Aston University
Birmingham, UK

Lucas Batista
Operations Research and Complex Systems Laboratory - ORCS Lab
Universidade Federal de Minas Gerais
Belo Horizonte, Brazil

Claus Aranha
Faculty of Engineering, Information and Systems
University of Tsukuba
Tsukuba, Japan


R package containing a component-based, modular implementation of the Multiobjective Evolutionary Algorithm with Decomposition (MOEA/D) framework.

The MOEA/D framework is seen as a combination of specific design decisions regarding several independent modules:

  • Decomposition strategy;
  • Aggregation function;
  • Objective scaling strategy;
  • Neighborhood assignment strategy;
  • Variation Stack;
  • Update strategy;
  • Constraint handling method;
  • Termination criteria.

This package provides several options for each module, as explained in the documentation of its main function, MOEADr::moead(). The input structure of this function is also explained in its documentation. More details on the component-based approach behind the MOEADr package are available in our paper, The MOEADr Package - A Component-Based Framework for Multiobjective Evolutionary Algorithms Based on Decomposition, available on the ArXiv: https://arxiv.org/abs/1807.06731.

To install the current release version in your system, simply use:

install.packages("MOEADr")

For the most up-to-date development version, install the github version using:

# install.packages("devtools")
devtools::install_github("fcampelo/MOEADr")

Example

As a simple example, we can reproduce the original MOEA/D (Zhang and Li, 2007) and run it on a 30-variable ZDT1 function:

 ## 1: prepare test problem
 library(smoof)
 ZDT1 <- make_vectorized_smoof(prob.name  = "ZDT1",
                               dimensions = 30)

 ## 2: set input parameters
 problem   <- list(name       = "ZDT1",
                   xmin       = rep(0, 30),
                   xmax       = rep(1, 30),
                   m          = 2)
 decomp    <- list(name       = "SLD", H = 99)
 neighbors <- list(name       = "lambda",
                   T          = 20,
                   delta.p    = 1)
 aggfun    <- list(name       = "wt")
 variation <- list(list(name  = "sbx",
                        etax  = 20, pc = 1),
                   list(name  = "polymut",
                        etam  = 20, pm = 0.1),
                   list(name  = "truncate"))
 update    <- list(name       = "standard", 
                   UseArchive = FALSE)
 scaling   <- list(name       = "none")
 constraint<- list(name       = "none")
 stopcrit  <- list(list(name  = "maxiter",
                     maxiter  = 200))
 showpars  <- list(show.iters = "dots",
                   showevery  = 10)
 seed      <- NULL

 ## 3: run MOEA/D
 out1 <- moead(problem = problem, 
               decomp = decomp, aggfun = aggfun, neighbors = neighbors, variation = variation, 
               update = update, constraint = constraint, scaling = scaling, stopcrit = stopcrit,
               showpars = showpars, seed = seed)

 ## 3.1: For your convenience, you can also use the preset_moead() function to reproduce the above setup, 
 ##      and only modify the desired parts:
 
 out2 <- moead(problem = problem,
               preset = preset_moead("original"), 
               stopcrit = list(list(name = "maxiter", maxiter = 1000)),
               showpars = showpars, seed = 42)

 # 4: Plot output:
 plot(out1$Y[,1], out1$Y[,2], type = "p", pch = 20)

Have fun!
Felipe

Copy Link

Version

Install

install.packages('MOEADr')

Monthly Downloads

191

Version

1.1.3

License

GPL-2

Maintainer

Felipe Campelo

Last Published

January 8th, 2023

Functions in MOEADr (1.1.3)

calcIGD

Inverted Generational Distance
box_constraints

Box constraints routine
check_stop_criteria

Stop criteria for MOEA/D
constraint_none

NULL constraint handling method for MOEA/D
generate_weights

Calculate weight vectors
get_localsearch_methods

Print available local search methods
get_scalarization_methods

Print available scalarization methods
get_decomposition_methods

Print available decomposition methods
get_stop_criteria

Print available stop criteria
evaluate_population

Evaluate population
find_nondominated_points

Find non-dominated points
define_neighborhood

Calculate neighborhood relations
example_problem

Example problem
get_constraint_methods

Print available constraint methods
order_neighborhood

Order Neighborhood for MOEA/D
perform_variation

Run variation operators
make_vectorized_smoof

Make vectorized smoof function
get_update_methods

Print available update methods
plot.moead

plot.moead
ls_dvls

Differential vector-based local search
ls_tpqa

Three-point quadratic approximation local search
preset_moead

preset_moead
stop_maxeval

Stop criterion: maximum number of evaluations
scale_objectives

Scaling of the objective function values
get_variation_operators

Print available variation operators
scalarization_ipbi

Inverted Penalty-based Boundary Intersection Scalarization
scalarization_pbi

Penalty-based Boundary Intersection Scalarization
scalarization_ws

Weighted Sum Scalarization
scalarize_values

Scalarize values for MOEA/D
scalarization_wt

Weighted Tchebycheff Scalarization
scalarization_awt

Adjusted Weighted Tchebycheff Scalarization
update_population

Update population
updt_best

Best Neighborhood Replacement Update for MOEA/D
print.moead

print.moead
updt_restricted

Restricted Neighborhood Replacement Update for MOEA/D
print_progress

Print progress of MOEA/D
stop_maxiter

Stop criterion: maximum number of iterations
moead

MOEA/D
stop_maxtime

Stop criterion: maximum runtime
summary.moead

summary.moead
updt_standard

Standard Neighborhood Replacement Update for MOEA/D
variation_polymut

Polynomial mutation
variation_binrec

Binomial Recombination
variation_localsearch

Local search Operators
variation_none

Identity operator
variation_diffmut

Differential Mutation
variation_sbx

Simulated binary crossover
variation_truncate

Truncate
unitary_constraints

Unitary constraints routine
create_population

Create population
decomposition_msld

Problem Decomposition using Multi-layered Simplex-lattice Design
decomposition_sld

Problem Decomposition using Simplex-lattice Design
decomposition_uniform

Problem Decomposition using Uniform Design
constraint_penalty

"Penalty" constraint handling method for MOEA/D
constraint_vbr

"Violation-based Ranking" constraint handling method for MOEA/D