This file contains just a few of the many issues and questions that you can
investigate using pga.

...................................
Peter Ross,
Department of AI,
University of Edinburgh,
80 South Bridge,
Edinburgh EH1 1HN
Scotland

peter@aisb.ed.ac.uk
...................................
Last update: June 29 1994
...................................


1.  The default reproduction strategy is `one'; namely, select from
    the population, definitely do crossover (so the crossover rate
    option is not applicable), maybe do mutation, insert into the
    population. This is based on Whitley's GENITOR. Try it, and compare
    it with `gen'-based reporduction in which (potentially) the whole
    of the population gets modified at each generation. You should find
    that in general `one'-based reproduction uses a lot fewer calls
    of the fitness function (shown as `evaluations' on the display)
    for most problems.

    However, it is not always a winner. Try the following:
      - use the default problem, `max', to maximise the number of 1s,
        and the default crossover operation, two-point crossover.
      - with a chromosome length of 100, the problem is solved before
        the populations converge.
      - with a chromosome length of 200, the average of each population
        catches up with the best rapidly; the populations are converging
        somewhat prematurely.
      - with a chromosome length of 300, premature convergence is
        clear, and eventually mutation has to do all the work.
    Try this with even longer chromosomes.
    Try using a higher mutation rate, or adaptive mutation.

    Explain this result. Remember that in a initial population
    of chromosomes each of length N, the `typical' random chromosome
    will have N/2 bits set, and the distribution will be binomial.
    The variance goes up only as sqrt(N) as N increases.

    Does this still happen with one-point crossover, or with uniform
    crossover, or tournament selection?

2.  Try the above, and the other problems, with different population
    size and different numbers of populations. For example, is it
    better to have one population of size P*S or P populations of
    size S? And how does the migration interval affect this?

3.  You can make multiple populations independent by making the
    migration interval 0. Thus you can see independent runs happening 
    in parallel. Does migration help? Try, for example, the simple 
    `max' problem with uniform crossover, a chromosome length of 300, 
    and various combinations of population number, population size 
    and migration interval.

4.  For each problem: try using a single population, and then see
    how population size affects the likelihood of successfully solving
    the problem. Experiment to see how low the `Evaluations' count
    (the number of times the fitness function got called) can be
    to solve the problem.

5.  Experiment with the 1-d knapsack problem, and compare the
    `evaluations' count with the number of evluations needed in
    other, search-based methods of solving the problem.

6.  Do a systematic comparison of the different crossover operations.
    Is there a clear winner?

7.  With the `royal road' functions, the GA can get horribly stuck.
    Try it and investigate how likely it is for the GA to find
    the solution. In pga version 2.4 the royal road function was
    R1 of Mitchell and Forrest's paper (see FOGA-2), which was
    fairly easily solved. In this version the royal road function
    is Holland's challenge problem, which is very much tougher for
    most GAs.

8.  The spatially-structured reproduction methods (-rssoneN, -rssgenN)
    can produce multiple solutions simultaneously, provided that the
    random walk (length N) is not too long for the chosen grid size.
    If N is beyond a certain problem-specific limit, the first
    clear winner that emerges gets to spread quickly throughout the
    grid before another which can resist it appears. What is this limit?
    How many different answers can you get in a problem such as mcbK?

9.  In tournament selection a large tournament size causes tremendous
    selection pressure, since it chooses the fittest of N random choices.
    Does `tm' selection manage to reduce this pressure? Investigate this
    question empirically and theoretically.

10. Does Gray-coding make a useful difference in the function
    optimisation problems (dj1, dj2, dj3, dj5, bf6)? You will need to
    do a series of experiments and compare the average performance
    with and without Gray-coding.

11. In timetabling, a real problem such as that found in the file
    ttdata.edai93 can be hard for humans to solve. Try this problem
    with
       -ett -Cuniform -stm3 -t -P1 -p1000
    (the large population size seems useful because each allele can take
    any of 36 different values, rather than just 0 and 1). It takes a
    while to converge, but pretty reliably converges to all chromosomes
    having the maximum fitness of 1.0. If you then save the final
    population in (say) tt93.chr and examine how many different
    timetables there are, say by
       % awk '{print $5}' tt93.chr | sort | uniq 
    you will find that there can be 800-900 (or even more) distinct
    timetables present! Explain why. (Hint: look at the timetables.
    They are not just permutations of one another, but how do they
    differ?).

    You can obtain a printout of the timetables by
       % awk '{print $5}' tt93.chr | sort | uniq  | decode -t

12. The problems dj2, dj5 and bf6 each involve maximising a function
    of two variables. Use the `decode' program to extract the location
    in 2 dimensions of each chromosome, and study how the distribution
    of the points in a population changes generation by generation.
    For example, in bf6 with generational reproduction, the GA drags
    all the points into the innnermost two or three rings of maxima
    very quickly, and in to the innermost (globally maximal) ring
    almost as quickly. Explain how it manages to do this. (Hint:
    consider what eg two-point crossover is doing in (x,y) space.)

13. In timetabling, try various mutation options selected by, say:
      -ett:r+t5 -m1.0 -a ...etc...
    This causes each new timetable to be mutated by moving one event
    to a new slot somehow (specified by the `r+t5' bit), with a
    probability at most 1.0 but dependent on how similar the two
    parents are. The `r' says to choose an event at random; the `t5'
    says to use tournament selection of size 5 to try to find a slot
    to move that event to which will improve the score as far as that
    event is concerned.

    Also try
      -ett:w+f ...etc...
    which chooses the event by roulette-wheel selection on the amount
    of blame that each event gets, and then looks for a slot where that
    event will violate no constraints. Explain why this does not work
    so well, even though it applies more pressure to move troublesome
    events to good slots than (say) -ett:r+t5. (Print out some timetables
    in each case and see what's causing the trouble).




