Multitask Evolution with Cartesian Genetic Programming

TL;DR

This paper presents a genetic programming approach that enables the simultaneous solving of multiple Boolean circuit synthesis tasks, improving efficiency over single-task methods.

Contribution

It introduces a multitask evolutionary method using Cartesian Genetic Programming for Boolean circuit synthesis, demonstrating enhanced performance.

Findings

Solves multiple logic functions more efficiently than single-task methods.

Achieves twice the success rate in Boolean circuit synthesis tasks.

Demonstrates the effectiveness of multitask evolution in genetic programming.

Abstract

We introduce a genetic programming method for solving multiple Boolean circuit synthesis tasks simultaneously. This allows us to solve a set of elementary logic functions twice as easily as with a direct, single-task approach.

Equations

$$\mathcal{T}=\{\text{AND},\text{AND\_N},\text{EQU},\text{NAND},\text{NOR},\text{NOT},\text{OR},\text{OR\_N},\text{XOR}\}.$$

Full text

Cartesian Genetic Programming, Multitask Learning

††copyright: rightsretained††journalyear: 2017††copyright: rightsretained††conference: GECCO ’17 Companion; July 15-19, 2017; Berlin, Germany††doi: http://dx.doi.org/10.1145/3067695.3075615††isbn: 978-1-4503-4939-0/17/07††ccs: Computing methodologies Search methodologies

1. Introduction

Most evolutionary algorithms and metaheuristics built to date have been used as single-task problem solvers. With a few exceptions in areas like case-based reasoning (Cunningham and Smyth, 1997) and robot shaping (Dorigo and Colombetti, 1998), traditionally there is no attempt to store solutions, subcomponents, or other evolved information from one task and to reuse it on other tasks. Instead, these search algorithms rely on direct guidance from an objective function to approach a solution via variation and selection.

Very recently, a disjoint handful of researchers have begun to design new kinds of evolutionary systems that depart significantly from this single-task, adaptationist paradigm. Preliminary efforts with multitask evolutionary systems have begun to reveal cases where transferring and re-using information across superficially dissimilar tasks can serve to help a problem-solving agent perform more efficiently, or to provide a means of solving problems that would otherwise be deceptive or intractable. A number of different mechanisms for effectively evolving solutions to multiple tasks simultaneously or in sequence have recently been proposed by authors working in different domains. New structured-population models such as MAP-elites, for instance, have been developed for robotics and design applications (Nguyen et al., 2016), ‘multifactorial’ methods have been introduced for combinatorial optimization (Gupta et al., 2016), and agent-based ‘path-reuse’ mechanisms have been proposed to allow deep neural networks that have been evolved for different pattern recognition tasks to reuse subcomponents that were trained for previous tasks (Fernando et al., 2017).

In this work, we are applying Cartesian genetic programming (CGP, (Miller, 2011)) in a multitask fashion to evolve logic circuits that solve elementary Boolean functions. Taking inspiration from the canonical literature on multitask learning in neural networks (Caruana, 1998), we follow what we call a ‘multi-behavior’ approach to multitask evolution: each individual genome in the evolutionary algorithm encodes a solution to several tasks at once (Figure 1). In the resulting program tree, the solutions to each task all share the same inputs, but have their own designated outputs. This allows subtrees that are useful in the solution to one task to be reused as partial solutions to other tasks.

CGP has often been applied in much this way to synthesize solutions to single tasks with more than one output. Our focus here is somewhat different: we are interested in finding ways of sharing and transferring information across multiple distinct tasks. The question here is whether we can use multitask CGP to more efficiently solve a set of tasks that would traditionally be treated separately.

2. Methodology

The set of tasks used in this study is a simple suite $\mathcal{T}$ of 9 elementary logic function synthesis tasks that were originally used by Lenski et al. to demonstrate that complex tasks are sometimes easier to solve in conjunction with other tasks than they are to solve directly (Lenski et al., 2003):

[TABLE]

Our primitive set consists only of $\{\texttt{NAND}\}$.

For a preliminary proof of concept we wish only to demonstrate the following claim:

Hypothesis: A multi-behavior approach will be able to solve all $|\mathcal{T}|=9$ tasks using less computational effort than a traditional single-task approach.

To test this, we apply a standard $(1+4)$-style implementation of Cartesian genetic programming to a fitness function that evaluates each circuit on all 9 tasks simultaneously. We treat the average fitness across all 9 tasks as a scalar fitness value.

Now, in multitask algorithm applications it sometimes happens that progress is impeded by task interference: progress on one task may overwrite the solution to previously solved tasks, preventing the algorithm from encoding solutions to many tasks at once. In light of this, we further hypothesize that multi-behavior CGP will perform better if we avoid mutating genes that belong to a successful solution to a task. We effect this by tracking which outputs each circuit element contributes information to. We then configure the probability that each element’s genes are mutated to be a decreasing function of the mean fitness of all the tasks it belongs to. We test this weighted mutation scheme with both linearly- and exponentially-decreasing weighting functions. All together, we implemented one single-task CGP algorithm and three multi-behavior algorithms (a constant-mutation case, the linear case, and the exponential case).

In order to achieve a fair comparison, we performed an extensive sweep over CGP’s free parameters and our weighted mutation scheme parameters to select configurations of each algorithm that solve the suite of tasks in the least computational effort on average. As a result of this parameter-tuning process, some algorithms are configured to use different circuit sizes than others. To compare results with different circuit sizes, our measure of computational effort is node-evaluations—that is, the number of individuals that have been evaluated, multiplied by their size. To solve all 9 tasks with each algorithm, we run each multi-behavior algorithm once on the task suite, and then we run the single-task algorithm 9 times in sequence, once for each of the tasks, measuring the total number of node-evaluations expended along the way before a solution is found.

3. Preliminary Results

Results on the 9-logic suite suggest that the multi-behavior CGP algorithm is more efficient than a single-task approach when a constant or exponentially-weighted mutation rate is used. Figure 2 shows the distribution of effort each algorithm required to successfully find solutions to all 9 tasks. On average, we find that the exponentially-weighted algorithm solves the tasks twice as easily as the single-task algorithm does.

One of the potential advantages of this kind of multitask evolution is that no prior knowledge is needed about how information might be reused across different tasks: evolution dynamically discovers subproblems that are redundant across tasks. Much more work is needed, however, to understand how sharing information across tasks works in different domains, and what conditions or structural similarities among tasks are necessary to see performance improvements from multitask evolution.

As this research continues, we intend to analyze the circuits generated by the multi-behavior approach for patterns of reuse, and to extend this methodology to more complex task suites and primitive sets.