We describe a design principle for adaptive systems under which adaptation is driven by particular challenges that the environment poses, as opposed to average or otherwise aggregated measures of performance over many challenges. We trace the development of this"particularity"approach from the use of lexicase selection in genetic programming to"particularist"approaches to other forms of machine learning and to the design of adaptive systems more generally.
For various evolutionary systems it was found that the abundance of phenotypes in a search space, defined as the size of their respective neutral networksNeutral networks, is key to understanding the trajectory an evolutionary process takes from an initial to a target solution. In this chapter we use a Linear Genetic Programming system to demonstrate that the abundance of phenotypes is determined by the combinatorics offered in its neutral components. This translates into the size of the neutral space available to a phenotype and also can explain the beautiful and rather curious observation that the abundance of phenotypes is dependent on their complexity in a negative exponential fashion.
Program synthesis with Genetic Programming searches for a correct program that satisfies the input specification, which is usually provided as input-output examples. One particular challenge is how to effectively handle loops and recursion avoiding programs that never terminate. A helpful abstraction that can alleviate this problem is the employment of Recursion Schemes that generalize the combination of data production and consumption. Recursion Schemes are very powerful as they allow the construction of programs that can summarize data, create sequences, and perform advanced calculations. The main advantage of writing a program using Recursion Schemes is that the programs are composed of well defined templates with only a few parts that need to be synthesized. In this paper we make an initial study of the benefits of using program synthesis with fold and unfold templates, and outline some preliminary experimental results. To highlight the advantages and disadvantages of this approach, we manually solved the entire GPSB benchmark using recursion schemes, highlighting the parts that should be evolved compared to alternative implementations. We noticed that, once the choice of which recursion scheme is made, the synthesis process can be simplified as each of the missing parts of the template are reduced to simpler functions, which are further constrained by their own input and output types.
Accurately predicting blood glucose levels in individuals with diabetes is essential for effectively managing and preventing complications. This paper explores the application of Grammatical Evolution, a genetic programming technique, for glucose prediction. It discusses how Grammatical Evolution has been employed in addressing various challenges related to glucose prediction, such as limited actual recorded data, prediction safety, interpretability of models, consideration of latent variables, and prognosis of hypoglycemia episodes. Building upon this research, the paper presents a comprehensive framework for glucose control that utilizes evolutionary techniques, primarily emphasizing structured grammatical evolution. The framework encompasses several stages, including data gathering, data augmentation, extraction of latent variability features, scenario clustering, structured grammatical evolution training, development of interpretable personal models, derivation of classification rules, glucose prediction, hypoglycemia alert, and glucose control. By harnessing the power of evolutionary algorithms, the framework optimizes model performance and adapts to individual patient characteristics. The proposed framework presents a promising approach to improve glucose monitoring and control, thereby contributing to better diabetes management and improved quality of life for patients.
In recent years, Large Language Models (LLMs)Large language models have rapidly progressed in their capabilities in natural language processing (NLP) tasks, which have interestingly grown in scope to include generating computer programs. Indeed, recent studies have demonstrated how LLMs can enable highly proficient genetic programming (GP) algorithms and novel evolutionary algorithms more broadly. Motivated by these opportunities, this paper introduces OpenELM, an open-source Python library for designing evolutionary algorithms that leverage LLMs to intelligently generate variation, as well as to assess fitness and measures of diversity. The library includes implementations of several variation operators, and is designed to accommodate those with limited compute resources, by enabling fast inference, being runnable through hosted notebooks (such as Google Colab), and allowing for API-based LLMs to be used instead of local models run on GPUs. Additionally, OpenELM includes a variety of domain implementations for easy experimentation and adaptation, including several GP domains. The hope is to help researchers easily develop new approaches and applications within the nascent and largely unexplored paradigm of evolutionary algorithms that leverage LLMs.
The efficacy of active learningActive learning in genetic programming (AL-GP) for image processing tasks was explored using two new population-based machine learning systems, decision tree genetic programming and SEE-Segment. Active learning was shown to improve the rate and consistency at which good models are found while reducing the required number of training samples to achieve good solutions in both ML systems. The importance of diversity in ensembles for AL-GP was revealed by varying the definition for diversity when performing active learning with SEE-Segment. It was also demonstrated how AL-GP was deployed in a research setting to help automate and accelerate progress by guiding labelling of training samples (human cells) to inform the development of classification models which were then used to automatically classify cells in video frames.
Software synthesisSoftware synthesis research has historically relied on tools such as step limits to handle undesired behavior like infinite loops. Here we explore the impact of different step limitsStep limits on several benchmark problems, and see that these limits do affect the evolved behaviors both in terms of generalization and stability. To assess stability Stability, we ran evolved programs with a range of step limits Step limits, and found several cases where programs failed to generalize with the step limit used during evolution, but generalized at other step limits Step limits. Two of our test problems evolved stable solutions in the sense that they correctly handled unseen test cases for all step limitsStep limits above a certain point, i.e., correctly computed the answer. Our other two test problems, however, sometimes evolved unstable solutions which only generalized (i.e., correctly handled unseen test cases) for specific step limits Step limits. These programs relied on the step limit to terminate, and would no longer generalize if the step limit was modified slightly. This indicates that step limitsStep limits can have a substantial impact on evolutionary performance, and suggests we need to revisit our notions of generalizationGeneralization in the context of evolutionary software synthesis Software synthesis.
We present different approaches for including knowledge in data-based modeling. For this, we utilize the model representation of symbolic regression (SR), which represents the models as short interpretable mathematical formulas. The integration of knowledge into symbolic regressionSymbolic regression via shape constraints is discussed alongside three real-world applications: modeling magnetization curves, modeling twin-screw extruders and model-based data validation.
We survey eight recent works by our group, involving the successful blending of evolutionary algorithms with machine learning and deep learning: 1. Binary and Multinomial Classification through Evolutionary Symbolic Regression, 2. Classy Ensemble: A Novel Ensemble Algorithm for Classification, 3. EC-KitY: Evolutionary Computation Tool Kit in Python, 4. Evolution of Activation Functions for Deep Learning-Based Image Classification, 5. Adaptive Combination of a Genetic Algorithm and Novelty Search for Deep Neuroevolution, 6. An Evolutionary, Gradient-Free, Query-Efficient, Black-Box Algorithm for Generating Adversarial Instances in Deep Networks, 7. Foiling Explanations in Deep Neural Networks, 8. Patch of Invisibility: Naturalistic Black-Box Adversarial Attacks on Object Detectors.
In this chapter, we present a new implementation of the popularPipeline optimization Tree-Based Pipeline Optimization Tool (TPOT). This new implementation, called TPOT2, was rebuilt from the ground up to be more modular, easier to maintain, and easier to expand. TPOT2 comes with new features and optimizationsOptimization, such as a more flexible graph-based representation of Scikit-Learn pipelines and the ability to specify various aspects of the evolutionary run. Using experiments on multiple benchmarkBenchmark datasets, we show that TPOT2 performs at least as well as TPOT1 with equivalent settings, with stronger performance on a few datasets. We outline some future directions for further optimizations and applications.
Fitness landscapes have historically been a powerful tool for analyzing the search space explored by evolutionary algorithms. In particular, they facilitate understanding how easily reachable an optimal solution is from a given starting point. However, simple fitness landscapes are inappropriate for analyzing the search space seen by selection schemes like lexicase selection in which the outcome of selection depends heavily on the current contents of the population (i.e. selection schemes with complex ecological dynamics). Here, we propose borrowing a tool from ecology to solve this problem: community assembly graphs. We demonstrate a simple proof-of-concept for this approach on an NK Landscape where we have perfect information. We then demonstrate that this approach can be successfully applied to a complex genetic programming problem. While further research is necessary to understand how to best use this tool, we believe it will be a valuable addition to our toolkit and facilitate analyses that were previously impossible.
Phylogenies (ancestry trees) tell the evolutionary history of an evolving population. In evolutionary computing, phylogenies reveal how evolutionary algorithms steer populations through a search space by illuminating the step-by-step evolution of solutions. To date, phylogenetic analyses have almost exclusively been applied in post hoc analyses of evolutionary algorithms for performance tuning and research. Here, we apply phylogenetic information at runtime to augment parent selection procedures that use training sets to assess candidate solution quality. We propose phylogenyPhylogeny-informed fitness estimationFitness estimation, thinning a fraction of costly training case evaluations by substituting the fitness profiles of near relatives as a heuristic estimate. We evaluate phylogenyPhylogeny-informed fitness estimationFitness estimation in the context of the down-sampled lexicase and cohort lexicase selectionLexicase selection algorithms on two diagnostic analyses and four genetic programming (GP) problems. Our results indicate that phylogenyPhylogeny-informed fitness estimationFitness estimation can mitigate the drawbacks of down-sampled lexicase, improving diversity maintenance and search space exploration. However, the extent to which phylogenyPhylogeny-informed fitness estimationFitness estimation improves problem-solving success for GP varies by problem, subsampling method, and subsampling level. This work serves as an initial step toward improving evolutionary algorithms by exploiting runtime phylogenetic analysis.
We consider the problem of optimizing a controller for agents whose observation and action spaces are continuous, i.e., where the controller is a multivariate real function $$f: \mathbb {R}^n \rightarrow \mathbb {R}^m$$ . We use genetic programming (GP) for solving this optimization problem. Namely, we employ a multi-tree-based GP variant, where a candidate solution is an array of m trees, each encoding a univariate function of the agent observation. We compare this form of optimization against the more common one where the controller is a multi-layer perceptron, with a predefined topology, whose weights are optimized through (neuro)evolution (NE). Moreover, we consider an evolutionary algorithm, GraphEA, that directly evolves graphs, each having n input nodes and m output nodes. We apply these three approaches to the case of simulated modular soft robots Soft robots, where a robot is an aggregation of identical soft modules, each employing a controller that processes the local observation and produces the local action. We find that, in our scenario, multi-tree-based GP is competitive with NE and tends to produce different behaviors. We then experimentally investigate the possibility of optimizing a controller using another, pre-optimized one, as teacher, i.e., we realize a form of offline imitation learning Imitation learning. We consider all the teacher-learner pairs resulting from the three evolutionary algorithms and find that NE is a better learner than GP and GraphEA. However, controllers obtained through offline imitation learningImitation learning are far less effective than those obtained through direct evolution. We hypothesize that this gap in effectiveness may be explained by the possibility, given by direct evolution, of exploring during the simulations a larger portion of the observation-action space.
The structure of relatedness among members of an evolved population tells much of its evolutionary history. In application-oriented evolutionary computation (EC), such phylogenetic information can guide algorithm selection and tuning. Although traditional direct tracking approaches provide the perfect phylogenetic record, sexual recombinationRecombination complicates management and analysis of this data. Taking inspiration from biological science, this work explores a reconstruction-based approach that uses end-state genetic information to estimate phylogenetic history after the fact. We apply recently developed "hereditary stratigraphy" genome annotations to lineages with sexual recombinationRecombination to design devices germane to species phylogenies and gene trees. As shown through a series of validation experiments, the proposed instrumentation can discern genealogical history, population size changes, and selective sweeps. Fully decentralized by nature, these methods afford new observability at scale, in particular, for distributed EC systems. Such capabilities anticipate continued growth of computational resources available to EC. Accompanying open-source software aims to expedite the application of reconstruction-based phylogenetic analysis where pertinent.
Modern methodologies across the disparate fields of artificial intelligence, including neural networks, evolutionary computation and machine learning, suffer from some limiting assumptions and perspectives that perhaps fundamentally prevent us from pursuing the creation of strong, or at least strongish, AI. This position paper offers several contrarian posits, namely that it is impossible to engineer intelligence, that there is no Occam's Razor for intelligence, that intelligence must be grounded and transferable, and that intelligence must be intrinsically self-reinforcing. Based on these, a new re-framing is discussed of the worlds, drivers, models and processes needed to support the creation of strongish AI. Key elements include the need for an intelligence function, the value of increasing the complexity of the world and drivers over time, and the importance of composable intelligences and processes. Some notations for this new framing are provided, musings on revisiting reproducibility in the context of intelligence are discussed and some preliminary thoughts for how to pursue these ideas using genetic programming for example are offered. Let's move together towards a common methodology for creating quantifiable, grounded intelligence capabilities that are shareable across different efforts and AI techniques, and work collectively to create robust artificial general intelligences.
While competitive coevolutionary algorithms are ideally suited to model adversarial dynamics, their complexity makes it difficult to understand what is happening when they execute. To achieve better clarity, we introduce a game named DefendIt and explore a previously developed pairwise dominance coevolutionary algorithm named PDCoEA.We devise a methodology for consistent algorithm comparison, then use it to empirically study the impact of population size, the impact of relative budget limits between the defender and attacker, and the impact of mutation rates on the dynamics and payoffs. Our methodology provides reliable comparisons and records of run and multi-run dynamics. Our supplementary material also offers enticing and detailed animations of a pair of players' game moves over the course of a game of millions of moves matched to the same run's populations' payoffs.
The use of correlation as a fitness function is explored in symbolic regression tasks and the performance is compared against the typical RMSE fitness function. Using correlation with an alignment step to conclude the evolution led to significant performance gains over RMSE as a fitness function. Using correlation as a fitness function led to solutions being found in fewer generations compared to RMSE, as well it was found that fewer data points were needed in the training set to discover the correct equations. The Feynman Symbolic Regression Benchmark as well as several other old and recent GP benchmark problems were used to evaluate performance.
We present a GUI-driven and efficient Genetic Programming (GP) and AI Planning framework designed for agent-based learning research. Our framework, ABL-Unity3D, is built in Unity3D, a game development environment. ABL-Unity3D addresses challenges entailed in co-opting Unity3D: making the simulator serve agent learning rather than humans playing a game, lowering fitness evaluation time to make learning computationally feasible, and interfacing GP with an AI Planner to support hybrid algorithms. We achieve this by developing a Graphical User Interface (GUI) using the Unity3D editor’s programmable interface and performance optimizations. These optimizations result in at least a 3x speedup. In addition, we describe ABL-Unity3D by explaining how to use it for an example experiment using GP and AI Planning. We benchmark ABL-Unity3D by measuring the performance and speed of the AI Planner alone, GP alone, and the AI Planner with GP.
