cross-task code reuse in genetic programming applied … · of generative visual learning based on...

Int. J. Appl. Math. Comput. Sci., , Vol. , No. , –DOI:

CROSS-TASK CODE REUSE IN GENETIC PROGRAMMINGAPPLIED TO VISUAL LEARNING

Wojciech Jaśkowski, Krzysztof Krawiec, Bartosz Wieloch

Institute of Computing Science, Poznan University of Technology, Polande-mail: wjaskowski,kkrawiec,[email protected]

We propose a method that enables effective code reuse between evolutionary runs that solve a set of relatedvisual learning tasks. We start with introducing a visual learning approach that uses genetic programmingindividuals to recognize objects. The process of recognition is generative, i.e., requires the learner to restorethe shape of the processed object. This method is extended with a code reuse mechanism by introducinga crossbreeding operator that allows importing the genetic material from other evolutionary runs. In theexperimental part, we compare the performance of the extended approach to the basic method on a real-worldtask of handwritten character recognition, and conclude that code reuse leads to better results in terms offitness and recognition accuracy. The detailed analysis of the crossbred genetic material shows also that codereuse is most profitable when the recognized objects exhibit visual similarity.

Keywords: Genetic programming, code reuse, knowledge sharing, visual learning, multi-task learning, opticalcharacter recognition

1. Introduction

Experimental evaluation of evolutionary computa-tion methods, similarly to other computational intel-ligence approaches, usually concerns isolated tasks,often given in a form of well-defined, standardizedbenchmarks. Though justified by the scientific rigorof reproducibility, this happens to focus the researchon the algorithms that match such experimentalframework, i.e., on the methods whose ‘lifecycle’ islimited to a single experiment. Each experiment, typ-ically composed of an evolutionary run on a partic-ular problem and examination of its outcomes, takesplace in isolation from the other experiments. The al-gorithm is not enabled to ‘recall’ its experience withother problems.

This approach is fundamentally different fromthe human way of problem solving, which is stronglybased on experience. Priors in human reasoning comefrom one’s history of dealing with similar tasks andare essential for acquiring new skills. By reusingknowledge, humans solve problems they have neverfaced before and perform well in difficult circum-stances, e.g., in presence of noise, imprecision, andinconsistency.

The inability to make use of the past experi-ence affects, among others, the genetics-based ma-chine learning that this paper is devoted to. In a typ-ical scenario, the learning algorithm (inducer) usesexclusively the provided training data to produce aclassifier. In that process, the inducer relies on fixedpriors that do not change from one learning processto another. There is no widely accepted methodol-ogy for reusing the knowledge that the inducer couldhave acquired in the past, and hence knowledge reuseis still listed among the most challenging issues inmachine learning (Mitchell, 2006).

In an attempt to narrow the gap between thehuman and the machine way of learning, we proposehere a simple yet effective approach to knowledgereuse. Our major contribution is a method of codereuse for genetic programming (Koza, 1992; Lang-don and Poli, 2002; O’Neill, 2009), which operatesbetween evolutionary runs that learn to recognize dif-ferent visual patterns given by disjoint training sets.The technical means for that is a crossbreeding op-erator that allows individuals to cross over with theindividuals evolved for other learning tasks. By wayof learning task (or task for short) we mean the pro-cess of learning a particular class of visual patterns.

2 W.Jaśkowski et al.

Within the proposed framework, such a task corre-sponds to a single evolutionary run that optimizes aspecific fitness function.

The remaining part of this paper starts with ashort review of related work and motivations for codereuse (Section 2). In Section 3 we detail the approachof generative visual learning based on genetic pro-gramming individuals that process visual primitives.Section 4 is the core part of this paper and presentsthe proposed method of code reuse within the geneticprogramming paradigm. Section 5 describes the com-putational experiment, and Section 7 draws conclu-sions and outlines the future research directions.

2. Motivations and Related WorkKoza (1994) made the key point that the reuse ofcode is a critical ingredient to scalable automatic pro-gramming. In the context of genetic programming,code reuse is often associated with knowledge en-capsulation. The canonical result in this field areAutomatically Defined Functions defined by Koza(1994, section 6.5.4). Since then, more research onencapsulation (Roberts et al., 2001) and code reuse(Koza et al., 1996) has been done within the geneticprogramming community. Proposed approaches in-clude reuse of assemblies of parts within the sameindividual (Hornby and Pollack, 2002), identifyingand re-using code fragments based on the frequencyof occurrences in the population (Howard, 2003),or explicit expert-driven task decomposition usinglayered learning (Hsu et al., 2004). Among otherprominent approaches, Rosca and Ballard (1996) uti-lized the genetic code in form of evolved subrou-tines, Haynes (1997) integrated a distributed searchof genetic programming-based systems with collectivememory, and Galvan Lopez et al. (2004) reused codeusing a special encapsulation terminal. In a recentdevelopment, Li et al. (2012) proposed a code reusemechanism for variable size genetic network program-ming.

In the research cited above, the code was reusedonly within a single evolutionary run. Surprisinglylittle work has been done in genetic programming toreuse the code between multiple tasks. To our knowl-edge, the first to notice this gap was Seront (1995),who investigated code reuse by initializing an evo-lutionary run with individuals from the concept li-brary consisting of solutions taken from other, similartasks. He also mentioned the possibility of introduc-ing a special mutation operator that would replacesome subtrees in population by subtrees taken fromthe concept library, in a way similar to our contribu-tion, but did not formalize nor computationally ver-ify it. An example of other approach to reusing the

knowledge between different tasks is Kurashige’s workon gait generation of a six-legged robot (Kurashigeet al., 2003), where the evolved motion control codeis treated as a primitive node in other motion learningtask.

In machine learning, the research on issues re-lated to knowledge reuse, i.e., meta-learning, knowl-edge transfer, and lifelong learning, seem to attractmore attention than in evolutionary computation(Vilalta and Drissi, 2002, for a survey). Among these,the closest machine learning counterpart of the ap-proach presented in this paper is multitask learn-ing, meant as simultaneous or sequential solving ofa group of learning tasks. Following Caruana (1997)and Ghosn and Bengio (2000), we may name severalpotential advantages of multitask learning: improvedgeneralization, reduced training time, intelligibility ofthe acquired knowledge, accelerated convergence ofthe learning process, and reduction of the numberof examples required to learn the concept(s). Theability of multitask learning to fulfill some of theseexpectations was demonstrated, mostly experimen-tally, in different machine learning scenarios, most ofwhich used artificial neural networks as the underly-ing learning paradigm (Pratt et al., 1991; O’Sullivanand Thrun, 1995).

In the field of genetic algorithms (Holland, 1975),the work done by Louis and McDonnell (2004) re-sembles our contribution the most. In their CaseInjected Genetic Algorithms (CIGAR) experience isstored in a form of solutions to problems solved ear-lier (‘cases’). When confronted with a new problem,CIGAR evolves a new population of individuals andperiodically enriches it with such remembered cases.The experiments demonstrated CIGAR’s superior-ity to genetic algorithm in terms of search conver-gence. However, CIGAR injects complete solutionsonly and requires the ‘donating’ task to be finishedbefore starting the ‘receiving’ task, which makes itsignificantly different from our approach.

