scholarly journals Graph representations in genetic programming

2021 ◽  
Author(s):  
Léo Françoso Dal Piccol Sotto ◽  
Paul Kaufmann ◽  
Timothy Atkinson ◽  
Roman Kalkreuth ◽  
Márcio Porto Basgalupp
Keyword(s):  
Genetic Programming ◽  
Evolutionary Algorithm ◽  
Digital Circuit ◽  
Search Performance ◽  
Genetic Operators ◽  
Code Reuse ◽  
Neutral Drift ◽  
Graph Representations ◽  
Regression Problems ◽  
The Individual

AbstractGraph representations promise several desirable properties for genetic programming (GP); multiple-output programs, natural representations of code reuse and, in many cases, an innate mechanism for neutral drift. Each graph GP technique provides a program representation, genetic operators and overarching evolutionary algorithm. This makes it difficult to identify the individual causes of empirical differences, both between these methods and in comparison to traditional GP. In this work, we empirically study the behaviour of Cartesian genetic programming (CGP), linear genetic programming (LGP), evolving graphs by graph programming and traditional GP. By fixing some aspects of the configurations, we study the performance of each graph GP method and GP in combination with three different EAs: generational, steady-state and $$(1+\lambda )$$ ( 1 + λ ) . In general, we find that the best choice of representation, genetic operator and evolutionary algorithm depends on the problem domain. Further, we find that graph GP methods can increase search performance on complex real-world regression problems and, particularly in combination with the ($$1 + \lambda$$ 1 + λ ) EA, are significantly better on digital circuit synthesis tasks. We further show that the reuse of intermediate results by tuning LGP’s number of registers and CGP’s levels back parameter is of utmost importance and contributes significantly to better convergence of an optimization algorithm when solving complex problems that benefit from code reuse.

scholarly journals FMCGP: frameshift mutation cartesian genetic programming

2021 ◽  
Author(s):  
Wei Fang ◽  
Mindan Gu
Keyword(s):  
Genetic Programming ◽  
Frameshift Mutation ◽  
Population Diversity ◽  
Search Performance ◽  
Mutation Operator ◽  
Cartesian Genetic Programming ◽  
Dna Mutation ◽  
Regression Problems ◽  
The Individual ◽  
Acyclic Directed Graph

AbstractCartesian Genetic Programming (CGP) is a variant of Genetic Programming (GP) with the individuals represented by a two-dimensional acyclic directed graph, which can flexibly encode many computing structures. In general, CGP only uses a point mutation operator and the genotype of an individual is of fixed size, which may lead to the lack of population diversity and then cause the premature convergence. To address this problem in CGP, we propose a Frameshift Mutation Cartesian Genetic Programming (FMCGP), which is inspired by the DNA mutation mechanism in biology and the frameshift mutation caused by insertion or deletion of nodes is introduced to CGP. The individual in FMCGP has variable-length genotype and the proposed frameshift mutation operator helps to generate more diverse offspring individuals by changing the compiling framework of genotype. FMCGP is evaluated on the symbolic regression problems and Even-parity problems. Experimental results show that FMCGP does not exhibit the bloat problem and the use of frameshift mutation improves the search performance of the standard CGP.

Evolved Synthesis of Digital Circuits

2011 ◽  
pp. 609-617 ◽  
Author(s):  
Laurentiu Ionescu ◽  
Alin Mazare ◽  
Gheorghe Serban ◽  
Emil Sofron
Keyword(s):  
Target Function ◽  
Living Organism ◽  
Digital Circuit ◽  
Evolvable Hardware ◽  
Genetic Operators ◽  
Rules And Principles ◽  
Evaluation Module ◽  
The Individual ◽  
High Level ◽  
Crossover And Mutation

