Coevolutionary Dynamics of a Multi-population Genetic Programming System

The 0/1 knapsack problem is one of the most exhaustively studied NP-hard combinatorial optimization problems. Many different approaches have been taken to obtain an approximate solution to the problem in polynomial time. Here we consider the biobjective 0/1 knapsack problem. The contribution of this paper is to show that a genetic programming system can evolve a set of heuristics that can give solutions on the Pareto front for multiobjective combinatorial problems. The genetic programming (GP) system outlined here evolves a heuristic which decides whether or not to add an item to the knapsack in such a way that the final solution is one of the Pareto optimal solutions. Moreover, the Pareto front obtained from the GP system is comparable to the front obtained from other human-designed heuristics. We discuss the issue of the diversity of the obtained Pareto front and the application of strongly-typed GP as a means of obtaining better diversity.

Gaussian-based edge detectors have been developed for many years, but there are still problems with how to set scales for Gaussian filters and how to combine Gaussian filters. In order to address both problems, a Genetic Programming (GP) system is proposed to automatically choose scales for Gaussian filters and automatically combine Gaussian filters. In this study, the GP system is utilised to construct rotation invariant Gaussian-based edge detectors based on a benchmark image dataset. The experimental results show that the GP evolved Gaussian-based edge detectors are better than the Gaussian gradient and rotation invariant surround suppression to extract edge features.

Document classification tasks generally have sparse and high dimensional features. It is important to effectively extract features. In document classification tasks, there are some similarities existing in different categories or different datasets. It is possible that one document classification task does not have labelled training data. In order to obtain effective classifiers on this specific task, this paper proposes a Genetic Programming (GP) system using transductive transfer learning. The proposed GP system automatically extracts features from different source domains, and these GP extracted features are combined to form new classifiers being directly applied to a target domain. From experimental results, the proposed transductive transfer learning GP system can evolve features from source domains to effectively apply to target domains which are similar to the source domains.

In this work, genetic programming systems are viewed as cooperative processes: individuals in the population cooperate to evolve a global solution. There are two basic forms of cooperation for distributed problem solving: task-sharing and result-sharing. We introduce two models that enable cooperation in genetic programming systems. The first model is based on task-sharing and the second one is based on result-sharing. We examine the effects of both forms of cooperation on the performance of genetic programming systems solving the insect locomotion problem. This article demostrates that cooperative genetic programming can be used to evolve several commonly observed gaits in insects.

Algorithms are needed in every aspect of parallel computing. Genetic Programming is an evolutionary technique for automating the design of algorithms through iterative steps of mutation and crossover operations on an initial population of randomly generated computer programs. This paper describes a novel parallel genetic programming (GP) system inspired by the symbiogenesis model of evolution, wherein new organisms are generated through the absorption of different life-forms in addition to the usual mutation and crossover operations. Different organisms are expressed in this GP system through multiple program representations. Two program representations considered in this paper are the procedural representation (PR) and the tree representation (TR). Populations of these representations evolve separately. Individuals in each population migrate to the other and participate in evolution via representation change algorithms. Parallelism is achieved through use of the AutoMap/AutoLink MPI library. The differences in the locality properties of the representations serve as a source of new ideas for creating the final algorithm.

Programming languages provide a variety of mechanisms to associate names with values, and these mechanisms play a central role in programming practice. For example, they allow multiple references to the same storage location or function in different parts of a complex program. By contrast, the representations used in current genetic programming systems provide few if any naming mechanisms, and it is therefore generally not possible for evolved programs to use names in sophisticated ways. In this chapter we describe a new approach to names in genetic programming that is based on Holland’s concept of tags. We demonstrate the use of tag-based names, we describe some of the ways in which they may help to extend the power and reach of genetic programming systems, and we look at the ways that tag-based names are actually used in an evolved program that solves a robot navigation problem.Keywordsgenetic programmingmodularitynamestagsstack-based genetic programmingPush programming languagePushGP

Genetic Programming (GP) is a form of nature-inspired computing, introduced over 30 years ago, with notable success in problems such as symbolic regression. However, there remains a lot of relatively unexploited potential for solving hard, real-world problems. There is consensus in the GP community that the lack of effective real-world benchmark problems negatively impacts the quality of research [4]. When a GP system is initialised, a number of parameters must be provided. The optimal setup configuration is often not known, due to the fact that many of the values are problem and domain specific, meaning the GP system is unable to produce satisfactory results. We believe that the implementation of continuous self-adaptation, along with the introduction of tunable and suitably difficult benchmark problems, will allow for the creation of more robust GP systems that are resilient to failure.

Comparison of genetic programming with neuro-fuzzy systems for predicting short-term water table depth fluctuations

Tree-adjunct grammar guided genetic programming (TAG3P) [5] is a grammar guided genetic programming system that uses context-free grammars along with tree-adjunct grammars as means to set language bias for the genetic programming system. In this paper, we show the experimental results of TAG3P on two problems: symbolic regression and trigonometric identity discovery. The results show that TAG3P works well on those problems.