From another perspective, our algorithm per-forms visual learning and that makes it related tocomputer vision and pattern recognition. Most vi-sual learning methods proposed so far operate ata particular stage of image processing and analy-sis (like local feature extraction, e.g., (Perez andOlague, 2013; Chang et al., 2010a)), which enableseasy interfacing with the remaining components ofthe recognition system; using a machine learning clas-sifier to reason from predefined image features is atypical example of such an approach. In contrastto that, we propose a learning method that spansthe entire processing chain, from the input image tothe final decision making, and produces a completerecognition system. Former research on such sys-

Cross-Task Code Reuse in Genetic Programming Applied to Visual Learning 3

tems is rather limited (Teller and Veloso, 1997; Rizkiet al., 2002; Howard et al., 2006; Tackett, 1993).Bhanu et al. (2005) and Krawiec and Bhanu (2005)proposed a methodology that evolved feature extrac-tion procedures encoded either as tree-like or lineargenetic programming individuals. The idea of us-ing genetic programming to process attributed visualprimitives, presented in the following section, was ex-plored for the first time by Krawiec (2006) and furtherdeveloped by Jaśkowski et al. (2007c) and Krawiec(2007).

Previously (Jaśkowski et al., 2007a), we demon-strated the possibility of explicit cross-task sharing ofcode between individuals. Here, we study a methodthat benefits from code fragments imported fromother individuals. In comparison with our earlierwork on this method (Jaśkowski et al., 2007b) herewe additionally demonstrate its validity on a nontriv-ial, large multi-class problem, compare it to other ma-chine learning techniques, analyze in-depth the effectsof code reuse, provide extensive results for compoundrecognition systems, and place this study in the con-text of related research.

3. Generative Visual LearningThe approach of generative visual learning (Jaśkowskiet al., 2007c; Krawiec, 2007) evolves individuals(learners) that recognize objects by reproducing theirshapes. This process is driven by a fitness functionthat applies a learner to each training image indepen-dently and verifies its ability to recognize image con-tent. The process of recognition of a single trainingimage starts with transforming it into a set of visualprimitives (Alg. 1). Then, the learner is applied tothe primitives and hierarchically groups them accord-ing to different criteria. At every stage of groupingprocess, the learner is allowed to issue drawing ac-tions that are intended to reproduce the input image.Reproduction takes place on a virtual canvas spannedover the input image. The fitness function comparesthe contents of the canvas to the input image, andrewards individuals that provide high quality of re-production. The trained learner may be then used forrecognition, meant as discriminating the instances ofthe shape class it was trained on from the instancesof all other classes (e.g., telling apart the examples ofspecific handwritten character from the examples ofall the other characters).

The generative approach incites each individ-ual to prove its ‘understanding’ of the analyzed im-age, i.e., its ability to (i) decompose the input shapeinto components by detecting the important imagefeatures, and (ii) reproducing the particular compo-nents. An ideal individual is expected to produce a

Algorithm 1 The process of recognizing image s bylearner L

1: function Recognize(L, s)2: L - evaluated program (learner)3: s - input image4: P ←ExtractPrimitives(s)5: GroupAndDraw(L,P ,c) c - canvas6: return Similarity(c,s)7: end function

minimal set of drawing actions that completely andexactly reproduce the shape of the object being rec-ognized. These desired properties of drawing actionsare promoted by an appropriately constructed fit-ness function. Breaking down the image interpreta-tion process into drawing actions allows us to exam-ine individual’s processing in a more thorough waythan in the non-generative approach, where the in-dividuals are expected to output decision (class as-signment) only. Here, an individual is rewarded notonly for the final result of decision making, but forthe entire ‘track’ of reasoning process. Thanks tothat, the risk of overfitting, so grave in learning fromhigh-dimensional image data, is significantly broughtdown.

Following Krawiec (2007), to reduce the amountof processed data, our learners receive only pres-elected salient features extracted from the originalraster image s (function ExtractPrimitives in Alg.1). Each such feature, called visual primitive (orprimitive) in the following, corresponds to an imagelocation with a prominent ‘edgeness’.

Note that our feature extraction method is sim-ple and could be improved by applying more accurateedge detection algorithms as described by, e.g., Fabi-janska (2012), or by using more sophisticated interestpoint detector, e.g., proposed by Trujillo and Olague(2006).

Each primitive is described by three scalarscalled hereafter attributes; these include two spa-tial coordinates of the edge fragment (x and y) andthe local gradient orientation. The complete set Pof primitives, derived from s by a simple procedure(Jaśkowski et al., 2007c), is usually much more com-pact than the original image, yet it well preserves itssketch. The top part of Fig. 1a presents an exemplaryinput image (s in Alg. 1), and the lower part showsthe set of primitives P retrieved from that image.

The actual process of recognition (procedureGroupAndDraw in Alg. 1) proceeds as follows. Anindividual L applied to an input image s builds a hi-erarchy of primitive groups in P . Each invoked treenode creates a new group of primitives and groups ofprimitives from the lower levels of the hierarchy. In


(a) (b) (c)

Fig. 1. A simple geometric figure s and its primitive representation P (a); the primitive hierarchy built by the learnerfrom primitives, imposed on the image (b) and shown in an abstract form (c).

Table 1. The genetic operators (function set).

Type Operatorℜ ERC – Ephemeral Random ConstantΩ Input() – the primitive representation P of the input image s

A px, py , po – the attributes of visual primitivesR Equals, Equals5Percent, Equals10Percent, Equals20Percent, LessThan, GreaterThanG Sum, Mean, Product, Median, Min, Max, Rangeℜ +(ℜ,ℜ), –(ℜ,ℜ), *(ℜ,ℜ), /(ℜ,ℜ), sin(ℜ), cos(ℜ), abs(ℜ), sqrt(ℜ), sgn(ℜ), ln(ℜ), AttributeValue(Ω,ℜ)Ω SetIntersection(Ω,Ω), SetUnion(Ω,Ω), SetMinus(Ω,Ω), SetMinusSym(Ω,Ω), SelectorMax(Ω,A), SelectorMin(Ω,A),

SelectorCompare(Ω,A,R,ℜ), SelectorCompareAggreg(Ω,A,R,G), CreatePair(Ω,Ω), CreatePairD(Ω,Ω),ForEach(Ω,Ω), ForEachCreatePair(Ω,Ω,Ω), ForEachCreatePairD(Ω,Ω,Ω), Ungroup(Ω), GroupHierarchyCount(Ω,ℜ),GroupHierarchyDistance(Ω, ℜ), GroupProximity(Ω, ℜ), GroupOrientationMulti(Ω, ℜ), Draw(Ω)

Fig. 2. An exemplary evolved individual capable of recognizing triangular shapes.


the end, the root node returns a nested primitive hi-erarchy built atop of P , which reflects the processingperformed by L for s.

An exemplary process of recognition by a hypo-thetical learner is shown in Fig. 1. Figure 1b depictsthe hierarchical grouping imposed by L on P in theprocess of recognition of image from Fig. 1a (pro-cedure GroupAndDraw). Figure 1c presents thesame hierarchy in abstraction from the input image.Note that the groups of primitives are allowed to in-tersect.

