Title:	Mixed Integer Evolution Strategies
Description:	Evolutionary black box optimization algorithms building on the 'bbotk' package. 'miesmuschel' offers both ready-to-use optimization algorithms, as well as their fundamental building blocks that can be used to manually construct specialized optimization loops. The Mixed Integer Evolution Strategies as described by Li et al. (2013) <doi:10.1162/EVCO_a_00059> can be implemented, as well as the multi-objective optimization algorithms NSGA-II by Deb, Pratap, Agarwal, and Meyarivan (2002) <doi:10.1109/4235.996017>.
URL:	https://github.com/mlr-org/miesmuschel
BugReports:	https://github.com/mlr-org/miesmuschel/issues
License:	MIT + file LICENSE
Encoding:	UTF-8
ByteCompile:	yes
Version:	0.0.4-3
Depends:	paradox (≥ 0.7.1)
Imports:	mlr3misc (≥ 0.5.0), checkmate (≥ 1.9.0), R6, bbotk (≥ 0.3.0.900), data.table, matrixStats, lgr
Suggests:	tinytest, mlr3tuning, mlr3, mlr3learners, ranger, xgboost, rpart
RoxygenNote:	7.3.2
Collate:	'dictionaries.R' 'MiesOperator.R' 'Filtor.R' 'FiltorMaybe.R' 'FiltorNull.R' 'FiltorProxy.R' 'FiltorSurrogate.R' 'FiltorSurrogateProgressive.R' 'FiltorSurrogateTournament.R' 'Mutator.R' 'MutatorCmpMaybe.R' 'MutatorDiscreteUniform.R' 'MutatorErase.R' 'MutatorGauss.R' 'MutatorMaybe.R' 'MutatorNull.R' 'MutatorProxy.R' 'MutatorSequential.R' 'ParamSetShadow.R' 'OperatorCombination.R' 'Recombinator.R' 'Selector.R' 'mies_methods.R' 'OptimizerMies.R' 'RecombinatorCmpMaybe.R' 'RecombinatorConvex.R' 'RecombinatorConvexPair.R' 'RecombinatorCrossoverNary.R' 'RecombinatorCrossoverUniform.R' 'RecombinatorMaybe.R' 'RecombinatorNull.R' 'RecombinatorProxy.R' 'RecombinatorSequential.R' 'RecombinatorSimulatedBinaryCrossover.R' 'RecombinatorSwap.R' 'Scalor.R' 'ScalorAggregate.R' 'ScalorDomcount.R' 'ScalorFixedProjections.R' 'ScalorHypervolume.R' 'ScalorNondom.R' 'ScalorOne.R' 'ScalorProxy.R' 'ScalorSingleObjective.R' 'SelectorBest.R' 'SelectorMaybe.R' 'SelectorNull.R' 'SelectorProxy.R' 'SelectorRandom.R' 'SelectorSequential.R' 'SelectorTournament.R' 'TerminatorBudget.R' 'TerminatorGenerationPerfReached.R' 'TerminatorGenerationStagnation.R' 'TerminatorGenerations.R' 'TunerMies.R' 'bibentries.R' 'repr.R' 'utils.R' 'utils_mo.R' 'zzz.R'
NeedsCompilation:	no
Packaged:	2025-03-19 17:34:09 UTC; user
Author:	Martin Binder [aut, cre], Lennart Schneider [ctb], Susanne Dandl [ctb], Andreas Hofheinz [ctb]
Maintainer:	Martin Binder <mlr.developer@mb706.com>
Repository:	CRAN
Date/Publication:	2025-03-19 19:10:02 UTC

miesmuschel: Mixed Integer Evolution Strategies

Description

miesmuschel offers both an Optimizer and a Tuner for general MIES-optimization, as well as all the building blocks for building a custom optimization algorithm that is more flexible and can be used for research into novel evolution strategies.

The call-graph of the default algorithm in OptimizerMies / TunerMies is as follows, and is shown here as an overview over the ⁠mies_*⁠ functions, and how they are usually connected. (Note that only the exported ⁠mies_*⁠ functions are shown.) See the help information of these functions for more info.

