Archive for the 'Uncategorized' Category

Push is a programming language designed for evolutionary computation, developed by Lee Spector in collaboration with many others including Alan Robinson, Jon Klein, Chris Perry, Maarten Keijzer, Bill Tozier, and Thomas Helmuth.

This i3ci weblog was created to post project updates and to facilitate communication among people working on Push. Let me know if you want author privileges. There is also a (very lightly used) Push email list.

1. Initialize:
(a) Set candidates to be the entire population.
(b) Set cases to be a list of all of the fitness cases in random order.

2. Loop:
(a) Set candidates to be the subset of the current candidates that have exactly the best fitness of any individual currently in candidates for the first case in cases.
(b) If candidates or cases contains just a single element then return the first individual in candidates.
(c) Otherwise remove the first case from cases and go to Loop.

More specifically this is “global pool, uniform random sequence, elitist lexicase parent selection.” It can be slow if run with large populations, but I believe that it can sometimes be quite useful, particularly for “modal” problems (= problems “that require qualitatively different actions for different inputs”).

This is just a note to say that although no notices about Clojush updates have been posted here in a while, many updates have been made. See the commit history at https://github.com/lspector/Clojush for details.

I’ve just pushed to github a new version of Clojush that adds a string type/stack (added by Tom Helmuth). This is also the first Push push (!) under a new collaborative source control regime within the lab. Expect more rapid updates in the near future, and possibly some other changes in project management.

20111104: - Added string stack and a variety of string stack instructions.
- Added two example pushgp runs that use the string stack in
the file examples/string.clj.

20110911: - Switched from Eclipse to Clooj/Leiningen for development and
rearranged the project for this.
- Added calls to end of all example files.
- Examples can be run from the OS command line (assuming
that leiningen is available) with calls like:
lein run examples.simple-regression
- Added local-file dependency and used file* for file access.
- Removed ant and tagged-ant examples because of bugs related
to confusion of push interpreted states and ant world states.

20110629: - Fixed abbreviate-tagged-code-macros printing of empty lists.
- Added seq condition to walklist to permit walking of seqs that
aren't actually full-fledged lists.
20110702: - Several fixes/refinements to tagged-code macros:
- Fixed incorrect no-op of arg-free calls with empty tag space.
- Added :additional_args to tagged-code macro structure; the
value should be a list of items and these will be executed
in order before calling the macro's instruction.
- Added optional 5th arg to tagged-code-macro-erc; this should
be a function of zero args that will be called to produce
the value of :additional_args (e.g. if you want to have one
random integer arg then you could specify a 5th arg of
(fn [] (list (lrand-int 101))).
- Changed format produced by abbreviate-tagged-code-macros to
handle :additional_args and to be slightly more concise.
20110714: - Added "trace" argument to eval-push and run-push. If this is
true then the resulting state will map :trace to a list of
executed instructions and literals, in reverse order of
execution. If the argument is :changes then instructions that
have no effect on the state will be excluded.

There have been a couple of Clojush updates since my last post here, with the most significant being tagged-code macros for facilitating the manipulation of code within the tag space (taking arguments from the tag space and then tagging results). Details are in the update comment below.

20110618: - Switched to Kyle Harrington's version of overlap; it's more clear,
possibly faster, and may fix a hard-to-trace bug that cropped up
in a long evolutionary run (?).
20110624: - Replaced lawnmower and dsoar examples with bugfixed versions
(thanks to Kyle Harrington).
- Added namespace and made miscellaneous other changes to
clojush-tests.clj.
- Added support for tagged-code macros. Tagged-code macro calls
have the effect of code instructions, but they take their
code arguments from the tag space and they tag their code return
values. They are implemented as macros to leverage the existing
code instruction set; note that this means that a single call
will contribute more than one iteration step toward the
evalpush-limit. Tagged-code macros appear in programs as hash maps
that map :tagged_code_macro to true, :instruction to a code
instruction, :argument_tags to a sequence of tags to be used
to acquire arguments, and :result_tags to a sequence of tags
to be used for tagging results. Execution of a macro expands
the needed code onto the exec stack to grab arguments from the tag
space and push them on the code stack, execute the code instruction,
and tag results. Note that results will also be left on the code
stack if global-pop-when-tagging is false. Conceptually, tag values
are "baked in" to these macros in much the same way that tag values
are "baked in" to the instruction names for stackless tag
instructions; we use hash maps simply because there is more
information to bake in and this prevents us from having to parse
the names (which would get messy and also waste time). Because
the maps make it difficult to read programs, however, a utility
function called abbreviate-tagged-code-macros is provided to
produce copies of programs with more human-readable (but not
currently executable) representations of tagged-macro calls.
A tagged-code-macro-erc is provided to generate random tagged-code
macros in pushgp runs. A new example, codesize20, provides
a simple demonstration of the use of tagged-code macros.