Internally, an individual is a procedure writtenin a form of a tree, with internal nodes representingfunctions that process sets of primitives. Every vi-sual primitive has three attributes: the coordinatesof its midpoint (px, py), and the orientation po ex-pressed as an absolute angle with respect to abscissa.The terminal nodes fetch the initial set of primitivesP derived from the input image s, and the consecu-tive internal nodes process the primitives, all the wayup to the root node. The functions, presented in Ta-ble 1, may be divided into scalar functions, selectors,iterators, and grouping operators. Scalar functionsimplement conventional arithmetic. Selectors filterprimitives based on their attributes; for instance, call-ing LessThan(A1, px,20) returns only those primitivesfrom the set A1 that have px < 20. Iterators processprimitives one by one; e.g., ForEach(A1, A2) will iter-ate over all primitives from the set A1, process everyone of them independently using the program (sub-tree) defined by its second argument A2, gather theresults of that processing into a single set, and returnthat set. Grouping operators group primitives basedon their attributes and features; e.g., GroupProxim-ity(A1, 10) will group the primitives in A1 accordingto their spatial proximity, using the 10 argument asa threshold for proximity relation, and return the re-sults of that grouping as a nested hierarchy of sets(every results of type Ω (see Table 1) is in general ahierarchy of sets of primitives, as shown in examplein Fig. 1).

Since the above instructions operate on differ-ent types, we use strongly-typed genetic program-ming (Montana, 1993), which implies that two nodesmay be connected only if their input/output typesmatch. The list of types includes numerical scalars,sets of primitives, attribute labels, binary arithmeticrelations, and aggregators.

Fig. 2 presents an exemplary evolved individualcapable of recognizing triangular shapes. Let us clar-ify the recognition process by tracking the executionof the leftmost tree branch (bottom-up processing).The SelectorMin operator selects from the entire in-put set of primitives (supplied by the ImageNode)those that have minimal value of the Y coordinate.

The resulting group of primitives is merged by oper-ator CreatePairD with the primitives selected by thesibling branch (nodes ImageNode and SelectorMax).That group of primitives is merged again by subse-quent CreatePairD node with another group of primi-tives. Finally, the resulting group of primitives is pro-cessed by symmetric set difference (SetMinusSym) atthe root node.

Apart from grouping of visual primitives, somebranches of the tree may contain drawing instructionsthat affect the canvas, which is ultimately subject toevaluation by the Similarity function in Alg. 1.Drawing actions insert line segments into the outputcanvas c. The coordinates of line segments are de-rived from the processed primitives. The simplestrepresentative of drawing nodes is the function calledDraw, which expects primitive set T as an argumentand draws on canvas c line segments connecting eachpair of primitives from T . Draw does not modify theset of primitives it processes. Other drawing func-tions, with names ending with upper-case letter D(see Table 1), perform drawing as a side-effect of theirprocessing.

The recognition of image s by an individual Lis completed by comparing the contents of canvas cto the original image s (the Similarity function inAlg. 1). It is assumed that the difference betweenc and s is proportional to the minimal total cost ofbijective assignment of pixels lit in c to pixels lit ins. The total cost is a sum of costs for each pixel as-signment. The cost of assignment depends on the dis-tance between pixels: when the distance is less than5, the cost is 0; maximum cost 1 is assigned whenthe distance is greater than 15; between 5 and 15 thecost is a linear function of the distance. These thresh-olds were adjusted by experimentation and depend onthe lower limit of distance between primitives spec-ified in the preprocessing procedure (see (Jaśkowskiet al., 2007c) for details). For each pixel that can-not be paired (e.g., because there are more lit pixelsin c than in s), an additional penalty of value 1 isadded to the total cost. In such a way, an individualis penalized for committing both false negative errors(when parts of input shape are not drawn on the can-vas) and false positive errors (the excess of drawing),including the special case of drawing line segmentsthat overlap (partially or completely). The pairingof image and canvas pixels is carried out by an ef-fective greedy heuristic. The heuristic iterates overcanvas pixels and to each of them assigns the closestnon-paired pixel from the input image.

To evaluate the fitness of an individual-learnerL, the above recognition process is carried out for alltraining images from the training set S of images.The (minimized) fitness of L is defined as the total


Algorithm 2 Evolution of classifiers for a single de-cision class. I1 is the initial population, gmax is thenumber of generations, and O stands for the set ofbreeding operators.

1: function Evolve(I1, gmax, O)2: for g ← 1 . . . gmax − 1 do3: Evaluate each L ∈ Ig

4: B ← Selection(Ig)5: Ig+1 ← apply breeding operators

from O to B6: end for7: return Igmax

8: end function

cost of the assignment normalized by the number oflit pixels in s, and averaged over the entire trainingset of images S. An ideal individual perfectly repro-duces shapes in all training images using the minimalnumber of line segments, so that its fitness amounts to0. The more the canvas produced by L differs fromthe input image (for one or more training images),the greater (worse) its fitness value. Thus, the fitnessfunction rewards individuals that exactly and com-pletely reproduce as many images from S as possible,promoting so the discovery of similarities between thetraining images.

Let us now explain how the generative recogni-tion process is employed in the multi-class classifica-tion task that is of interest in this paper. For each de-cision class (handwritten character class in our exper-iment), we run a separate evolutionary process thatuses only examples from that class in the trainingset S. A highly fit individual resulting from such aprocess should be able to well reproduce the shapesrepresented by images in S, and at the same timeis unlikely to accurately (and minimally) reproducethe shapes from the other classes. Examples of suchclose-to-perfect and imperfect reproductions will begiven in Figs. 6a and 6b in the experimental part ofthis paper.

In other words, our learning algorithm uses train-ing examples from the positive class only, havingno idea about the existence of other classes (objectshapes). This learning paradigm, known as one-classlearning (Moya and Hostetler, 1993), may be ben-eficial in terms of training time (fewer training ex-amples) and is context-free in the sense that no otherclasses are involved in the training process. To handlea k-class classification problem, we run k independentevolutionary processes, each of them devoted to oneclass (see Alg. 2). The k best individuals obtainedfrom particular runs form the complete multi-classclassifier (recognition system), ready to recognize new

Algorithm 3 GPCR evolutionary process. m is thelength of the primary run, n is the length of en-tire evolutionary process (primary run and secondaryrun).

1: function GPCR(m, n) m < n2: for c← 1 . . . k do Loop over primary runs3: I1

c ← RandomPopulation( )4: Pc ← Evolve(I1

c , m,Mutate, Crossover)

5: end for6: P ← (P1, . . . , Pk) Pools for crossbreeding7: for c← 1 . . . k do Loop over secondary runs8: In

c ← Evolve(I1c , n−m,

Mutate,Crossover, Crossbreed(P ))9: end for

10: return (In1 , . . . , In

k )11: end function

images using a straightforward procedure detailed inSection 5.2.

4. Code ReuseGiven the similar visual nature of the learning tasksrelated to particular classes of characters, we expectthem to require some common knowledge. Someclasses may need similar fragments of genetic codeto, e.g., detect the important features like stroke endsor stroke junctions. For instance, locating the ends ofthe shape of letter Y may require a similar code (sub-tree) as locating the ends of letter X. To exploit suchcommonalities and avoid unnecessary redundancy, weenable cross-task code reuse between the evolutionaryprocesses devoted to particular classes.

