Evaluation

The animats are certainly very quick to learn how to jump! Multiple jumps seem to cause no problems either. It takes a bit longer in evolution terms to discover the rocket jump, but there is evolutionary pressure toward that behavior thanks to the squared height fitness function. The problem is not too difficult, so keeping the population small helps.

The dodging behavior is learned relatively quickly, thanks to the simplicity of the representation. Generally, any balanced combination of weights for the vectors works well, engendering movement away from the estimated point of impact, from closest collision point, and from the projectile itself.

In some cases, this approach is suboptimal; on average, however, it performs well. The genetic algorithm would need more information about the relative positions to perform better (instead of blindly optimizing weights).

The fitness function providing rewards on a per-jump or per-dodge basis actually works very well; we don't need to provide a more regular form of reward. The fact that fitness is continuous is of great help to the genetic algorithm, because it guides the evolution better than Boolean success indicators.

This scheme reveals how it's possible to evolve behaviors, using simple genetic operators and a customized representation. The representation is better suited to modeling sequences than learning classifier systems and fuzzy rules; the learning benefits from this explicitness.

However, the representation is incompatible with these other schemes based on rules. In addition, the linear flow of the sequence and its insensitivity to environmental stimuli would be problematic, particularly when applying this representation to the behaviors from Chapter 31.

For this reason, it may be advantageous to merge the two representations, including the best of sequences (nonlinear ones) and rules together. In fact, the next part covers this in the introduction to the discussion about finite state machines, which represent sequences with transition rules. Then, we cover hierarchical finite state machines, which enable us to integrate classical rules and other finite state machines within each other.