Traditionally physical systems have been designed by engineers using complex collections of rules and principles. The design process is top-down in nature and begins with a precise specification. This contrasts very strongly with the mechanisms which have produced the extraordinary diversity and sophistication of living creatures. In this case the ‘‘designs’’ are evolved by a process of natural selection. The design starts as a set of instructions encoded in the DNA whose coding regions are first transcribed into RNA in the cell nucleus and then later translated into proteins in the cell cytoplasm. The DNA carries the instructions for building molecules using sequences of amino acids. Eventually after a number of extraordinarily complex and subtle biochemical reactions an entire living organism is created. The survivability of the organism can be seen as a process of assembling a larger system from a number of component parts and then testing the organism in the environment in which it finds itself (Miller, 2000). The main target of the evolvable hardware is to build a digital circuit using bio inspired methods like genetic algorithms. Here the potential solutions are coded like configuration vectors which command interconnection between logical cells inside the reconfigurable circuit. All configuration vectors represent the genotype and one single configuration vector is the individual with its own characteristics (like chromosome). The individuals are generated by genetic operators like crossover or mutation. One individual give one solution circuit which is tested in evaluation module. The circuit obtained from the individual consist the phenotype. The circuit behavior is compared with target functions, which we desire to implement. The result is fitness: if the circuit approximates the behavior of the target function, we have a good fitness for the individual which generate the circuit. Then each individual whit its fitness gets into selection module where the future parents in crossover and mutation are decided. Finally we have a circuit solution which implements the target function. We have an evolved synthesis of digital circuit – a method like assemble and test. This method can be useful because explore the design space beyond the limits imposed by traditional design methods. Two research directions are developed in evolvable hardware. In extrinsic evolvable hardware the individuals are obtained from software implementation on computer and phenotype consist in high level abstract circuits like SPICE object files or FPGA configuration files (.bit). The intrinsic evolution, on the other hand, supposes that entire evolution process is inside one or more chips (FPGA): the hardware implementation of evolved hardware. The challenge is to design an intrinsic evolution because can be used for applications like robots control system. But this involves implementation of the software based algorithms in hardware modules.

Adaptive Fitness Predictors in Coevolutionary Cartesian Genetic Programming

2019 ◽  
Vol 27 (3) ◽  
pp. 497-523 ◽  
Author(s):  
Michaela Drahosova ◽  
Lukas Sekanina ◽  
Michal Wiglasz
Keyword(s):  
Genetic Programming ◽  
Evolutionary Algorithm ◽  
Filter Design ◽  
Training Data ◽  
Cartesian Genetic Programming ◽  
Design Problems ◽  
Quality Of Results ◽  
Regression Problems ◽  
Time Required

In genetic programming (GP), computer programs are often coevolved with training data subsets that are known as fitness predictors. In order to maximize performance of GP, it is important to find the most suitable parameters of coevolution, particularly the fitness predictor size. This is a very time-consuming process as the predictor size depends on a given application, and many experiments have to be performed to find its suitable size. A new method is proposed which enables us to automatically adapt the predictor and its size for a given problem and thus to reduce not only the time of evolution, but also the time needed to tune the evolutionary algorithm. The method was implemented in the context of Cartesian genetic programming and evaluated using five symbolic regression problems and three image filter design problems. In comparison with three different CGP implementations, the time required by CGP search was reduced while the quality of results remained unaffected.

scholarly journals Evolving graphs with semantic neutral drift

2019 ◽  
Author(s):  
Timothy Atkinson ◽  
Detlef Plump ◽  
Susan Stepney
Keyword(s):  
Performance Analysis ◽  
Genetic Programming ◽  
Digital Circuit ◽  
Benchmark Problems ◽  
Evolving Graphs ◽  
Rule Based ◽  
Neutral Drift ◽  
Complex Processes ◽  
Simple Growth

Abstract We introduce the concept of Semantic Neutral Drift (SND) for genetic programming (GP), where we exploit equivalence laws to design semantics preserving mutations guaranteed to preserve individuals’ fitness scores. A number of digital circuit benchmark problems have been implemented with rule-based graph programs and empirically evaluated, demonstrating quantitative improvements in evolutionary performance. Analysis reveals that the benefits of the designed SND reside in more complex processes than simple growth of individuals, and that there are circumstances where it is beneficial to choose otherwise detrimental parameters for a GP system if that facilitates the inclusion of SND.