The method, Genetic Programming with CodeReuse (GPCR, Alg. 3), runs in parallel k evolution-ary processes for n generations, one process for eachof k classes. For the initial m generations (m < n),evolution proceeds exactly as in the basic algorithmdescribed in the previous section (referred to as GPin the following). We call this part of evolutionaryprocess the primary run (line 4 in Alg. 3). Whenthe cth run (c = 1...k) reaches the mth generation,we store a snapshot (copy) of its population in a poolPc. Next, the process’s population is re-initialized inthe same way as the initial population of the primaryrun, and the evolution continues for the remainingn−m generations, referred to as secondary run (line 8in Alg. 3). The secondary run is initialized using thesame random seed as the primary run, so the initialpopulations of the primary and secondary runs areexactly the same (I1 in Alg. 3).

The secondary runs differ from the primary onesin that they activate an extra crossbreeding operator


m gen.

n-m gen.

...

...

P1 P2 P3 Pk

Task 1 Task 2 Task 3 Task kprimary

runs

secondaryruns

Fig. 3. The architecture of GPCR.

that is allowed to import genetic material from thepools. Its algorithm is presented in Alg. 4, along withthe standard breeding operators used in genetic pro-gramming. Crossbreeding for the cth secondary runworks similarly to subtree-swapping crossover, how-ever, it interbreeds an individual from the currentpopulation (a ‘native’) with an individual from one ofthe pools of the other decision classes Pj , j = c (an‘alien’). First, it selects a native parent from the cur-rent population using the same selection procedure ascrossover. Then, it picks out an alien parent by ran-domly choosing one of the pools Pj , j = c, and thenrandomly selecting an individual from Pj , disregard-ing its fitness. Fitness is ignored in this process as itreflects alien’s performance on a different task (deci-sion class); in particular, alien’s low fitness does notnecessarily mean that it lacks code fragments that areuseful for solving the native’s task. Finally, the cross-breeding operator randomly selects two nodes Nn andNa in the native and the alien parent respectively, andreplaces Nn by the subtree rooted in Na. The modi-fied native parent (offspring) is injected into the sub-sequent population (provided it meets the tree depthconstraint), and the alien parent is discarded. Thus,crossbreeding may involve large portions of code aswell as small code fragments, in an extreme case evensingle terminal nodes.

Fig. 3 outlines the dataflow in GPCR. Each col-umn of two blocks in the diagram comprises the pri-mary run and the secondary run for one decision class(task), and the arrows depict the transfer of geneticmaterial between them. Overall, GPCR involves kprimary runs lasting m generations and k secondaryruns lasting n−m generations, so the total number ofindividual evaluations is the same as in standard GPrunning k runs for n generations each. Thus, the ad-ditional computational overhead brought by GPCRincludes the cost of re-initialization of k populationsat the verge between the primary and secondary runs

Algorithm 4 Genetic Programming operators1: function Mutate(p) A single parent2: s1 ← randomly selected subtree in parent p3: s2 ← randomly generated subtree4: return child produced by replacing s1 with

s2 in p5: end function

6: function Crossover(p1, p2) Two parents7: s1 ← randomly selected subtree in parent p18: s2 ← randomly selected subtree in parent p29: c1, c2 ← swap s1 with s2 in p1 and p2

10: return c1, c211: end function

12: function Crossbreed(p, c, P ) A parent, itstask id, and pools from primary run

13: Pj ← randomly selected pool from Psuch that j = c

14: a← randomly selected individual from Pj

15: s1 ← randomly selected subtree in parent p16: s2 ← randomly selected subtree in alien a17: return child produced by replacing s1 with

s2 in p18: end function

and the cost of crossbreeding. As these operationsare generally computationally inexpensive when com-pared to the fitness assessment, the overall computa-tional effort of GPCR is roughly the same as that ofGP1. This enables fair comparison and allows us tofocus exclusively on the performance of the evolvedsolutions in the experimental part of the paper.

5. The ExperimentIn the experimental part, we approach a real-worldmulti-class problem of handwritten character recog-nition and demonstrate how GPCR compares to GPon that task in terms of fitness as well as classifica-tion accuracy (recognition performance). The taskis to recognize letters from Elder Futhark, the oldestform of the runic alphabet. To make the task realisticand self-contained, we consider all character classespresent in this problem, which look in print as follows:f U þ a r k g w h n i jI p R s t b e m l ŋ d o

Elder Futhark letters are written with straightpen strokes only, which makes them a good testbed

1The cost of population re-initialization is in fact close tozero: as the secondary run starts with exactly the same popu-lation as the primary run, one can cheaply create a copy of theinitial population of the primary run and use it as a startingpoint for the secondary run.


Fig. 4. Examples of handwritten Elder Futhark charac-ters.

for our approach that uses line segments as draw-ing actions (see Section 3). Using a TabletPC com-puter, we prepared the training set containing 240images (examples, objects) of k = 24 runic alphabetcharacters, each character class represented by 10 ex-amples written by 7 persons (three persons providedtwo character sets each). Fig. 4 shows examples ofselected handwritten characters.

The purpose of the experiment is to compare themethod with code reuse (GPCR) to the basic geneticprogramming (GP) that provides us with the con-trol results. Technically, for each of k = 24 charac-ter classes we run a generational evolutionary processmaintaining a population of 10,000 individuals. Eachprocess lasts for n = 600 generations; this numberof generations was necessary for GP to reach a firmleveling-off of fitness graph indicating little chance forfurther improvement. To provide for statistical signif-icance, we repeat each process 30 times, starting eachtime from a different initial population created usingKoza’s ramped half-and-half operator with ramp from2 to 6 (Koza, 1992). We apply the tournament selec-tion with tournament of size 5, using individuals’ sizesfor tie breaking and thus promoting smaller trees andalleviating the problem of code bloat. The tree depthlimit is set to 10; the mutation and crossover opera-tions may be repeated up to 5 times if the resultingindividuals do not meet this constraint; otherwise,the parent solutions are copied into the subsequentgeneration. The algorithm was implemented in Javawith help of the ECJ package (Luke, 2002), exceptfor the fitness function written for efficiency in C++.For the evolutionary parameters not mentioned here,ECJ’s defaults were used.

For GP runs, offspring are created by crossingover the selected parent solutions from the previ-ous generation (with probability 0.8; see Crossoverfunction in Alg. 4), or mutating them by replacingsubtrees (with probability 0.2; see Mutate function

in Alg. 4). For GPCR, the primary run lasts form = 300 generations with the same settings as GPand the same contents of the initial population, so itis literally the same as the first m generations of thecorresponding GP run. In the secondary run (lastingfor 300 generations as well) the mutation probabil-ity is lowered to 0.1 and the remaining 0.1 is yieldedto the crossbreeding operator. Apart from this shiftin probabilities associated with particular operators,the GP and GPCR settings are virtually identical andtake the same computation time.

To intensify the search and prevent prematureconvergence to local optima, we used the island model(Whitley et al., 1999). We split the population into10 equally-sized islands and, starting from the 50th

generation, exchange individuals between the islandsevery 20th generation. During the exchange, everyodd-numbered island donates the clones of its best-performing individuals (10% of population, selectedby tournament of size 5) to the five even-numberedislands, where they replace the worst-performing in-dividuals selected using an inverse tournament of thesame size. Reciprocally, the even-numbered islandsdonate their representatives to the odd-numbered is-lands in the same way. The islands should not beconfused with the boxes depicting the evolutionaryruns in Fig. 3 — the island model is implementedwithin each evolutionary run independently, both inGPCR and in basic GP, so its presence does not biastheir comparison.

