G
- the gene typeC
- the fitness typepublic final class AdaptiveEngine<G extends Gene<?,G>,C extends Comparable<? super C>> extends Object implements EvolutionStreamable<G,C>
AdaptiveEngine
allows you to dynamically create engines with
different configurations, depending on the last EvolutionResult
of
the previous evolution stream. It is therefore possible to increase the
mutation probability if the population is converging to fast. The sketch
below shows how the AdaptiveEngine
is working.
+----------+
| ES[i] |
+-------------------------------+------+ |
| +---+
(Start) | EvolutionResult[i-1] -> Engine[i] |-----------+-->
-----+-->| ^ | Result |
^ +-----------|--------------------------+ |
| | |
+---------------+--------------<-----------------------+
public static void main(final String[] args) {
final Problem<double[], DoubleGene, Double> problem = Problem.of(
v -> Math.sin(v[0])*Math.cos(v[1]),
Codecs.ofVector(DoubleRange.of(0, 2*Math.PI), 2)
);
final Engine.Builder<DoubleGene, Double> builder = Engine
.builder(problem)
.minimizing();
final Genotype<DoubleGene> result =
AdaptiveEngine.<DoubleGene, Double>of(er -> engine(er, builder))
.stream()
.limit(Limits.bySteadyFitness(50))
.collect(EvolutionResult.toBestGenotype());
System.out.println(result + ": " +
problem.fitness().apply(problem.codec().decode(result)));
}
private static EvolutionStreamable<DoubleGene, Double> engine(
final EvolutionResult<DoubleGene, Double> result,
final Engine.Builder<DoubleGene, Double> builder
) {
return var(result) < 0.2
? builder
.alterers(new Mutator<>(0.5))
.build()
.limit(5)
: builder
.alterers(
new Mutator<>(0.05),
new MeanAlterer<>())
.selector(new RouletteWheelSelector<>())
.build()
.limit(15);
}
private static double var(final EvolutionResult<DoubleGene, Double> result) {
return result != null
? result.getPopulation().stream()
.map(Phenotype::getFitness)
.collect(DoubleMoments.toDoubleMoments(Double::doubleValue))
.getVariance()
: 0.0;
}
ConcatEngine
,
CyclicEngine
Constructor and Description |
---|
AdaptiveEngine(Function<? super EvolutionResult<G,C>,? extends EvolutionStreamable<G,C>> engine)
Return a new adaptive evolution engine, with the given engine generation
function.
|
Modifier and Type | Method and Description |
---|---|
static <G extends Gene<?,G>,C extends Comparable<? super C>> |
of(Function<? super EvolutionResult<G,C>,? extends EvolutionStreamable<G,C>> engine)
Return a new adaptive evolution engine, with the given engine generation
function.
|
EvolutionStream<G,C> |
stream(EvolutionInit<G> init) |
EvolutionStream<G,C> |
stream(Supplier<EvolutionStart<G,C>> start) |
public AdaptiveEngine(Function<? super EvolutionResult<G,C>,? extends EvolutionStreamable<G,C>> engine)
engine
- the engine generating function used for adapting the engines.NullPointerException
- if the given engine
is null
public EvolutionStream<G,C> stream(Supplier<EvolutionStart<G,C>> start)
stream
in interface EvolutionStreamable<G extends Gene<?,G>,C extends Comparable<? super C>>
public EvolutionStream<G,C> stream(EvolutionInit<G> init)
stream
in interface EvolutionStreamable<G extends Gene<?,G>,C extends Comparable<? super C>>
public static <G extends Gene<?,G>,C extends Comparable<? super C>> AdaptiveEngine<G,C> of(Function<? super EvolutionResult<G,C>,? extends EvolutionStreamable<G,C>> engine)
G
- the gene typeC
- the fitness typeengine
- the engine generating function used for adapting the engines.
Be aware, that the EvolutionResult
for the first created
Engine
is null
.NullPointerException
- if the given engine
is null
© 2007-2019 Franz Wilhelmstötter (2019-02-19 21:44)