OptimizerMies$.optimize(inst)
|- mies_prime_operators()  # prime operators on instance's search_space
|- mies_init_population()  # sample and evaluate first generation
|  `- mies_evaluate_offspring()  # evaluate sampled individuals
|     `- inst$eval_batch()  # The OptimInst's evaluation method
`- repeat # Repeat the following until terminated
   |- mies_step_fidelity()  # Evaluate individuals with changing fidelity
   |  `- inst$eval_batch()  # The OptimInst's evaluation method
   |- mies_generate_offspring()  # Sample parents, recombine, mutate
   |  `- mies_select_from_archive()  # Use 'Selector' on 'Archive'
   |     `- mies_get_fitnesses()  # Get objective values as fitness matrix
   |- mies_evaluate_offspring()  # evaluate sampled individuals
   |  `- inst$eval_batch()  # The OptimInst's evaluation method
   `- mies_survival_plus() / mies_survival_comma()  # survival
      `- mies_select_from_archive()  # Use 'Selector' on 'Archive'

Author(s)

Maintainer: Martin Binder mlr.developer@mb706.com

Other contributors:

• Lennart Schneider lennart.sch@web.de (ORCID) [contributor]

• Susanne Dandl dandl.susanne@googlemail.com (ORCID) [contributor]

• Andreas Hofheinz andreas.hofheinz@outlook.com [contributor]

See Also

Useful links:

• https://github.com/mlr-org/miesmuschel

• Report bugs at https://github.com/mlr-org/miesmuschel/issues

Filtor Base Class

Description

Base class representing filter operations, inheriting from MiesOperator.

A Filtor gets a table of individuals that are to be filtered, as well as a table of individuals that were already evaluated, along with information on the latter individuals' performance values. Furthermore, the number of individuals to return is given. The Filtor returns a vector of unique integers indicating which individuals were selected.

Filter operations are performed in ES algorithms to facilitate concentration towards individuals that likely perform well with regard to the fitness measure, without evaluating the fitness measure, for example through a surrogate model.

Fitness values are always maximized, both in single- and multi-criterion optimization.

Unlike most other operator types inheriting from MiesOperator, the ⁠$operate()⁠ function has four arguments, which are passed on to ⁠$.filter()⁠

• values :: data.frame
  Individuals to filter. Must pass the check of the ParamSet given in the last ⁠$prime()⁠ call and may not have any missing components.

• known_values :: data.frame
  Individuals to use for filtering. Must pass the check of the ParamSet given in the last ⁠$prime()⁠ call and may not have any missing components. Note that known_values may be empty.

• fitnesses :: numeric | matrix
  Fitnesses for each individual given in known_values. If this is a numeric, then its length must be equal to the number of rows in values. If this is a matrix, if number of rows must be equal to the number of rows in values, and it must have one column when doing single-crit optimization and one column each for each "criterion" when doing multi-crit optimization.

• n_filter :: integer(1)
  Number of individuals to select. Some Filtors select individuals with replacement, for which this value may be greater than the number of rows in values.

The return value for an operation will be a numeric vector of integer values of ength n_filter indexing the individuals that were selected. Filtor must always return unique integers, i.e. select every individual at most once.

Inheriting

Filtor is an abstract base class and should be inherited from. Inheriting classes should implement the private ⁠$.filter()⁠ function. The user of the object calls ⁠$operate()⁠, and the arguments are passed on to private ⁠$.filter()⁠ after checking that the operator is primed, that the values and known_values arguments conforms to the primed domain and that other values match.

The private$.needed_input() function should also be overloaded, it is called by the public ⁠$needed_input()⁠ function after initial checks; see the documentation there.

Typically, the ⁠$initialize()⁠ function should also be overloaded, and optionally the ⁠$prime()⁠ function; they should call their super equivalents.

Super class

miesmuschel::MiesOperator -> Filtor

Active bindings

Methods

Public methods

• Filtor$new()

• Filtor$needed_input()

• Filtor$clone()

Method new()

Initialize base class components of the Filtor.

Usage

Filtor$new(
  param_classes = c("ParamLgl", "ParamInt", "ParamDbl", "ParamFct"),
  param_set = ps(),
  supported = c("single-crit", "multi-crit"),
  packages = character(0),
  dict_entry = NULL,
  own_param_set = quote(self$param_set)
)

Arguments

Method needed_input()

Calculate the number of values that are required to filter down to output_size, given the current configuraiton parameter settings.

Usage

Filtor$needed_input(output_size)

Arguments

Returns

integer(1): The minimum number of rows required to filter down to output_size. At least output_size.

Method clone()

The objects of this class are cloneable with this method.

Usage

Filtor$clone(deep = FALSE)

Arguments

See Also

Other base classes: FiltorSurrogate, MiesOperator, Mutator, MutatorDiscrete, MutatorNumeric, OperatorCombination, Recombinator, RecombinatorPair, Scalor, Selector, SelectorScalar

Other filtors: FiltorSurrogate, dict_filtors_maybe, dict_filtors_null, dict_filtors_proxy, dict_filtors_surprog, dict_filtors_surtour

Abstract Surrogate Model Filtering Base Class

Description

Abstract base class for surrogate model filtering.

A surrogate model is a regression model, based on an mlr3::Learner, which predicts the approximate performance of newly sampled configurations given the empirical performance of already evaluated configurations. The surrogate model can be used to propose points that have, according to the surrogate model, a relatively high chance of performing well.

The FiltorSurrogate base class can be inherited from to create different Filtors that filter based on a surrogate model, for example tournament filtering or progresive filtering.

Configuration Parameters

FiltorSurrogateProgressive's configuration parameters are the hyperparameters of the surrogate_learner Learner, as well as the configuration parameters of the surrogate_selector Selector.

Supported Operand Types

Supported Domain classes depend on the supported feature types of the surrogate_learner, as reported by surrogate_learner$feature_types: "ParamInt" requires "integer", "ParamDbl" requires "numeric", "ParamLgl" requires "logical", and "ParamFct" requires "factor".

Super classes

miesmuschel::MiesOperator -> miesmuschel::Filtor -> FiltorSurrogate

Active bindings

Methods

Public methods

• FiltorSurrogate$new()

• FiltorSurrogate$prime()

• FiltorSurrogate$clone()

Method new()

Initialize the base class components of the FiltorSurrogate.

Usage

FiltorSurrogate$new(
  surrogate_learner,
  surrogate_selector = SelectorBest$new(),
  param_set = ps(),
  packages = character(0),
  dict_entry = NULL
)

Arguments

Method prime()

See MiesOperator method. Primes both this operator, as well as the wrapped operator given to surrogate_selector during construction.

Usage

FiltorSurrogate$prime(param_set)

Arguments

Returns

invisible self.

Method clone()

The objects of this class are cloneable with this method.

Usage

FiltorSurrogate$clone(deep = FALSE)

Arguments

See Also

Other base classes: Filtor, MiesOperator, Mutator, MutatorDiscrete, MutatorNumeric, OperatorCombination, Recombinator, RecombinatorPair, Scalor, Selector, SelectorScalar

Other filtors: Filtor, dict_filtors_maybe, dict_filtors_null, dict_filtors_proxy, dict_filtors_surprog, dict_filtors_surtour

Operator Base Class

Description

Base class representing MIES-operators: Recombinator, Mutator, and Selector.

Operators perform a specific function within ES algorithms, and by exchanging them, the character of ES algorithms can be modified. Operators operate on collections of individuals and return modified individuals (mutated or recombined) or indices of selected individuals. Operators can be combined using MutatorCombination / RecombinatorCombination and other operators wrappers.

Before applying operators, they have to be primed for the domain of the individuals which they are operating on; this is done using the ⁠$prime()⁠ function. Afterwards, the ⁠$operate()⁠ function may be called with a data.frame of individuals that fall into this domain. ⁠$operate()⁠ may be called multiple times after priming, and a once primed operator can be primed again for a different domain by calling ⁠$prime()⁠ agian (which forgets the old priming).

Inheriting

MiesOperator is an abstract base class and should be inherited from. Inheriting classes should implement the private ⁠$.operate()⁠ function. The user of the object calls ⁠$operate()⁠, and the arguments are passed on to private ⁠$.operate()⁠ after checking that the operator is primed, and that the values argument conforms to the primed domain. Typically, the ⁠$initialize()⁠ and ⁠$prime()⁠ functions are also overloaded, but should call their super equivalents.

In most cases, the MiesOperator class should not be inherited from, directly; instead, the operator classes (Recombinator, Mutator, Selector) or their subclasses should be inherited.

Active bindings

Methods

Public methods

• MiesOperator$new()

• MiesOperator$repr()

• MiesOperator$print()

• MiesOperator$prime()

• MiesOperator$operate()

• MiesOperator$help()

• MiesOperator$clone()

Method new()

Initialize base class components of the MiesOperator.

Usage

MiesOperator$new(
  param_classes = c("ParamLgl", "ParamInt", "ParamDbl", "ParamFct"),
  param_set = ps(),
  packages = character(0),
  dict_entry = NULL,
  dict_shortaccess = NULL,
  own_param_set = quote(self$param_set),
  endomorphism = TRUE
)

Arguments

Method repr()

Create a call object representing this operator.

Usage

MiesOperator$repr(
  skip_defaults = TRUE,
  show_params = TRUE,
  show_constructor_args = TRUE,
  ...
)

Arguments

Method print()

Print this operator.

Usage

MiesOperator$print(verbose = FALSE, ...)

Arguments

Method prime()

Prepare the MiesOperator to function on the given ParamSet. This must be called before ⁠$operate()⁠. It may be called multiple times in the lifecycle of the MiesOperator object, and prior primings are forgotten when priming on a new ParamSet. The ParamSet on which the MiesOperator was last primed can be read from ⁠$primed_ps⁠.

Usage

MiesOperator$prime(param_set)

Arguments

Returns

invisible self.

Method operate()

Operate on the given individuals. This calls private ⁠$.operate()⁠, which must be overloaded by an inheriting class, passing through all function arguments after performing some checks.

Usage

MiesOperator$operate(values, ...)

Arguments

Returns

data.frame: the result of the operation. If the input was a data.table instead of a data.frame, the output is also data.table.

Method help()

Run utils::help() for this object.

Usage

MiesOperator$help(help_type = getOption("help_type"))

Arguments

Returns

help_files_with_dopic object, which opens the help page.

Method clone()

The objects of this class are cloneable with this method.

Usage

MiesOperator$clone(deep = FALSE)

Arguments

See Also

Other base classes: Filtor, FiltorSurrogate, Mutator, MutatorDiscrete, MutatorNumeric, OperatorCombination, Recombinator, RecombinatorPair, Scalor, Selector, SelectorScalar

Mutator Base Class

Description

Base class representing mutation operations, inheriting from MiesOperator.

Mutations get a table of individuals as input and return a table of modified individuals as output. Individuals are acted on as individuals: every line of output corresponds to the same line of input, and presence or absence of other input lines does not affect the result.

Mutation operations are performed in ES algorithms to facilitate exploration of the search space around individuals.

Inheriting

Mutator is an abstract base class and should be inherited from. Inheriting classes should implement the private ⁠$.mutate()⁠ function. The user of the object calls ⁠$operate()⁠, and the arguments are passed on to private ⁠$.mutate()⁠ after checking that the operator is primed, and that the values argument conforms to the primed domain. Typically, the ⁠$initialize()⁠ function should also be overloaded, and optionally the ⁠$prime()⁠ function; they should call their super equivalents.

In many cases, it is advisable to inherit from one of the abstract subclasses, such as MutatorNumeric, or MutatorDiscrete.

Super class

miesmuschel::MiesOperator -> Mutator

Methods

Public methods

• Mutator$new()

• Mutator$clone()

Method new()

Initialize base class components of the Mutator.

Usage

Mutator$new(
  param_classes = c("ParamLgl", "ParamInt", "ParamDbl", "ParamFct"),
  param_set = ps(),
  packages = character(0),
  dict_entry = NULL,
  own_param_set = quote(self$param_set)
)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

Mutator$clone(deep = FALSE)

Arguments

See Also

Other base classes: Filtor, FiltorSurrogate, MiesOperator, MutatorDiscrete, MutatorNumeric, OperatorCombination, Recombinator, RecombinatorPair, Scalor, Selector, SelectorScalar

Other mutators: MutatorDiscrete, MutatorNumeric, OperatorCombination, dict_mutators_cmpmaybe, dict_mutators_erase, dict_mutators_gauss, dict_mutators_maybe, dict_mutators_null, dict_mutators_proxy, dict_mutators_sequential, dict_mutators_unif

Discrete Mutator Base Class

Description

Base class for mutation operations on discrete individuals, inheriting from Mutator.

MutatorDiscrete operators perform mutation on discrete (logical and factor valued) individuals. Inheriting operators implement the private ⁠$.mutate_discrete()⁠ function that is called once for each individual and is given a character vector.

Inheriting

MutatorDiscrete is an abstract base class and should be inherited from. Inheriting classes should implement the private ⁠$.mutate_discrete()⁠ function. During ⁠$operate()⁠, the ⁠$.mutate_discrete()⁠ function is called once for each individual, with the parameters values (the individual as a single character vector), and levels (a list of character containing the possible values for each element of values). Typically, ⁠$initialize()⁠ should also be overloaded.

Super classes

miesmuschel::MiesOperator -> miesmuschel::Mutator -> MutatorDiscrete

Methods

Public methods

• MutatorDiscrete$new()

• MutatorDiscrete$clone()

Method new()

Initialize base class components of the MutatorNumeric.

Usage

MutatorDiscrete$new(
  param_classes = c("ParamLgl", "ParamFct"),
  param_set = ps(),
  packages = character(0),
  dict_entry = NULL,
  own_param_set = quote(self$param_set)
)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

MutatorDiscrete$clone(deep = FALSE)

Arguments

See Also

Other base classes: Filtor, FiltorSurrogate, MiesOperator, Mutator, MutatorNumeric, OperatorCombination, Recombinator, RecombinatorPair, Scalor, Selector, SelectorScalar

Other mutators: Mutator, MutatorNumeric, OperatorCombination, dict_mutators_cmpmaybe, dict_mutators_erase, dict_mutators_gauss, dict_mutators_maybe, dict_mutators_null, dict_mutators_proxy, dict_mutators_sequential, dict_mutators_unif

Numeric Mutator Base Class

Description

Base class for mutation operations on numeric and integer valued individuals, inheriting from Mutator.

MutatorNumeric operators perform mutation on numeric (integer and real valued) individuals. Inheriting operators implement the private ⁠$.mutate_numeric()⁠ function that is called once for each individual and is given a numeric vector.

Inheriting

MutatorNumeric is an abstract base class and should be inherited from. Inheriting classes should implement the private ⁠$.mutate_numeric()⁠ function. During ⁠$operate()⁠, the ⁠$.mutate_numeric()⁠ function is called once for each individual, with the parameters values (the individual as a single numeric vector), lowers and uppers (numeric vectors, the lower and upper bounds for each component of values). Typically, ⁠$initialize()⁠ should also be overloaded.

MutatorNumerics that perform real-valued operations, such as e.g. MutatorGauss, operate on integers by widening the lower and upper bounds of integer components by 0.5, applying their operation, and rounding resulting values to the nearest integer (while always staying inside bounds).

Super classes

miesmuschel::MiesOperator -> miesmuschel::Mutator -> MutatorNumeric

Methods

Public methods

• MutatorNumeric$new()

• MutatorNumeric$clone()

Method new()

Initialize base class components of the MutatorNumeric.

Usage

MutatorNumeric$new(
  param_classes = c("ParamInt", "ParamDbl"),
  param_set = ps(),
  packages = character(0),
  dict_entry = NULL,
  own_param_set = quote(self$param_set)
)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

MutatorNumeric$clone(deep = FALSE)

Arguments

See Also

Other base classes: Filtor, FiltorSurrogate, MiesOperator, Mutator, MutatorDiscrete, OperatorCombination, Recombinator, RecombinatorPair, Scalor, Selector, SelectorScalar

Other mutators: Mutator, MutatorDiscrete, OperatorCombination, dict_mutators_cmpmaybe, dict_mutators_erase, dict_mutators_gauss, dict_mutators_maybe, dict_mutators_null, dict_mutators_proxy, dict_mutators_sequential, dict_mutators_unif

Self-Adaptive Operator Combinations

Description

Combines multiple operators and makes operator-configuration parameters self-adaptive.

The OperatorCombination operators combine operators for different subspaces of individuals by wraping other MiesOperators given during construction. Different MiesOperators are assigned to different components or sets of components and operate on them independently of the rest of the components or the other operators. An operator can be assigned to a single component by giving it in operators with the name of the component, or to multiple components by giving it in operators with the name of a group. Groups are created by the groups argument, but several default groups that catch components by type exist.

Details

Operators can be made self-adaptive by coupling their configuration parameter values to values in individuals. This is done by giving functions in adaptions; these functions are executed for each individual before an operator is applied, and the result given to a named operator configuration parameter.

OperatorCombination is the base class from which MutatorCombination and RecombinatorCombination inherit. The latter two are to be used for Mutator and Recombinator objects, respectively.

Besides groups created with the groups construction argument, there are special groups that all unnamed operators fall into based on their Domain class: "ParamInt", "ParamDbl", "ParamFct", and "ParamLgl". A component of an individual that is not named directly in operators or made part of a group in groups is automatically in one of these special groups. There is furthermore a special catch-all group "ParamAny", which catches all components that are are not operated directly, not in a group, and not in another special group that is itself named directly or in a group. I.e., all components that would otherwise have no assigned operation.

RecombinatorCombination can only combine operators where ⁠$n_indivs_in⁠ and ⁠$n_indivs_out⁠ can be combined. This is currently supported either when ⁠$n_indivs_in⁠ and ⁠$n_indivs_out⁠ for each operator are the same (but ⁠$n_indivs_in⁠ may be unequal ⁠$n_indivs_out⁠ in eacho of them); or when ⁠$n_indivs_in⁠ is equal to ⁠$n_indivs_out⁠ for each operator and the set of all ⁠$n_indivs_in⁠ that occur contains 1 and one more integer. ⁠$n_indivs_in⁠ and ⁠$n_indivs_out⁠ for the resulting RecombinatorCombination operator will be set the maximum of occuring ⁠$n_indivs_in⁠ and ⁠$n_indivs_out⁠, respectively.

Supported Operand Types

Supported Domain classes are calculated based on the supported classes of the wrapped operators. They are frequently just the set union of supported classes, unless inference can be drawn from type-specific groups that an operator is assigned to. If e.g. an operator that supports p_dbl and p_int is assigned to group "ParamInt", and an operator that supports p_lgl is assigned to component "a", then the result will support p_lgl and p_int only.

Configuration Parameters

The OperatorCombination has the configuration parameters of all encapsulated MiesOperators, minus the configuration parameters that are named in the adaptions. Configuration parameter names are prefixed with the name of the MiesOperator in the operators list.

Dictionary

This Mutator can be created with the short access form mut() (muts() to get a list), or through the the dictionary dict_mutators in the following way:

# preferred:
mut("combine", <operators>, ...)
muts("combine", <operators>, ...)  # takes vector IDs, returns list of Mutators

# long form:
dict_mutators$get("combine", <operators>, ...)

This Recombinator can be created with the short access form rec() (recs() to get a list), or through the the dictionary dict_recombinators in the following way:

# preferred:
rec("combine", <operators>, ...)
recs("combine", <operators>, ...)  # takes vector IDs, returns list of Recombinators

# long form:
dict_recombinators$get("combine", <operators>, ...)

Super class

miesmuschel::MiesOperator -> OperatorCombination

Active bindings

Methods

Public methods

• OperatorCombination$new()

• OperatorCombination$prime()

• OperatorCombination$clone()

Method new()

Initialize the OperatorCombination object.

Usage

OperatorCombination$new(
  operators,
  groups = list(),
  adaptions = list(),
  binary_fct_as_logical = FALSE,
  on_type_not_present = "warn",
  on_name_not_present = "stop",
  granularity = 1,
  dict_entry = NULL,
  dict_shortaccess = NULL
)

Arguments

Method prime()

See MiesOperator method. Primes both this operator, as well as the wrapped operators given to operators during construction. Priming of wrapped operators happens according to component assignments to wrapped operators.

Usage

OperatorCombination$prime(param_set)

Arguments

Returns

invisible self.

Method clone()

The objects of this class are cloneable with this method.

Usage

OperatorCombination$clone(deep = FALSE)

Arguments

Super classes

miesmuschel::MiesOperator -> miesmuschel::OperatorCombination -> MutatorCombination

Methods

Public methods

• MutatorCombination$new()

• MutatorCombination$clone()

Method new()

Initialize the MutatorCombination object.

Usage

MutatorCombination$new(
  operators = list(),
  groups = list(),
  adaptions = list(),
  binary_fct_as_logical = FALSE,
  on_type_not_present = "warn",
  on_name_not_present = "stop"
)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

MutatorCombination$clone(deep = FALSE)

Arguments

Super classes

miesmuschel::MiesOperator -> miesmuschel::OperatorCombination -> RecombinatorCombination

Active bindings

Methods

Public methods

• RecombinatorCombination$new()

• RecombinatorCombination$clone()

Method new()

Initialize the RecombinatorCombination object.

Usage

RecombinatorCombination$new(
  operators = list(),
  groups = list(),
  adaptions = list(),
  binary_fct_as_logical = FALSE,
  on_type_not_present = "warn",
  on_name_not_present = "stop"
)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

RecombinatorCombination$clone(deep = FALSE)

Arguments

See Also

Other base classes: Filtor, FiltorSurrogate, MiesOperator, Mutator, MutatorDiscrete, MutatorNumeric, Recombinator, RecombinatorPair, Scalor, Selector, SelectorScalar

Other mutators: Mutator, MutatorDiscrete, MutatorNumeric, dict_mutators_cmpmaybe, dict_mutators_erase, dict_mutators_gauss, dict_mutators_maybe, dict_mutators_null, dict_mutators_proxy, dict_mutators_sequential, dict_mutators_unif

Other mutator wrappers: dict_mutators_cmpmaybe, dict_mutators_maybe, dict_mutators_proxy, dict_mutators_sequential

Other recombinators: Recombinator, RecombinatorPair, dict_recombinators_cmpmaybe, dict_recombinators_convex, dict_recombinators_cvxpair, dict_recombinators_maybe, dict_recombinators_null, dict_recombinators_proxy, dict_recombinators_sbx, dict_recombinators_sequential, dict_recombinators_swap, dict_recombinators_xonary, dict_recombinators_xounif

Other recombinator wrappers: dict_recombinators_cmpmaybe, dict_recombinators_maybe, dict_recombinators_proxy, dict_recombinators_sequential

Examples

set.seed(1)
data = data.frame(x = 0, y = 0, a = TRUE, b = "a",
  stringsAsFactors = FALSE)  # necessary for R <= 3.6
p = ps(x = p_dbl(-1, 1), y = p_dbl(-1, 1), a = p_lgl(), b = p_fct(c("a", "b")))

# Demo operators:
m0 = mut("null")  # no mutation
msmall = mut("gauss", sdev = 0.1)  # mutates to small value around 0
mbig = mut("gauss", sdev = 100)  # likely mutates to +1 or -1
mflip = mut("unif", can_mutate_to_same = FALSE)  # flips TRUE/"a" to FALSE/"b"

# original:
data

# operators by name
op = mut("combine", operators = list(x = msmall, y = mbig, a = m0, b = mflip))
op$prime(p)
op$operate(data)

# operators by type
op = mut("combine",
  operators = list(ParamDbl = msmall, ParamLgl = m0, ParamFct = mflip)
)
op$prime(p)
op$operate(data)

# the binary ParamFct 'b' counts as 'ParamLgl' when
# 'binary_fct_as_logical' is set to 'TRUE'.
op = mut("combine",
  operators = list(ParamDbl = msmall, ParamLgl = m0),
  binary_fct_as_logical = TRUE
)
op$prime(p)
op$operate(data)

# operators by type; groups can be mixed types
op = mut("combine",
  operators = list(group1 = m0, group2 = msmall, group3 = mflip),
  groups = list(group1 = c("a", "x"), group2 = "y", group3 = "b")
)
op$prime(p)
op$operate(data)

# Special type-groups can be used inside groups.
op = mut("combine",
  operators = list(group1 = m0, b = mflip),
  groups = list(group1 = c("ParamDbl", "a"))
)
op$prime(p)
op$operate(data)

# Type-groups only capture all parameters that were not caught by name.
# The special 'ParamAny' group captures all that is left.
op = mut("combine",
  operators = list(ParamAny = m0, ParamDbl = msmall, x = mbig)
)
op$prime(p)
op$operate(data)

# Configuration parameters are named by names in the 'operators' list.
op$param_set

###
# Self-adaption:
# In this example, the 'ParamDbl''s operation is changed depending on the
# value of 'b'.
op = mut("combine",
  operators = list(ParamAny = m0, ParamLgl = mflip, ParamDbl = msmall),
  adaptions = list(ParamDbl.sdev = function(x) if (x$a) 100 else 0.1)
)
op$prime(p)

data2 = data[c(1, 1, 1, 1), ]
data2$a = c(TRUE, TRUE, FALSE, FALSE)

data2
# Note the value of x$a gets used line-wise, and that it is used *before*
# being flipped here. So the first two lines get large mutations, even though
# they have 'a' 'FALSE' after the operation.
op$operate(data2)

OptimInstanceMultiCrit Class

Description

bbotk's OptimInstanceMultiCrit class. Re-exported since bbotk will change the name.

Super classes

bbotk::OptimInstance -> bbotk::OptimInstanceBatch -> bbotk::OptimInstanceBatchMultiCrit -> OptimInstanceMultiCrit

Methods

Public methods

• OptimInstanceMultiCrit$clone()

Method clone()

The objects of this class are cloneable with this method.

Usage

OptimInstanceMultiCrit$clone(deep = FALSE)

Arguments

OptimInstanceSingleCrit Class

Description

bbotk's OptimInstanceSingleCrit class. Re-exported since bbotk will change the name.

Super classes

bbotk::OptimInstance -> bbotk::OptimInstanceBatch -> bbotk::OptimInstanceBatchSingleCrit -> OptimInstanceSingleCrit

Methods

Public methods

• OptimInstanceSingleCrit$clone()

Method clone()

The objects of this class are cloneable with this method.

Usage

OptimInstanceSingleCrit$clone(deep = FALSE)

Arguments

Optimizer Class

Description

bbotk's Optimizer class. Re-exported since bbotk will change the name.

Super classes

bbotk::Optimizer -> bbotk::OptimizerBatch -> Optimizer

Methods

Public methods

• Optimizer$clone()

Method clone()

The objects of this class are cloneable with this method.

Usage

Optimizer$clone(deep = FALSE)

Arguments

Mixed Integer Evolution Strategies Optimizer

Description

Perform optimization using evolution strategies. OptimizerMies and TunerMies implement a standard ES optimization algorithm, performing initialization first, followed by a loop of performance evaluation, survival selection, parent selection, mutation, and recombination to generate new individuals to be evaluated. Currently, two different survival modes ("comma" and "plus") are supported. Multi-fidelity optimization, similar to the "rolling-tide" algorithm described in Fieldsend (2014), is supported. The modular design and reliance on MiesOperator objects to perform central parts of the optimization algorithm makes this Optimizer highly flexible and configurable. In combination with OperatorCombination mutators and recombinators, an algorithm as presented in Li (2013) can easily be implemented.

OptimizerMies implements a standard evolution strategies loop:

1. Prime operators, using mies_prime_operators()

2. Initialize and evaluate population, using mies_init_population()

3. Generate offspring by selecting parents, recombining and mutating them, using mies_generate_offspring()

4. Evaluate performance, using mies_evaluate_offspring()

5. Select survivors, using either mies_survival_plus() or mies_survival_comma(), depending on the survival_strategy configuration parameter

6. Optionally, evaluate survivors with higher fidelity if the multi-fidelity functionality is being used

7. Jump to 3.

Terminating

As with all optimizers, Terminators are used to end optimization after a specific number of evaluations were performed, time elapsed, or other conditions are satisfied. Of particular interest is TerminatorGenerations, which terminates after a number of generations were evaluated in OptimizerMies. The initial population counts as generation 1, its offspring as generation 2 etc.; fidelity refinements (step 6. in the algorithm description above) are always included in their generation, TerminatorGenerations avoids terminating right before they are evaluated. Other terminators may, however, end the optimization process at any time.

Multi-Fidelity

miesmuschel provides a simple multi-fidelity optimization mechanism that allows both the refinement of fidelity as the optimization progresses, as well as fidelity refinement within each generation. When multi_fidelity is TRUE, then one search space component of the OptimInstance must have the "budget" tag, which is then optimized as the "budget" component. This means that the value of this component is determined by the fidelity/fidelity_offspring parameters, which are functions that get called whenever individuals get evaluated. The fidelity function is evaluated before step 2 and before every occurrence of step 6 in the algorithm, it returns the value of the budget search space component that all individuals that survive the current generation should be evaluated with. fidelity_offspring is called before step 4 and determines the fidelity that newly sampled offspring individuals should be evaluated with; it may be desirable to set this to a lower value than fidelity to save budget when preliminarily evaluating newly sampled individuals that may or may not perform well compared to already sampled individuals. Individuals that survive the generation and are not removed in step 5 will be re-evaluated with the fidelity-value in step 6 before the next loop iteration.

fidelity and fidelity_offspring must have arguments inst, budget_id, last_fidelity and last_fidelity_offspring. inst is the OptimInstance bein optimized, the functions can use it to determine the progress of the optimization, e.g. query the current generation with mies_generation. budget_id identifies the search space component being used as budget parameter. last_fidelity and last_fidelity_offspring contain the last values given by fidelity / fidelity_offspring. Should the offspring-fidelity (as returned by fidelity_offspring always be the same as the parent generation fidelity (as returned by fidelity), for example, then fidelity_offspring can be set to a function that just returns last_fidelity; this is actually the behaviour that fidelity_offspring is initialized with.

OptimizerMies avoids re-evaluating individuals if the fidelity parameter does not change. This means that setting fidelity and fidelity_offspring to the same value avoids re-evaluating individuals in step 6. When fidelity_monotonic is TRUE, re-evaluation is also avoided should the desired fidelity parameter value decrease. When fidelity_current_gen_only is TRUE, then step 6 only re-evaluates individuals that were created in the current generation (in the previous step 4) and sets the fidelity for individuals that are created in step 6, but it does not re-evaluate individuals that survived from earlier generations or were already in the OptimInstance when optimization started; it is recommended to leave this value at TRUE which it is initialized with.

Additional Components

The search space over which the optimization is performed is fundamentally tied to the Objective, and therefore to the OptimInstance given to OptimizerMies$optimize(). However, some advanced Evolution Strategy based algorithms may need to make use of additional search space components that are independent of the particular objective. An example is self-adaption as implemented in OperatorCombination, where one or several components can be used to adjust operator behaviour. These additional components are supplied to the optimizer through the additional_component_sampler configuration parameter, which takes a Sampler object. This object both has an associated ParamSet which represents the additional components that are present, and it provides a method for generating the initial values of these components. The search space that is seen by the MiesOperators is then the union of the OptimInstance's ParamSet, and the Sampler's ParamSet.

Configuration Parameters

OptimizerMies has the configuration parameters of the mutator, recombinator, parent_selector, survival_selector, init_selector, and, if given, elite_selector operator given during construction, and prefixed according to the name of the argument (mutator's configuration parameters are prefixed "mutator." etc.). When using the construction arguments' default values, they are all "proxy" operators: MutatorProxy, RecombinatorProxy and SelectorProxy. This means that the respective configuration parameters become mutator.operation, recombinator.operation etc., so the operators themselves can be set via configuration parameters in this case.

Further configuration parameters are:

• lambda :: integer(1)
  Offspring size: Number of individuals that are created and evaluated anew for each generation. This is equivalent to the lambda parameter of mies_generate_offspring(), see there for more information. Must be set by the user.

• mu :: integer(1)
  Population size: Number of individuals that are sampled in the beginning, and which are selected with each survival step. This is equivalent to the mu parameter of mies_init_population(), see there for more information. Must be set by the user.

• survival_strategy :: character(1)
  May be "plus", or, if the elite_selector construction argument is not NULL, "comma": Choose whether mies_survival_plus() or mies_survival_comma() is used for survival selection. Initialized to "plus".

• n_elite :: integer(1)
  Only if the elite_selector construction argument is not NULL, and only valid when survival_strategy is "comma": Number of elites, i.e. individuals from the parent generation, to keep during "Comma" survival. This is equivalent to the n_elite parameter of mies_survival_comma(), see there for more information.

• initializer :: function
  Function that generates the initial population as a Design object, with arguments param_set and n, functioning like paradox::generate_design_random or paradox::generate_design_lhs. This is equivalent to the initializer parameter of mies_init_population(), see there for more information. Initialized to generate_design_random().

• additional_component_sampler :: Sampler | NULL
  Additional components that may be part of individuals as seen by mutation, recombination, and selection MiesOperators, but that are not part of the search space of the OptimInstance being optimized. This is equivalent to the additional_component_sampler parameter of mies_init_population(), see there for more information. Initialized to NULL (no additional components).

• fidelity :: function
  Only if the multi_fidelity construction argument is TRUE: Function that determines the value of the "budget" component of surviving individuals being evaluated when doing multi-fidelity optimization. It must have arguments named inst, budget_id, last_fidelity and last_fidelity_offspring, see the "Multi-Fidelity"-section for more details. Its return value is given to mies_init_population() and mies_step_fidelity(). When this configuration parameter is present (i.e. multi_fidelity is TRUE), then it is initialized to a function returning the value 1.

• fidelity_offspring :: function
  Only if the multi_fidelity construction argument is TRUE: Function that determines the value of the "budget" component of newly sampled offspring individuals being evaluated when doing multi-fidelity optimization. It must have arguments named inst, budget_id, last_fidelity and last_fidelity_offspring, see the "Multi-Fidelity"-section for more details. Its return value is given to mies_evaluate_offspring(). When this configuration parameter is present (i.e. multi_fidelity is TRUE), then it is initialized to a function returning the value of last_fidelity, i.e. the value returned by the last call to the fidelity configuration parameter. This is the recommended value when fidelity should not change within a generation, since this means that survivor selection is performed with individuals that were evaluated with the same fidelity (at least if fidelity_current_gen_only is also set to FALSE) .

• fidelity_current_gen_only :: logical(1)
  Only if the multi_fidelity construction argument is TRUE: When doing fidelity refinement in mies_step_fidelity(), whether to refine all individuals with different budget component, or only individuals created in the current generation. This is equivalent to the current_gen_only parameter of mies_step_fidelity(), see there for more information.
  When this configuration parameter is present (i.e. multi_fidelity is TRUE), then it is initialized to FALSE, the recommended value.

• fidelity_monotonic :: logical(1)
  Only if the multi_fidelity construction argument is TRUE: Whether to only do fidelity refinement in mies_step_fidelity() for individuals for which the budget component value would increase. This is equivalent to the monotonic parameter of mies_step_fidelity(), see there for more information.
  When this configuration parameter is present (i.e. multi_fidelity is TRUE), then it is initialized to TRUE. When optimization is performed on problems that have a categorical "budget" parameter, then this value should be set to FALSE.

Super classes

bbotk::OptimizerBatch -> miesmuschel::Optimizer -> OptimizerMies

Active bindings

Methods

Public methods

• OptimizerMies$new()

• OptimizerMies$clone()

Method new()

Initialize the OptimizerMies object.

Usage

OptimizerMies$new(
  mutator = MutatorProxy$new(),
  recombinator = RecombinatorProxy$new(),
  parent_selector = SelectorProxy$new(),
  survival_selector = SelectorProxy$new(),
  elite_selector = NULL,
  init_selector = survival_selector,
  multi_fidelity = FALSE
)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

OptimizerMies$clone(deep = FALSE)

Arguments

Super classes

mlr3tuning::Tuner -> mlr3tuning::TunerBatch -> mlr3tuning::TunerBatchFromOptimizerBatch -> TunerMies

Methods

Public methods

• TunerMies$new()

• TunerMies$clone()

Method new()

Initialize the TunerMies object.

Usage

TunerMies$new(
  mutator = MutatorProxy$new(),
  recombinator = RecombinatorProxy$new(),
  parent_selector = SelectorProxy$new(),
  survival_selector = SelectorProxy$new(),
  elite_selector = NULL,
  init_selector = survival_selector,
  multi_fidelity = FALSE
)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

TunerMies$clone(deep = FALSE)

Arguments

References

Fieldsend, E J, Everson, M R (2014). “The rolling tide evolutionary algorithm: A multiobjective optimizer for noisy optimization problems.” IEEE Transactions on Evolutionary Computation, 19(1), 103–117.

Li, Rui, Emmerich, TM M, Eggermont, Jeroen, B"ack, Thomas, Sch"utz, Martin, Dijkstra, Jouke, Reiber, HC J (2013). “Mixed integer evolution strategies for parameter optimization.” Evolutionary computation, 21(1), 29–64.

Examples

lgr::threshold("warn")

op.m <- mut("gauss", sdev = 0.1)
op.r <- rec("xounif", p = .3)
op.parent <- sel("random")
op.survival <- sel("best")

#####
# Optimizing a Function
#####

library("bbotk")

# Define the objective to optimize
objective <- ObjectiveRFun$new(
  fun = function(xs) {
    z <- exp(-xs$x^2 - xs$y^2) + 2 * exp(-(2 - xs$x)^2 - (2 - xs$y)^2)
    list(Obj = z)
  },
  domain = ps(x = p_dbl(-2, 4), y = p_dbl(-2, 4)),
  codomain = ps(Obj = p_dbl(tags = "maximize"))
)

# Get a new OptimInstance
oi <- OptimInstanceSingleCrit$new(objective,
  terminator = trm("evals", n_evals = 100)
)

# Create OptimizerMies object
mies_opt <- opt("mies", mutator = op.m, recombinator = op.r,
  parent_selector = op.parent, survival_selector = op.survival,
  mu = 10, lambda = 5)

# mies_opt$optimize performs MIES optimization and returns the optimum
mies_opt$optimize(oi)

#####
# Optimizing a Machine Learning Method
#####

# Note that this is a short example, aiming at clarity and short runtime.
# The settings are not optimal for hyperparameter tuning. The resampling
# in particular should not be "holdout" for small datasets where this gives
# a very noisy estimate of performance.

library("mlr3")
library("mlr3tuning")

# The Learner to optimize
learner = lrn("classif.rpart")

# The hyperparameters to optimize
learner$param_set$values[c("cp", "maxdepth")] = list(to_tune())

# Get a TuningInstance
ti = TuningInstanceSingleCrit$new(
  task = tsk("iris"),
  learner = learner,
  resampling = rsmp("holdout"),
  measure = msr("classif.acc"),
  terminator = trm("gens", generations = 10)
)

# Create TunerMies object
mies_tune <- tnr("mies", mutator = op.m, recombinator = op.r,
  parent_selector = op.parent, survival_selector = op.survival,
  mu = 10, lambda = 5)

# mies_tune$optimize performs MIES optimization and returns the optimum
mies_tune$optimize(ti)

ParamSetShadow

Description

Wraps another ParamSet and shadows out a subset of its Domains. The original ParamSet can still be accessed through the ⁠$origin⁠ field; otherwise, the ParamSetShadow behaves like a ParamSet where the shadowed Domains are not present.

Super class

paradox::ParamSet -> ParamSetShadow

Active bindings

Methods

Public methods

• ParamSetShadow$new()

• ParamSetShadow$test_constraint()

• ParamSetShadow$add_dep()

• ParamSetShadow$clone()

Method new()

Initialize the ParamSetShadow object.

Usage

ParamSetShadow$new(set, shadowed)

Arguments

Method test_constraint()

Checks underlying ParamSet's constraint. It uses the underlying ⁠$values⁠ for shadowed values.

Usage

ParamSetShadow$test_constraint(x, ...)

Arguments

Returns

logical(1).

Method add_dep()

Adds a dependency to the unterlying ParamSet.

Usage

ParamSetShadow$add_dep(id, on, cond, allow_dangling_dependencies = FALSE, ...)

Arguments

Returns

invisible(self).

Method clone()

The objects of this class are cloneable with this method.

Usage

ParamSetShadow$clone(deep = FALSE)

Arguments

Examples

p1 = ps(x = p_dbl(0, 1), y = p_lgl())
p1$values = list(x = 0.5, y = TRUE)
print(p1)

p2 = ParamSetShadow$new(p1, "x")
print(p2$values)

p2$values$y = FALSE
print(p2)

print(p2$origin$values)

Recombinator Base Class

Description

Base class representing recombination operations, inheriting from MiesOperator.

Recombinators get a table of individuals as input and return a table of modified individuals as output. Individuals are acted on by groups: every ⁠$n_indivs_out⁠ lines of output corresponds to a group of ⁠$n_indivs_in⁠ lines of input, and presence or absence of other input groups does not affect the result.

Recombination operations are performed in ES algorithms to facilitate exploration of the search space that combine partial solutions.

Inheriting

Recombinator is an abstract base class and should be inherited from. Inheriting classes should implement the private ⁠$.recombine()⁠ function. The user of the object calls ⁠$operate()⁠, which calls ⁠$.recombine()⁠ for each ⁠$n_indivs_in⁠ sized group of individuals after checking that the operator is primed, that the values argument conforms to the primed domain. ⁠$.recombine()⁠ should then return a table of ⁠$n_indivs_out⁠ individuals for each call. Typically, the ⁠$initialize()⁠ function should also be overloaded, and optionally the ⁠$prime()⁠ function; they should call their super equivalents.

Super class

miesmuschel::MiesOperator -> Recombinator

Active bindings

Methods

Public methods

• Recombinator$new()

• Recombinator$clone()

Method new()

Initialize base class components of the Recombinator.

Usage

Recombinator$new(
  param_classes = c("ParamLgl", "ParamInt", "ParamDbl", "ParamFct"),
  param_set = ps(),
  n_indivs_in = 2,
  n_indivs_out = n_indivs_in,
  packages = character(0),
  dict_entry = NULL,
  own_param_set = quote(self$param_set)
)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

Recombinator$clone(deep = FALSE)

Arguments

See Also

Other base classes: Filtor, FiltorSurrogate, MiesOperator, Mutator, MutatorDiscrete, MutatorNumeric, OperatorCombination, RecombinatorPair, Scalor, Selector, SelectorScalar

Other recombinators: OperatorCombination, RecombinatorPair, dict_recombinators_cmpmaybe, dict_recombinators_convex, dict_recombinators_cvxpair, dict_recombinators_maybe, dict_recombinators_null, dict_recombinators_proxy, dict_recombinators_sbx, dict_recombinators_sequential, dict_recombinators_swap, dict_recombinators_xonary, dict_recombinators_xounif

Pair Recombinator Base Class

Description

Base class for recombination that covers the common case of combining two individuals, where two (typically complementary) child individuals could be taken as the result, such as bitwise crossover or SBX crossover.

This is a relatively lightweight class, it adds the keep_complement active binding and sets ⁠$n_indivs_in⁠ and ⁠$n_indivs_out⁠ appropriately.

Inheriting

RecombinatorPair is an abstract base class and should be inherited from. Inheriting classes should implement the private ⁠$.recombine_pair()⁠ function. During ⁠$operate()⁠, the ⁠$.recombine_pair()⁠ function is called with the same input as the ⁠$.recombine()⁠ function of the Recombinator class. It should return a data.table of two individuals.

Constructors of inheriting classes should have a keep_complement argument.

Super classes

miesmuschel::MiesOperator -> miesmuschel::Recombinator -> RecombinatorPair

Active bindings

Methods

Public methods

• RecombinatorPair$new()

• RecombinatorPair$clone()

Method new()

Initialize base class components of the RecombinatorPair.

Usage

RecombinatorPair$new(
  keep_complement = TRUE,
  param_classes = c("ParamLgl", "ParamInt", "ParamDbl", "ParamFct"),
  param_set = ps(),
  packages = character(0),
  dict_entry = NULL,
  own_param_set = quote(self$param_set)
)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

RecombinatorPair$clone(deep = FALSE)

Arguments

See Also

Other base classes: Filtor, FiltorSurrogate, MiesOperator, Mutator, MutatorDiscrete, MutatorNumeric, OperatorCombination, Recombinator, Scalor, Selector, SelectorScalar

Other recombinators: OperatorCombination, Recombinator, dict_recombinators_cmpmaybe, dict_recombinators_convex, dict_recombinators_cvxpair, dict_recombinators_maybe, dict_recombinators_null, dict_recombinators_proxy, dict_recombinators_sbx, dict_recombinators_sequential, dict_recombinators_swap, dict_recombinators_xonary, dict_recombinators_xounif

Sampler for Projection Weights

Description

Sampler for a single p_uty that samples weight-matrices as used by ScalorFixedProjection.

Super class

paradox::Sampler -> SamplerRandomWeights

Active bindings

Methods

Public methods

• SamplerRandomWeights$new()

• SamplerRandomWeights$clone()

Method new()

Initialize the SamplerRandomWeights object.

Usage

SamplerRandomWeights$new(
  nobjectives = 2,
  nweights = 1,
  weights_component_id = "scalarization_weights"
)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

SamplerRandomWeights$clone(deep = FALSE)

Arguments

Examples

set.seed(1)

Scalarizer

Description

Scalarizer objects are functions taking a fitness-matrix fitnesses (Nindivs x Nobjectives, with higher values indicating higher desirability) and a list of weight matrices weights (Nindivs elements of Nobjectives x Nweights matrices; positive weights indicate a positive contribution to scale) and returns a matrix of scalarizations (Nindivs x Nweights, with higher values indicating greater desirability).

Any other function conforming to these requirements can also be used in place of a Scalarizer, but the provided Scalarizer functions cover the most common use cases.

Scalarizers are constructed from constructor-functions, such as scalarizer_linear() or scalarizer_chebyshev().

See Also

Other Scalarizers: scalarizer_chebyshev(), scalarizer_linear()

Scalor Base Class

Description

Base class representing ranking operations, inheriting from MiesOperator.

A Scalor gets a table of individuals as input, along with information on the individuals' performance values and returns a vector of a possible scalarization of individuals' fitness (or other qualities).

Scalors can be used by Selectors as a basis to select individuals by. This way it is possible to have tournament selection (SelectorTournament) or elite selection (SelectorBest) based on different, configurable qualities of individuals.

Unlike most other operator types inheriting from MiesOperator, the ⁠$operate()⁠ function has two arguments, which are passed on to ⁠$.scale()⁠

• values :: data.frame
  Individuals to operate on. Must pass the check of the ParamSet given in the last ⁠$prime()⁠ call and may not have any missing components.

• fitnesses :: numeric | matrix
  Fitnesses for each individual given in values. If this is a numeric, then its length must be equal to the number of rows in values. If this is a matrix, if number of rows must be equal to the number of rows in values, and it must have one column when doing single-crit optimization and one column each for each "criterion" when doing multi-crit optimization.
  Note that fitness values are always maximized, both in single- and multi-criterion optimization, so objective output is multiplied with -1 if it is tagged as "minimize".

The return value of an operation should be a numeric vector with one finite value for each entry of values, assigning high values to individuals in some way more "desirable" than others with low values.

Inheriting

Scalor is an abstract base class and should be inherited from. Inheriting classes should implement the private ⁠$.scale()⁠ function. The user of the object calls ⁠$operate()⁠, and the arguments are passed on to private ⁠$.scale()⁠ after checking that the operator is primed, that the values argument conforms to the primed domain and that other values match. Typically, the ⁠$initialize()⁠ function should also be overloaded, and optionally the ⁠$prime()⁠ function; they should call their super equivalents.

Super class

miesmuschel::MiesOperator -> Scalor

Active bindings

Methods

Public methods

• Scalor$new()

• Scalor$clone()

Method new()

Initialize base class components of the Mutator.

Usage

Scalor$new(
  param_classes = c("ParamLgl", "ParamInt", "ParamDbl", "ParamFct"),
  param_set = ps(),
  supported = c("single-crit", "multi-crit"),
  packages = character(0),
  dict_entry = NULL,
  own_param_set = quote(self$param_set)
)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

Scalor$clone(deep = FALSE)

Arguments

See Also

Other base classes: Filtor, FiltorSurrogate, MiesOperator, Mutator, MutatorDiscrete, MutatorNumeric, OperatorCombination, Recombinator, RecombinatorPair, Selector, SelectorScalar

Other scalors: dict_scalors_aggregate, dict_scalors_domcount, dict_scalors_fixedprojection, dict_scalors_hypervolume, dict_scalors_nondom, dict_scalors_one, dict_scalors_proxy, dict_scalors_single

Selector Base Class

Description

Base class representing selection operations, inheriting from MiesOperator.

A Selector gets a table of individuals as input, along with information on the individuals' performance values and the number of individuals to select, and returns a vector of integers indicating which individuals were selected.

Selection operations are performed in ES algorithms to facilitate concentration towards individuals that perform well with regard to the fitness measure.

Fitness values are always maximized, both in single- and multi-criterion optimization.

Unlike most other operator types inheriting from MiesOperator, the ⁠$operate()⁠ function has three arguments, which are passed on to ⁠$.select()⁠

• values :: data.frame
  Individuals to operate on. Must pass the check of the Domain given in the last ⁠$prime()⁠ call and may not have any missing components.

• fitnesses :: numeric | matrix
  Fitnesses for each individual given in values. If this is a numeric, then its length must be equal to the number of rows in values. If this is a matrix, if number of rows must be equal to the number of rows in values, and it must have one column when doing single-crit optimization and one column each for each "criterion" when doing multi-crit optimization.
  The fitnesses-value passed on to ⁠$.select()⁠ is always a matrix.

• n_select :: integer(1)
  Number of individuals to select. Some Selectors select individuals with replacement, for which this value may be greater than the number of rows in values.

• group_size :: integer
  Sampling group size hint, indicating that the caller would prefer there to not be any duplicates within this group size, e.g. because the Selector is called to select individuals to be given to a Recombinator with a certain n_indivs_in, or because it is called as a survival_selector in mies_survival_comma() or mies_survival_plus(). The Selector may or may not ignore this value, however. This may possibly happen because of certain configuration parameters, or because the input size is too small.
  Must either be a scalar value or sum up to n_select. Must be non-negative. A scalar value of 0 is interpreted the same as 1.
  If not given, this value defaults to 1.

The return value for an operation will be a numeric vector of integer values of length n_select indexing the individuals that were selected. Some Selectors select individuals with replacement, for which the return value may contain indices more than once.

Inheriting

Selector is an abstract base class and should be inherited from. Inheriting classes should implement the private ⁠$.select()⁠ function. The user of the object calls ⁠$operate()⁠, and the arguments are passed on to private ⁠$.select()⁠ after checking that the operator is primed, that the values argument conforms to the primed domain and that other values match. Typically, the ⁠$initialize()⁠ function should also be overloaded, and optionally the ⁠$prime()⁠ function; they should call their super equivalents.

Super class

miesmuschel::MiesOperator -> Selector

Active bindings

Methods

Public methods

• Selector$new()

• Selector$clone()

Method new()

Initialize base class components of the Selector.

Usage

Selector$new(
  is_deterministic = FALSE,
  param_classes = c("ParamLgl", "ParamInt", "ParamDbl", "ParamFct"),
  param_set = ps(),
  supported = c("single-crit", "multi-crit"),
  packages = character(0),
  dict_entry = NULL,
  own_param_set = quote(self$param_set)
)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

Selector$clone(deep = FALSE)

Arguments

See Also

Other base classes: Filtor, FiltorSurrogate, MiesOperator, Mutator, MutatorDiscrete, MutatorNumeric, OperatorCombination, Recombinator, RecombinatorPair, Scalor, SelectorScalar

Other selectors: SelectorScalar, dict_selectors_best, dict_selectors_maybe, dict_selectors_null, dict_selectors_proxy, dict_selectors_random, dict_selectors_sequential, dict_selectors_tournament

Selector making use of Scalors

Description

Base class inheriting from Selector for selection operations that make use of scalar values, generated by Scalor.

Inheriting

SelectorScaling is an abstract base class and should be inherited from. Inheriting classes should implement the private ⁠$.select_scalar()⁠ function. During ⁠$operate()⁠, the ⁠$.select_scalar()⁠ function is called, it should have three arguments, similar to Selector's ⁠$.select()⁠ function. values and n_select are as given to ⁠$.select()⁠ of the Selector. The fitnesses argument is first scaled by the associated Scalor and then passed on as a numeric vector.

Typically, ⁠$initialize()⁠ should also be overloaded when inheriting.

Super classes

miesmuschel::MiesOperator -> miesmuschel::Selector -> SelectorScalar

Active bindings

Methods

Public methods

• SelectorScalar$new()

• SelectorScalar$prime()

• SelectorScalar$clone()

Method new()

Initialize base class components of the SelectorScalar.

Usage

SelectorScalar$new(
  scalor = ScalorSingleObjective$new(),
  is_deterministic = FALSE,
  param_classes = c("ParamLgl", "ParamInt", "ParamDbl", "ParamFct"),
  param_set = ps(),
  supported = scalor$supported,
  packages = character(0),
  dict_entry = NULL
)

Arguments

Method prime()

See MiesOperator method. Primes both this operator, as well as the wrapped operator given to scalor during construction.

Usage

SelectorScalar$prime(param_set)

Arguments

Returns

invisible self.

Method clone()

The objects of this class are cloneable with this method.

Usage

SelectorScalar$clone(deep = FALSE)

Arguments

See Also

Other base classes: Filtor, FiltorSurrogate, MiesOperator, Mutator, MutatorDiscrete, MutatorNumeric, OperatorCombination, Recombinator, RecombinatorPair, Scalor, Selector

Other selectors: Selector, dict_selectors_best, dict_selectors_maybe, dict_selectors_null, dict_selectors_proxy, dict_selectors_random, dict_selectors_sequential, dict_selectors_tournament

TuningInstanceMultiCrit Class

Description

mlr3tuning's TuningInstanceMultiCrit class. Re-exported since mlr3tuning will change the name.

Super classes

bbotk::OptimInstance -> bbotk::OptimInstanceBatch -> bbotk::OptimInstanceBatchMultiCrit -> mlr3tuning::TuningInstanceBatchMultiCrit -> TuningInstanceMultiCrit

Methods

Public methods

• TuningInstanceMultiCrit$clone()

Method clone()

The objects of this class are cloneable with this method.

Usage

TuningInstanceMultiCrit$clone(deep = FALSE)

Arguments

TuningInstanceSingleCrit Class

Description

mlr3tuning's TuningInstanceSingleCrit class. Re-exported since mlr3tuning will change the name.

Super classes

bbotk::OptimInstance -> bbotk::OptimInstanceBatch -> bbotk::OptimInstanceBatchSingleCrit -> mlr3tuning::TuningInstanceBatchSingleCrit -> TuningInstanceSingleCrit

Methods

Public methods

• TuningInstanceSingleCrit$clone()

Method clone()

The objects of this class are cloneable with this method.

Usage

TuningInstanceSingleCrit$clone(deep = FALSE)

Arguments

Set a Function's Environment

Description

Useful to represent functions efficiently within repr().

Usage

crate_env(fun, namespace = "R_GlobalEnv", ..., selfref = NULL)

Arguments

Value

function: The given fun with changed environment.

Examples

identity2 = crate_env(function(x) x, "base")
identical(identity, identity2)  # TRUE

y = 1
f1 = mlr3misc::crate(function(x) x + y, y, .parent = .GlobalEnv)
f2 = crate_env(function(x) x + y, "R_GlobalEnv", list(y = 1))

# Note identical() does not apply because both contain (equal, but not
# identical) 'y = 1'-environments
all.equal(f1, f2)  # TRUE
f1(10)  # 10 + 1 == 11

factorial1 = mlr3misc::crate(
  function(x) if (x > 0) x * factorial1(x - 1) else 1,
  y, .parent = .GlobalEnv
)
environment(factorial1)$factorial1 = factorial1

factorial2 = crate_env(
  function(x) if (x > 0) x * factorial1(x - 1) else 1,
  "R_GlobalEnv", list(y = 1), selfref = "factorial1")
# putting 'factorial1' into the list (or repeating function(x) ....)
# would *not* work, since we want:
identical(environment(factorial2)$factorial1, factorial2)  # TRUE

all.equal(factorial1, factorial2)  # TRUE

g = crate_env(function(x) x + y + z, "miesmuschel",
  list(y = 1), list(z = 2), selfref = c(X = 1, Y = 2, Z = 2))
g(0)  # 0 + 1 + 2 == 3
identical(environment(g)$X, g)
identical(parent.env(environment(g))$Y, g)
identical(parent.env(environment(g))$Z, g)
identical(
  parent.env(parent.env(environment(g))),
  loadNamespace("miesmuschel")
)

Dictionary of Filtors

Description

Dictionary of Filtors

Usage

dict_filtors

Format

An object of class DictionaryFiltor (inherits from DictionaryEx, Dictionary, R6) of length 15.

Methods

Methods inherited from Dictionary, as well as:

• help(key, help_type)
  (character(1), character(1))
  Displays help for the dictionary entry key. help_type is one of "text", "html", "pdf" and given as the help_type argument of R's help().

See Also

Other dictionaries: dict_mutators, dict_recombinators, dict_scalors, dict_selectors, mut()

Filtor-Combination that Filters According to Two Filtors

Description

Filtor that wraps two other Filtors given during construction and chooses which operation to perform. Each of the resulting n_filter individuals is chosen either from ⁠$filtor⁠, or from ⁠$filtor_not⁠.

This makes it possible to implement filter methods such as random interleaving, where only a fraction of p individuals were filtered and the others were not.

Letting the number of individuals chosen by ⁠$filtor⁠ be n_filter_f, then n_filter_f is either fixed set to round(n_filter * p), (when random_choise is FALSE) or to rbinom(1, n_filter, p) (when random_choice is TRUE).

When random_choice is FALSE, then ⁠$needed_input()⁠ is calculated directly from ⁠$needed_input()⁠ of ⁠$filtor⁠ and ⁠$filtor_not⁠, as well as n_filter_f and n_filter - n_filter_f.

When random_choice is TRUE, then ⁠$needed_input()⁠ is considers the "worst case" from ⁠$filtor⁠ and ⁠$filtor_not⁠, and assumes that ⁠$needed_input()⁠ is monotonically increasing in its input argument.

To make the worst case less extreme, the number of individuals chosen with random_choice set to TRUE is limited to qbinom(-20, n_filter, p, log.p = TRUE) (with lower.tail FALSE and TRUE for ⁠$filtor⁠ and ⁠$filtor_not⁠, respectively), which distorts the binomial distribution with probability 1 - exp(-20) or about 1 - 0.5e-9.

Configuration Parameters

This operator has the configuration parameters of the Filtors that it wraps: The configuration parameters of the operator given to the filtor construction argument are prefixed with "maybe.", the configuration parameters of the operator given to the filtor_not construction argument are prefixed with "maybe_not.".

Additional configuration parameters:

• p :: numeric(1)
  Probability per individual (when random_choise is TRUE), or fraction of individuals (when random_choice is FALSE), that are chosen from ⁠$filtor⁠ instead of ⁠$filtor_not⁠. Must be set by the user.

• random_choice :: logical(1)
  Whether to sample the number of individuals chosen by ⁠$filtor⁠ according to rbinom(1, n_filter, p), or to use a fixed fraction. Initialized to FALSE.

Supported Operand Types

Supported Domain classes are the set intersection of supported classes of filtor and filtor_not.

Dictionary

This Filtor can be created with the short access form ftr() (ftrs() to get a list), or through the the dictionary dict_filtors in the following way:

# preferred:
ftr("maybe", <filtor> [, <filtor_not>])
ftrs("maybe", <filtor> [, <filtor_not>])  # takes vector IDs, returns list of Filtors

# long form:
dict_filtors$get("maybe", <filtor> [, <filtor_not>])

Super classes

miesmuschel::MiesOperator -> miesmuschel::Filtor -> FiltorMaybe

Active bindings

Methods

Public methods

• FiltorMaybe$new()

• FiltorMaybe$prime()

• FiltorMaybe$clone()

Method new()

Initialize the FiltorMaybe object.

Usage

FiltorMaybe$new(filtor, filtor_not = FiltorNull$new())

Arguments

Method prime()

See MiesOperator method. Primes both this operator, as well as the wrapped operators given to filtor and filtor_not during construction.

Usage

FiltorMaybe$prime(param_set)

Arguments

Returns

invisible self.

Method clone()

The objects of this class are cloneable with this method.

Usage

FiltorMaybe$clone(deep = FALSE)

Arguments

See Also

Other filtors: Filtor, FiltorSurrogate, dict_filtors_null, dict_filtors_proxy, dict_filtors_surprog, dict_filtors_surtour

Other filtor wrappers: dict_filtors_proxy

Examples

library("mlr3")
library("mlr3learners")

fm = ftr("maybe", ftr("surprog", lrn("regr.lm"), filter.pool_factor = 2), p = 0.5)
p = ps(x = p_dbl(-5, 5))
known_data = data.frame(x = as.numeric(1:5))
fitnesses = as.numeric(1:5)
new_data = data.frame(x = c(0.5, 1.5, 2.5, 3.5, 4.5))

fm$prime(p)

fm$needed_input(2)

fm$operate(new_data, known_data, fitnesses, 2)

fm$param_set$values$p = 0.33

fm$needed_input(3)

fm$operate(new_data, known_data, fitnesses, 3)

Null-Filtor

Description

Null-filtor that does not perform filtering. Its needed_input() is always the output_size, and operate() selects the first n_filter values from its input.

Useful in particular with operator-wrappers such as FiltorProxy, and to make filtering optional.

Configuration Parameters

This operator has no configuration parameters.

Supported Operand Types

Supported Domain classes are: p_lgl ('ParamLgl'), p_int ('ParamInt'), p_dbl ('ParamDbl'), p_fct ('ParamFct')

Dictionary

This Filtor can be created with the short access form ftr() (ftrs() to get a list), or through the the dictionary dict_filtors in the following way:

# preferred:
ftr("null")
ftrs("null")  # takes vector IDs, returns list of Filtors

# long form:
dict_filtors$get("null")

Super classes

miesmuschel::MiesOperator -> miesmuschel::Filtor -> FiltorNull

Methods

Public methods

• FiltorNull$new()

• FiltorNull$clone()

Method new()

Initialize the FiltorNull object.

Usage

FiltorNull$new()

Method clone()

The objects of this class are cloneable with this method.

Usage

FiltorNull$clone(deep = FALSE)

Arguments

See Also

Other filtors: Filtor, FiltorSurrogate, dict_filtors_maybe, dict_filtors_proxy, dict_filtors_surprog, dict_filtors_surtour

Examples

fn = ftr("null")

p = ps(x = p_dbl(-5, 5))
known_data = data.frame(x = as.numeric(1:5))
fitnesses = as.numeric(1:5)

new_data = data.frame(x = c(2.5, 4.5))

fn$prime(p)

fn$needed_input(1)

fn$operate(new_data, known_data, fitnesses, 1)

Proxy-Filtor that Filters According to its Configuration Parameter

Description

Filtor that performs the operation in its operation configuration parameter. This can be used to make filtor operations fully parametrizable.

Configuration Parameters

• operation :: Filtor
  Operation to perform. Must be set by the user. This is primed when ⁠$prime()⁠ of SelectorProxy is called, and also when ⁠$operate()⁠ is called, to make changing the operation as part of self-adaption possible. However, if the same operation gets used inside multiple SelectorProxy objects, then it is recommended to ⁠$clone(deep = TRUE)⁠ the object before assigning them to operation to avoid frequent re-priming.

Supported Operand Types

Supported Domain classes are: p_lgl ('ParamLgl'), p_int ('ParamInt'), p_dbl ('ParamDbl'), p_fct ('ParamFct')

Dictionary

This Selector can be created with the short access form sel() (sels() to get a list), or through the the dictionary dict_selectors in the following way:

# preferred:
sel("proxy")
sels("proxy")  # takes vector IDs, returns list of Selectors

# long form:
dict_selectors$get("proxy")

Super classes

miesmuschel::MiesOperator -> miesmuschel::Filtor -> FiltorProxy

Methods

Public methods

• FiltorProxy$new()

• FiltorProxy$prime()

• FiltorProxy$clone()

Method new()

Initialize the FiltorProxy object.

Usage

FiltorProxy$new()

Method prime()

See MiesOperator method. Primes both this operator, as well as the operator given to the operation configuration parameter. Note that this modifies the ⁠$param_set$values$operation⁠ object.

Usage

FiltorProxy$prime(param_set)

Arguments

Returns

invisible self.

Method clone()

The objects of this class are cloneable with this method.

Usage

FiltorProxy$clone(deep = FALSE)

Arguments

See Also

Other filtors: Filtor, FiltorSurrogate, dict_filtors_maybe, dict_filtors_null, dict_filtors_surprog, dict_filtors_surtour

Other filtor wrappers: dict_filtors_maybe

Examples

library("mlr3")
library("mlr3learners")
fp = ftr("proxy")
p = ps(x = p_dbl(-5, 5))
known_data = data.frame(x = as.numeric(1:5))
fitnesses = as.numeric(1:5)
new_data = data.frame(x = c(2.5, 4.5))

fp$param_set$values$operation = ftr("null")
fp$prime(p)
fp$operate(new_data, known_data, fitnesses, 1)

fp$param_set$values$operation = ftr("surprog", lrn("regr.lm"), filter.pool_factor = 2)
fp$operate(new_data, known_data, fitnesses, 1)

Progressive Surrogate Model Filtering

Description

Performs progressive surrogate model filtering. A surrogate model is used, as described in the parent class FiltorSurrogate. The filtering is "progressive" in that successive values are filtered more agressively.

Algorithm

Given the number n_filter of of individuals to sample, and the desired pool size at round i pool_size(i), progressive surrogate model filtering proceeds as follows:

1. Train the surrogate_learner LearnerRegr on the known_values and their fitnesses.

2. Take pool_size(1) configurations, predict their expected performance using the surrogate model, and put them into a pool P of configurations to consider.

3. Initialize i to 1.

4. Take the individual that is optimal according to predicted performance, remove it from P and add it to solution set S.

5. If the number of solutions in S equals n_filter, quit.

6. If pool_size(i + 1) is larger than pool_size(i), take the next pool_size(i + 1) - pool_size(i) configurations, predict their expected performance using the surrogate model, and add them to P. Otherwise, remove pool_size(i) - pool_size(i + 1) random individuals from the pool. The size of P ends up being pool_size(i + 1) - i, as i individuals have also been removed and added to S.

7. Increment i, jump to 4.

(The algorithm presented here is optimized for clarity; the actual implementation does all the surrogate model prediction in one go, but is functionally equivalent).

pool_size(i) is calculated as round(n_filter * pool_factor * (pool_factor_last / pool_factor) ^ (i / n_filter)), i.e. a log-linear interpolation from pool_factor * n_filter to pool_factor_last * n_filter.

The pool_factor and pool_factor_last configuration parameters of this algorithm determine how agressively the surrogate model is used to filter out sampled configurations. If the filtering is agressive (large values), then more "exploitation" at the cost of "exploration" is performed. When pool_factor is small but pool_factor_last is large (or vice-versa), then different individuals are filtered with different agressiveness, potentially leading to a tradeoff between "exploration" and "exploitation".

When pool_factor_last is set, it defaults to pool_factor, with no new individuals added and no individuals removed from the filter pool during filtering. It is equivalent to taking the top n_filter individuals out of a sample of n_filter * pool_factor.

Configuration Parameters

FiltorSurrogateProgressive's configuration parameters are the hyperparameters of the FiltorSurrogate base class, as well as:

• filter.pool_factor :: numeric(1)
pool_factor parameter of the progressive surrogate model filtering algorithm, see the corresponding section. Initialized to 1. Together with the default of filter.pool_factor_last, this is equivalent to random sampling new individuals.

• filter.pool_factor_last :: numeric(1)
pool_factor_last parameter of the progressive surrogate model filtering algorithm, see the corresponding section. When not given, it defaults to filter.pool_factor, equivalent to taking the top n_filter from n_filter * pool_factor individuals.

Supported Operand Types

See FiltorSurrogate about supported operand types.

Dictionary

This Filtor can be created with the short access form ftr() (ftrs() to get a list), or through the the dictionary dict_filtors in the following way:

# preferred:
ftr("surprog", <surrogate_learner> [, <surrogate_selector>])
ftrs("surprog", <surrogate_learner> [, <surrogate_selector>])  # takes vector IDs, returns list of Filtors

# long form:
dict_filtors$get("surprog", <surrogate_learner> [, <surrogate_selector>])

Super classes

miesmuschel::MiesOperator -> miesmuschel::Filtor -> miesmuschel::FiltorSurrogate -> FiltorSurrogateProgressive

Methods

Public methods

• FiltorSurrogateProgressive$new()

• FiltorSurrogateProgressive$clone()

Method new()

Initialize the FiltorSurrogateProgressive.

Usage

FiltorSurrogateProgressive$new(
  surrogate_learner,
  surrogate_selector = SelectorBest$new()
)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

FiltorSurrogateProgressive$clone(deep = FALSE)

Arguments

See Also

Other filtors: Filtor, FiltorSurrogate, dict_filtors_maybe, dict_filtors_null, dict_filtors_proxy, dict_filtors_surtour

Examples

library("mlr3")
library("mlr3learners")
fp = ftr("surprog", lrn("regr.lm"), filter.pool_factor = 2)

p = ps(x = p_dbl(-5, 5))
known_data = data.frame(x = as.numeric(1:5))
fitnesses = as.numeric(1:5)
new_data = data.frame(x = c(2.5, 4.5))

fp$prime(p)

fp$needed_input(1)

fp$operate(new_data, known_data, fitnesses, 1)

Tournament Surrogate Model Filtering

Description

Performs tournament surrogate model filtering. A surrogate model is used, as described in the parent class FiltorSurrogate.

Algorithm

Selects individuals from a tournament by taking the top per_tournament individuals, according to surrogate_selector and as predicted by surrogate_learner, from a sample of tournament_size(i), where tournament_size(1) is given by tournament_size, tournament_size(ceiling(n_filter / per_tournament)) is given by tournament_size_last, and tournament_size(i) for i between these values is linearly interpolated on a log scale.

Configuration Parameters

FiltorSurrogateProgressive's configuration parameters are the hyperparameters of the FiltorSurrogate base class, as well as:

• filter.per_tournament :: integer(1)
  Number of individuals to select from each tournament. If per_tournament is not a divider of n_filter, then the last tournament selects a random subset of n_filter %% per_tournament individuals out of the top per_tournament individuals. Initialized to 1.

• filter.tournament_size :: numeric(1)
  Tournament size used for filtering. If tournament_size_last is not given, all n_filter individuals are selected in batches of per_tournament from tournaments of this size. If it is given, then the actual tournament size is interpolated between tournament_size and tournament_size_last on a logarithmic scale. Tournaments with tournament size below per_tournament select per_tournament individuals without tournament, i.e. no filtering. Initialized to 1.

• filter.tournament_size_last :: numeric(1)
  Tournament size used for the last tournament, see description of tournament_size. Defaults to tournament_size when not given, i.e. all tournaments have the same size.

Supported Operand Types

See FiltorSurrogate about supported operand types.

Dictionary

This Filtor can be created with the short access form ftr() (ftrs() to get a list), or through the the dictionary dict_filtors in the following way:

# preferred:
ftr("surtour", <surrogate_learner> [, <surrogate_selector>])
ftrs("surtour", <surrogate_learner> [, <surrogate_selector>])  # takes vector IDs, returns list of Filtors

# long form:
dict_filtors$get("surtour", <surrogate_learner> [, <surrogate_selector>])

Super classes

miesmuschel::MiesOperator -> miesmuschel::Filtor -> miesmuschel::FiltorSurrogate -> FiltorSurrogateTournament

Methods

Public methods

• FiltorSurrogateTournament$new()

• FiltorSurrogateTournament$clone()

Method new()

Initialize the FiltorSurrogateTournament.

Usage

FiltorSurrogateTournament$new(
  surrogate_learner,
  surrogate_selector = SelectorBest$new()
)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

FiltorSurrogateTournament$clone(deep = FALSE)

Arguments

See Also

Other filtors: Filtor, FiltorSurrogate, dict_filtors_maybe, dict_filtors_null, dict_filtors_proxy, dict_filtors_surprog

Examples

library("mlr3")
library("mlr3learners")
fp = ftr("surtour", lrn("regr.lm"), filter.tournament_size = 2)

p = ps(x = p_dbl(-5, 5))
known_data = data.frame(x = as.numeric(1:5))
fitnesses = as.numeric(1:5)
new_data = data.frame(x = c(2.5, 4.5))

fp$prime(p)

fp$needed_input(1)

fp$operate(new_data, known_data, fitnesses, 1)

Dictionary of Mutators

Description

Dictionary of Mutators

Usage

dict_mutators

Format

An object of class DictionaryMutator (inherits from DictionaryEx, Dictionary, R6) of length 15.

Methods

Methods inherited from Dictionary, as well as:

• help(key, help_type)
  (character(1), character(1))
  Displays help for the dictionary entry key. help_type is one of "text", "html", "pdf" and given as the help_type argument of R's help().

See Also

Other dictionaries: dict_filtors, dict_recombinators, dict_scalors, dict_selectors, mut()

Mutator Choosing Action Component-Wise Independently

Description

Mutator that chooses which operation to perform probabilistically. The Mutator wraps two other Mutators given during construction, and both of these operators are run. The ultimate result is sampled from the results of these operations independently for each individuum and component: with probability p (configuration parameter), the result from the Mutator given to the mutator construction argument is used, and with probability p - 1 the one given to mutator_not is used.

Configuration Parameters

This operator has the configuration parameters of the Mutators that it wraps: The configuration parameters of the operator given to the mutator construction argument are prefixed with "cmpmaybe.", the configuration parameters of the operator given to the mutator_not construction argument are prefixed with "cmpmaybe_not.".

Additional configuration parameters:

• p :: numeric(1)
  Probability per component with which to apply the operator given to the mutator construction argument. Must be set by the user.

Supported Operand Types

Supported Domain classes are the set intersection of supported classes of mutator and mutator_not.

Dictionary

This Mutator can be created with the short access form mut() (muts() to get a list), or through the the dictionary dict_mutators in the following way:

# preferred:
mut("cmpmaybe", <mutator> [, <mutator_not>])
muts("cmpmaybe", <mutator> [, <mutator_not>])  # takes vector IDs, returns list of Mutators

# long form:
dict_mutators$get("cmpmaybe", <mutator> [, <mutator_not>])

Super classes

miesmuschel::MiesOperator -> miesmuschel::Mutator -> MutatorCmpMaybe

Active bindings

Methods

Public methods

• MutatorCmpMaybe$new()

• MutatorCmpMaybe$prime()

• MutatorCmpMaybe$clone()

Method new()

Initialize the MutatorCmpMaybe object.

Usage

MutatorCmpMaybe$new(mutator, mutator_not = MutatorNull$new())

Arguments

Method prime()

See MiesOperator method. Primes both this operator, as well as the wrapped operators given to mutator and mutator_not during construction.

Usage

MutatorCmpMaybe$prime(param_set)

Arguments

Returns

invisible self.

Method clone()

The objects of this class are cloneable with this method.

Usage

MutatorCmpMaybe$clone(deep = FALSE)

Arguments

See Also

Other mutators: Mutator, MutatorDiscrete, MutatorNumeric, OperatorCombination, dict_mutators_erase, dict_mutators_gauss, dict_mutators_maybe, dict_mutators_null, dict_mutators_proxy, dict_mutators_sequential, dict_mutators_unif

Other mutator wrappers: OperatorCombination, dict_mutators_maybe, dict_mutators_proxy, dict_mutators_sequential

Examples

set.seed(1)
mcm = mut("cmpmaybe", mut("gauss", sdev = 5), p = 0.5)
p = ps(x = p_int(-5, 5), y = p_dbl(-5, 5))
data = data.frame(x = rep(0, 5), y = rep(0, 5))

mcm$prime(p)
mcm$operate(data)

mcm$param_set$values$p = 0.2
mcm$operate(data)

mcm2 = mut("cmpmaybe",
  mutator = mut("gauss", sdev = 0.01),
  mutator_not = mut("gauss", sdev = 10),
  p = 0.5
)

mcm2$prime(p)
mcm2$operate(data)

Uniform Sample Mutator

Description

"Mutates" individuals by forgetting the current value and sampling new individuals from scratch.

Since the information loss is very high, this should in most cases be combined with MutatorCmpMaybe.

Configuration Parameters

• initializer :: function
  Function that generates the initial population as a Design object, with arguments param_set and n, functioning like paradox::generate_design_random or paradox::generate_design_lhs. This is equivalent to the initializer parameter of mies_init_population(), see there for more information. Initialized to generate_design_random().

Supported Operand Types

Supported Domain classes are: p_lgl ('ParamLgl'), p_int ('ParamInt'), p_dbl ('ParamDbl'), p_fct ('ParamFct')

Dictionary

This Mutator can be created with the short access form mut() (muts() to get a list), or through the the dictionary dict_mutators in the following way:

# preferred:
mut("erase")
muts("erase")  # takes vector IDs, returns list of Mutators

# long form:
dict_mutators$get("erase")

Super classes

miesmuschel::MiesOperator -> miesmuschel::Mutator -> MutatorErase

Methods

Public methods

• MutatorErase$new()

• MutatorErase$clone()

Method new()

Initialize the MutatorErase object.

Usage

MutatorErase$new()

Method clone()

The objects of this class are cloneable with this method.

Usage

MutatorErase$clone(deep = FALSE)

Arguments

See Also

Other mutators: Mutator, MutatorDiscrete, MutatorNumeric, OperatorCombination, dict_mutators_cmpmaybe, dict_mutators_gauss, dict_mutators_maybe, dict_mutators_null, dict_mutators_proxy, dict_mutators_sequential, dict_mutators_unif

Examples

set.seed(1)
mer = mut("erase")
p = ps(x = p_lgl(), y = p_fct(c("a", "b", "c")), z = p_dbl(0, 1))
data = data.frame(x = rep(TRUE, 5), y = rep("a", 5),
  z = seq(0, 1, length.out = 5),
  stringsAsFactors = FALSE)  # necessary for R <= 3.6

mer$prime(p)
mer$operate(data)

Gaussian Distribution Mutator

Description

Individuals are mutated with an independent normal random variable on each component.

Configuration Parameters

• sdev :: numeric
  Standard deviation of normal distribuion. This is absolute if sdev_is_relative is FALSE, and multiplied with each individual component's range (upper - lower) if sdev_is_relative is TRUE. This may either be a scalar, in which case it is applied to all input components, or a vector, in which case it must have the length of the input and applies to components in order in which they appear in the priming ParamSet. Must be set by the user.

• sdev_is_relative :: logical(1)
  Whether sdev is absolute (FALSE) or relative to component range (TRUE). Initialized to FALSE.

• truncated_normal :: logical(1)
  Whether to draw individuals from a normal distribution that is truncated at the bounds of each component (TRUE), or to draw from a normal distribution and then restrict to bounds afterwards (FALSE). The former (TRUE) will lead to very few to no samples landing on the exact bounds (analytically it would be none almost surely, but this is subject to machine precision), the latter (FALSE) can lead to a substantial number of samples landing on the exact bounds. Initialized to FALSE.

Supported Operand Types

Supported Domain classes are: p_int ('ParamInt'), p_dbl ('ParamDbl')

Dictionary

This Mutator can be created with the short access form mut() (muts() to get a list), or through the the dictionary dict_mutators in the following way:

# preferred:
mut("gauss")
muts("gauss")  # takes vector IDs, returns list of Mutators

# long form:
dict_mutators$get("gauss")

Super classes

miesmuschel::MiesOperator -> miesmuschel::Mutator -> miesmuschel::MutatorNumeric -> MutatorGauss

Methods

Public methods

• MutatorGauss$new()

• MutatorGauss$clone()

Method new()

Initialize the MutatorGauss object.

Usage

MutatorGauss$new()

Method clone()

The objects of this class are cloneable with this method.

Usage

MutatorGauss$clone(deep = FALSE)

Arguments

See Also

Other mutators: Mutator, MutatorDiscrete, MutatorNumeric, OperatorCombination, dict_mutators_cmpmaybe, dict_mutators_erase, dict_mutators_maybe, dict_mutators_null, dict_mutators_proxy, dict_mutators_sequential, dict_mutators_unif

Examples

set.seed(1)
mg = mut("gauss", sdev = 0.1)
p = ps(x = p_int(-5, 5), y = p_dbl(-5, 5))
data = data.frame(x = rep(0, 5), y = rep(0, 5))

mg$prime(p)
mg$operate(data)

mg$param_set$values$sdev = 100
mg$operate(data)

Mutator Choosing Action Probabilistically

Description

Mutator that chooses which operation to perform probabilistically. The Mutator wraps two other Mutators given during construction, and for each individuum, the operation to perform is sampled: with probability p (configuration parameter), the Mutator given to the mutator construction argument is applied, and with probability p - 1 the one given to mutator_not is applied.

Configuration Parameters

This operator has the configuration parameters of the Mutators that it wraps: The configuration parameters of the operator given to the mutator construction argument are prefixed with "maybe.", the configuration parameters of the operator given to the mutator_not construction argument are prefixed with "maybe_not.".

Additional configuration parameters:

• p :: numeric(1)
  Probability per individual with which to apply the operator given to the mutator construction argument. Must be set by the user.

Supported Operand Types

Supported Domain classes are the set intersection of supported classes of mutator and mutator_not.

Dictionary

This Mutator can be created with the short access form mut() (muts() to get a list), or through the the dictionary dict_mutators in the following way:

# preferred:
mut("maybe", <mutator> [, <mutator_not>])
muts("maybe", <mutator> [, <mutator_not>])  # takes vector IDs, returns list of Mutators

# long form:
dict_mutators$get("maybe", <mutator> [, <mutator_not>])

Super classes

miesmuschel::MiesOperator -> miesmuschel::Mutator -> MutatorMaybe

Active bindings

Methods

Public methods

• MutatorMaybe$new()

• MutatorMaybe$prime()

• MutatorMaybe$clone()

Method new()

Initialize the MutatorMaybe object.

Usage

MutatorMaybe$new(mutator, mutator_not = MutatorNull$new())

Arguments

Method prime()

See MiesOperator method. Primes both this operator, as well as the wrapped operators given to mutator and mutator_not during construction.

Usage

MutatorMaybe$prime(param_set)

Arguments

Returns

invisible self.

Method clone()

The objects of this class are cloneable with this method.

Usage

MutatorMaybe$clone(deep = FALSE)

Arguments

See Also

Other mutators: Mutator, MutatorDiscrete, MutatorNumeric, OperatorCombination, dict_mutators_cmpmaybe, dict_mutators_erase, dict_mutators_gauss, dict_mutators_null, dict_mutators_proxy, dict_mutators_sequential, dict_mutators_unif

Other mutator wrappers: OperatorCombination, dict_mutators_cmpmaybe, dict_mutators_proxy, dict_mutators_sequential

Examples

set.seed(1)
mm = mut("maybe", mut("gauss", sdev = 5), p = 0.5)
p = ps(x = p_int(-5, 5), y = p_dbl(-5, 5))
data = data.frame(x = rep(0, 5), y = rep(0, 5))

mm$prime(p)
mm$operate(data)

mm$param_set$values$p = 0.3
mm$operate(data)

mm2 = mut("maybe",
  mutator = mut("gauss", sdev = 0.01),
  mutator_not = mut("gauss", sdev = 10),
  p = 0.5
)

mm2$prime(p)
mm2$operate(data)

Null Mutator

Description

Null-mutator that does not perform any operation on its input. Useful in particular with operator-wrappers such as MutatorMaybe or MutatorCombination.

Configuration Parameters

This operator has no configuration parameters.

Supported Operand Types

Supported Domain classes are: p_lgl ('ParamLgl'), p_int ('ParamInt'), p_dbl ('ParamDbl'), p_fct ('ParamFct')

Dictionary

This Mutator can be created with the short access form mut() (muts() to get a list), or through the the dictionary dict_mutators in the following way:

# preferred:
mut("null")
muts("null")  # takes vector IDs, returns list of Mutators

# long form:
dict_mutators$get("null")

Super classes

miesmuschel::MiesOperator -> miesmuschel::Mutator -> MutatorNull

Methods

Public methods

• MutatorNull$new()

• MutatorNull$clone()

Method new()

Initialize the MutatorNull object.

Usage

MutatorNull$new()

Method clone()

The objects of this class are cloneable with this method.

Usage

MutatorNull$clone(deep = FALSE)

Arguments

See Also

Other mutators: Mutator, MutatorDiscrete, MutatorNumeric, OperatorCombination, dict_mutators_cmpmaybe, dict_mutators_erase, dict_mutators_gauss, dict_mutators_maybe, dict_mutators_proxy, dict_mutators_sequential, dict_mutators_unif

Examples

mn = mut("null")
p = ps(x = p_int(-5, 5), y = p_dbl(-5, 5), z = p_lgl())
data = data.frame(x = rep(0, 5), y = rep(0, 5), z = rep(TRUE, 5))

mn$prime(p)
mn$operate(data)

Proxy-Mutator that Mutates According to its Configuration parameter

Description

Mutator that performs the operation in its operation configuration parameter. This is useful, e.g., to make OptimizerMies's mutation operation fully parametrizable.

Configuration Parameters

• operation :: Mutator
  Operation to perform. Must be set by the user. This is primed when ⁠$prime()⁠ of MutatorProxy is called, and also when ⁠$operate()⁠ is called, to make changing the operation as part of self-adaption possible. However, if the same operation gets used inside multiple MutatorProxy objects, then it is recommended to ⁠$clone(deep = TRUE)⁠ the object before assigning them to operation to avoid frequent re-priming.

Supported Operand Types

Supported Domain classes are: p_lgl ('ParamLgl'), p_int ('ParamInt'), p_dbl ('ParamDbl'), p_fct ('ParamFct')

Dictionary

This Mutator can be created with the short access form mut() (muts() to get a list), or through the the dictionary dict_mutators in the following way:

# preferred:
mut("proxy")
muts("proxy")  # takes vector IDs, returns list of Mutators

# long form:
dict_mutators$get("proxy")

Super classes

miesmuschel::MiesOperator -> miesmuschel::Mutator -> MutatorProxy

Methods

Public methods

• MutatorProxy$new()

• MutatorProxy$prime()

• MutatorProxy$clone()

Method new()

Initialize the MutatorProxy object.

Usage

MutatorProxy$new()

Method prime()

See MiesOperator method. Primes both this operator, as well as the operator given to the operation configuration parameter. Note that this modifies the ⁠$param_set$values$operation⁠ object.

Usage

MutatorProxy$prime(param_set)

Arguments

Returns

invisible self.

Method clone()

The objects of this class are cloneable with this method.

Usage

MutatorProxy$clone(deep = FALSE)

Arguments

See Also

Other mutators: Mutator, MutatorDiscrete, MutatorNumeric, OperatorCombination, dict_mutators_cmpmaybe, dict_mutators_erase, dict_mutators_gauss, dict_mutators_maybe, dict_mutators_null, dict_mutators_sequential, dict_mutators_unif

Other mutator wrappers: OperatorCombination, dict_mutators_cmpmaybe, dict_mutators_maybe, dict_mutators_sequential

Examples

set.seed(1)
mp = mut("proxy", operation = mut("gauss", sdev = 0.1))
p = ps(x = p_int(-5, 5), y = p_dbl(-5, 5))
data = data.frame(x = rep(0, 5), y = rep(0, 5))

mp$prime(p)
mp$operate(data)

mp$param_set$values$operation = mut("null")
mp$operate(data)

Run Multiple Mutator Operations in Sequence

Description

Mutator that wraps multiple other Mutators given during construction and uses them for mutation in sequence.

Configuration Parameters

This operator has the configuration parameters of the Mutators that it wraps: The configuration parameters of the operator given to the mutators construction argument are prefixed with "mutator_1", "mutator_2", ... up to "mutator_#", where ⁠#⁠ is length(mutators).

Supported Operand Types

Supported Domain classes are the set intersection of supported classes of the Mutators given in mutators.

Dictionary

This Mutator can be created with the short access form mut() (muts() to get a list), or through the the dictionary dict_mutators in the following way:

# preferred:
mut("sequential", <mutators>)
muts("sequential", <mutators>)  # takes vector IDs, returns list of Mutators

# long form:
dict_mutators$get("sequential", <mutators>)

Super classes

miesmuschel::MiesOperator -> miesmuschel::Mutator -> MutatorSequential

Active bindings

Methods

Public methods

• MutatorSequential$new()

• MutatorSequential$prime()

• MutatorSequential$clone()

Method new()

Initialize the MutatorSequential object.

Usage

MutatorSequential$new(mutators)

Arguments

Method prime()

See MiesOperator method. Primes both this operator, as well as the wrapped operators given to mutator and mutator_not during construction.

Usage

MutatorSequential$prime(param_set)

Arguments

Returns

invisible self.

Method clone()

The objects of this class are cloneable with this method.

Usage

MutatorSequential$clone(deep = FALSE)

Arguments

See Also

Other mutators: Mutator, MutatorDiscrete, MutatorNumeric, OperatorCombination, dict_mutators_cmpmaybe, dict_mutators_erase, dict_mutators_gauss, dict_mutators_maybe, dict_mutators_null, dict_mutators_proxy, dict_mutators_unif

Other mutator wrappers: OperatorCombination, dict_mutators_cmpmaybe, dict_mutators_maybe, dict_mutators_proxy

Examples

set.seed(1)

# dataset:
#  - x1 is mutated around +- 10
#  - x2 influences sdev of mutation of x1
ds = data.frame(x1 = 0, x2 = c(.01, 0.1, 1))
p = ps(x1 = p_dbl(-10, 10), x2 = p_dbl(0, 10))

# operator that only mutates x1, with sdev given by x2
gauss_x1 = mut("combine",
  operators = list(
    x1 = mut("gauss", sdev_is_relative = FALSE),
    x2 = mut("null")
  ),
  adaptions = list(x1.sdev = function(x) x$x2)
)

gauss_x1$prime(p)
gauss_x1$operate(ds)  # see how x1[1] changes little, x1[3] changes a lot

# operator that mutates x1  with sdev given by x2, as well as x2. However,
# the value that x2 takes after mutation does not influence the value that
# the mutator of x1 "sees" -- although x2 is mutated to extreme values,
# mutation of x1 happens as in `gauss_x1`.
gauss_x1_x2 = mut("combine",
  operators = list(
    x1 = mut("gauss", sdev_is_relative = FALSE),
    x2 = mut("gauss", sdev = 100)
  ),
  adaptions = list(x1.sdev = function(x) x$x2)
)

gauss_x1_x2$prime(p)
gauss_x1_x2$operate(ds)  # see how x1 changes in similar ways to above

# operator that mutates sequentially: first x2, and then x1 with sdev given
# by x2. The value that x2 takes after mutation *does* influence the value
# that the mutator of x1 "sees": x1 is mutated either to a large degree,
# or not at all.

gauss_x2_then_x1 = mut("sequential", list(
    mut("combine",
      operators = list(
        x1 = mut("null"),
        x2 = mut("gauss", sdev = 100)
      )
    ),
    mut("combine",
      operators = list(
        x1 = mut("gauss", sdev_is_relative = FALSE),
        x2 = mut("null")
      ),
      adaptions = list(x1.sdev = function(x) x$x2)
    )
))

gauss_x2_then_x1$prime(p)
gauss_x2_then_x1$operate(ds)

Uniform Discrete Mutator

Description

Discrete components are mutated by sampling from a uniform distribution, either from all possible values of each component, or from all values except the original value.

Since the information loss is very high, this should in most cases be combined with MutatorCmpMaybe.

Configuration Parameters

• can_mutate_to_same :: logical(1)
  Whether to sample from entire range of each parameter (TRUE) or from all values except the current value (FALSE). Initialized to TRUE.

Supported Operand Types

Supported Domain classes are: p_lgl ('ParamLgl'), p_fct ('ParamFct')

Dictionary

This Mutator can be created with the short access form mut() (muts() to get a list), or through the the dictionary dict_mutators in the following way:

# preferred:
mut("unif")
muts("unif")  # takes vector IDs, returns list of Mutators

# long form:
dict_mutators$get("unif")

Super classes

miesmuschel::MiesOperator -> miesmuschel::Mutator -> miesmuschel::MutatorDiscrete -> MutatorDiscreteUniform

Methods

Public methods

• MutatorDiscreteUniform$new()

• MutatorDiscreteUniform$clone()

Method new()

Initialize the MutatorDiscreteUniform object.

Usage

MutatorDiscreteUniform$new()

Method clone()

The objects of this class are cloneable with this method.

Usage

MutatorDiscreteUniform$clone(deep = FALSE)

Arguments

See Also

Other mutators: Mutator, MutatorDiscrete, MutatorNumeric, OperatorCombination, dict_mutators_cmpmaybe, dict_mutators_erase, dict_mutators_gauss, dict_mutators_maybe, dict_mutators_null, dict_mutators_proxy, dict_mutators_sequential

Examples

set.seed(1)
mdu = mut("unif")
p = ps(x = p_lgl(), y = p_fct(c("a", "b", "c")))
data = data.frame(x = rep(TRUE, 5), y = rep("a", 5),
  stringsAsFactors = FALSE)  # necessary for R <= 3.6

mdu$prime(p)
mdu$operate(data)

mdu$param_set$values$can_mutate_to_same = FALSE
mdu$operate(data)

Dictionary of Recombinators

Description

Dictionary of Recombinators

Usage

dict_recombinators

Format

An object of class DictionaryRecombinator (inherits from DictionaryEx, Dictionary, R6) of length 15.

Methods

Methods inherited from Dictionary, as well as:

• help(key, help_type)
  (character(1), character(1))
  Displays help for the dictionary entry key. help_type is one of "text", "html", "pdf" and given as the help_type argument of R's help().

See Also

Other dictionaries: dict_filtors, dict_mutators, dict_scalors, dict_selectors, mut()

Recombinator Choosing Action Component-Wise Independently

Description

Recombinator that chooses which operation to perform probabilistically and independently for each component. The Recombinator wraps two other Recombinators given during construction, and both of these operators are run. The ultimate result is sampled from the results of these operations independently for each individuum and component: with probability p (configuration parameter), the result from the Recombinator given to the recombinator construction argument is used, and with probability p - 1 the one given to recombinator_not is used.