5.1. Fitness comparison. In order to confrontGPCR with GP, we first compared their results interms of fitness. Table 2 presents the average fitness(computed on the training set) of the best-of-run in-dividuals for each runic letter. Clearly, the fitness forGPCR is better in all cases. Statistical analysis re-veals that, for 21 classes marked by stars, reusing thecode significantly pays off (t-test, α = 0.05).

We also evaluated the best-of-run individuals onthe test set of characters, which was disjoint withthe training set and contained 1440 images, that is60 images for each character class. On the test set,GPCR outperformed GP for 22 classes, and in 15cases the difference was statistically significant (seeTable 3). The two cases where GP outdid GPCRwere statistically insignificant. On average, the fit-ness of the GPCR best-of-run individual was betterthan that of the GP best-of-run individual by nearly21% for the training set and by nearly 24% on thetest set.

Figure 5 presents the progress of GP (solid lines)and GPCR evolutionary processes (dotted lines) forthe 5 first letters of the runic alphabet. These graphsare representative for the behavior of both methods


Table 2. Fitness of best-of-run individuals for the training set for GPCR and GP averaged over 30 runs for each runicletter. The lower the value, the better fitness; stars mark statistical significance (t-test, α = 0.05).

Letter f U þ a r k g w h n i j

GP 0.301 0.128 0.275 0.261 0.261 0.226 0.212 0.185 0.166 0.153 0.066 0.235GPCR 0.188* 0.119* 0.144* 0.205* 0.196* 0.191* 0.192* 0.173* 0.149* 0.149* 0.066 0.217*

Letter I p R s t b e m l ŋ d o

GP 0.214 0.447 0.203 0.299 0.214 0.293 0.208 0.249 0.182 0.244 0.235 0.278GPCR 0.197 0.267* 0.188* 0.254* 0.211* 0.226* 0.184* 0.187* 0.164* 0.215 0.212* 0.257*

Table 3. Overall comparison of GPCR and GP best-of-run fitness. GPCR is better for all 24 letters on the training setand for 22 letters on the test set. These differences are statistically significant in 21 cases in training and 15cases in testing (t-test, α = 0.05).

GPCR Average fitness gain # better # worse # stat. better # stat. worse

Training set 20.9% 24 0 21 0Test set 23.9% 22 2 15 0

for all 24 characters. GPCR series start from the300th generation, when the secondary run is initial-ized, while its primary runs are the same as GP’s first300 generations. The convergence of GPCR is muchfaster than GP’s: the line is nearly vertical for thefirst few generations of the secondary run. Note alsothat GPCR significantly outperforms GP on the so-phisticated characters, while on a simple one (U) itdoes not have much chance for improvement.

5.2. Comparison of recognition systems. Wecompare GPCR and GP also in terms of the multi-class recognition performance. For this purpose, wecombine all 24 best-of-run individuals, forming thecomplete recognition system that undergoes evalua-tion on the test set of characters. The system clas-sifies an example t by computing fitness values of all24 individuals for t and indicating the class associatedwith the individual that produced the smallest (thebest) value. Such procedure is motivated by an obser-vation, that individual’s fitness should be close to 0only for the positive examples (images from the classit was trained on). For the negative examples, the re-production process should most probably fail, draw-ing inappropriate line segments on the canvas andthus resulting in inferior fitness (cf. Section 3). Asa demonstration, Fig. 6a presents the close-to-perfectreconstructions produced by the 24 best-of-run indi-viduals for examples from the corresponding positiveclasses. On the other hand, in Fig. 6b, where eachshape was reconstructed using the same individual

taught on class I, only the reconstruction of charac-ter I is correct2.

The above recognition procedure, called simplerecognition system in the following, may be obtainedat a relatively low computational expense of one evo-lutionary process per class. Given more runs, recog-nition accuracy may be further boosted by employ-ing more voters per each class, as opposed to one-voter-per-class scheme used by the simple recognitionsystem. This is especially appealing in the contextof evolutionary computation, where each run usuallyproduces a different best-of-run individual, so theirfusion may be synergistic. To exploit this opportu-nity, we come up with a vote-l recognition system thatuses l best-of-run individuals for each class. Given30 runs performed for each class in this study, webuild ⌊30/l⌋ separate vote-l systems. When classi-fying an example, the vote-l system considers all l24

possible combinations of voters, using one voter perclass in each combination. Each combination pro-duces one decision, using the same procedure as thesimple recognition system. The class indicated mostfrequently across all combinations is the final decisionof the vote-l recognition system. Technically, there isno need to construct all l24 ensembles, because theresult can be computed at lower than quadratic timecomplexity.

Table 4 compares GP to GPCR with respect tothe test-set classification accuracy of the simple recog-nition system and the vote-l method with a differentnumber of voters l. The table shows the averages

2Though also reconstruction of letter i seems correct, closerexamination reveals surplus overlying strokes that will be pe-nalized by the fitness measure.


(a) Training set

Fig. 5. Fitness graphs of best-so-far individuals for the 5 first letters of runic alphabet (f, U, þ, a and r). Solid linecorresponds to the GP experiment whereas dotted line to the GPCR one. Averaged over 30 evolutionary processes.

Table 4. Test-set classification accuracy (%) for different voting methods.simple vote-2 vote-3 vote-4 vote-5 vote-30

GP 69.79±1.66 78.50±1.12 82.50±1.02 85.21±0.79 86.66±0.61 91.32GPCR 81.94±0.89 87.88±0.49 91.19±0.41 92.58±0.31 93.18±0.27 95.56

with .95 confidence intervals; for vote-30, confidenceintervals cannot be provided as, with 30 independentruns for each character class, only one unique vote-30recognition system can be built. Quite obviously, themore voters, the better the performance. But moreimportantly, GPCR improves the baseline result ofGP for every number of voters. The gap betweenthem narrows when the number of voters increases,but remains substantial even for the vote-30 case.

Finally, these results are also competitive to thecommonly used standard techniques. A radial ba-sis function neural network, a support vector ma-chine, and a 3-layer perceptron, when taught on thesame training data digitized to 32 × 32 raster im-ages, attain test-set accuracy of 79.25%, 89.75%, and90.67%, respectively (using the default parameter set-tings provided by the Weka software environment(Hall et al., 2009)).

Table 5 presents the test set results for the vote-30 GPCR experiment in terms of true positives andfalse positives. Nine out of 24 characters are recog-nized perfectly. Overall, only three characters arerecognized in less than 90% of cases: U, w, and l.Analysis of the confusion matrix (not shown here forbrevity) allows us to conclude that U is sometimesmistaken for l, hence both yield high false positiveerrors. Similarly, the recognition system occasionallyincorrectly classifies w as þ. Since the letters in these

pairs are very similar to each other and even a humanmay find it difficult to tell them apart in handwriting,this result may be considered appealing.

5.3. Discussion. We demonstrated that codereuse between different tasks may boost the resultsof the evolutionary process. Although we considereda classification problem here, it is important to no-tice that GPCR and GP were compared, above all,on the set of optimization tasks (Section 5.1) with awell defined, close-to-continuous fitness function (de-scribed in Section 3). This suggests that applicabilityof cross-task code reuse is not limited exclusively tomachine learning and pattern recognition. We hy-pothesize that other types of tasks, like regression,could benefit from such code reuse as well, providedthe existence of common knowledge that helps solvingmultiple tasks.

