Embedded Robotics (Thomas Braunl, 2 ed, 2006)

21 Genetic Programming

+

Figure 21.1: Tree structure and evaluation of S-expression

We deal only with integer data values. Our Lisp subset contains pre-defined constants zero, low, and high, and allows the generation of other integer constants by using the function (INC v). Information from the robot’s vision sensor can be obtained by calling obj_size or obj_pos. An evaluation of any of these two atoms will implicitly grab a new image from the camera and then call the color object detection procedure.

There are four atoms psd_aaa for measuring the distance between the robot and the nearest obstacle to the left, right, front, and back. Evaluating any of these atoms activates a measurement of the corresponding PSD (position sensitive device) sensor. These sensors are very useful for obstacle avoidance, wall-following, detecting other robots, etc.

There are four movement atoms remaining. Two for driving (forward and backward), and two for turning (left and right). When one of these is evaluated, the robot will drive (or turn, respectively) by a small fixed amount.

Finally, there are three program constructs for selection, iteration, and sequence. An “if-then-else” S-expression allows branching. Since we do not provide explicit relations, for example like (< 3 7), the comparison operator “less” is a fixed part of the if-statement. The S-expression contains two integer values for the comparison, and two statements for the “then” and “else” branch. Similarly, the while-loop has a fixed “less” comparison operator as loop condition. The iteration continues while the first integer value is less than the second. The two integer arguments are followed by the iteration statement itself.

These are all constructs, atoms, and S-expression lists allowed in our Lisp subset. Although more constructs might facilitate programming, it might make evolution more complex and would therefore require much more time to evolve useful solutions.

Although Lisp is an untyped language, we are only interested in valid S- expressions. Our S-expressions have placeholders for either integer values or statements. So during genetic processing, only integers may be put into integer slots and only statements may be put into statement slots. For example, the first two entries following the keyword in a WHILE_LESS-list must be integer values, but the third entry must be a statement. An integer value can be either

310

21 Genetic Programming

We implemented the Lisp interpreter as a recursive C program (Lisp purists would have implemented it in Lisp) that is executed by the EyeSim simulator. Program 21.1 shows an extract of the main Lisp decoding routine.

Program 21.1: Lisp interpreter in C

1int compute(Node n)

2{ int ret, return_val1, return_val2;

3...

4CAMGetColFrame (&img, 0);

5if (DEBUG) LCDPutColorGraphic(&img);

6ret = -1; /* no return value */

7

8switch(n->symbol) {

9case PROGN2:

10compute(n->children[0]);

11compute(n->children[1]);

12break;

13

14case IF_LESS:

15return_val1 = compute(n->children[0]);

16return_val2 = compute(n->children[1]);

17if (return_val1 <= return_val2) compute(n->children[2]);

21case WHILE_LESS:

22do {

23return_val1 = compute(n->children[0]);

24return_val2 = compute(n->children[1]);

25if (return_val1 <= return_val2) compute(n->children[2]);

26} while (return_val1 <= return_val2);

27break;

28

29case turn_left: turn_left(&vwhandle);

30break;

31case turn_right: turn_right(&vwhandle);

32break;

33...

34case obj_size: ColSearch2 (img, RED_HUE, 10, &pos, &ret);

35break;

36case obj_pos: ColSearch2 (img, RED_HUE, 10, &ret, &val);

37break;

38case low: ret = LOW;

39break;

40case high: ret = HIGH;

41break;

42default: printf("ERROR in compute\n");

43exit(1);

44}

45return ret;

46}

312

21 Genetic Programming

The following shows an example with the crossover point marked in bold face:

1.(IF_LESS obj_pos low turn_left turn_right)

2.(WHILE_LESS psd_front (PROGN2 turn_right drive_straight))

1.(IF_LESS obj_pos low (PROGN2 turn_right drive_straight) turn_right)

2.(WHILE_LESS psd_front turn_left)

Both selected crossover points represent statements. The statement turnleft in parent no. 1 is replaced by the PROGN2-statement of parent no. 2, whereas the PROGN2-statement of parent no. 2 is replaced by statement turn_left as the new child program. Figure 21.2 presents the crossover operator graphically for this example.

