Present: Lee, Tom, Bill, Tim, Karthik (scribe), Mike, Beryl, Wren, Satyajeet, Frode (Hangouts)

Overview of domains people think they’re working on during the semester:

Wren: Calcium dynamics of pollen tubes. First tasks once the relevant data is here – inferring an equation from the data?

Beryl: Currently interested in the Quantum Computing domain. Some references of work to build on -> ( https://github.com/omribernstein/qgame

https://github.com/knod/qromp )

Mike: Interested in analytics of crime data. Data acquisition might be significantly non-trivial. Potential collaborations with CSSI at UMass? ( http://www.cssi.umass.edu/ ) ? {Also lookup http://thesunrisefoundation.org/ for potentially interesting data for work along these lines. }

Karthik: Focus this semester -> Semantic-Code Search integrated with an EC system, Lexicase-GSX, Human-Readable GP

Tim: Classifier for a bladder cancer problem. First classifier – Weka C4.5?

Bill: Epigenetic layering tests. Intention to test the system beyond hand-picked problems.

Tom: ( Lexicase selection paper accepted to the IEEE transactions on evolutionary computation. ) Benchmark problems for GP. Improvements to Clojush.

Frode: Clojush simplification during a run as a genetic operator.

Present: Lee, Tom, Lance, Nic, Mike, Tim, Ben, Wren, Karthik, Eddie (scribe)

**Hampshire students bring ideas of what you would like to work on this semester for next week’s meeting**

Clojush Issues

JVM settings in project.clj.

• Could that be changed?

Revert big child

• If child is bigger than some limit, what should happen?
  • Default was to replicating parent.
  • Default changed to random child for now.
  • Could later be changed to delete parts of the child to get under size limit.

More benchmark problems

• About 18 problems
• Stacks for a few kinds of vectors implemented
• Automatically uses instructions for included stacks

Mutual information theory

To evolve general solutions to problems, pick cases that are most informative? Boost fitness if candidates provide valuable information?

(My notes on this topic were pretty spotty and chaotic because my math skills are very lacking. For those who missed the meeting, Lance mentioned notes on his website and I found this presentation on the topic, I suspect it will be much more helpful than what I originally wrote.)

Add test to lexicase that will use mutual information to test how well programs generalize from training tests to validation tests in the hopes that it will encourage programs to evolve so that the final solution is sufficiently generalized.

Introductions

Cellular Automata

• Physics conservation – can it help avoid fixed states or limit cycles?
• How do we get to the emergence of adaptive complexity?
• Scott Aaronson’s work on cellular automata

Tom’s Work

• check sum problem – hard to solve
• mutual information – Lance willing to give lecture
  • if two things are related functionally in any way
  • dependent on distribution of random variables

Clojush Demo

Fly Demo

Present: Lee, Tom, Tim, Karthik (scribe), Lance, Mike, Wren, Beryl, Bill

Present: Lee, Tom, Nic, Lance, Mike, Tim, Bill, Kwaku (virtual), Karthik (virtual)

Tom’s Benchmarks

He’d gladly have help coding and doing experiments on program synthesis benchmark problems.

Clojush 2

Clojush 2 is now live. It adds a linear representation for genomes, which is translated into regular Push programs for execution. People should try it out and report bugs!

Documentation of Recent Push

Mike (and Nic) will be working on documenting the use of Push as they get to know it.

Bladder Cancer Data Set

Clojush 2 has the training error down near 70. Lee hasn’t figured out how to control overfitting yet.

Discussion of Paper: Evolving Neural Networks That Are Both Modular and Regular: HyperNeat Plus the Connection Cost Technique Categories and Subject Descriptors

• There are different kinds of modularity, and what we want is different from what they present.
• Evolving an interface for functions is hard!
  • Push environments might be helpful here.
• Varying the “environment” of the problem might help.
  • Lexicase is sort of like varying the environment. Maybe?
• It seems like it would be reasonable to add a test case that tries to improve modularity based on the compressibility of the program.
  • We’d likely be interested in minimizing the amount a program is compressed. Something like: (compressed size of program)/(uncompressed size of program)

Present: Lee, Tom, Karthik (scribe), Mike, Bill (hangouts)

Prime agenda item’s :-
Tom’s proposal defense practice.
Clojush 2.0

Administrative stuff :
– More students, yay!
– Faculty guests over the semester : Nic McPhee, Lance Williams
– Meeting next week : 10-12 on 27th
– Lee’s presentation at the BEACON center, on a bunch of topics, ranging from the GPTP work to some ALIFE work

Collaboration with Jason Moore:

• Lexicase selection might potentially be super useful for those kinds of problems.
• Some of the data is non binary.
• PushGP runs in progress.
• Potential for more people to start doing some runs on this dataset!

Clojush 2.0

• ULTRA padding issues sorted out. (Padding removed in the new Clojush)
• wc slightly better, factorial slightly worse on initial tests.
• Representation for the genome is a linear sequence that can be converted into a Push program for execution.
• Epigenetic switching of instructions is easier with a linear genome.
• Possible release this weekend.

Tom’s proposal defense practice:

• Start time 11.02AM
• Prime focus of proposal being Lexicase selection, which is novel in multiple ways in the domain of software synthesis using Genetic Programming.
• End time 11.49 AM ( Overall roughly 45min)

Present: Lee, Tom (scribe), Tim

NO MEETING NEXT WEEK!

For the following week: Read the paper Evolving Neural Networks That Are Both Modular and Regular: HyperNeat Plus the Connection Cost Technique Categories and Subject Descriptors, which will be sent to the email list by Tom.

Dartmouth Trip

• Lee touted lexicase as potentially good for their work
• We got a bladder cancer data set to try things with.
• Lee did some initial hackings, starting with simple trees, and is now trying Clojush
• Tim will be working on this.

WC + Tags

No difference between tags and no tags 🙁

Plush

It could be that instructions are no-oping near the beginning of programs, either because of a bug or just because the required stacks are empty. We could track the number of no-oping instructions to see if it increases throughout a run. It could be interesting to see what percent of instructions noop at each program position during each generation — you could have generations on the x-axis and program positions on the y-axis, and a heatmap showing what percent of instructions noop.

Present

Lee, Thom, Bill, Karthik, Tim, Wren, Omri (scribe)

Administrative

New CS hire for grant administration stuff: Lisa Karlin (things that used to go to Jean should go to Lisa)

Dartmouth trip next Monday, involves

• A PhD defense that has to do with evolution and networks, public defense 10-11AM
• A possible meeting with Jason Moore’s research group (studying GP and genetics, among other things), sometime between 1-3PM
• Lee is giving a seminar from 3-4PM (“Expressive Program Evolution”)

Currently this week, Lee is participating in a(n awesome) workshop on open-ended evolutionary computation with Wolfgang Banzhaf and Susan Stepny (in Newfoundland, via Skype)

Plush woes

Plush programs are getting really big. Why? We don’t know, and it’s quite a problem.

Lexicase paper

Due August 6th

Thom will be back from Florida August 1s with revisions

Lee will have time to review and write a letter

Semantic distance

Karthik queries: how do you measure semantic distance in GP?

Maybe base it off of constraints?

Hard problem!

Next week

Meeting at regular time and place, i.e. ASH Conference Room 9:15-10:30AM (Tues July 29th)

People planning to go to Dartmouth

Get to Lee’s house at 7:30 on Monday (July 28)!

Present : Lee, Tom, Bill, Karthik(Scribe), Tim

Administrative stuff : GECCO next week, Frode’s presentation got moved to the first session/first talk.

Clojush 2.0 : 
Clojush 2.0 nearing release – Mixed results so far on different problems in terms of success rate on different problems, but this is not the current priority – the idea’s that going to a linear genome allows for greater capabilities that can be subsequently explored.
Clojush 2.0 is *NOT* backwards compatible – the “Plush” genome is what’s manipulated to eventually generate a Push program.
Close-paren probabilities come from a binomial distribution. Modify/tweak this for it to get slightly better before full release ?
– Availability of Hill Climbing genetic operators on Plush.
– Selection *mid-generation* ? + Not use reversion/ use it “reasonably” ?
– Experiments on potential reversion.
– Lein deploy : long term thing to do, but not a priority.

Tom’s GECCO talk practice :- 
– The overall idea of using GP for “traditional” programming problems.
– Some details on Lexicase selection.
– Minor details on Push, since code is evolved in Push.
– The ULTRA genetic operator.
– The idea of achieving *perfect* solutions, at least with respect to both the training data and the unseen test data.

To-Do’s :

– Send Lee details on plans for next week(s), since we won’t be meeting next week thanks to GECCO.

– Talk about the meeting with Jason Moore in the next meeting.

Administrative

• Present: Lee, Tom (scribe), Tim, Karthik (remote), Bill (remote)
• Tom will practice GECCO talk next week
• Frode should send us GECCO slides shortly

Plush genomes -> Push programs

• Do we want any Push program to be able to be represented by a Plush genome?
  • Lee: Yes!
  • Tom: Maybe?
• To do so, we have new instructions:
  • meta_open – opens new paren
  • meta_splice_backward – deleted previous paren pair

Hill-climbing vs. Genetic Operators

• e.g. simplification, epigenetics, etc.
• Is it useful to test and revert (using a fitness evaluation), or is just making the change and letting selection work it out just as good?
• Maybe Bill or Tom should experiment with this — EHC vs. using epigenetic genetic operators with more generations to make up for EHC’s extra evaluations.
• Simplest is to never do hill climbing, just have genetic operators.
• Decision: Implement a wrapper argument (like :make-reverting) that can be used in genetic operator pipelines that cases the next operator to be reverted if not better than its input program.

Issue of what to do with child programs that exceed size limits

Decision: implement argument with these options:

• return clone of one parent (default, as previously)
• return empty program
• return random program
• return one parent with some part(s) deleted