On the other hand, the results suggest that us-ing a generative, close-to-continuous fitness functionbased on one-class data to evolve components of acomplex recognition system that makes discrete de-cisions about multiple classes was a good choice. Inparticular, the fitter individuals obtained in GPCRtranslated into the better classification performanceof the recognition system, which we shown in Sec-tion 5.2.


(a)

(b)

Fig. 6. (a) Individuals tested on examples from their positive classes produce high-quality reproductions. (b) An indi-vidual taught on class I, when tested on examples from all classes, produces poor reproduction for most of thenegative examples. Dotted line – input image, continuous line – reconstruction (drawing actions).

Table 5. True positive (TP) and false positive (FP) ratios for vote-30 GPCR method.Letter f U þ a r k g w h n i j

TP 90.0% 80.0% 100% 95.0% 98.3% 100% 98.3% 81.7% 100% 93.3% 98.3% 98.3%FP 0.0% 18.3% 21.7% 1.7% 0.0% 1.7% 3.3% 3.3% 0.0% 6.7% 8.3% 0.0%

Letter I p R s t b e m l ŋ d o

TP 100% 98.3% 93.3% 100% 95.0% 100% 100% 96.7% 80.0% 100% 100% 96.7%FP 3.3% 1.7% 0.0% 1.7% 3.3% 0.0% 3.3% 0.0% 21.7% 6.7% 0.0% 0.0%

Though the reader may be tempted to considerGPCR (and other methods that transfer knowledgebetween different tasks) as yet another performanceimprovement technique, there is something more toit. Cross-task reuse of code cannot take place in isola-tion: learning/optimization process requires an exter-nal knowledge source that has not been derived fromthe same training data. In this sense, the setup ofGPCR is different from the setup of performance im-provement techniques that do not require such mea-sures, like automatically defined functions. In return,GPCR enables in-depth analysis of task similaritythat is subject of the following section.

GPCR with its crossbreeding operator can beseen as a variant of island model in which the individ-uals on different islands learn different tasks and op-timize different fitness functions. Note, however, thatin the island model genetic material is exchanged,usually, every several generations. In contrast, inGPCR genetic material is exchanged between the evo-

lutionary processes (“islands”) only once: at the endof the primary run. The crossbreeding operator acti-vated in the secondary runs uses this once-saved ge-netic material over and over again, but never modifiesit anymore. Though it is possible to modify GPCRto resemble the island model more, here we chose asetup that was conceptually less complex and tech-nically easier to implement in our computational in-frastructure (less communication between “islands”).

6. Detailed analysis of code reuseThe results presented so far reveal the ‘symptoms’of code reuse, i.e., its impact on individuals’ per-formance. In the following we look under the hoodof that process, attempting to describe it in a morequantitative manner by ‘data mining’ a secondaryrun. In particular, the questions of interest are i) howmuch of individual’s knowledge results from cross-breeding, mutation and crossover; and ii) how much


knowledge is adopted by an individual from a partic-ular pool Pi.

Since an individual is a tree-like expression, twotypes of approaches may be considered: node-orientedand edge-oriented. The idea behind the node-orientedanalysis is to count the tree nodes in individuals anddistinguish the initial-nodes, the mutation-nodes andthe pool-nodes, depending on node’s origin, i.e., theinitial population, mutation, or crossbreeding. How-ever, such node-oriented approach would quantifyinformation rather than knowledge, since it wouldnot take into account the mutual connections of treenodes. That is why we favor here an edge-orientedanalysis and define the initial-edges, the mutation-edges and the pool-edges, depending on the sourcean edge comes from. An edge connecting the parenttree with the subtree inserted by mutation, crossover,or crossbreeding will be called a new-edge. For anyindividual, the initial-edges, the mutation-edges, thepool-edges, and the new-edges sum up to the totalnumber of edges.

We define the amount of knowledge received byan individual from the primary run as the total num-ber of its pool-edges. For an individual composed ofnodes that come each from a different genetic oper-ation, this measure amounts to 0, no matter whatthe actual numbers of pool-nodes is. This is con-sistent with intuition: such a tree does not inheriteven a single pair of connected nodes from the pri-mary run, so no code is reused (the arrangement ofnodes could as well result from mutation). Moreover,unlike the node-oriented measure, the edge-orientedmeasure prefers one subtree of n1 + n2 nodes reusedfrom pool Pi to two separate subtrees of sizes n1 andn2 also reused from Pi. Such behavior is reasonable,since in the latter case, the total amount of knowledgeis reduced due to partitioning of the genetic code.

We chose the letter þ for the detailed analysisof code reuse to find out why the results of GPCRfor this class are much better than the results ofGP. Table 6 presents the statistics of edge typesfor the best-of-run individuals, averaged over the 30runs. Our first observation is that nearly half of theedges (48.5%) comes from the pools whereas the rest(51.5%) results from the other genetic operators (pop-ulation initialization, mutation, and crossover). Only7.7% of the code comes from mutation despite thefact that its probability is the same as probability ofcrossbreeding (0.1). This confirms that crossbreedingis a valuable source of useful pieces of genetic code.Apparently, the trees in the pools perform useful com-putations, so they are preferred to the purely randomsubtrees inserted by mutation.

Table 7 presents the sorted distribution of edgesreused from particular pools by the best-of-run indi-

viduals for class þ. It should not come as a surprisethat pool-w, amounting to more than 9% of reusedcode (11.2 edges per individual on average), helpedthe most to recognize the examples from the class þ(see Table 7). As no other letter is as visually similarto þ as w, evolution reused the solutions for w. Theircode fragments proliferated throughout the popula-tion and increased the survival chances of the cross-bred individuals. We hypothesize that this is also whyit was so easy for GPCR to beat GP on this letter.

It is striking how the top five ranked letters (w, f,a, I, l) are similar to þ in shape — they all have onevertical segment and at least one diagonal segmenton the right. On the other hand, the last entriesof Table 7 contain mostly the letters that are visu-ally dissimilar to þ — with multiple long diagonal orvertical lines or without long lines at all. The leastused pool corresponds to the simplest letter i, whichwas probably not challenging enough to give rise to areusable code.

Figure 7 shows the dynamics of the edge typestatistics during the evolution for letter þ, averagedover the 30 runs. Only the first 100 generations ofthe secondary run are shown since the graph does notchange much after this point. We can observe thatthe total number of pool edges grows very fast in thebeginning of the evolution, reaches the peak value of85 around the 15th generation, and then, after drop-ping a bit, oscillates between 65 and 75. During thefirst 30 generations some interesting patterns emerge.Firstly, we observe the steady growth of edges frompool-w that produces the widest stripe in the end ofgraph, which is in accordance with the superior utilityof pool-w code for þ, discovered in the static analy-sis. Secondly, the drop of the total number of reusededges from 85 edges in the 15th generation to 65 edgesin the 50th generation is mostly caused by removingthe edges previously acquired from pool-f and (lessprominently) from pool-a. We hypothesize that thecode acquired from these pools, initially very useful,was later replaced by the code from pool-w and bythe new-edges, since the number of new-edges growsmonotonically during the first 100 generations.