Mutation The mutation operation introduces a random change into an individual and thereby introduces diversity into the new individual and the next generation in general. While mutation is considered essential by some [Blickle, Thiele 1995], others believe it to be almost redundant [Koza 1992]. Mutation works as follows:

1.Select one parent from the current generation.

2.Select a mutation point.

3.Delete sub-tree at mutation point.

4.Replace sub-tree with randomly generated sub-tree.

Figure 21.3: Mutation

The following shows an example with the mutation point marked in bold face:

(IF_LESS obj_pos low

(PROGN2 drive_straight drive-straight) turn_right)

(IF_LESS obj_pos low

(WHILE_LESS psd_front high drive_straight) turn_right)

314

Evolution

The selected sub-tree (PROG2N2-sequence) is deleted from the parent program and subsequently replaced by a randomly generated sub-tree (here: a WHILE-loop construct containing a drive_straight statement). Figure 21.3 presents the mutation operator graphically.

21.4 Evolution

315

21 Genetic Programming

sufficiently close to the desired location. In this case, the elapsed simulation time for achieving the goal will also be part of the fitness function.

Selection After evaluating all the individuals of a population, we need to perform a selection process based on the fitness values assigned to them. The selection process identifies parents for generating the next generation with the help of previously described genetic operators. Selection plays a major role in genetic programming, since the diversity of the population is dependent on the choice of the selection scheme.

Fitness proportionate. The traditional genetic programming/genetic algorithm model selects individuals in the population according to their fitness value relative to the average of the whole population. However, this simple selection scheme has severe selection pressure that may lead to premature convergence. For example, during the initial population, an individual with the best fitness in the generation will be heavily selected, thus reducing the diversity of the population.

Tournament selection. This model selects n (e.g. two) individuals from the population and the best will be selected for propagation. The process is repeated until the number of individuals for the next generation is reached.

Linear rank selection. In this method, individuals are sorted according to their raw fitness. A new fitness value is then assigned to the individuals according to their rank. The ranks of individuals range from 1 to N. Now the selection process is identical to the proportionate schema. The advantage of the linear rank selection is that small differences between individuals are exploited and, by doing so, the diversity of the population is maintained.

Truncation selection. In this model, the population is first sorted according to its fitness values, and then from a certain point fitness value F, the poorer performing individuals below this value are cut off, only the better performing individuals remain eligible. Selection among these is now purely random; all remaining individuals have the same selection probability.

21.5 Tracking Problem

We chose a fairly simple problem to test our genetic programming engine, which can later be extended to a more complex scenario. A single robot is placed at a random position and orientation in a rectangular driving area enclosed by walls. A colored ball is also placed at a random position. Using its camera, the robot has to detect the ball, drive toward it, and stop close to it. The robot’s camera is positioned at an angle so the robot can see the wall ahead from any position in the field; however, note that the ball will not always be visible.

Before we consider evolving a tracking behavior, we thoroughly analyze the problem by implementing a hand-coded solution. Our idea for solving this problem is shown below.

316

21 Genetic Programming

Sensor input: obj_size (0..60), obj_pos (–1, 0..79)

sensor values are evaluated from the image in each step

Constructs: (WHILE_LESS a b c)

C equivalent: while (a<b) c;

(IF_LESS a b c d)

C equivalent: if (a<b) c; else d;

Bearing in mind that obj_size and obj_pos are in fact calls to the image processing subroutine, the procedural translation of the Lisp program in Program 21.3 is almost identical to the hand-coded C solution in Program 21.2:

while (obj_size<20)

if (obj_pos<20) rotate_left;

else if (obj_pos<40) drive_straight; else rotate_right;

Figure 21.4 shows a graphical representation of the program tree structure. Of course the choice of the available constants and program constructs simplifies finding a solution and therefore also simplifies the evolution discussed below. Figure 21.5 and Figure 21.6 show the execution of the hand-coded solution from several different starting directions.

obj_

pos 40 strai. right

Figure 21.4: Lisp program tree structure

Figure 21.5: Execution of hand-coded solution in EyeSim simulator

318