A blend of fuzzy logic and genetic programming is used in this research to achieve a single fine-tuned fuzzy rule, upon giving hundreds of fuzzy rules as the input. The system has Poisson arrival rate of vehicles, and decisions are taken to alter the sequence of lights based on the queue lengths of the lanes. The traffic simulator handles routing of vehicles in a single four-leg intersection with left and right turns. The fuzzy logic traffic controller system is used to generate the simulation data to feed the genetic programming system. The genetic programming system then creates an optimum fuzzy rule. This fine-tuned fuzzy rule is proven to be qualitatively better with respect to the mean square queue length and its error of the total system at any given point of time.

The author used J.R. Koza's (1992) genetic programming to evolve programs that classified contiguous regions of proteins as being /spl alpha/-helix cores or not. He snipped positive and negative examples of /spl alpha/-helix core regions out of a set of 90 proteins. These proteins were chosen from the Brookhaven Protein Data Bank to be non-homologous. The fitness of the programs was defined as the correlation coefficient between the observed and the predicted /spl alpha/-helicity of the above regions. The fittest program produced by the genetic programming system that predicted the training set at least as well as the testing set had a correlation of 0.4818 between the observed classifications and the classifications predicted by the program (on the proteins in the testing set). >

<p>One of the greater issues in Genetic Programming (GP) is the computational effort required to run the evolution and discover a good solution. Phenomena such as program bloating (where genetic programs rapidly grow in size) can quickly exhaust available memory resources and slow down the evolutionary process, while the heavy cost of performing fitness evaluation can make problems which have a lot of available data very slow to solve. These issues may limit GP in some tasks it can appropriately be applied to, as well as inhibit its applications in time/space sensitive environments. In this thesis, we look at developing solutions to some of these issues in GP computational cost. First, we develop an algebraic program simplification method based on simple rules and hashing techniques, and use this method in conjunction with the standard GP on a variety of tasks. Our results suggest that program simplification can lead to a significant reduction in program size, while not significantly changing the effectiveness of the systems in finding solution programs. Secondly, we analyse the effects of program simplification on the internal GP "building blocks" to investigate whether simplification is a destructive or constructive force. Using two models for building blocks (numerical-nodes and the more complex fixed-depth subtree), we track building blocks through GP runs on a symbolic regression problem, both with and without using simplification. We find that the program simplification process can both disrupt and construct building blocks in the GP populations. However, GP systems using simplification appear to retain important building blocks, and the simplification process appears to lead to an increase in genetic diversity. These may help explain why using simplification does not reduce the effectiveness of GP systems in solving tasks. Lastly, we develop two methods of reducing the cost of fitness evaluation by reducing the number of node evaluations performed. The first method is elitism avoidance, which avoids re-evaluating programs which have been placed in the population using elitismreproduction. Thismethod reduces the CPU time for evolving solutions for six different GP tasks. The second method is a subtree caching mechanism which store fitness evaluations for subtrees in a cache so that they may be fetched when these subtrees are encountered in future fitness evaluations. Results suggest that using this mechanism can significantly reduce both the number of node evaluations and the overall CPU time used in evolving solutions, without reducing the fitness of the solutions produced.</p>

Most genetic programming systems use hard-coded genetic operators that are applied according to user-specified parameters. Because it is unlikely that the provided operators or the default parameters will be ideal for all problems or all program representations, practitioners often devote considerable energy to experimentation with alternatives. Attempts to bring choices about operators and parameters under evolutionary control, through self-adaptative algorithms or meta-genetic programming, have been explored in the literature and have produced interesting results. However, no systems based on such principles have yet been demonstrated to have greater practical problem-solving power than the more-standard alternatives. This chapter explores the prospects for extending the practical power of genetic programming through the refinement of an approach called autoconstructive evolution, in which the algorithms used for the reproduction and variation of evolving programs are encoded in the programs themselves, and are thereby subject to variation and evolution in tandem with their problem-solving components. We present the motivation for the autoconstructive evolution approach, show how it can be instantiated using the Push programming language, summarize previous results with the Pushpop system, outline the more recent AutoPush system, and chart a course for future work focused on the production of practical systems that can solve hard problems.

Genetic programming (GP) is applied to the design of fuzzy logic controllers (FLCs) for mobile robot path tracking. GP is applied to automatic discovery of full knowledge bases for use in fuzzy logic control applications. An extension to a rule learning GP system is presented that achieves this objective. In addition, GP is employed to handle selection of fuzzy set intersection operators (t-norms). The new GP system is applied to design a mobile robot path tracking controller and performance is shown to be comparable to that of a manually designed controller. GP was successfully applied to discover FLCs capable of steering a mobile robot to track straight-line paths in the plane. Instances of simultaneous evolution of membership functions and rules showed that GP was capable of evolving a FLC that demonstrated satisfactory responsiveness to various initial conditions while utilizing minimal human interface.

We proposed a new strategy to explicitly define introns that increases the probability of selecting good crossover points as evolution goes on. Our approach differs from existing methods in the procedure followed to adapt the probabilities of groups of code being protected. We also provide some experimental results in symbolic regression and classification that reinforced our belief in the usefulness of this procedure. Collateral effects of Evolutive Introns (EIs) are also studied to determine possible modifications in the behavior of a classical Genetic Programming (GP) system.