7. ConclusionsDespite the large number of classes (24), the low num-ber of training examples per class (10), the variabilityof handwriting styles (7 persons), and without accessto negative examples (one-class learning), our evolu-tionary learning method attains an attractive classifi-cation accuracy on the large and diversified test set ina real-world problem of handwritten character recog-nition. Most of the errors committed by the GPCRrecognition systems involve character classes that are


Table 6. The distribution of edge types for the best-of-run individuals for class þ averaged over 30 runs. The averagetotal number of edges is 124 (100%).

Edge type initial-edges mutation-edges pool-edges new-edges

edges 0.9 9.6 60.1 53.5% 0.7% 7.7% 48.5% 43.1%

Table 7. The sorted distribution of edges reused from particular pools by the best-of-run individuals for class þ (averagedover 30 runs).

Letter w f a I l s r p b t m U

pool-edges 11.2 4.1 3.8 3.6 3.2 3.1 3.1 3.1 3.1 3.0 2.5 2.2% 9.1% 3.3% 3.1% 2.9% 2.6% 2.5% 2.5% 2.5% 2.5% 2.4% 2.0% 1.8%

Letter d ŋ h R j k n g e o i

pool-edges 2.1 2.0 1.6 1.5 1.4 1.3 1.2 0.9 0.9 0.7 0.4% 1.7% 1.6% 1.3% 1.2% 1.2% 1.0% 1.0% 0.8% 0.7% 0.6% 0.3%

Fig. 7. The numbers of different edge types in individuals in the first 100 generations of secondary run of letter þ.Each stripe represents one edge type. The graphs were averaged over 100 best-of-generation individuals and 30evolutionary runs.

hard to tell apart also for humans (e.g., U and l, wand þ). Thanks to one-class learning, the recogni-tion system may be easily extended by a new class byrunning a separate evolutionary process; the existingcomponents do not have to be modified.

GPCR, the proposed mechanism of code reuse,boosts fitness and recognition accuracy, so thatthe resulting recognition system outperforms thestandard GP. GPCR is a straightforward, easy-to-implement extension of the canonical genetic pro-gramming, and its extra computational overhead isclose to insignificant. It may be hypothesized thatit would prove helpful also in other recognition taskswhere common visual primitives occur in many de-cision classes, like handwriting recognition for con-temporary languages (e.g., Chang et al. (2010b) and

Ciresan et al. (2012)). Moreover, the results in termsof fitness suggest that GPCR would be beneficial alsofor other types of tasks that do not necessarily endup with a multi-class recognizer.

In a more general perspective, we demonstratedthat the paradigm of genetic programming, thanksto symbolic representation of solutions and the abil-ity of abstraction from a specific context, offers anexcellent platform for knowledge transfer. However,there is not enough evidence yet to claim that theseresults generalize beyond our genetic programming-based visual learning. At least three major factorsdetermine the profitability of code reuse: the repre-sentation of solutions, the presence of commonalitiesbetween the learning tasks, and the crossbreeding op-erator. In particular, an appropriate crossbreeding


operator that preserves the chunks of code for a spe-cific knowledge representation may improve the con-vergence of the secondary run. This leads to an in-teresting idea of posing an inverse problem that maybecome a further research topic: instead of trying todevise a code reuse method for a particular knowledgerepresentation, one could try to design a knowledgerepresentation that enables code reuse. Furthermore,analogously to evolving evolvability, this could lead tothe concept of evolving reusability, where the objec-tive for the evolutionary process would be to evolveindividuals’ encoding that promotes code reusability.

The results obtained in this study suggest a suc-cessful match between the abstraction level of knowl-edge representation and the level at which GPCR op-erates. Supposedly, our operators that group andselect visual primitives are well suited for identify-ing the common subtasks (code fragments) and theirreuse. The detailed analysis shows that knowledgeproliferates most successfully throughout the popu-lation when transferred from the similar tasks (e.g.,characters þ and w). We hypothesize that, among thereused code fragments, the most useful are those onesthat help the individuals to detect object featuresthat repeat across the classes, like stroke junctionsand stroke ends. However, this supposition needs amore in-depth analysis and will be subject of anotherstudy.

ReferencesBhanu, B., Lin, Y. and Krawiec, K. (2005). Evolutionary

Synthesis of Pattern Recognition Systems, Springer-Verlag, New York.

Caruana, R. (1997). Multitask learning, Mach. Learn.28(1): 41–75.

Chang, Y. F., Lee, J. C., Rijal, O. M. and Bakar, S.A. R. S. A. (2010a). Efficient online handwrittenchinese character recognition system using a two-dimensional functional relationship model, Interna-tional Journal of Applied Mathematics and Com-puter Science 20(4): 727–738.

Chang, Y., Lee, J., Rijal, O. and Bakar, S. (2010b). Ef-ficient online handwritten chinese character recogni-tion system using a two-dimensional functional re-lationship model, Int. J. Appl. Math. Comput. Sci.20(4): 727–738.

Ciresan, D. C., Meier, U. and Schmidhuber, J. (2012).Multi-column deep neural networks for image classi-fication, CVPR, IEEE, pp. 3642–3649.

Fabijanska, A. (2012). A survey of subpixel edge detec-tion methods for images of heat-emitting metal spec-imens, Applied Mathematics and Computer Science22(3): 695–710.

Galvan Lopez, E., Poli, R. and Coello Coello, C. A.(2004). Reusing code in genetic programming, in

M. Keijzer, U.-M. O’Reilly, S. M. Lucas, E. Costaand T. Soule (Eds), Genetic Programming 7th Eu-ropean Conference, EuroGP 2004, Proceedings, Vol.3003 of LNCS, Springer-Verlag, Coimbra, Portugal,pp. 359–368.

Ghosn, J. and Bengio, Y. (2000). Bias learning, knowledgesharing, ijcnn 01: 1009.

Hall, M., Frank, E., Holmes, G., Pfahringer, B., Reute-mann, P. and Witten, I. H. (2009). The wekadata mining software: an update, SIGKDD Explor.Newsl. 11(1): 10–18.

Haynes, T. (1997). On-line adaptation of search viaknowledge reuse, in J. R. Koza, K. Deb, M. Dorigo,D. B. Fogel, M. Garzon, H. Iba and R. L. Riolo (Eds),Genetic Programming 1997: Proceedings of the Sec-ond Annual Conference, Morgan Kaufmann, Stan-ford University, CA, USA, pp. 156–161.

Holland, J. (1975). Adaptation in natural and artificialsystems, Vol. 1, University of Michigan Press, AnnArbor.

Hornby, G. S. and Pollack, J. B. (2002). Creating high-level components with a generative representation forbody-brain evolution, Artif. Life 8(3): 223–246.

Howard, D. (2003). Modularization by multi-run fre-quency driven subtree encapsulation, in R. L. Rioloand B. Worzel (Eds), Genetic Programming Theoryand Practice, Kluwer, chapter 10, pp. 155–172.

Howard, D., Roberts, S. C. and Ryan, C. (2006). Prag-matic genetic programming strategy for the problemof vehicle detection in airborne reconnaissance., Pat-tern Recognition Letters 27(11): 1275–1288.

