Cartesian genetic programming

Conference Paper · July 2009with 21 Reads 
How we measure 'reads'
A 'read' is counted each time someone views a publication summary (such as the title, abstract, and list of authors), clicks on a figure, or views or downloads the full-text. Learn more
DOI: 10.1145/1570256.1570428
Conference: Proceedings of the 11th Annual Conference Companion on Genetic and Evolutionary Computation Conference: Late Breaking Papers
Cite this publication
Abstract
Cartesian Genetic Programming is a form of genetic programming. It is increasing in popularity. It was developed by Julian Miller with Peter Thomson in 1997. In its classic form it uses a very simple integer based genetic representation of a program in the form of a directed graph. In a number of studies, it has been shown to be efficient in comparison with other GP techniques. Since then, the classical form of CGP has been enhanced in various ways by including automatically defined functions. Most recently, it has been developed by Julian Miller, Wolfgang Banzhaf and Simon Harding to include self-modification operators. This again has increased its efficiency. The tutorial will cover the basic technique, advanced developments and applications to a variety of problem domains.

Do you want to read the rest of this conference paper?

Request Full-text Paper PDF
  • ... General Form of Miller's CGP, where n i , n r and n c and a represent number of inputs, number of rows, number of columns and arity respectively[19] ...
    ... CGP Genotype[19] ...
    Article
    Full-text available
    This work presents an optimization method for the synthesis of finite state machines. The focus is on the reduction in the onchip area and the cost of the circuit. A list of finite state machines from MCNC91 benchmark circuits have been evolved using Cartesian Genetic Programming. On the average, almost 30% of reduction in the total number of gates has been achieved. The effects of some parameters on the evolutionary process have also been discussed in the paper.
  • ... The proposed method utilizes Cartesian Genetic Programming (CGP) which represents candidate filters as acyclic directed graphs in a rectangular array of processing nodes. This representation has been confirmed as very efficient in recent years [16]. Evolved switching filters are compared with numerous conventional filters and previously evolved filters in tasks of shot noise elimination and impulse burst noise elimination. ...
    ... For the search in the search space induced by the CGP representation, a technique denoted as evolutionary strategy is usually adopted [16]. The population consists of a finite number of chromosomes and each one represents a candidate filter using the CGP encoding. ...
    Article
    Full-text available
    Image processing represents a research field in which high-quality solutions have been obtained using various soft computing techniques. Evolutionary algorithms constitute a class of stochastic search methods that are applicable in both optimization and design tasks. In the area of circuit design Cartesian Genetic Programming has often been utilized in combination with an algorithm of Evolutionary Strategy. Digital image filters represent a specific class of circuits whose design can be performed by means of this approach. Switching filters are advanced non-linear filtering techniques in which the main idea is to detect and filter the noise pixels while keeping the uncorrupted pixels unchanged in order to increase the quality of the resulting image. The aim of this article is to present a robust design technique based on Cartesian Genetic Programming for the automatic synthesis of switching image filters intended for real-time processing applications. The robustness of the proposed evolutionary approach is evaluated using four design problems including the removal of salt and pepper noise, random shot noise, impulse burst noise and impulse burst noise combined with random shot noise. An extensive evaluation is performed in order to compare the properties of the evolved switching filters with the best conventional solutions. The evaluation has shown that the evolved switching filters exhibit a very good trade off between the quality of filtering and the implementation cost in field programmable gate arrays.
  • ... Weights are assigned to the connections between the nodes. This two-dimensional form of computational nodes, which constitute the network architecture, is termed Cartesian genetic programming (Rothermich and Miller 2002;Miller and Harding 2008). The CGP is an efficient and reliable programming method that can be used to evolve an ANN. ...
    ... Graph showing the proximity between the estimated values and actual values for IDR currency with 98.872% accuracy of a network having 400 nodes and 10-feedback scenario for a span of 1000 days. (Miller et al. 2008) 6 6 . 8 2 Hybrid (ANN, Decision Tree, Naïve Bayesian Classifier, and K-Nearest Neighbor) ...
    Article
    Full-text available
    Forecasting the foreign exchange rate is an uphill task. Numerous methods have been used over the years to develop an efficient and reliable network for forecasting the foreign exchange rate. This study utilizes recurrent neural networks (RNNs) for forecasting the foreign currency exchange rates. Cartesian genetic programming (CGP) is used for evolving the artificial neural network (ANN) to produce the prediction model. RNNs that are evolved through CGP have shown great promise in time series forecasting. The proposed approach utilizes the trends present in the historical data for its training purpose. Thirteen different currencies along with the trade-weighted index (TWI) and special drawing rights (SDR) is used for the performance analysis of recurrent Cartesian genetic programming-based artificial neural networks (RCGPANN) in comparison with various other prediction models proposed to date. The experimental results show that RCGPANN is not only capable of obtaining an accurate but also a computationally efficient prediction model for the foreign currency exchange rates. The results demonstrated a prediction accuracy of 98.872 percent (using 6 neurons only) for a single-day prediction in advance and, on average, 92% for predicting a 1000 days’ exchange rate in advance based on ten days of data history. The results prove RCGPANN to be the ultimate choice for any time series data prediction, and its capabilities can be explored in a range of other fields.
  • ... CGP was developed from methods developed for the automatic evolution of digital circuits by Miller and Thomson [10] for the purpose of evolving digital circuits. Unlike traditional Genetic Programming (GP), CGP represents a program as a directed (that for feed-forward functions is acyclic) graph. ...
    Conference Paper
    Full-text available
    The credit default swap has become well-known as one of the causes of the 2007-2010 credit crisis but more research is vitally needed to analyze and define its impact more precisely and help the financial market transparency. This paper uses cartesian genetic programming as a discovery tool for finding the relationship between credit default swap spreads and debts and studying the arbitrage channel. (Arbitrage is the practice of taking advantage of a price difference between markets.) To our knowledge this work is the first attempt toward studying the credit default swap market via an evolutionary process and our results prove that cartesian genetic programming is human competitive and it has the potential to become a regression discovery tool in credit default swap market.
  • ... Interestingly, the controller memorizes the points along the track where crashes occurred by storing a list of the distFromStartLine values for each crash; in subsequent laps, the controller slows down when approaching one of such points. 6) Witold Szymaniak, Poznan´UniversityPoznan´Poznan´University of Technology, Poznan´,Poznan´, Poland, submitted a reactive controller represented as a directed acyclic graph, which was evolved with Cartesian genetic programming [36] implemented using the evolutionary computation in Java (ECJ) package [37]. The set of inputs is restricted to angle to track, front track sensor, speed, lateral speed, and distRaced) and two composite inputs relating to track curvature; most rangefinder sensors are never used directly. ...
    Article
    Full-text available
    In this paper, we overview the 2009 Simulated Car Racing Championship-an event comprising three competitions held in association with the 2009 IEEE Congress on Evolutionary Computation (CEC), the 2009 ACM Genetic and Evolutionary Computation Conference (GECCO), and the 2009 IEEE Symposium on Computational Intelligence and Games (CIG). First, we describe the competition regulations and the software framework. Then, the five best teams describe the methods of computational intelligence they used to develop their drivers and the lessons they learned from the participation in the championship. The organizers provide short summaries of the other competitors. Finally, we summarize the championship results, followed by a discussion about what the organizers learned about 1) the development of high-performing car racing controllers and 2) the organization of scientific competitions.
  • ... The most typical form of GP is the tree-based version pioneered by Koza [17]. There are many other types, however, including a family easily expressed as graph-based networks, which include Cartesian Genetic Programming [24], Parallel Distributed Genetic Programming [27], Linear Genetic Programming (LGP) [3], and others [26]. These forms of GP are often static-length, while the complexity of the program is derived from the ratio of neutral to active code in the representation. ...
    Article
    Full-text available
    We study properties of Linear Genetic Programming (LGP) through several regression and classification benchmarks. In each problem, we decompose the results into bias and variance components, and explore the effect of varying certain key parameters on the overall error and its decomposed contributions. These parameters are the maximum program size, the initial population, and the function set used. We confirm and quantify several insights into the practical usage of GP, most notably that (a) the variance between runs is primarily due to initialization rather than the selection of training samples, (b) parameters can be reasonably optimized to obtain gains in efficacy, and (c) functions detrimental to evolvability are easily eliminated, while functions well-suited to the problem can greatly improve performance—therefore, larger and more diverse function sets are always preferable.
  • ... While recent GPU implementations [34] improve the ability to evaluate large populations, they can't remove memory bottlenecks that limit feasible populations to perhaps 10 8 . However there seems to be no literature on interactions between population size and selection operators, despite a range from as few as 5 [38] to as many as 10 6 in our own recent experiments. Memory limitations also led us to use P = 2 in our (P, P × A) algorithm. ...
    Article
    Directed protein evolution has led to major advances in organic chemistry, enabling the development of highly optimised proteins. The SELEX method has also been highly effective in evolving ribose nucleic acid (RNA) or deoxy-ribose nucleic acid (DNA) molecules; variants have been proposed which allow SELEX to be used in protein evolution. All of these methods can be viewed as evolutionary algorithms implemented in chemistry.A number of methods rely on selection of natural cells, or of artificial bubbles. These methods result in a new form of selection mechanism, which we call vesicular selection (VS). It is not, prima facie, clear whether VS is an effective selection mechanism, or how its performance is affected by changes in vesicle size. It is difficult to investigate this in vitro, so we use in silico methods derived from evolutionary computation. The primary aim is to test whether this selection method hinders biochemical evolutionary search (in which case, it might be worth investing research effort in discovering alternative selection methods).An in silico implementation of this selection method, embedded in an otherwise-typical evolutionary computation system, shows reasonable ability to solve tough optimisation problems, together with an acceptable ability to concentrate the solutions found. We compare it with tournament selection (TS), a standard evolutionary computation method, which can be finely tuned for high selection pressure, but only coarsely tuned for low selection pressure. By contrast, the new selection mechanism VS is highly tunable at low selection pressures. It is thus particularly suited to problem domains where extensive exploration capabilities are required. Since there is very good reason to believe that protein search spaces require highly exploratory search, the selection mechanism is well matched to its application in combinatorial chemistry.
  • ... The original form of Genetic Programming (GP) was put forward by Koza [1].This type of encoding structure has a positive effect on implementing crossover operator. Miller and Thomson [2] proposed the Cartesian genetic programming (CGP) and successfully applied it in circuit designing. Brameier proposed Linear Genetic Programming [3]. ...
    Conference Paper
    This paper presents a new form of gene expression programming based on distribution-estimation model with tree structure (TS) and graph structure (GS); The results of experiments indicates that the proposed approach achieves a good performance and EDGEP are effective in max problem and 6 multiplexer problem.
  • ... The HERA approach is based on a tight coupling between an evolutionary algorithm and a dynamic reconfigurable, FPGA-based, architecture. The evolutionary algorithm used is a variation of the canonic Genetic Algorithm (GA) modified taking into account some concepts typical of Cartesian Genetic Programming (CGP) [12]. The focus of this Section is, however, on the FPGA-based architecture. ...
    Article
    Full-text available
    Turning away from traditional design techniques, which fol-low the various phases of design and testing, Evolvable Hardware circuits are created through evolutionary strategies aimed at improving the cir-cuits behavior with respect to a given specification. These evolutionary strategies are stochastic search methods that mimic the process of natu-ral biological evolution and are implemented as Evolutionary Algorithms (EAs). This approach permits the exploration of a large design search space, which can ideally enable Evolvable Hardware to find solutions that are more efficient than those found using traditional design methods. This paper describes how an FPGA-based Evolvable Hardware system, using partial dynamic reconfiguration, has been improved introducing a new ICAP controller: the Speed Efficient Dynamic Partial Reconfigura-tion Controller (SEDPRC). Experimental results have shown that the novel controller brings benefits both to the overall running time (the reconfiguration time has been reduced by 37.2%) and to the resources required to implement the controller itself.
  • ... Because the shape and length of the final program are normally not known by the user, GP usually represents programs in the tree form of various lengths [9], [10], [11]. Other representations are also developed in grammar-based GP [12], linear GP [13], [14], cartesian genetic programming [15], gene expression programming (GEP) [16] and achieve promising results. Currently, GP is arguably the most popular method for discovering effective dispatching rules for scheduling problems [1], [2], [17], [18]. ...
    Article
    Full-text available
    Dispatching rules have been commonly used in practice for making sequencing and scheduling decisions. Due to specific characteristics of each manufacturing system, there is no universal dispatching rule that can dominate in all situations. Therefore, it is important to design specialized dispatching rules to enhance the scheduling performance for each manufacturing environment. Evolutionary computation approaches such as tree-based genetic programming (TGP) and gene expression programming (GEP) have been proposed to facilitate the design task through automatic design of dispatching rules. However, these methods are still limited by their high computational cost and low exploitation ability. To overcome this problem, we develop a new approach to automatic programming via iterated local search (APRILS) for dynamic job shop scheduling. The key idea of APRILS is to perform multiple local searches started with programs modified from the best obtained programs so far. The experiments show that APRILS outperforms TGP and GEP in most simulation scenarios in terms of effectiveness and efficiency. The analysis also shows that programs generated by APRILS are more compact than those obtained by genetic programming. An investigation of the behavior of APRILS suggests that the good performance of APRILS comes from the balance between exploration and exploitation in its search mechanism.
  • ... Here several policies are represented by a population of NNs improved through mutations and/or repeated recombinations of the population's fittest individuals (e.g., Montana and Davis, 1989;Fogel et al., 1990;Maniezzo, 1994;Happel and Murre, 1994;Nolfi et al., 1994b). Compare Genetic Programming (GP) (Cramer, 1985) (see also Smith, 1980) which can be used to evolve computer programs of variable size (Dickmanns et al., 1987;Koza, 1992), and Cartesian GP (Miller and Thomson, 2000;Miller and Harding, 2009) for evolving graph-like programs, including NNs (Khan et al., 2010) and their topology (Turner and Miller, 2013). Related methods include probability distribution-based EAs (Baluja, 1994;Saravanan and Fogel, 1995;Sałustowicz and Schmidhuber, 1997;Larraanaga and Lozano, 2001), Covariance Matrix Estimation Evolution Strategies (CMA-ES) (Hansen and Ostermeier, 2001;Hansen et al., 2003;Heidrich-Meisner and Igel, 2009), and NeuroEvolution of Augmenting Topologies (NEAT) (Stanley and Miikkulainen, 2002). ...
    Article
    In recent years, deep neural networks (including recurrent ones) have won numerous contests in pattern recognition and machine learning. This historical survey compactly summarises relevant work, much of it from the previous millennium. Shallow and deep learners are distinguished by the depth of their credit assignment paths, which are chains of possibly learnable, causal links between actions and effects. I review deep supervised learning (also recapitulating the history of backpropagation), unsupervised learning, reinforcement learning & evolutionary computation, and indirect search for short programs encoding deep and large networks.
  • Conference Paper
    This paper introduces the implementation of Koza-style tree-based Genetic Programming on General Purpose Graphic Processing Units (GPGPU) using the EASEA language, and shows how a GP algorithm can be easily implemented using EASEA and CUDA. Performance is first discussed on a classical toy problem taken from one of Koza's books and then on a real world problem inspired from aeronautics, that extends the results to difficult problems with large data sets.
  • Conference Paper
    Cartesian genetic programming (CGP) is a branch of genetic programming in which candidate designs are represented using directed acyclic graphs. Evolutionary circuit design is the most typical application of CGP. This paper presents a new software tool---CGPAnalyzer---developed to analyse and visualise a genetic record (i.e. a log file) generated by CGP-based circuit design software. CGPAnalyzer automatically finds key genetic improvements in the genetic record and presents relevant phenotypes. The comparison module of CGPAnalyzer allows the user to select two phenotypes and compare their structure, history and functionality. It thus enables to reconstruct the process of discovering new circuit designs. This feature is demonstrated by means of the analysis of the genetic record from a 9-parity circuit evolution. The CGPAnalyzer tool is a desktop application with a graphical user interface created using Java v.8 and Swing library.
  • Chapter
    The concept of approximation has intensively been studied, developed and applied not only in computer science, but also in mathematics and engineering disciplines. The never ending requirement for low power consumption led to making approximate circuits and computer systems even in the areas in which only accurately working solutions have traditionally been accepted. Approximate circuits are the circuits relaxing the requirement on the functional equivalence between the specification and implementation in order to reduce the area on a chip, delay or energy consumption. Approximate computing machines further exploit and apply this idea at all system levels. This paper introduces the field of approximate computing and shows how evolutionary design methods can automate the design process of approximate computing systems, in particular, approximate logic circuits.
  • Article
    Utilizing evolutionary algorithms to realize self-recovery is a new idea of fault tolerance, but evolution is time-consuming. Most evolvable fault-tolerant systems so far are off-situation evolution, where the evolution process plays a role just in the system's design stage. In this case, the system does not have capability of evolution recovery during its running time. Although this kind of evolvable fault-tolerant system overcomes the evolution time-consuming, it only repairs the anticipated errors rather than unanticipated errors. To solve the problem, we propose a new recovery approach based on in-situation evolution, the fault-tolerant system is a coupling design of the reconfigurable system and the detected system. Once the target system fails, the reconfigurable system implements in-system evolution to achieve runtime recovery. To decrease the time overhead of evolution process, the proposed system takes different measures according to failure modes: if the anticipated errors are detected, it searches the pre-designed library for recovery configurations; otherwise, when the unanticipated errors happened, it generates new recovery configurations online by evolvable hardware, and updates the pre-designed library by the evolved configurations. At last, this fault-tolerant method is equipped in different failure modes of some typical circuits. The experiments illustrate that the proposed evolvable recovery approach promotes the reliability, and pre-designed configuration library decreases the evolution time overhead.
  • Article
    To increase the speed of evolvable hardware, a complete on-chip evolvable hardware technique is adopted, where both hardware evaluation and evolutionary algorithm itself are configured on chip. At the same time, a multi-objective evolutionary algorithm based on Pareto dominance is proposed to satisfy and conciliate multiple objectives in many combinational circuits design. This method is applied to the design of a 1-bit full adder and its feasibility is validated by the result of the experiment. The data of result also shows that the speed of evolvable hardware is dramatically increased.
  • Conference Paper
    Boolean functions represent an important primitive when constructing many stream ciphers. Since they are often the only nonlinear element of such ciphers, without them the algorithm would be trivial to break. Therefore, it is not surprising there exist a substantial body of work on the methods of constructing Boolean functions. Among those methods, evolutionary computation (EC) techniques play a significant role. Previous works show it is possible to use EC methods to generate high-quality Boolean functions that even surpass those built by algebraic constructions. However, up to now, there was no work investigating the use of Cartesian Genetic Programming (CGP) for producing Boolean functions suitable for cryptography. In this paper we compare Genetic Programming (GP) and CGP algorithms in order to reach the conclusion which algorithm is better suited to evolve Boolean functions suitable for cryptographic usage. Our experiments show that CGP performs much better than the GP when the goal is obtaining as high as possible nonlinearity. Our results indicate that CGP should be further tested with different fitness objectives in order to check the boundaries of its performance.
  • Conference Paper
    The design of circuits is an important research field and the corresponding optimization problems are complex and computationally expensive. Here, a Cartesian Genetic Programming (CGP) technique was used to design combinational logic circuits. Several configurations were tested for seeding the initial population. First, the number of rows, columns, and levels-back were varied. In addition, the initial population was generated using only NAND gates. These configurations were compared with results from the literature in four benchmark circuits, where in all instances it was possible to find that some seeding configurations contributed beneficially to the evolutionary process, allowing CGP to find a solution employing a lower number of fitness evaluations. Finally, the variation of the number of nodes of the individuals during the search was also analyzed and the results showed that there is a correlation between the topology of the initial population and the region of the search space which is explored.
  • Conference Paper
    Full-text available
    Recent research has considered the role of locality in GP representations. We use a modified statistical technique drawn from numerical ecology, the Mantel test, to measure the locality of integer-encoded GP. Weak locality is identified in a case study on Cartesian Genetic Programming (CGP), a directed acyclic graph representation. A method of varying syntactic program locality continuously through the application of a biased mutation operator is demonstrated. The impact of varying locality under the new measure is assessed over a randomly generated set of polynomial symbolic regression problems. We observe that enforcing higher levels of locality in CGP is associated with poorer performance on the problem set and discuss implications in the context of existing models of GP genotype-phenotype maps.
  • Conference Paper
    Full-text available
    Cartesian Genetic Programming (CGP) is a well-known form of Genetic Programming developed by Julian Miller in 1999-2000. In its classic form, it uses a very simple integer address-based genetic representation of a program in the form of a directed graph. Graphs are very useful program representations and can be applied to many domains (e.g. electronic circuits, neural networks). It can handle cyclic or acyclic graphs. In a number of studies, CGP has been shown to be comparatively efficient to other GP techniques. It is also very simple to program. The classical form of CGP has undergone a number of developments which have made it more useful, efficient and flexible in various ways. These include self-modifying CGP (SMCGP), cyclic connections (recurrent-CGP), encoding artificial neural networks and automatically defined functions (modular CGP). SMCGP uses functions that cause the evolved programs to change themselves as a function of time. This makes it possible to find general solutions to classes of problems and mathematical algorithms (e.g. arbitrary parity, n-bit binary addition, sequences that provably compute pi and e to arbitrary precision, and so on). Recurrent-CGP allows evolution to create programs which contain cyclic, as well as acyclic, connections. This enables application to tasks which require internal states or memory. It also allows CGP to create recursive equations. CGP encoded artificial neural networks represent a powerful training method for neural networks. This is because CGP is able to simultaneously evolve the networks connections weights, topology and neuron transfer functions. It is also compatible with Recurrent-CGP enabling the evolution of recurrent neural networks. The tutorial will cover the basic technique, advanced developments and applications to a variety of problem domains. It will present a live demo of how the open source cgplibrary can be used.
  • Conference Paper
    We are interested in engineering smart machines that enable backtracking of emergent behaviors. Our SSNNS simulator consists of hand-picked tools to explore spiking neural networks in more depth with flexibility. SSNNS is based on the Spike Response ...
  • Article
    Full-text available
    A biologically inspired developmental model targeted at hardware implementation (off-shelf FPGA) is proposed which exhibits extremely robust transient fault-tolerant capability: in the software simulation of the experimen- tal application. In a 6x6 cell French Flag, some individuals were discovered us- ing evolution that have the ability to "recover" themselves from almost any kinds of transient faults, even in the worst case of only one "live" cell remain- ing. All cells in this model have identical genotype (physical structures), and only differ in internal states.
  • Article
    Full-text available
    Techniques from the field of Evolutionary Computation are used to evolve a wide variety of aesthetically pleasing images using Cartesian Genetic Programming (CGP). The challenges that arise from employing a fitness function based on aesthetics, and the benefits that CGP can provide, are investigated and discussed. A significant piece of software was developed that places a focus on providing the user with efficient control over the evolutionary process. Several 'non-user' fitness functions that assess the phenotypes and genotypes of the chromosomes were also employed with varying success. To improve these results, methods of maintaining diversity within the population that take advantage of the neutrality of CGP are implemented and tested.
  • Article
    Full-text available
    We argue that there is an upper limit on the complexity of software that can be constructed using current methods. Furthermore, this limit is orders of mag-nitude smaller than the complexity of living systems. We argue that many of the ad-vantages of autonomic computing will not be possible unless fundamental aspects of living systems are incorporated into a new paradigm of software construction. Truly self-healing and maintaining software will require methods of construction that mimic the biological development of multi-cellular organisms. We demonstrate a prototype system which is capable of autonomous repair and regeneration without using engineered methods. A method for evolving programs that construct multi-cellular structures (organisms) is described.
  • Article
    The development of an entire organism from a single cell is one of the most profound and awe inspiring phenomena in the whole of the natural world. The complexity of living systems itself dwarfs anything that man has produced. This is all the more the case for the processes that lead to these intricate systems. In each phase of the development of a multi-cellular being, this living system has to survive, whether stand-alone or supported by various structures and processes provided by other living systems. Organisms construct themselves, out of humble single-celled beginnings, riding waves of interaction between the information residing in their genomes - inherited from the evolutionary past of their species via their progenitors - and the resources of their environment. Permanent renewal and self-repair are natural extrapolations of developmental recipes, as is adaptation to different environmental conditions. Multi-cellular organisms consist of a huge amount of cells, the atoms of life, modular structures used to perform all the functions of a body. It is estimated that there are of the order of 1013 cells in the human body. Some of them are dying and
  • Conference Paper
    Full-text available
    As is typical in evolutionary algorithms, fitness evaluation in GP takes the majority of the computational effort. In this paper we demonstrate the use of the Graphics Processing Unit (GPU) to accelerate the evaluation of individuals. We show that for both binary and floating point based data types, it is possible to get speed increases of several hundred times over a typical CPU implementation. This allows for evaluation of many thousands of fitness cases, and hence should enable more ambitious solutions to be evolved using GP.
  • Chapter
    Full-text available
    Structure-based virtual screening is a technology increasingly used in drug discovery. Although successful at estimating binding modes for input ligands, these technologies are less successful at ranking true hits correctly by binding free energy. This chapter presents the automated removal of false positives from virtual hit sets, by evolving a post docking filter using Cartesian Genetic Programming(CGP). We also investigate characteristics of CGP for this problem and confirm the absence of bloat and the usefulness of neutral drift.
  • Chapter
    Full-text available
    Self-modifying Cartesian genetic programming (SMCGP) is a general purpose, graph-based, form of genetic programming founded on Cartesian genetic programming. In addition to the usual computational functions, it includes functions that can modify the program encoded in the genotype. SMCGP has high scalability in that evolved programs encoded in the genotype can be iterated to produce an infinite sequence of programs (phenotypes). It also allows programs to acquire more inputs and produce more outputs during iterations. Another attractive feature of SMCGP is that it facilitates the evolution of provably general solutions to various computational problems.
  • Article
    Full-text available
    An evolutionary algorithm is used as an engine for discovering new designs of digital circuits, particularly arithmetic functions. These designs are often radically different from those produced by top-down, human, rule-based approaches. It is argued that by studying evolved designs of gradually increasing scale, one might be able to discern new, efficient, and generalizable principles of design. The ripple-carry adder principle is one such principle that can be inferred from evolved designs for one and two-bit adders. Novel evolved designs for three-bit binary multipliers are given that are 20% more efficient (in terms of number of two-input gates used) than the most efficient known conventional design.
  • Conference Paper
    Full-text available
    A biologically inspired developmental model targeted at hardware implementation (off-shelf FPGA) is proposed which exhibits extremely robust transient fault-tolerant capability. All cells in this model have identical genotype (physical structures), and only differ in internal states. In a 3x3 cell digital organism, some individuals which implement a 2-bit multiplier were discovered using evolution that have the ability to “recover” themselves from almost any kinds of transient faults. An intrinsic evolvable hardware platform based on FPGA was realized to speed up the evolution process.
  • Article
    Full-text available
    In a previous work it was argued that by studying evolved designs of gradually increasing scale, one might be able to discern new, efficient, and generalisable principles of design. These ideas are tested in the context of designing digital circuits, particularly arithmetic circuits. This process of discovery is seen as a principle extraction loop in which the evolved data is analysed both phenotypically and genotypically by processes of data mining and landscape analysis. The information extracted is then fed back into the evolutionary algorithm to enhance its search capabilities and hence increase the likelihood of identifying new principles which explain how to build systems which are too large to evolve.
  • Conference Paper
    Full-text available
    The paper introduces a new approach to automatic design of image filters for a given type of noise. The approach employs evolvable hardware at simplified functional level and produces circuits that outperform conventional designs. If an image is available both with and without noise, the whole process of filter design can be done automatically, without influence of a designer.
  • Conference Paper
    An evolutionary algorithm automatically discovers suitable solutions to a problem, which may lie anywhere in a large search space of candidate solutions. In the case of genetic programming, this means performing an efficient search of all possible computer programs represented as trees. Exploration of the search space appears to be constrained by structural mechanisms that exist in genetic programming as a consequence of using trees to represent solutions. As a result, programs with certain structures are more likely to be evolved, and others extremely unlikely. We investigate whether the graph representation used in Cartesian genetic programming causes an analogous biasing effect, imposing natural limitations on the class of solution structures that are likely to be evolved. Representation bias and structural bias are identified: the rarer ldquoregularrdquo structures appear to be easier to evolve than more common ldquoirregularrdquo ones.
  • Conference Paper
    Full-text available
    The design of a new biologically inspired artificial developmental system is described in this paper. In general, developmental systems converge slower and are more computationally expensive than direct evolution. However, the performance trends of development indicate that the full benefit of development will arise with larger and more complex problems that exhibit some sort of regularity in their structure: thus, the aim is to evolve larger electronic systems through the modularity allowed by development. The hope is that the proposed artificial developmental system will exhibit adaptivity and fault tolerance in the future. The cell signalling and the system of Gene Regulatory Networks present in biological organisms are modelled in our developmental system, and tailored for tackling real world problems on electronic hardware. For the first time, a Gene Regulatory Network system is successfully shown to develop the complete circuit structure of a desired digital circuit without the help of another mechanism or any problem specific structuring. Experiments are presented that show the modular behaviour of the developmental system, as well as its ability to solve non-modular circuit problems.
  • Conference Paper
    This paper describes the application of intrinsic evolvable hardware to combinational circuit design and synthesis, as an alternative to conventional approaches. This novel reconfigurable architecture is inspired by Cartesian genetic programming and dedicated for implementing high performance digital image filters on a custom Xilinx Virtex FPGA xcv1000, together with a flexible local interconnection hierarchy. As a highly parallel architecture, it scales linearly with the filter complexity. It is reconfigured by an external genetic reconfiguration processing unit with a hardware GA implementation embedded. Due to pipelining, parallelization and no function call overhead, it yields a significant speedup of one to two orders of magnitude over a software implementation, which is especially useful for the real-time applications. The experimental results conclude that in terms of computational effort, filtered image signal and implementation cost, the intrinsic evolvable hardware solution outperforms traditional approaches.
  • Conference Paper
    Full-text available
    An intrinsic evolvable hardware platform was realized to accelerate the evolutionary search process of a biologically inspired developmental model targeted at off-shelf FPGA implementation. The model has the capability of exhibiting very large transient fault-tolerance. The evolved circuits make up a digital "organism" from identical cells which only differ in internal states. Organisms implementing a 2-bit multiplier were evolved that can "recover" from almost any kinds of transient faults. This paper focuses on the design concerns and details of the evolvable hardware system, including the digital organism/cell and the intrinsic FPGA-based evolvable hardware platform.
  • Conference Paper
    Full-text available
    In this paper we present a new chromosome representation for evolving digital circuits. The representation is based very closely on the c hip architecture of the Xilinx 6216 FPGA. We e xamine the e ffectiveness of evolving circuit functionality by using randomly chosen examples taken from the truth table. We consider the merits of a cell architecture in which functional cells alternate with routing cells and compare this with an architecture in which any cell can implement a function o r be merely used for r outing signals. It i s noteworthy that t he presence of elitism significantly improves the Genetic Algorithm performance.
  • Conference Paper
    Full-text available
    We present a method for constructing electronic circuits that uses analogues of biological multi-cellular development, genetic regulatory networks, and transcription and translation processes to build circuits. We show how small circuits may be evolved and how they may be reused to build larger circuits. We also demonstrate that the artificial ‘organisms’ are capable of regeneration so that circuit functionality can be recovered after damage.
  • Conference Paper
    Full-text available
    This paper presents a method for co-evolving neuro-inspired developmental programs for playing checkers. Each player’s program is represented by seven chromosomes encoding digital circuits, using a form of genetic programming, called Cartesian Genetic Programming (CGP). The neural network that occurs by running the genetic programs has a highly dynamic morphology in which neurons grow, and die, and neurite branches together with synaptic connections form and change in response to situations encountered on the checkers board. The results show that, after a number of generations, by playing each other the agents play much better than those from earlier generations. Such learning abilities are encoded at a genetic level rather than at the phenotype level of neural connections.
  • Conference Paper
    Full-text available
    Embedded Cartesian Genetic Programming (ECGP) is a form of Ge- netic Programming based on an acyclic directed graph representation. In this paper we investigate the use of ECGP together with a technique called Product Reduction (PR) to reduce the time required to evolve a digital multiplier. The results are compared with Cartesian Genetic Programming (CGP) with and without PR and show that ECGP improves evolvability and also that PR im- proves the performance of both techniques by up to eight times on the digital multiplier problems tested.
  • Conference Paper
    Full-text available
    A review is given o f approaches to g rowing n eural networks and electronic circuits. A new method for growing graphs and circuits using a de- velopmental process is discussed. The method is inspired by the view that the cell is the basic unit of biology. Programs that construct circuits are evolved to bu ild a sequence of digital circuits at user specified iterations. The pro- grams can be run for an arbitrary number of iterations so circuits of huge size could be created that could not be evolved. It is shown that the circuit build- ing programs are capable of correctly predicting the next circuit in a sequence of larger even parity functions. The new method however finds building spe- cific circuits more difficult than a non-developmental method.
  • Conference Paper
    Full-text available
    The exploitation of the physical characteristics has already been dem- onstrated in the intrinsic evolution of electronic circuits. This paper is an initial attempt at creating a world in which "physics" can be exploited in simulation. As a starting point we investigate a model of gate-like components with added noise. We refer to this as a kind of messiness. The principal idea behind these messy gates is that artificial evolution makes a virtue of the untidiness. We are ultimately trying to study the question: What kind of components should we use in artificial evolution? Several experiments are described that show that the messy circuits have a natural robustness to noise, as well as an implicit fault- tolerance. In addition, it was relatively easy for evolution to generate novel cir- cuits that were surprisingly efficient.
  • Conference Paper
    Full-text available
    We analyze and compare four dierent evolvable hardware approaches for classication tasks: An approach based on a programmable logic array architecture, an approach based on two-phase incremental evolution, a generic logic architecture with automatic denition of build- ing blocks, and a specialized coarse-grained architecture with pre-dened building blocks. We base the comparison on a common data set and report on classication accuracy and training eort. The results show that classication accuracy can be increased by using modular, special- ized classier architectures. Furthermore, function level evolution, ei- ther with predened functions derived from domain-specic knowledge or with functions that are automatically dened during evolution, also gives higher accuracy. Incremental and function level evolution reduce the search space and thus shortens the training eort.
  • Conference Paper
    Full-text available
    The paper presents for the first time automatic module acquisition and evolution within the graph based Cartesian Genetic Programming method. The method has been tested on a set of even parity problems and compared with Cartesian Genetic Programming without modules. Results are given that show that the new modular method evolves solutions up to 20 times quicker than the original non-modular method and that the speedup is more pronounced on larger problems. Analysis of some of the evolved modules shows that often they are lower order parity functions. Prospects for further improvement of the method are discussed.
  • Conference Paper
    Full-text available
    Prime generating polynomial functions are known that can produce sequences of prime numbers (e.g. Euler polynomials). However, polynomials which produce consecutive prime numbers are much more difficult to obtain. In this paper, we propose approaches for both these problems. The first uses Cartesian Genetic Programming (CGP) to directly evolve integer based prime-prediction mathematical formulae. The second uses multi-chromosome CGP to evolve a digital circuit, which represents a polynomial. We evolved polynomials that can generate 43 primes in a row. We also found functions capable of producing the first 40 consecutive prime numbers, and a number of digital circuits capable of predicting up to 208 consecutive prime numbers, given consecutive input values. Many of the formulae have been previously unknown.
  • Conference Paper
    Full-text available
    This work is a study of neutrality in the context of Evolutionary Computation systems. In particular, we introduce the use of explicit neutrality with an integer string coding scheme to allow neutrality to be measured during evolution. We tested this method on a Boolean benchmark problem. The experimental results indicate that there is a positive relationship between neutrality and evolvability: neutrality improves evolvability. We also identify four characteristics of adaptive/neutral mutations that are associated with high evolvability. They may be the ingredients in designing effective Evolutionary Computation systems for the Boolean class problem.
  • Conference Paper
    Full-text available
    Self Modifying CGP (SMCGP) is a developmental form of Cartesian Genetic Programming(CGP). It is able to modify its own phe- notype during execution of the evolved program. This is done by the inclusion of modification operators in the function set. Here we present the use of the technique on several different sequence generation and regression problems.
  • Conference Paper
    Full-text available
    Embedded Cartesian Genetic Programming (ECGP) is an extension of Cartesian Genetic Programming (CGP) capable of acquiring, evolving and re-using partial solutions. In this paper, we apply for the first time CGP and ECGP to the ones-max and order-3 deceptive problems, which are normally associated with Genetic Algorithms. Our approach uses CGP and ECGP to evolve a sequence of commands for a tape-head, which produces an arbitrary length binary string on a piece of tape. Computational effort figures are calculated for CGP and ECGP and our results compare favourably with those of Genetic Algorithms.
  • Conference Paper
    As the size of CMOS devices is approaching the atomic level, the increasing intrinsic device variability is leading to higher failure rates in conventional CMOS designs. This paper introduces a design tool capable of evolving CMOS topologies using a modified form of Cartesian genetic programming and a multi-objective strategy. The effect of intrinsic variability within the design is then analysed using statistically enhanced SPICE models based on 3D-atomistic simulations. The goal is to produce industry-feasible topology designs which are more tolerant to the random fluctuations that will be prevalent in future technology nodes. The results show evolved XOR and XNOR CMOS topologies and compare the impact of threshold voltage variation on the evolved designs with those from a standard cell library.
  • Conference Paper
    Full-text available
    A cell based optimization (CBO) algorithm is proposed which takes inspiration from the collective behaviour of cellular slime molds (Dictyostellium discoideum). Experiments with CBO are conducted to study the ability of simple cell-like agents to collectively manage resources across a distributed network. Cells, or agents, only have local information can signal, move, divide, and die. Heterogeneous populations of the cells are evolved using Cartesian genetic programming (CGP). Several experiments were carried out to examine the adaptation of cells to changing user demand patterns. CBO performance was compared using various methods to change demand. The experiments showed that populations consistently evolve to produce effective solutions. The populations produce better solutions when user demand patterns fluctuated over time instead of environments with static demand. This is a surprising result that shows that populations need to be challenged during the evolutionary process to produce good results.
  • Conference Paper
    Full-text available
    Biological neurons are extremely complex cells whose morphology grows and changes in response to the external environment. Yet, artificial neural networks (ANNs) have represented neurons as simple computational devices. It has been evident for a long time that ANNs have learning abilities that are insignificant compared with some of the simplest biological brains. We argue that we understand enough neuroscience to create much more sophisticated models. In this paper, we report on our attempts to do this.We identify and evolve seven programs that together represents a neuron which grows post evolution into a complete 'neurological' system. The network that occurs by running the programs has a highly dynamic morphology in which neurons grow, and die, and neurite branches together with synaptic connections form and change. We have evaluated the capability of these networks for playing the game of checkers. Our method has no board evaluation function, no explicit learning rules and no human expertise at playing checkers is used. The learning abilities of these networks are encoded at a genetic level rather than at the phenotype level of neural connections.
  • Conference Paper
    Full-text available
    Self modifying CGP (SMCGP) is a developmental form of Cartesian genetic programming(CGP). It differs from CGP by including primitive functions which modify the program. Beginning with the evolved genotype the self-modifying functions produce a new program (phenotype) at each iteration. In this paper we have applied it to a well known digital circuit building problem: even-parity. We show that it is easier to solve difficult parity problems with SMCGP than either with CGP or modular CGP, and that the increase in efficiency grows with problem size. More importantly, we prove that SMCGP can evolve general solutions to arbitrary-sized even parity problems.
  • Conference Paper
    Full-text available
    Polymorphic digital circuits contain ordinary and polymorphic gates. In the past, Cartesian genetic programming (CGP) has been applied to synthesize polymorphic circuits at the gate level. However, this approach is not scalable. Experimental results presented in this paper indicate that larger and more efficient polymorphic circuits can be designed by a combination of conventional design methods (such as BDD, Espresso or ABC system) and evolutionary optimization (conducted by CGP). Proposed methods are evaluated on two benchmark circuits - multiplier/sorter and parity/majority circuits of variable input size.
  • Conference Paper
    Full-text available
    Simple digital FIR filters have recently been evolved directly in the reconfigurable gate array, ignoring thus a classical method based on multiply–and–accumulate structures. This work indicates that the method is very problematic. In this paper, the gate-level approach is extended to IIR filters, a new approach is proposed to the fitness calculation based on the impulse response evaluation and a comparison is performed between the evolutionary FIR filter design utilizing a full set and a reduced set of gates. The objective of these experiments is to show that the evolutionary design of digital filters at the gate level does not produce filters that are useful in practice when linearity of filters is not guaranteed by the evolutionary design method.
  • Conference Paper
    Full-text available
    This paper presents a novel representation of Cartesian genetic programming (CGP) in which multiple networks are used in the classification of high resolution X-rays of the breast, known as mammograms. CGP networks are used in a number of different recombination strategies and results are presented for mammograms taken from the Lawrence Livermore National Laboratory database.
  • Conference Paper
    Full-text available
    Evolutionary hardware design reveals the potential to provide autonomous systems with self-adaptation properties. We first outline an architectural concept for an intrinsically evolvable embedded system that adapts to slow changes in the environment by simulated evolution, and to rapid changes in available resources by switching to preevolved alternative circuits. In the main part of the paper, we treat evolutionary circuit design as a multi-objective optimization problem and compare two multi-objective optimizers with a reference genetic algorithm. In our experiments, the best results were achieved with TSPEA2, an optimizer that prefers a single objective while trying to maintain diversity.
  • Conference Paper
    Full-text available
    A study is made to learn h ow multicellular organisms might have e merged from single- celled organisms. An understanding of this phenomenon might provide a better understanding of natural and man-made multicellular systems. The experiment performed is an Artificial Life simulation that uses Cartesian Genetic Programming to evolve the behaviors of individual cells. Cells have the ability to sense c hemicals around them, signal, divide, and move towards or away from chemicals. Interesting g roup behavior emerged from the simple instruction sets used by the cells.
  • Conference Paper
    Full-text available
    Genetic Programming was first introduced by Koza using tree representation together with a crossover technique in which random sub-branches of the parents' trees are swapped to create the offspring. Later Miller and Thomson introduced Cartesian Genetic Programming, which uses directed graphs as a representation to replace the tree structures originally introduced by Koza. Cartesian Genetic Programming has been shown to perform better than the traditional Genetic Programming; but it does not use cross- over to create offspring, it is implemented using mutation only. In this paper a new crossover method in Genetic Programming is introduced. The new technique is based on an adaptation of the Cartesian Genetic Programming representation and is tested on two simple regression prob- lems. It is shown that by implementing the new crossover technique, convergence is faster than that of using mutation only in the Cartesian Genetic Programming method.
  • Conference Paper
    Full-text available
    Embedded Cartesian Genetic Programming (ECGP) is an extension of the directed graph based Cartesian Genetic Pr- ogramming (CGP), which is capable of automatically ac- quiring, evolving and re-using partial solutions in the form of modules. In this paper, we apply for the first time, CGP and ECGP to the well known Lawnmower problem and to the Hierarchical-if-and-Only-if problem. The latter is nor- mally associated with Genetic Algorithms. Computational eort figures are calculated from the results of both CGP and ECGP and our results compare favourably with other techniques.
  • Conference Paper
    Full-text available
    Embedded Cartesian Genetic Programming (ECGP) is a form of the graph based Cartesian Genetic Programming (CGP) in which modules are automatically acquired and evolved. In this paper we compare the efficiencies of the ECGP and CGP techniques on three classes of problem: digital adders, digital multipliers and digital comparators. We show that in most cases ECGP shows a substantial improvement in performance over CGP and that the computational speedup is more pronounced on larger problems.
  • Conference Paper
    Full-text available
    This paper shows that the evolutionary design of digital cir- cuits which is conducted at the gate level is able to produce human-competitive circuits at the transistor level. In addi- tion to standard gates, we utilize unconventional gates (such as the NAND/NOR gate and NOR/NAND gate) that con- sist of a few transistors but exhibit non-trivial 3-input logic functions. Novel implementations of adders and majority circuits evolved using these gates contain fewer transistors than the smallest existing implementations of these circuits. Moreover, it was shown that the use of these gates signi- cantly improves the success rate of the search process.
  • Conference Paper
    Full-text available
    Classical Evolutionary Programming (CEP) and Fast Evo- lutionary Programming (FEP) have been applied to real- valued function optimisation. Both of these techniques di- rectly evolve the real-values that are the arguments of the real-valued function. In this paper we have applied a form of genetic programming called Cartesian Genetic Program- ming (CGP) to a number of real-valued optimisation bench- mark problems. The approach we have taken is to evolve a computer program that controls a writing-head, which moves along and interacts with a finite set of symbols that are interpreted as real numbers, instead of manipulating the real numbers directly. In other studies, CGP has already been shown to benefit from a high degree of neutrality. We hope to exploit this for real-valued function optimisation problems to avoid being trapped on local optima. We have also used an extended form of CGP called Embedded CGP (ECGP) which allows the acquisition, evolution and re-use of modules. The effectiveness of CGP and ECGP are com- pared and contrasted with CEP and FEP on the benchmark problems. Results show that the new techniques are very ef- fective.
  • Conference Paper
    Full-text available
    A coevolutionary competitive learning environment for two antagonistic agents is presented. The agents are controlled by a new kind of computational network based on a com-partmentalised model of neurons. The genetic basis of neu-rons is an important [27] and neglected aspect of previous approaches. Accordingly, we have defined a collection of chromosomes representing various aspects of the neuron: soma, dendrites and axon branches, and synaptic connec-tions. Chromosomes are represented and evolved using a form of genetic programming (GP) known as Cartesian GP. The network formed by running the chromosomal programs, has a highly dynamic morphology in which neurons grow, and die, and neurite branches together with synaptic con-nections form and change in response to environmental in-teractions. The idea of this paper is to demonstrate the importance of the genetic transfer of learned experience and life time learning. The learning is a consequence of the com-plex dynamics produced as a result of interaction (coevolu-tion) between two intelligent agents. Our results show that both agents exhibit interesting learning capabilities.
  • Conference Paper
    Full-text available
    ABSTRACT The paper focuses on the evolution of algorithms for control of a machine in the presence of sensor faults, using Carte- sian Genetic Programming. The key challenges in creating training sets and a fltness function that encourage a general solution are discussed. The evolved algorithms are analysed and discussed. It was found that highly novel, mathemati- cally elegant and hitherto unknown,solutions were found. Categories and Subject Descriptors
  • Conference Paper
    Full-text available
    Embedded Cartesian Genetic Programming (ECGP) is an extension of Cartesian Genetic Programming (CGP) that can automatically acquire, evolve and re-use partial solu- tions in the form of modules. In this paper, we introduce for the first time a new multi-chromosome approach to CGP and ECGP that allows dicult problems with multiple out- puts to be broken down into many smaller, simpler problems with single outputs, whilst still encoding the entire solution in a single genotype. We also propose a multi-chromosome evolutionary strategy which selects the best chromosomes from the entire population to form the new fittest individ- ual, which may not have been present in the population. The multi-chromosome approach to CGP and ECGP is tested on a number of multiple output digital circuits. Computational Eort figures are calculated for each problem and compared against those for CGP and ECGP. The results indicate that the use of multiple chromosomes in both CGP and ECGP provide a significant performance increase on all problems tested.