Learning to Control the Program Evolution Process with Cultural Algorithms

1997 ◽  
Vol 5 (2) ◽  
pp. 181-211 ◽  
Author(s):  
Elena Zannoni ◽  
Robert G. Reynolds
Keyword(s):  
Genetic Programming ◽  
Population Level ◽  
Extraction Process ◽  
Cultural Algorithms ◽  
Genetic Operators ◽  
Regression Problem ◽  
Standard Procedures ◽  
Programming Process ◽  
Time Required ◽  
Effective Use

Traditional software engineering dictates the use of modular and structured programming and top-down stepwise refinement techniques that reduce the amount of variability arising in the development process by establishing standard procedures to be followed while writing software. This focusing leads to reduced variability in the resulting products, due to the use of standardized constructs. Genetic programming (GP) performs heuristic search in the space of programs. Programs produced through the GP paradigm emerge as the result of simulated evolution and are built through a bottom-up process, incrementally augmenting their functionality until a satisfactory level of performance is reached. Can we automatically extract knowledge from the GP programming process that can be useful to focus the search and reduce product variability, thus leading to a more effective use of the available resources? An answer to this question is investigated with the aid of cultural algorithms. A new system, cultural algorithms with genetic programming (CAGP), is presented. The system has two levels. The first is the pool of genetic programs (population level), and the second is a knowledge repository (belief set) that is built during the GP run and is used to guide the search process. The microevolution within the population brings about potentially meaningful characteristics of the programs for the achievement of the given task, such as properties exhibited by the best performers in the population. CAGP extracts these features and represents them as the set of the current beliefs. Beliefs correspond to constraints that all the genetic operators and programs must follow. Interaction between the two levels occurs in one direction through the extraction process and, in the other, through the modulation of an individual's program parameters according to which, and how many, of the constraints it follows. CAGP is applied to solve an instance of the symbolic regression problem, in which a function of one variable needs to be discovered. The results of the experiments show an overall improvement on the average performance of CAGP over GP alone and a significant reduction of the complexity of the produced solution. Moreover, the execution time required by CAGP is comparable with the time required by GP alone.

scholarly journals A NEW LINEAR GENETIC PROGRAMMING APPROACH BASED ON STRAIGHT LINE PROGRAMS: SOME THEORETICAL AND EXPERIMENTAL ASPECTS

2009 ◽  
Vol 18 (05) ◽  
pp. 757-781 ◽  
Author(s):  
CÉSAR L. ALONSO ◽  
JOSÉ LUIS MONTAÑA ◽  
JORGE PUENTE ◽  
CRUZ ENRIQUE BORGES
Keyword(s):  
Data Structure ◽  
Genetic Programming ◽  
Computer Programs ◽  
Symbolic Regression ◽  
Programming Approach ◽  
Linear Genetic Programming ◽  
Straight Line ◽  
Structured Representations ◽  
Regression Problems ◽  
Straight Line Programs

Tree encodings of programs are well known for their representative power and are used very often in Genetic Programming. In this paper we experiment with a new data structure, named straight line program (slp), to represent computer programs. The main features of this structure are described, new recombination operators for GP related to slp's are introduced and a study of the Vapnik-Chervonenkis dimension of families of slp's is done. Experiments have been performed on symbolic regression problems. Results are encouraging and suggest that the GP approach based on slp's consistently outperforms conventional GP based on tree structured representations.

scholarly journals Guided Subtree Selection for Genetic Operators in Genetic Programming for Dynamic Flexible Job Shop Scheduling

2020 ◽  
Author(s):  
Fangfang Zhang ◽  
Yi Mei ◽  
S Nguyen ◽  
Mengjie Zhang
Keyword(s):  
Genetic Programming ◽  
Job Shop ◽  
Job Shop Scheduling ◽  
Computational Time ◽  
Flexible Job Shop ◽  
Flexible Job Shop Scheduling ◽  
Genetic Operators ◽  
Operation Sequencing ◽  
Shop Scheduling ◽  
Selection For

