Present

Lance, Lee, Thom, Bill, Tim, Omri (scribe)

Administrative

August 12 & 19 no meetings

Lee will be submitting to Templeton for a grant (origins of life, adaptive complexity stuff)

Lee: contact Bill Tozier about visit

Dartmouth trip–anybody who wants to go is welcome

GECCO

• Bill and Lee have to make posters
• Practice presentations
  • July 1 for Thom
  • Frode? (somebody should email him)
    • should send us his slides by July 1
    • maybe he could record a video that we could watch?

Lance

Lance is here for the year!

He’s very interested in the origins of adaptive complexity, and specifically finds reified autoconstruction a promising line

We discussed VM resource management and arbitrary code generation

Miscellany

Is anybody willing to maintain/re-build the lab website?

• Add python push link
• Include more publications
• Fix things (such as broken link to my own paper)

Apparently it’s Omri’s job now (despite his rejection of it)!

Present

Lee, Thom, Bill, George, Karthik, Omri (scribe)

Thom

Less than 2000 problem is important–why isn’t it easy?

Thom has no time

Bill

Bill has set up lexicase in his system

Quantum stuff

George to work on minimal evoluationary loop:
1. Get comfortable with ClojureScript workflow
2. Manually try out some qgame programs
3. Generate random qgame programs
4. Very simple selection/reproduction

TDS paper discussion

• Can solve some pretty hard problems, but runs into an “exponential wall”–maybe GP could be really useful here
• Perhaps we should we write to the authors about non-binary test cases in GP (something they seem to have overlooked)
• Case order is manually optimized, whereas in lexicase order is randomized for each evaluation
• Raises the question: how do we deal with large numbers–potentially infinite–test cases?
• Their method has difficulty with arbitrary structure and instructions

Miscellany

There may be a workshop in Newfoundland with Wolfgang

Present

Lee, Thom, Karthik, Bill, Jake, Frode, Kwaku, Omri (scribe)

GPTP

Lee, Thom, Karthik, and Bill are going. They will be collaborating with Moshe.

A little unsure what we’re doing with the Analyzing HUMIEs paper.

GECCO

Frode got his paper accepted to the Undergraduate Workshop at GECCO (yay!), with a revision suggestion that he do runs on additional problems.

Moshe will not be going but someone in his lab will be. So we will use GECCO for collaboration.

Miscellany

We discussed Bill’s PhD application, and the arguments around its significance.

notes
hampshire computational intelligence laboratory

Rian Shims visiting from Binghamton University

Introductions by lab members
August 19 – no meeting

Bill

• Mean Best Fitness or Exact Solutions?
• discussion about which is more useful or better to report
• throw both in to please both camps!

Karthik
– semantic code search using Z3

Omri

•  hampshire grad floating about pioneer valley
•  discussed hackathon and clojure meetup
•  evolutionary loop in quantum computing?

Tom

•  < 2000 problem
• starting with small programs and having a different overall max size seems to improve results
• linear push, closeline, epigenetics on the frontier

Jake

• Push visualization

Lee

• cell visualization
• agent AI discussion for class – how to set up the arbitration in the universe

Rian

• hierarchical temporal memory (HTM) algorithms

Present: Lee, Tom (scribe) Karthik, Bill, Omri

We should invite Ryan Shams to a lab meeting.

Lee’s A-Life-y thing

• Lazy can be annoying
• footnote – agent handling of errors in Clojush should get better
• Reducers might be useful

Bill’s Wind Turbine Results

• Lots of data
• Some promising results so far
• May try co-evolutionary methods

Closeline Linear Push

So far, it is unclear whether this is “The Future” of Push, or just another tool that could be selectively applied depending on the problem. If selective, it would be nice to have a switch in Clojush to turn it on and off. If not, then we should make a final version so others can use it.

Either way, eventually the code should be cleaned up. In particular, maybe all epigenetic lines should be stored in a map of them, so that we can have closelines, offlines, etc.

Less Than 2000 Problem

• There might be something interesting to look into in comparing the complexity of the data to the complexity of the evolved programs. If programs are more complex, then maybe they don’t generalize?
• General principle of “start small” might help somewhere here:
  • Small population
  • small number of test cases
  • small program sizes
• Offline -> epigenetics might be helpful for getting smaller programs of the right size.

CI-lab meeting 04/09/2014

Present : Karthik (scribe), Omri, Bill, Tom, Lee, Jake, Kwaku (Hangouts)

Omri : Working on Div III : Website with quantum computer simulator/visualizer. Immediate next task : Circuit diagram component.
Managed to calculate tangle finally.

Jake : Div III stuff – working on rendering issues.

Brevis not scaling well enough? Rotation math/confusing stuff – so evolve this instead.

The long term issue on producing GP results that are “human-understandable”/interesting issues on protected division ending up with a no-op.

Generative tests, etc – to potentially solve generalization problems. Generalization is still a problem to solve. Validation within runs. Tom’s training/test split.