Hsu, W. H., Harmon, S. J., Rodriguez, E. and Zhong, C.(2004). Empirical comparison of incremental reusestrategies in genetic programming for keep-away soc-cer, in M. Keijzer (Ed.), Late Breaking Papers at the2004 Genetic and Evolutionary Computation Con-ference, Seattle, Washington, USA.

Jaśkowski, W., Krawiec, K. and Wieloch, B. (2007a).Genetic programming for cross-task knowledge shar-ing, in D. Thierens (Ed.), Genetic and Evolution-ary Computation Conference GECCO, Associationfor Computing Machinery, pp. 1620–1627.

Jaśkowski, W., Krawiec, K. and Wieloch, B. (2007b).Knowledge reuse in genetic programming applied tovisual learning, in D. Thierens (Ed.), Genetic andEvolutionary Computation Conference GECCO, As-sociation for Computing Machinery, pp. 1790–1797.

Jaśkowski, W., Krawiec, K. and Wieloch, B. (2007c).Learning and recognition of hand-drawn shapes us-ing generative genetic programming, in M. G. et al.(Ed.), EvoWorkshops 2007, Vol. 4448 of LNCS,Springer-Verlag, Berlin Heidelberg, pp. 281–290.

Koza, J. (1992). Genetic Programming, MIT Press, Cam-bridge, MA.

Koza, J. R. (1994). Genetic Programming II: AutomaticDiscovery of Reusable Programs, MIT Press, Cam-bridge Massachusetts.


Koza, J. R., Bennett III, F. H., Andre, D. and Keane,M. A. (1996). Reuse, parameterized reuse, and hi-erarchical reuse of substructures in evolving electri-cal circuits using genetic programming, in T. H. etal. (Ed.), Proceedings of International Conferenceon Evolvable Systems: From Biology to Hardware(ICES-96), Vol. 1259 of Lecture Notes in ComputerScience, Springer-Verlag.

Krawiec, K. (2006). Learning high-level visual conceptsusing attributed primitives and genetic program-ming, in F. R. (Ed.), EvoWorkshops 2006, LNCS3907, Springer-Verlag, Berlin Heidelberg, pp. 515–519.

Krawiec, K. (2007). Generative learning of visual conceptsusing multiobjective genetic programming, PatternRecognition Letters 28: 2385–2400.

Krawiec, K. and Bhanu, B. (2005). Visual learningby coevolutionary feature synthesis, IEEE Transac-tions on System, Man, and Cybernetics – Part B35(3): 409–425.

Kurashige, K., Fukuda, T. and Hoshino, H. (2003).Reusing primitive and acquired motion knowledgefor gait generation of a six-legged robot using geneticprogramming, Journal of Intelligent and RoboticSystems 38(1): 121–134.

Langdon, W. B. and Poli, R. (2002). Foundations of Ge-netic Programming, Springer-Verlag.

Li, B., Li, X., Mabu, S. and Hirasawa, K. (2012). To-wards automatic discovery and reuse of subroutinesin variable size genetic network programming, inX. Li (Ed.), Proceedings of the 2012 IEEE Congresson Evolutionary Computation, Brisbane, Australia,pp. 485–492.

Louis, S. and McDonnell, J. (2004). Learning with case-injected genetic algorithms, Evolutionary Computa-tion, IEEE Transactions on 8(4): 316–328.

Luke, S. (2002). ECJ evolutionary computation system.(http://cs.gmu.edu/ eclab/projects/ecj/).

Mitchell, T. M. (2006). The discipline of machine learning,Technical Report CMU-ML-06-108, Machine Learn-ing Department, Carnegie Mellon University.

Montana, D. J. (1993). Strongly typed genetic program-ming, BBN Technical Report #7866, Bolt Beranekand Newman, Inc., 10 Moulton Street, Cambridge,MA 02138, USA.

Moya, M. R., K. M. W. and Hostetler, L. D. (1993). One-class classifier networks for target recognition appli-cations, Proceedings world congress on neural net-works, International Neural Network Society, Port-land, OR, pp. 797–801.

O’Neill, M. (2009). Riccardo poli, william B. langdon,nicholas F. mcphee: A field guide to genetic pro-gramming lulu.com, 2008, 250 pp, ISBN 978-1-4092-0073-4, Genetic Programming and Evolvable Ma-chines 10(2): 229–230.

O’Sullivan, J. and Thrun, S. (1995). A robot that im-proves its ability to learn.

Perez, C. B. and Olague, G. (2013). Genetic programmingas strategy for learning image descriptor operators,Intelligent Data Analysis 17(4): 561–583.

Pratt, L. Y., Mostow, J. and Kamm, C. A. (1991). Di-rect Transfer of Learned Information among NeuralNetworks, Proceedings of the Ninth National Con-ference on Artificial Intelligence (AAAI-91), AAAI,pp. 584–589.

Rizki, M. M., Zmuda, M. A. and Tamburino, L. A. (2002).Evolving pattern recognition systems, IEEE Trans-actions on Evolutionary Computation 6(6): 594–609.

Roberts, S. C., Howard, D. and Koza, J. R. (2001). Evolv-ing modules in genetic programming by subtree en-capsulation, in J. F. M. et al. (Ed.), Genetic Pro-gramming, Proceedings of EuroGP’2001, Vol. 2038of LNCS, Springer-Verlag, pp. 160–175.

Rosca, J. P. and Ballard, D. H. (1996). Discovery of sub-routines in genetic programming, in P. J. Angelineand K. E. Kinnear, Jr. (Eds), Advances in GeneticProgramming 2, MIT Press, Cambridge, MA, USA,chapter 9, pp. 177–202.

Seront, G. (1995). External concepts reuse in genetic pro-gramming, in E. V. Siegel and J. R. Koza (Eds),Working Notes for the AAAI Symposium on GeneticProgramming, AAAI, MIT, Cambridge, MA, USA,pp. 94–98.

Tackett, W. A. (1993). Genetic generation of “den-dritic” trees for image classification, Proceedings ofWCNN93, IEEE Press, pp. IV 646–649.

Teller, A. and Veloso, M. (1997). PADO: A new learningarchitecture for object recognition, in K. Ikeuchi andM. Veloso (Eds), Symbolic Visual Learning, OxfordPress, New York, pp. 77–112.

Trujillo, L. and Olague, G. (2006). Synthesis of in-terest point detectors through genetic program-ming, in M. Keijzer, M. Cattolico, D. Arnold,V. Babovic, C. Blum, P. Bosman, M. V. Butz,C. Coello Coello, D. Dasgupta, S. G. Ficici, J. Fos-ter, A. Hernandez-Aguirre, G. Hornby, H. Lipson,P. McMinn, J. Moore, G. Raidl, F. Rothlauf, C. Ryanand D. Thierens (Eds), GECCO 2006: Proceedingsof the 8th annual conference on Genetic and evo-lutionary computation, Vol. 1, ACM Press, Seattle,Washington, USA, pp. 887–894.

Vilalta, R. and Drissi, Y. (2002). A perspective viewand survey of meta-learning., Artif. Intell. Rev.18(2): 77–95.

Whitley, D., Rana, S. and Heckendorn, R. (1999). The is-land model genetic algorithm: On separability, pop-ulation size and convergence, Journal of Computingand Information Technology 7(1): 33–47.

cross-task code reuse in genetic programming applied … · of generative visual learning based on...

Documents