21 December 2012

Present: Lee, Tom, Emma, Micah (GHangout), Kwaku (GHangout)

Scribe: Tom

Note: If you need jobs done soon, you can send them to Emma to have them done on the UMass cluster.

GECCO Ideas
Here are some things that we can do to try to solve the kata bowling and calculator problems.

Selection
Both Lee and Tom will try out weighted lexicase with tournaments and redundancy test case removal.

Weighted Lexicase
The idea here is to give more pressure toward important test cases.


 * Lee's idea: 2 lists: one random, one sorted "easiest to hardest" by solution rates. Then, 1/2 the time you pick from one list, half the time the other, with removal from both, for the lexicase ordering.
 * Has some problems, such as the "worst" test case getting considerably more attention than the second to "worst" case.
 * Tournament-based weighted lexicase:
 * Run tournaments based on solution rates of test cases. This means you select n test cases at random, and then select the test case with the lowest solution rate to go next in the lexicase ordering. Repeat, with removal, over the test cases until all are in the list.
 * Seems reasonable. Both Tom and Lee will try this out.

Clustering / Redundancy Test Case Removal
The idea here is the reduce the importance of similar test cases.


 * Lee's Redundant Test Case Removal
 * Idea: If two (or more) test cases create the same exact ordering amongst the population, then treat them as 1 test case.
 * In initial experiments of the calculator problem, this resulted in some test cases being grouped together in the first few generations, but after that all 34 test cases reacted exactly the same.
 * Same thing happened when only looking at the elite set for each test case.
 * But, these runs were done when not using the measure during selection; we might see different results if we're using the measure.

Tom thinks other clustering algorithms might also be worth trying, though he agrees with Lee that these might introduce annoying parameters / other issues.

Genetic Operators
Lee has been trying some things:
 * Mutation:
 * Tagging mutations - replace some code with a tagged_# call, and put (tag_#) at the beginning of the program.
 * Paren adding mutations
 * Crossover:
 * Complementary lexicase mate selection
 * Amalgamation

Instructions
It may be worthwhile to experiment with different instructions / new instructions / combinatorics of instructions.

Previous Meeting -- Next Meeting  --  CI Home