Conference PaperPDF Available

Recent developments in autoconstructive evolution

Authors:

Abstract

This is an extended abstract for an invited keynote presentation at the 7th Workshop on Evolutionary Computation for the Automated Design of Algorithms (ECADA). We first outline the motivation, primary mechanisms, and prior results of the evolutionary computation technique called "autoconstructive evolution." We then briefly describe a collection of recent enhancements to the technique, along with a few preliminary results of ongoing experimental work.
Recent Developments in Autoconstructive Evolution
Lee Spector
School of Cognitive Science
Hampshire College
893 West Street
Amherst, Massachuses 01002
lspector@hampshire.edu
Eva Moscovici
College of Information and Computer Sciences
University of Massachuses Amherst
140 Governors Drive
Amherst, MA 01003
evamoshkovich92@gmail.com
ABSTRACT
is is an extended abstract for an invited keynote presentation at
the 7th Workshop on Evolutionary Computation for the Automated
Design of Algorithms (ECADA). We rst outline the motivation,
primary mechanisms, and prior results of the evolutionary com-
putation technique called “autoconstructive evolution.” We then
briey describe a collection of recent enhancements to the tech-
nique, along with a few preliminary results of ongoing experimental
work.
CCS CONCEPTS
Computing methodologies Genetic programming;
Arti-
cial life;
Soware and its engineering Genetic program-
ming;
KEYWORDS
genetic programming, autoconstructive evolution, soware synthe-
sis
ACM Reference format:
Lee Spector and Eva Moscovici. 2017. Recent Developments in Autocon-
structive Evolution. In Proceedings of GECCO ’17 Companion, Berlin, Ger-
many, July 15-19, 2017, 3 pages.
DOI: hp://dx.doi.org/10.1145/3067695.3082058
1 AUTOCONSTRUCTIVE EVOLUTION
Autoconstructive evolution is an evolutionary computation tech-
nique that has been a topic of intermient research and develop-
ment since the year 2000 [1, 2, 11, 12, 16, 17].
Autoconstructive evolution systems can be considered to be
instances of genetic programming systems, insofar as they are em-
ployed to solve computational problems for which the solutions are
executable computer programs, and insofar as they nd solutions
by processing populations of executable computer programs that
undergo cycles of variation and selection [9].
In contrast to other genetic programming systems, however, in
an autoconstructive evolution system the evolving programs are
Permission to make digital or hard copies of all or part of this work for personal or
classroom use is granted without fee provided that copies are not made or distributed
for prot or commercial advantage and that copies bear this notice and the full citation
on the rst page. Copyrights for components of this work owned by others than the
author(s) must be honored. Abstracting with credit is permied. To copy otherwise, or
republish, to post on servers or to redistribute to lists, requires prior specic permission
and/or a fee. Request permissions from permissions@acm.org.
GECCO ’17 Companion, Berlin, Germany
©
2017 Copyright held by the owner/author(s). Publication rights licensed to ACM.
978-1-4503-4939-0/17/07. . . $15.00
DOI: hp://dx.doi.org/10.1145/3067695.3082058
responsible not only for solving a specied computational prob-
lem, but also for producing their own children in the evolutionary
process. is allows the methods of reproduction and variation
themselves to vary and to evolve. e way that it does so is roughly
analogous to the ways in which reproductive methods (considered
broadly to include everything from karyotype to mate selection be-
haviors) evolve in biological systems; the reproductive methods are
embodied in the organisms themselves, and may evolve along with
other features of the organisms through variation and selection.
One motivation for research on autoconstructive evolution is
the speculation that it may have the potential to solve problems
beyond the reach of ordinary genetic programming systems, be-
cause evolved methods of reproduction and variation may be more
eective than those designed by hand. However, the task faced by
an autoconstructive evolution system is clearly more dicult than
that faced by an ordinary genetic programming system, because it
must “invent” and rene its reproductive mechanisms while also
solving its target computational problem.
Prior research on autoconstructive evolution has explored a va-
riety of options for the aspects of reproduction and variation that
are under the control of the evolving programs, the ways in which
child-production is integrated into the genetic programming gener-
ational loop, and the representations and instruction sets available
to programs for the construction of children. Some of this prior
work was summarized in our paper for the 2016 Workshop on Evo-
lutionary Computation for the Automated Design of Algorithms,
which also introduced the AutoDoG system on which our current
research is based [16].
2 AUTODOG
e AutoDoG system (named for “Autoconstructive Diversication
of Genomes”) is implemented on the foundation of the PushGP
genetic programming system, which has been used for a variety of
purposes and projects unrelated to autoconstructive evolution (for
example, [3, 4, 6, 7, 15]).
AutoDoG is simply PushGP, which implements a standard gen-
erational genetic programming loop, run in a conguration that
uses only the single
autoconstruction
genetic operator in place
of the collection of hand-wrien mutation and recombination oper-
ators that are normally employed. e
autoconstruction
genetic
operator takes two parent genomes as inputs and produces a child
genome by executing the program encoded by one of the parent
genomes, with both parent genomes available as data from which
the child genome can be constructed. Details are available in [
16
],
but the following are a few of the other key features of AutoDoG
relative to previous autoconstructive evolution systems:
1154
GECCO ’17 Companion, July 15-19, 2017, Berlin, Germany Lee Spector and Eva Moscovici
e use of a diversity-maintaining parent selection algo-
rithm (lexicase selection [
7
,
13
]), which may help to pre-
vent the collapse of population diversity as methods for
reproduction and variation evolve.
e representation of both parents and children using lin-
ear (Plush) genomes for structured (Push) programs [
5
],
which permits the use of relatively simple primitive in-
structions for generating and varying children.
Explicit diversication constraints that prevent the survival
of children that do not produce diverse children themselves,
and are therefore unlikely to contribute to the evolution
of either problem-solving or reproductive functionality.
e 2016 workshop paper demonstrated that AutoDoG could use
autoconstruction to solve a non-trivial problem, the Replace Space
with Newline problem from our soware synthesis benchmark
suite [
6
]. It also presented evidence that the reproductive methods
used by individuals in AutoDoG populations evolve in signicant
ways as runs proceed.
3 RECENT DEVELOPMENTS
Since the 2016 workshop, AutoDoG has been enhanced in several
ways, including:
Several new diversication tests have been developed. Pre-
viously, a child was permied to survive if and only if
two of its own children (generated only for the purpose
of this test and then discarded) diered from their parent
by dierent, non-zero amounts. Among the new tests that
have been developed are tests that require dierences more
specically in program sizes and instruction sets, and tests
that require variation over more than one generation of
descendants.
e domain-specic language for genome manipulation,
which programs use to generate and vary the genomes
of their children, has been enriched. Among the new ele-
ments are high-level instructions that implement compo-
nents of the hand-wrien genetic operators that are used
in non-autoconstructive runs of PushGP, such as uniform
mutation and alternation [
14
]. Evolving programs may use
these genetic operator components, with evolved param-
eters, in evolved combinations, and in conjunction with
other genome-manipulation instructions, to construct their
children.
A mechanism has been added for the application of “en-
tropy,” in the form of random gene deletion, to the results
of autoconstructive production of children. Because we
want variation methods to be encoded in individuals, so
that they may evolve, we do not implement exogenous
mutations upon which the evolutionary process may come
to rely. Exogenous deletions, however, are permissible, be-
cause they cannot introduce new genetic material. Initial
experiments suggest that the presence of entropy favors
individuals that repair or at least add material to their
children, presumably because these behaviors oset the
random deletions caused by entropy. is may facilitate
the emergence of meaningful variation.
New mechanisms have been added to favor individuals
with relatively more diversifying methods for reproduction
and variation. AutoDoG’s diversication constraints are
binary: children that meet them are allowed to survive,
while those that do not are not. e new mechanisms
provide more discrimination among those that do survive,
using stochastic screening procedures that are applied to
the population before each parent selection event. With
one method, for example, a degree of parental similarity
is randomly chosen for each parent selection event, and
individuals that are more similar to their parents than the
chosen degree are excluded from consideration. Another
method screens on the basis not of the similarity of parent
and child, but on the similarity of the parent’s and child’s
reproductive behaviors. Yet another mechanism screens
on the basis of genealogical “age,” using a method that we
call “AMPS” for “Age-Mediated Parent Selection. AMPS
builds on the ideas of ALPS [8] and Age-Pareto Optimiza-
tion [
10
], providing a mechanism that can be added with
lile eort to standard (parent-selection-based) genetic
programming systems. When used in conjunction with
autoconstructive evolution, AMPS can provide selection
in favor of more-diversifying reproductive methods, by
incorporating child/parent dierences into the function
that is used to compute the ages of children from those of
their parents.
4 PRELIMINARY RESULTS
Experiments with the methods described above, alone and in vari-
ous combinations, are ongoing. As of this writing, we do not have
sucient data to draw rm conclusions about the ecacy of any
of these techniques, or about the long-term prospects for autocon-
structive evolution using the ideas outlined here. However, we do
have preliminary results that exhibit some points of interest.
For example, we have found that autoconstructive evolution
can sometimes achieve high success rates even within the com-
putational limits that we normally use for non-autoconstructive
genetic programming, expressed in terms of population sizes and
generation limits. is was a surprise. We have been motivated by
the prospect that autoconstructive evolution could solve problems
not solvable by non-autoconstructive genetic programming, but
we expected it to require signicantly greater resources to solve
problems that could also be solved non-autoconstructively, since
it must invent and rene its own methods for reproduction and
variation even as it works to solve the target problem.
Prior work accorded with this expectation. We had previously
documented non-autoconstructive genetic programming solving
the Replace Space with Newlines problem in roughly 50% of runs,
with a population size of 1000 and within 300 generations [
6
]. In
[
16
] we reported that AutoDoG had also solved this problem, but
that it had done so only in 5–10% of our runs, even though we
allowed runs to continue for more generations.
Using some of the new developments described above, however,
we are now able to nd solutions to the Replace Space with Newlines
problem using autoconstructive evolution at least as frequently as
we previously could with non-autoconstructive evolution, within
1155
Recent Developments in Autoconstructive Evolution GECCO ’17 Companion, July 15-19, 2017, Berlin, Germany
the same resource constraints. For example, 75% of a recent suite
of 20 AutoDoG runs with population size 1000 succeeded within
300 generations.
We have also recently conducted 20 runs of AutoDoG on the
Mirror Image soware synthesis problem [
6
], and achieved 100%
success, with 16 runs (80%) nding solutions in fewer than 300
generations. e highest success rate within 300 generations for
non-autoconstructive evolution on this problem documented in [
6
]
was 78%.
e numbers of runs described here are too low to claim with
any certainty that autoconstructive evolution performs beer than
non-autoconstructive genetic programming, on problems that both
can solve, using the same computational resources. But these re-
sults do suggest that the performance of autoconstructive evo-
lution is at least sometimes in the same ballpark as that of non-
autoconstructive genetic programming, which is notable because
of the extra work that an autoconstructive evolution system must
do to bootstrap the evolutionary process.
Recent experiments have also provided what may be the rst
evidence that autoconstructive evolution can indeed extend the
reach of genetic programming to solve problems that it could not
otherwise solve. No previous run of non-autoconstructive genetic
programming, or of any other program synthesis method of which
we are aware, has solved the String Dierences problem described
in [
6
]. However, we have recently found a (single) solution to this
problem with AutoDoG, using some of the enhancements described
above.
ese results are preliminary and largely anecdotal, and we cau-
tion the reader against concluding anything denitive about the
power or potential of autoconstructive evolution on their basis
alone. ey do, however, serve to illustrate the kinds experiments
that we are conducting, and they provide a preview of the more
complete results that we plan to present at the 7th Workshop on Evo-
lutionary Computation for the Automated Design of Algorithms.
ACKNOWLEDGMENTS
We thank the members of the Hampshire College Computational In-
telligence Lab for helpful discussions, J. Erikson for systems support,
and Hampshire College for support for the Hampshire College In-
stitute for Computational Intelligence. is material is based upon
work supported by the National Science Foundation under Grants
No. 1617087, 1129139 and 1331283. Any opinions, ndings, and
conclusions or recommendations expressed in this publication are
those of the authors and do not necessarily reect the views of the
National Science Foundation.
REFERENCES
[1]
Kyle Harrington, Emma Tosch, Lee Spector, and Jordan Pollack. 2011. Compo-
sitional Autoconstructive Dynamics. In Unifying emes in Complex Systems
Volume VIII: Proceedings of the Eighth International Conference on Complex Systems
(New England Complex Systems Institute Series on Complexity). NECSI Knowledge
Press, 856–870.
[2]
Kyle I. Harrington, Lee Spector, Jordan B. Pollack, and Una-May O’Reilly.
2012. Autoconstructive evolution for structural problems. In Proceedings of
the fourteenth international conference on Genetic and evolutionary computa-
tion conference companion (GECCO Companion ’12). ACM, 75–82.
DOI:
hp:
//dx.doi.org/10.1145/2330784.2330797
[3]
omas Helmuth. 2015. General Program Synthesis from Examples Using Genetic
Programming with Parent Selection Based on Random Lexicographic Orderings
of Test Cases. Ph.D. Dissertation. College of Information and Computer Sci-
ences, University of Massachuses Amherst, USA. hps://web.cs.umass.edu/
publication/details.php?id=2398
[4]
omas Helmuth, Nicholas Freitag McPhee, and Lee Spector. 2016. e Impact
of Hyperselection on Lexicase Selection. In GECCO ’16: Proceedings of the 2016
Annual Conference on Genetic and Evolutionary Computation. ACM, Denver, USA,
717–724.
DOI:
hp://dx.doi.org/doi:10.1145/2908812.2908851 Nominated for best
paper.
[5]
omas Helmuth, Nicholas Freitag McPhee, and Lee Spector. 2016. Plush: Linear
Genomes for Structured Push Programs. In Genetic Programming eory and
Practice XIV. Springer.
[6]
omas Helmuth and Lee Spector. 2015. General program synthesis bench-
mark suite. In GECCO ’15: Proceedings of the 2015 Conference on Genetic and
Evolutionary Computation (July, 2015).
[7]
omas Helmuth, Lee Spector, and James Matheson. 2015. Solving Uncom-
promising Problems With Lexicase Selection. Evolutionary Computation, IEEE
Transactions on 19, 5 (Oct 2015), 630–643.
DOI:
hp://dx.doi.org/10.1109/TEVC.
2014.2362729
[8]
Gregory S. Hornby. 2006. ALPS: the age-layered population structure for reducing
the problem of premature convergence. In GECCO 2006: Proceedings of the 8th
annual conference on Genetic and evolutionary computation, Vol. 1. ACM Press,
Seale, Washington, USA, 815–822. DOI:hp://dx.doi.org/doi:10.1145/1143997.
1144142
[9]
John R. Koza. 1992. Genetic Programming: On the Programming of Computers by
Means of Natural Selection. MIT Press, Cambridge, MA, USA.
[10]
Michael Schmidt and Hod Lipson. 2010. Age-Fitness Pareto Optimization. In
Genetic Programming eory and Practice VIII, Rick Riolo, Trent McConaghy,
and Ekaterina Vladislavleva (Eds.). Genetic and Evolutionary Computation,
Vol. 8. Springer, Ann Arbor, USA, Chapter 8, 129–146. hp://www.springer.
com/computer/ai/book/978-1- 4419-7746-5
[11]
Lee Spector. 2001. Autoconstructive Evolution: Push, PushGP, and Pushpop. In
Proceedings of the Genetic and Evolutionary Computation Conference (GECCO-
2001). Morgan Kaufmann, 137–146. hp://hampshire.edu/lspector/pubs/ace.pdf
[12]
Lee Spector. 2011. Towards Practical Autoconstructive Evolution: Self-Evolution
of Problem-Solving Genetic Programming Systems. In Genetic Programming e-
ory and Practice VIII, Rick Riolo, Trent McConaghy, and Ekaterina Vladislavleva
(Eds.). Genetic and Evolutionary Computation, Vol. 8. Springer New York, 17–33.
DOI:hp://dx.doi.org/10.1007/978-1- 4419-7747- 2 2
[13]
Lee Spector. 2012. Assessment of Problem Modality by Dierential Performance
of Lexicase Selection in Genetic Programming: A Preliminary Report. In 1st
workshop on Understanding Problems (GECCO-UP). ACM, 401–408.
DOI:
hp:
//dx.doi.org/doi:10.1145/2330784.2330846
[14]
Lee Spector and omas Helmuth. 2013. Uniform Linear Transformation with
Repair and Alternation in Genetic Programming. In Genetic Programming eory
and Practice XI, Rick Riolo, Jason H. Moore, and Mark Kotanchek (Eds.). Springer,
Chapter 8, 137–153. DOI:hp://dx.doi.org/doi:10.1007/978-1- 4939-0375- 7 8
[15]
Lee Spector, Jon Klein, and Maarten Keijzer. 2005. e Push3 execution stack and
the evolution of control. In GECCO 2005: Proceedings of the 2005 conference on
Genetic and evolutionary computation, Vol. 2. ACM Press, Washington DC, USA,
1689–1696. hp://www.cs.bham.ac.uk/wbl/biblio/gecco2005/docs/p1689.pdf
[16]
Lee Spector, Nicholas Freitag McPhee, omas Helmuth, Maggie M. Casale,
and Julian Oks. 2016. Evolution Evolves with Autoconstruction. In GECCO
’16 Companion: Proceedings of the Companion Publication of the 2016 Annual
Conference on Genetic and Evolutionary Computation. ACM, Denver, Colorado,
USA, 1349–1356. DOI:hp://dx.doi.org/doi:10.1145/2908961.2931727
[17]
Lee Spector and Alan Robinson. 2002. Genetic Programming and Autoconstruc-
tive Evolution with the Push Programming Language. Genetic Programming and
Evolvable Machines 3, 1 (March 2002), 7–40.
DOI:
hp://dx.doi.org/doi:10.1023/A:
1014538503543
1156
... Autoconstructive evolution In autoconstructive evolution, the aim is to not only evolve a solution to an optimization problem, but also to evolve the genetic operators that are used for recombination, selection, and diversification (Spector and Robinson, 2002;Harrington et al., 2012;Spector and Moscovici, 2017). To this end, each individual represents a tuple of a solution encoding and the encoding of the programs for the genetic operators, respectively. ...
... Another difference is that for adapting the genetic operators of the evolutionary algorithms, there is no need to engineer and monitor any features representing the algorithm's state. Although Spector and Moscovici (2017) obtain promising initial results, the combined evolution of solutions and their genetic operators is comparatively challenging, and it remains an open question whether autoconstructive evolution is indeed superior to non-autoconstructive evolution. ...
Preprint
Full-text available
Algorithm configuration (AC) is concerned with the automated search of the most suitable parameter configuration of a parametrized algorithm. There is currently a wide variety of AC problem variants and methods proposed in the literature. Existing reviews do not take into account all derivatives of the AC problem, nor do they offer a complete classification scheme. To this end, we introduce taxonomies to describe the AC problem and features of configuration methods, respectively. We review existing AC literature within the lens of our taxonomies, outline relevant design choices of configuration approaches, contrast methods and problem variants against each other, and describe the state of AC in industry. Finally, our review provides researchers and practitioners with a look at future research directions in the field of AC.
... Replace Space with Newline [16], [29], [46], [82], [47], [74], [48], [39], [75], [36], [83], [50], [51], [81], [84], [15], [76], [52], [40], [42], [80], [45], [85], [54], [38], [77], [49] [12], [63], [54] -30 ...
... Mirror Image [16], [29], [47], [74], [48], [39], [75], [50], [51], [76], [52], [40], [42], [80], [45], [85], [38] [11], [61], [12], [2], [63] -22 ...
Preprint
Full-text available
The automatic generation of computer programs is one of the main applications with practical relevance in the field of evolutionary computation. With program synthesis techniques not only software developers could be supported in their everyday work but even users without any programming knowledge could be empowered to automate repetitive tasks and implement their own new functionality. In recent years, many novel program synthesis approaches based on evolutionary algorithms have been proposed and evaluated on common benchmark problems. Therefore, we identify in this work the relevant evolutionary program synthesis approaches and provide an in-depth analysis of their performance. The most influential approaches we identify are stack-based, grammar-guided, as well as linear genetic programming. Further, we find that these approaches perform well on benchmark problems if there is a simple mapping from the given input to the correct output. On problems where this mapping is complex, e.g., if the problem consists of several sub-problems or requires iteration/recursion for a correct solution, results tend to be worse. Consequently, for future work, we encourage researchers not only to use a program's output for assessing the quality of a solution but also the way towards a solution (e.g., correctly solved sub-problems).
Article
Full-text available
We describe a broad class of problems, called “uncompromising problems,” characterized by the requirement that solutions must perform optimally on each of many test cases. Many of the problems that have long motivated genetic programming research, including the automation of many traditional programming tasks, are uncompromising. We describe and analyze the recently proposed “lexicase” parent selection algorition and show that it can facilitate the solution of uncompromising problems by genetic programming. Unlike most traditional parent selection techniques, lexicase selection does not base selection on a fitness value that is aggregated over all test cases; rather, it considers test cases one at a time in random order. We present results comparing lexicase selection to more traditional parent selection methods, including standard tournament selection and implicit fitness sharing, on four uncompromising problems: finding terms in finite algebras, designing digital multipliers, counting words in files, and performing symbolic regression of the factorial function. We provide evidence that lexicase selection maintains higher levels of population diversity than other selection methods, which may partially explain its utility as a parent selection algorithm in the context of uncompromising problems.
Conference Paper
Full-text available
While most hyper-heuristics search for a heuristic that is later used to solve classes of problems, autoconstructive evolution represents an alternative which simultaneously searches both heuristic and solution space. In this study we contrast autoconstructive evolution, in which intergenerational variation is accomplished by the evolving programs themselves, with a genetic programming system, PushGP, to understand the dynamics of this hybrid approach. A problem size scaling analysis of these genetic programming techniques is performed on structural problems. These problems involve fewer domain-specific features than most model problems while maintaining core features representative of program search. We use two such problems, Order and Majority, to study autoconstructive evolution in the Push programming language.
Chapter
In most genetic programming systems, candidate solution programs themselves serve as genome upon which variation operators act. However, because of the hierarchical structure of computer programs and the syntactic constraints that they must obey, it is difficult to implement variation operators that affect different parts of programs with uniform probability. This lack of uniformity can have detrimental effects on evolutionary search, such as increases in code bloat. In prior work, structured programs were linearized prior to variation in order to facilitate uniform variation. However, this necessitated syntactic repair after variation, which reintroduced non-uniformities. In this chapter we describe a new approach that uses linear genomes that are translated into hierarchical programs for execution. We present the new approach in detail and show how it facilitates both uniform variation and the evolution of programs with meaningful structure.
Conference Paper
In autoconstructive evolutionary algorithms, individuals implement not only candidate solutions to specified computational problems, but also their own methods for variation of offspring. This makes it possible for the variation methods to themselves evolve, which could, in principle, produce a system with an enhanced capacity for adaptation and superior problem solving power. Prior work on autoconsruction has explored a range of system designs and their evolutionary dynamics, but it has not solved hard problems. Here we describe a new approach that can indeed solve at least some hard problems. We present the key components of this approach, including the use of linear genomes for hierarchically structured programs, a diversity-maintaining parent selection algorithm, and the enforcement of diversification constraints on offspring. We describe a software synthesis benchmark problem that our new approach can solve, and we present visualizations of data from single successful runs of autoconstructive vs. non-autoconstructive systems on this problem. While anecdotal, the data suggests that variation methods, and therefore significant aspects of the evolutionary process, evolve over the course of the autoconstructive runs.
Conference Paper
Lexicase selection is a parent selection method that has been shown to improve the problem solving power of genetic programming over a range of problems. Previous work has shown that it can also produce hyperselection events, in which a single individual is selected many more times than other individuals. Here we investigate the role that hyperselection plays in the problem-solving performance of lexicase selection. We run genetic programming on a set of program synthesis benchmark problems using lexicase and tournament selection, confirming that hyperselection occurs significantly more often and more drastically with lexicase selection, which also performs significantly better. We then show results from an experiment indicating that hyperselection is not integral to the problem-solving performance or diversity maintenance observed when using lexicase selection. We conclude that the power of lexicase selection stems from the collection of individuals that it selects, not from the unusual frequencies with which it sometimes selects them.
Chapter
Several genetic programming researchers have argued for the utility of genetic operators that act uniformly. By “act uniformly” we mean two specific things: that the probability of an inherited program component being modified during inheritance is independent of the size and shape of the parent programs beyond the component in question; and that pairs of parents are combined in ways that allow arbitrary combinations of components from each parent to appear in the child. Uniform operators described in previous work have had limited utility, however, because of a mismatch between the relevant notions of uniformity and the hierarchical structure and variable sizes of many genetic programming representations. In this chapter we describe a new genetic operator, ULTRA, which incorporates aspects of both mutation and crossover and acts approximately uniformly across programs of variable sizes and structures. ULTRA treats hierarchical programs as linear sequences and includes a repair step to ensure that syntax constraints are satisfied after variation. We show that on the drug bioavailability and Pagie-1 benchmark problems ULTRA produces significant improvements both in problem-solving power and in program size relative to standard operators. Experiments with factorial regression and with the boolean 6-multiplexer problem demonstrate that ULTRA can manipulate programs that make use of hierarchical structure, but also that it is not always beneficial. The demonstrations evolve programs in the Push programming language, which makes repair particularly simple, but versions of the technique should be applicable in other genetic programming systems as well.
Conference Paper
Recent interest in the development and use of non-trivial benchmark problems for genetic programming research has highlighted the scarcity of general program synthesis (also called "traditional programming") benchmark problems. We present a suite of 29 general program synthesis benchmark problems systematically selected from sources of introductory computer science programming problems. This suite is suitable for experiments with any program synthesis system driven by input/output examples. We present results from illustrative experiments using our reference implementation of the problems in the PushGP genetic programming system. The results show that the problems in the suite vary in difficulty and can be useful for assessing the capabilities of a program synthesis system.
Article
Many potential target problems for genetic programming are modal in the sense that qualitatively different modes of response are required for inputs from different regions of the problem's domain. This paper presents a new approach to solving modal problems with genetic programming, using a simple and novel parent selection method called lexicase selection. It then shows how the differential performance of genetic programming with and without lexicase selection can be used to provide a measure of problem modality, and it argues that defining such a measure in this way is not as methodologically problematic as it may initially appear. The modality measure is illustrated through the analysis of genetic programming runs on a simple modal symbolic regression problem. This is a preliminary report that is intended in part to stimulate discussion on the significance of modal problems, methods for solving them, and methods for measuring the modality of problems. Although the core concepts in this paper are presented in the context of genetic programming, they are also relevant to applications of other forms of evolutionary computation to modal problems.