Co-evolutionary geography.
Spatial co-evolution – Quicker, Fitter and Less bloated
https://www.lri.fr/~hansen/proceedings/2012/GECCO/proceedings/p759.pdf

Lecture meeting/seminar – April 29th/5pm –
http://www-unix.ecs.umass.edu/~gong/
Potential resonance with Monte-Carlo tree search.

Why Turing machines and “Go” aren’t equivalent in power :
http://www.researchgate.net/post/Can_we_simulate_a_Universal_Turing_Machine_using_the_game_of_Go

Bill – code overhaul/changed instruction set. Some changes in the hill climber, etc.
Wind turbine stuff – target being human competitive.

Tom – Working on the Lexicase paper. /Article revision.

Frode – Simplification paper/poster for GECCO. Looking at journals where this might be a good fit.

GPTP :
Travel etc.

Clojush : eval push limit
Other things on Clojush/Java integration :
– Potentially introduce a new Push instruction
– Asynchronous timeout to prevent instructions that take arbitrarily long.

Present: Lee, Tom (scribe), Frode, Karthik (virtual)

Notes and Lab Page

• Get Karthik up to speed for posting lab notes
• Update lab pages when possible: especially fly section

Simplification Paper – Journal Article

• Put together poster paper and Frode’s workshop paper

Laziness Can Get You Into Trouble

Lee’s Heisenbug memory leak

Tom’s Selection Comparisons Lexicase/Tourney

• Try graphing lexicase selections with total error on the x-axis instead of rank
• Maybe look at minimum error by test case vectors to see if they are similar or different between runs. Could (but not necessarily) show whether or not the runs are exploring similar or different search spaces.

Present: Lee, Tom (scribe), Bill, Charles Ofria

Note: Student travel grants for GECCO are now open for application.

Diversity

• Charles suggests using (average) Hamming distance of output vectors instead of behavioral diversity to measure the population diversity
  • This will do a better job of measuring the coverage of the phenotypic space (or “trait coverage”)
  • could just sample this, don’t have to compare every pair of individuals

Discussion of co-solvability paper

• Very related in motivation to lexicase
• lexicase is mostly different in that it can select individuals that are really bad at a few test cases as long as they are really good at others.
• Also, co-solvability requires binary test cases, without an obvious way to use on non-binary cases

Attending: Lee, Tom (scribe), Bill, Omri, Kartik (virtual), Kwaku (virtual)

Z3

Karthik – can probably connect Clojush and Z3 through Java API.

Lexicase Paper Rejection

• Some possible additions ideas:
  • Investigate how much of pop is let around after each step of lexicase
  • time runs for this paper
• Lexicase speedup idea: use a lexicase comparator, and then find optimum in population
  • To do this, would need a lexicase comparator that takes 2 individuals (or error vectors) as well as a test case ordering, and returns the individual with better initial cases based on the ordering
  • Then, you can use the comparator to find the “max” (or “min”) of the population – basically, use it with reduce to find best individual for that ordering
  • We should include this as a possibility in paper, but probably not implement it.
• Thoughts on niching/fitness sharing:
  • We should definitely enhance our discussion with related techniques, but not necessarily implement and compare with them
  • We should clarify how lexicase is different
  • If we find one option that is common and simple, we could try it out if we have time.

Present

Lee, Thom, Bill, Jake, Frode, Omri (scribe)

Administrative

We should reconsider meeting time. Lee, send out an email about this.

Next Friday is international Moshe Sipper Day. Possibly no meeting Wednesday, to be replaced by the Friday meeting with Moshe.

Homework: review the past winners of the humies, prior to the Friday meeting.

Maybe Omri will try to digitize the Koza GP VHSs.

Frode: NOOP experiments

• Is this a good idea in the first place?
• How to decide when to remove an instruction that NOOPs?
• How to remove an instruction that NOOPs?
• Maybe think in terms of simplification in general, instead of NOOP removal in particular?

Omri: qgame and qromp

• qgame exists as a ClojureScript library now
• What about Clojure integration (in addition to ClojureScript)?
• Possible demo of ClojureScript usage in general, as well as qromp, next meeting

Thom’s stuff

• ‘ultra-padding’ and ‘()’ padding seem to have the same effects
• Problems with git and Windows line endings

Bill’s stuff

• Working on python stuff
• Read an interesting article about ALPS
• Giving a talk tomorrow

Jake: Push visualizer

• Getting back into the swing of things
• Push program visualizer webapp is coming along
• Possible demo next meeting

Linear push discussion

• Baked-in metadata or ‘end’s as code?
  • Baked-in metadata: how to evolve where/how ends/starts exist?
  • ‘end’s as code: how to deal with nesting? How to deal with tagging?
• Compile to parens program or parse at runtime?
  • Compile to parens: speed for multiple evaluations of a program, separation of genome from execution, minimal changes to existing Push interpreter
  • Parse at runtime: only one Push program representation