mlr-org / miesmuschel Goto Github PK

selector that selects 'at least' x%, or at least n, with method 1, otherwise method 2

There seems to be adifference in behaviour when one vs. when more than one dimension used. In particular independence should also be tested.

I will need to find a way to efficiently avoid the priming requirement here.

1. Simple GA with simple use of OperatorCombination. Example objective and HPO.
2. Using mies_* functions explicitly
3. Self-Adaptive GA
4. Multifidelity GA

for when the method is used with a populated archive.

Mutator that projects on some constraint / "repairs" after mutation.

e.g. prevent crossover with identical individuals, or prevent selecting double individuals in survival selection?

Defaults that are questionable:

1. Defaults that defeat the behaviour (something does nothing):
   • TermBudget, TermGenerations have default set to Inf, should be not set instead?
   • OperatorProxy have Null operators as default
   • ... this also makes the optimizermies very boring by default
   • p default is 1 for *Maybe operators
2. Defaults that are probably not general
   • OptimizerMies lambda = 10, mu = 1
3. Defaults that may well be wrong
   • gauss sdev_is_relative should probably be FALSE, sdev maybe not 1, maybe truncated_normal should be true

use set instead.

Current truncated normal operator very likely has rounding issues

Selector that selects a relative / absolute number from strata as defined by a given component

Fit surrogate model and use as filter before evaluation. Probably by fitting a model on whole dataset, doing selection with filter and surrogate objective value.

Some object that scalarizes (e.g. nondom sorting, but also performance, or other value); selectors could then do best-selection, tournament selection, other things..

Possibly suggest to the user to use trafos.

e.g. check if optimization with col named 'generation' works

Is wasteful and probably not saving much complexity.

If for some reason the user doesn't want to shuffle there would be the idea of having the raw selector; shuffling would use SelectorSequential(list(SelectorXxx, SelectorRandom)).

The situation is a bit annoying because this is probably the only reason to have a SelectorSequential at all. Also the number of selected individuals is provided dynamically, so to make SelectorSequential useful at all there would need to be a way to select x * n individuals in step 1, followed by n individuals in step 2.

• how are missing values represented? NA?
• does assert_dt / assert work correctly with that?
• recombination somehow intelligently tree-wise?

deps across shadow bounds forbidden, within shadow work.

• we need some non-dominated sorting, that would pretty much give us NSGA-II

• Use suggested packages only when available
• onUnload remove from dicts again
• try to get rid of .datatable.aware
• use backports?

Have a lot of if (empty<x>) stopf("there are elements <x> that should not be there"), that should be abbrevated

test operate() with wrong cols, test operate() with data.table, with data.frame

• sequential operator application
• Intified Gauss
• Uniform Numeric
• Polynomial as in Deb et al. A Combined Genetic Adaptive Search (GeneAS) for Engineering Design
• one-point crossover
• arbitrary-point-crossover
• mean crossover with gaussian (distance-relative)
• Simulated Binary Crossover (Deb et al. Simulated binary crossover for continuous search space. Complex Systems)
• DomHV Selector
• K-tournament Selector (MO)
• Non-dominated sorting selector
• Ranking-base selector (Eiben et al. Introduction to evolutionary computing.)
• Fitness-proportional selector
• mutDoubleGeom
• hamming weight preserving bitflip

for multicrit optimization, so that a sensible minimum / maximum can be defined.

Currently start at 1, except if some are already present. See also #35

Mixed Integer Evolution Strategies for Parameter Optimization
Rui Li, Michael T.M. Emmerich, Jeroen Eggermont, Thomas Bäck, M. Schütz, J. Dijkstra, and J.H.C. Reiber
Evolutionary Computation 2013 21:1, 29-64

that mutates according to some R function?

Often we have things like types = c("ParamInt", "ParamDbl", "ParamFct", "ParamLgl"), but we should have a shorter representation of these. E.g. "All supported params", "All supported params that are numeric in some way", "All categorical params", ...

Use a sampler and use that form within a function

Is there special care needed for this?

Would need to have a sensible way of initializing them.

Permutation Operations

• Insertion / Jump: remove item from X1, insert it to X2, shift items between X1 and X2 to left/right
• Inversion: reverse items between X1 and X2
• Swap: swap items X1 and X2
• Scramble: shuffle items between X1 and X2
• Ordered Crossover
• Partially Mapped Crossover