© 2020, Springer Nature Switzerland AG. Dynamic flexible job shop scheduling (DFJSS) has been widely studied in both academia and industry. Both machine assignment and operation sequencing decisions need to be made simultaneously as an operation can be processed by a set of machines in DFJSS. Using scheduling heuristics to solve the DFJSS problems becomes an effective way due to its efficiency and simplicity. Genetic programming (GP) has been successfully applied to evolve scheduling heuristics for job shop scheduling automatically. However, the subtrees of the selected parents are randomly chosen in traditional GP for crossover and mutation, which may not be sufficiently effective, especially in a huge search space. This paper proposes new strategies to guide the subtree selection rather than picking them randomly. To be specific, the occurrences of features are used to measure the importance of each subtree of the selected parents. The probability to select a subtree is based on its importance and the type of genetic operators. This paper examines the proposed algorithm on six DFJSS scenarios. The results show that the proposed GP algorithm with the guided subtree selection for crossover can converge faster and achieve significantly better performance than its counterpart in half of the scenarios while no worse in all other scenarios without increasing the computational time.

scholarly journals Adaptive Test Selection for Factorization-based Surrogate Fitness in Genetic Programming

2017 ◽  
Vol 42 (4) ◽  
pp. 339-358 ◽  
Author(s):  
Krzysztof Krawiec ◽  
Paweł Liskowski
Keyword(s):  
Genetic Programming ◽  
Evolutionary Algorithm ◽  
Matrix Factorization ◽  
Fitness Function ◽  
Interaction Matrix ◽  
Simulated Evolution ◽  
Adaptive Test ◽  
Selection For ◽  
Correct Program ◽  
Non Negative Matrix Factorization

Abstract Genetic programming (GP) is a variant of evolutionary algorithm where the entities undergoing simulated evolution are computer programs. A fitness function in GP is usually based on a set of tests, each of which defines the desired output a correct program should return for an exemplary input. The outcomes of interactions between programs and tests in GP can be represented as an interaction matrix, with rows corresponding to programs in the current population and columns corresponding to tests. In previous work, we proposed SFIMX, a method that performs only a fraction of interactions and employs non-negative matrix factorization to estimate the outcomes of remaining ones, shortening GP’s runtime. In this paper, we build upon that work and propose three extensions of SFIMX, in which the subset of tests drawn to perform interactions is selected with respect to test difficulty. The conducted experiment indicates that the proposed extensions surpass the original SFIMX on a suite of discrete GP benchmarks.

High-dimensional Unbalanced Binary Classification by Genetic Programming with Multi-criterion Fitness Evaluation and Selection

2021 ◽  
pp. 1-26
Author(s):  
Wenbin Pei ◽  
Bing Xue ◽  
Lin Shang ◽  
Mengjie Zhang
Keyword(s):  
Genetic Programming ◽  
Fitness Function ◽  
Binary Classification ◽  
Class Imbalance ◽  
Area Under The Curve ◽  
High Dimensional ◽  
Genetic Operators ◽  
Minority Class ◽  
Fitness Evaluation ◽  
Unbalanced Classification

Abstract High-dimensional unbalanced classification is challenging because of the joint effects of high dimensionality and class imbalance. Genetic programming (GP) has the potential benefits for use in high-dimensional classification due to its built-in capability to select informative features. However, once data is not evenly distributed, GP tends to develop biased classifiers which achieve a high accuracy on the majority class but a low accuracy on the minority class. Unfortunately, the minority class is often at least as important as the majority class. It is of importance to investigate how GP can be effectively utilized for high-dimensional unbalanced classification. In this paper, to address the performance bias issue of GP, a new two-criterion fitness function is developed, which considers two criteria, i.e. the approximation of area under the curve (AUC) and the classification clarity (i.e. how well a program can separate two classes). The obtained values on the two criteria are combined in pairs, instead of summing them together. Furthermore, this paper designs a three-criterion tournament selection to effectively identify and select good programs to be used by genetic operators for generating better offspring during the evolutionary learning process. The experimental results show that the proposed method achieves better classification performance than other compared methods.

Sign in / Sign up

Export Citation Format

Share Document