Pyevolve is an open-source framework for genetic algorithms. The initial long-term goal of the project was to create a complete and multi-platform framework for genetic algorithms in pure Python. However, the most recent developmental versions currently support also Genetic Programming (GP)[3]; accordingly, Pyevolve now aims at becoming a pure Python framework for evolutionary algorithms.

Figures - uploaded by Christian Perone

Author content

All figure content in this area was uploaded by Christian Perone

Content may be subject to copyright.

ResearchGate Logo

Discover the world's research

  • 20+ million members
  • 135+ million publications
  • 700k+ research projects

Join for free

Pyevolve: a Python Open-Source

Framework for Genetic Algorithms

Christian S. Perone, christian.perone@gmail.com

Pyevolve is an open-source framework for genetic algorithms.

The initial long-term goal of the project was to create a com-

plete and multi-platform framework for genetic algorithms in

pure Python. However, the most recent developmental ver-

sions currently support also Genetic Programming (GP)[3 ]; accordingly,

Pyevolve now aims at becoming a pure Python framework for evolution-

ary algorithms.

The project started back in 2007; the current stable version is Pyevolve

0.5, which was released on January 22nd, 2009 and publically available

since then from the project site (http://pyevolve.sourceforge.net ). The

features presented in this article are from the last development version,

which will be included in the next official distribution Pyevolve 0.6 —

available in the near future.

Pyevolve is organized in packages to keep the API simple and intuitive.

Figure 1 shows how the different packages are organized while Figure 2

shows how the components work together. Pyevolve offers several inter-

esting features.

It is multiplatform – the framework was written in pure Python, so

it can run on Mac, Windows, Linux platforms, and on any portable de-

vices where Python is available (e.g., the Sony PlayStation Portable

or Symbian OS based cellphones);

It is extensible – the user can easily add new chromosome struc-

tures, genetic operators, database or visualization adapters, etc.

It is loaded with standard features – Pyevolve provides imple-

mentations of the most commonly used genetic operators, scaling

schemes, selection methods, etc.

Fig. 1: Structure of the Pyevolve framework

It heavily uses default parameters – to increase users' produc-

tivity, there are default values for almost all parameters;

It has easy-to-use and well documented APIs – the API is very

easy to learn and was developed to be simple and intuitive. Every

component of the framework is documented and public available

with examples1;

It supports multiprocessing – the framework supports the use

of multiple cores, it will alternate the CPU cores of the machine to

evaluate the fitness function for each individual in population;

It is open-source! – the framework is entirely open-source and it

is licensed upon a very permissive PSF2-like license.

1At the URL: http://pyevolve.sourceforge.net, the project home site

2The same used by Python Language

SIGEVOlution Volume 4, Issue 1 12

EDITORIAL

Fig. 2: Overview of the framework components

Genetic Algorithms in Pyevolve

The genetic algorithm core implemented in Pyevolve is based on the al-

gorithm described in [1].

Chromosome Representations

The framework includes the classical representations used in genetic al-

gorithms (1D Binary String and 2D Binary String ) and several other

representations (1D List , 2D List, and Trees).

What defines the data type of the representation is the genetic algorithm

initialization function. Pyevolve provides ready-to-use built-in initializa-

tion routines for integer numbers, real numbers and for user-defined alle-

les. Besides the few representations available in the distribution, the flex-

ibility of Python allows the creation of new representations by extending

the existing ones.

Initialization

for 1D Binary String chromosomes: binary string initialization;

for 1D List chromosomes: integer initialization, real initialization,

user-defined allele initialization;

for 2D List chromosomes: integer initialization, real initialization,

user-defined allele initialization;

for Tree chromosomes: integer initialization, user-defined allele ini-

tialization;

Reproduction/Crossover Operators

for 1D Binary String chromosomes: single-point crossover, two-

point crossover, uniform crossover;

for 1D List chromosomes: single-point crossover, two-point

crossover, uniform crossover, order crossover;

for 2D List chromosomes: single vertical point crossover, single hor-

izontal point crossover, uniform crossover;

for Tree chromosomes: sub-tree crossover, strict sub-tree

crossover.

SIGEVOlution Volume 4, Issue 1 13

EDITORIAL

Mutation Operators

for 1D Binary String chromosomes: swap mutation, flip mutation;

for 1D List chromosomes: swap mutation, integer-range mutation,

real-range mutation, integer-Gaussian mutation, real-Gaussian mu-

tation, integer-binary mutation, user-defined allele mutation;

for 2D List chromosomes: swap mutation, integer-Gaussian muta-

tion, real-Gaussian mutation, user-defined allele mutation;

for Tree chromosomes: swap mutation, integer-range mutation,

real-range mutation, Gaussian-integer mutation, Gaussian-real mu-

tation.

Scaling methods

Pyevolve provides several scaling schemes: Linear Scaling, Sigma Trun-

cation Scaling, Power Law Scaling, Boltzmann Scaling, and Raw Scaling.

Selection methods

It also includes several selection methods: Rank Selection, Uniform Se-

lection, Tournament Selection, and Roulette Wheel Selection.

Interactive Mode

The interactive mode allows the user to pause evolution and interactively

work on the population. The user can collect statistics, analyze individu-

als or even modify individuals and then restart the evolutionary process.

When the user enters the interactive mode, the framework gives access

(i) to the evolutionary engine, (ii) to the population and (iii) to several

numerical/graphical analysis methods like for instance the population fit-

ness histograms (see Figure 3).

An example of how the Interactive Mode works is reported below (part of

the output was omitted for the sake of brevity):

# python pyevolve_ex7_rastrigin.py

Gen. 0 (0.00%): Max/Min/Avg Fitness(Raw) [(...)]

Gen. 20 (3.33%): Max/Min/Avg Fitness(Raw) [(...)]

Loading modules for Interactive Mode... done !

## Pyevolve v.0.6 - Interactive Mode ##

Press CTRL-Z to quit interactive mode.

>>> population[0].fitness

189.50864407423373

>>> population[0].mutator

Slot [Mutator] (Count: 1)

Name: G1DListMutatorRealGaussian - Weight: 0.50

Doc: The mutator of G1DList, Gaussian Mutator

Accepts the rangemin and rangemax genome params (...)

>>> ga_engine.getCurrentGeneration()

30

>>> population.getStatistics()

- Statistics

Minimum raw score = 155.42

Minimum fitness = 189.51

Total fitness = 26292.87

Standard deviation of raw scores = 36.42

(...)

Fig. 3: Histogram for population fitness, created using the Interactive

Mode

SIGEVOlution Volume 4, Issue 1 14

EDITORIAL

Database and Visualization Adapters

Pyevolve has several database and visualization adapters to save or load

statistics and data collected during the evolutionary process:

CSV file format adapter

SQLite3 database adapter

MySQL database adapter

HTTP Get/Post adapter

XML RPC adapter

VPython visualization adapter

The SQLite3 database format is also used by the plotting tool included

in Pyevolve. The user can get real-time statistics using HTTP Get/Post or

XML RPC adapters, or visualize the real-time statistics using the VPython

adapter (see Figure 4).

Fig. 4: The VPython real-time visualization adapter

Visualization

Pyevolve comes with a graphical plotting tool that can be used to visu-

alize several statistics collected during the evolutionary process. As an

example, Figure 5shows a plot for the propagation of most adapted in-

dividuals: the x-axis represents each individual in the population; the

y-axis reports the generation. Other examples of the available visualiza-

tions are shown in Figure 6and Figure 7.

Fig. 5: A heat plot for raw fitness using Gaussian interpolation

Fig. 6: Plot of the raw fitness during evolution

SIGEVOlution Volume 4, Issue 1 15

EDITORIAL

Fig. 7: Comparison of population fitness during different runs

Fig. 8: A max and min raw/scaled fitness difference over the generations

Coding Example

As an example, we report the code for a genetic algorithm solving the

minimization of the Rastrigin [6] function f(x) with 20 variables,

f( x) = 10 n+

20

∑

i=1

x2

i−10 cos(2πx i )(1)

where n is the number of variables and -5.12 ≤ xi ≤ 5.12.

import math

from pyevolve import *

def rastrigin(genome):

fitness = 0.0

for gene in genome:

fitness += gene** 2 - 10* math.cos(2* math.pi*gene)

return (10* len (genome)) +fitness

genome =G1DList.G1DList(20)

genome.setParams(rangemin=-5.12 , rangemax=5.13)

genome.initializator.set(

Initializators.G1DListInitializatorReal)

genome.mutator.set(Mutators.G1DListMutatorRealGaussian)

genome. evaluator += rastrigin

ga =GSimpleGA.GSimpleGA(genome)

ga.setMinimax(Consts.minimaxType["minimize"])

ga.setGenerations(800)

ga.setMutationRate(0.06)

ga.evolve(freq_stats=40)

print ga.bestIndividual()

.NET and Java Interoperability

Pyevolve is compatible with Jython3and with IronPython4interpreters.

Jython is a Python interpreter written in Java, which means that all the

applications running in Jython can be executed on any Java platform. Ac-

cordingly, users can extend and use Pyevolve on any Java platform.

3Tested with the Jython 2.5b1

4Tested with the IronPython 2.0.1

SIGEVOlution Volume 4, Issue 1 16

EDITORIAL

IronPython is a Python interpreter for the .NET platform that allows the in-

teroperability between Pyevolve and .NET when the framework is run on

IronPython. Note that there are some performance issues when exploit-

ing interoperability and that there are also compatibility issues related to

some Python modules that are missing from Jython and IronPython (e.g.,

SQLite3 used in Pyevolve to store and plot statistical data). However, the

core evolutionary engine of Pyevolve runs properly on both Jython and

IronPython.

What Does "multi" in Multi-platform Stand For?

Pyevolve is written in pure Python and it can run on any platform sup-

porting the Python 2.5 core. Thus, we can run it on the usual operating

systems (Linux, Windows and Mac OS X), but also on the many portable

devices which support the Python 2.5 core (e.g., the Sony PlayStation

Portable (PSP) and the Symbian OS based cellphones).

Pyevolve on Sony PSP

The PlayStation Portable (PSP) is a handheld game console manufactured

and marketed by Sony Computer Entertainment. The PSP has a 333MHz

clock, 32MB RAM, and a GPU with 2 MB onboard VRAM running at 166

MHz. Using the Stackless Python port for PSP5and the basic drawing

API, the Traveling Salesman Problem (TSP) was ported to the PSP (see

Figure 9); it took 42 seconds to find an optimal solution for a problem

with 20 cities, using a population of 200 individuals using order crossover

with a 100% probability and swap mutation with a 10% probability.

Pyevolve on Nokia N73

The Nokia N73 cellphone uses a Dual ARM 9 220 MHz CPU and has Sym-

bian OS 9.1, S60 3rd edition. Nokia has developed the PyS606, which is

the open-source Python language port to the Symbian S60 smartphone

platforms. PyS60 has recently included the Python 2.5.4 core, so we

can run Pyevolve using PyS60 as it is — no change in the framework

is needed.

5http://code.google.com/p/pspstacklesspython/

6Python for S60, available at http://wiki.opensource.nokia.com/projects/PyS60

Fig. 9: Traveling Salesman Problem running on the Sony PlayStation

Portable

The framework was tested on the Nokia N73 cellphone. The TSP was

implemented for PyS60 using Pyevolve in the same manner as on the

Sony PSP, but using the Canvas API of PyS60 (see Figure 10); it took 129

seconds to find an optimal solution for a problem with 20 cities, using a

population of 200 individuals with a crossover rate of 100% and a muta-

tion rate of 10%. The order crossover and the Swap mutation operation

were used in this example.

Genetic Programming

Pyevolve tries to make Genetic Programming as simple and intuitive as

possible, resulting in a good learning curve for people approaching this

paradigm for the first time. For this purpose, Pyevolve uses simple solu-

tions to reduce the programming burden:

Function set definition: Pyevolve does not require the creation of

full classes for defining very simple functions. Each function needs

just one line of code and it's very intuitive (as shown in the later

example);

SIGEVOlution Volume 4, Issue 1 17

EDITORIAL

Fig. 10: Traveling Salesman Problem running on the Nokia N73

Automatic function set detection: the framework automatically

detects the function set just by defining the function name prefix;

Automatic function arguments detection: the framework auto-

matically detects the number of arguments of the functions;

Compilation of the tree into bytecode: instead of simulating the

execution of the program tree for each fitness evaluation, Pyevolve

compiles individuals into Python bytecode and runs it;

Using the dynamic typing of Python, users can specify highly flexible GP

functions; for example, it is possible to write a function "mul(*)", to mul-

tiply variables of different types, e.g., to multiply a list with an integer or

an integer with another integer using the same function.

As an example, we report below a simple example for the symbolic re-

gression of

f(a,b ) = p a2 + b2

import math

from pyevolve import *

error_accum =Util.ErrorAccumulator()

def gp_add(a, b): return a+b

def gp_sub(a, b): return a-b

def gp_mul(a, b): return a* b

def gp_sqrt(a): return math.sqrt(abs(a))

def eval_func(chromosome):

global error_accum

error_accum.reset()

code_comp =chromosome.getCompiledCode()

for a in xrange(0 , 5):

for b in xrange(0 , 5):

evaluated = eval(code_comp)

target =math. sqrt((a*a)+(b*b))

error_accum += (target, evaluated)

return error_accum.getRMSE()

if __name__ == "__main__" :

genome =GTree.GTreeGP()

genome.setParams(max_depth=4 , method="ramped" )

genome. evaluator += eval_func

ga =GSimpleGA.GSimpleGA(genome)

ga. setParams(gp_terminals =['a' , 'b'],

gp_function_prefix = "gp")

ga.setMinimax(Consts.minimaxType["minimize"])

ga.setPopulationSize(500)

ga.evolve(freq_stats=10)

print ga.bestIndividual()

SIGEVOlution Volume 4, Issue 1 18

EDITORIAL

Fig. 11: The best individual of the population.

Visualization of Trees

With a simple function call, it is possible to visualize the individuals in the

population:

best =ga.bestIndividual()

best.writeDotImage("best_individual.jpg")

This code takes the best individual of the population and creates the vi-

sualization in the Figure 11. The user can also visualize more individuals

on the same image (see Figure 12).

Using Python decorators on the functions of the function set, the user can

change the graphical representation of the function. Here is an example:

@GTree.gpdec(representation="+", color ="red")

def gp_add(a, b): return a+b

In the example, the node text of the function "gp_add" is changed to "+"

and the color of the node is set to red. The output of this change is shown

in Figure 13.

Current Development

The current developmental version of Pyevolve implements additional

choromosome types, genetic operators, and selection methods. It also

supports easy-to-use distributed evolution over LAN/WAN. Finally, some

work has also been undertaken to improve the performance of the ge-

netic operators of the GA and GP.

Acknowlegments

I wish to thank some of the open-source projects that have made Pye-

volve possible: Matplotlib7 (used in the graphical plots), VPython8(used

in the real-time visualization adapter) and Pydot9(used in the creation of

Dot graph files for GP trees).

Bibliography

[1] David E. Goldberg. Genetic Algorithms in Search, Optimization, and

Machine Learning. Addison-Wesley Professional, January 1989.

[2] Python Software Foundation. Python success stories; also available

in http://www.python.org/about/success/, 2009.

[3] John R. Koza. Genetic Programming: On the Programming of Com-

puters by Means of Natural Selection. Cambridge, MA: The MIT Press,

1992.

[4] William B. Langdon Riccardo Poli and Nicholas Freitag McPhee. A

field guide to genetic programming. Published via lulu.com and

freely available at www.gp-field-guide.org.uk, with contributions by

J. R. Koza, 2008.

[5] Daniel G. Shafer. Python streamlines space shuttle mission design;

also available in http://www.python.org/about/success/usa/, 2003.

[6] D. Whitley, K. Mathias, S. Rana, and J. Dzubera. Building better test

functions. In Proceedings of the Sixth International Conference on

Genetic Algorithms, pages 239–246. Morgan Kaufmann, 1995.

7http://matplotlib.sourceforge.net/

8http://vpython.org/

9http://code.google.com/p/pydot/

SIGEVOlution Volume 4, Issue 1 19

EDITORIAL

Fig. 12: The best ten individuals in the population.

Fig. 13: Changing the node color and text.

About the author

Christian S. Perone (christian.perone@gmail.com)

was born in Sarandi/RS (Brazil) in 1984 and currently

lives in Porto Alegre/RS. He received his B.S. in Com-

puter Science from University of Passo Fundo in Passo

Fundo/RS and works for Compasso in Porto Alegre/RS.

SIGEVOlution Volume 4, Issue 1 20

... Pyevolve is another pure Python library for building the genetic algorithm [5]. Even that it is published in 2009, it is less popular than DEAP and this is based on the total number of installations (50K for all the time), GitHub stars (301), and citations. ...

  • Ahmed Fawzy Gad Ahmed Fawzy Gad

This paper introduces PyGAD, an open-source easy-to-use Python library for building the genetic algorithm. PyGAD supports a wide range of parameters to give the user control over everything in its life cycle. This includes, but is not limited to, population, gene value range, gene data type, parent selection, crossover, and mutation. PyGAD is designed as a general-purpose optimization library that allows the user to customize the fitness function. Its usage consists of 3 main steps: build the fitness function, create an instance of the pygad.GA class, and calling the pygad.GA.run() method. The library supports training deep learning models created either with PyGAD itself or with frameworks like Keras and PyTorch. Given its stable state, PyGAD is also in active development to respond to the user's requested features and enhancement received on GitHub https://github.com/ahmedfgad/GeneticAlgorithmPython. PyGAD comes with documentation https://pygad.readthedocs.io for further details and examples.

... The GA module implemented in the ENIIGMA fitting tool is build on Pyevolve 4 (Perone 2009), an open-source and extensible library dedicated to perform evolutionary computation in Python programming language. The GA computation is composed of three main characteristics, namely, generation of random population of probable solutions, fitness-oriented to evaluate the population, and variation-driven to improve the next population (Holland 1975;Koza 1992). ...

Context. A variety of laboratory ice spectra simulating different chemical environments, ice morphology as well as thermal and energetic processing are demanded to provide an accurate interpretation of the infrared spectra of protostars. To answer which combination of laboratory data best fit the observations, an automated statistically-based computational approach becomes necessary. Aims. To introduce a new approach, based on evolutionary algorithms, to search for molecules in ice mantles via spectral decomposition of infrared observational data with laboratory ice spectra. Methods. A publicly available and open-source fitting tool, called ENIIGMA (dEcompositioN of Infrared Ice features using Genetic Modelling Algorithms), is introduced. The tool has dedicated Python functions to carry out continuum determination of the protostellar spectra, silicate extraction, spectral decomposition and statistical analysis to calculate confidence intervals and quantify degeneracy. As an assessment of the code, several tests were conducted with known ice samples and constructed mixtures. A complete analysis of the Elias 29 spectrum was performed as well. Results. The ENIIGMA fitting tool can identify the correct ice samples and their fractions in all checks with known samples tested in this paper. Concerning the Elias 29 spectrum, the broad spectral range between 2.5-20 $\mu$m was successfully decomposed after continuum determination and silicate extraction. This analysis allowed the identification of different molecules in the ice mantle, including a tentative detection of CH$_3$CH$_2$OH. Conclusions. The ENIIGMA is a toolbox for spectroscopy analysis of infrared spectra that is well-timed with the launch of the James Webb Space Telescope. Additionally, it allows for exploring the different chemical environments and irradiation fields in order to correctly interpret astronomical observations.

... To this end, the MM torsional potential energy of C-C-N-N torsion were fitted to the QM-derived potential energy profile obtained from ar elaxed scan performed at the M062X/6-31G(d) level in the gas phase with Gaussian 09. [47] The python package pyevolve [48] was used to fit the two profiles (see the Supporting Information) The three 8c-Ab42 fibrils were solvated with TIP3P [49] water molecules by using at runcated octahedron box with al ayer of 20 and neutralized by adding Na + ions. [50] The systems were energy minimized in at hree-stage protocol, which involved hydrogen atoms, then water molecules, and finally the whole system, with a maximum number of 20 000 minimization cycles for the last stage. ...

Many (poly‐)phenolic natural products, for example, curcumin and taxifolin, have been studied for their activity against specific hallmarks of neurodegeneration, such as amyloid‐β 42 (Aβ42) aggregation and neuroinflammation. Due to their drawbacks, arising from poor pharmacokinetics, rapid metabolism, and even instability in aqueous medium, the biological activity of azobenzene compounds carrying a pharmacophoric catechol group, which have been designed as bioisoteres of curcumin has been examined. Molecular simulations reveal the ability of these compounds to form a hydrophobic cluster with Aβ42, which adopts different folds, affecting the propensity to populate fibril‐like conformations. Furthermore, the curcumin bioisosteres exceeded the parent compound in activity against Aβ42 aggregation inhibition, glutamate‐induced intracellular oxidative stress in HT22 cells, and neuroinflammation in microglial BV‐2 cells. The most active compound prevented apoptosis of HT22 cells at a concentration of 2.5 μm (83 % cell survival), whereas curcumin only showed very low protection at 10 μm (21 % cell survival). Improving on nature: Synthetic bioisosteres of the natural product curcumin are designed, synthesized, and computationally evaluated by molecular dynamics and replica‐exchange molecular dynamics simulations for their interaction with amyloid‐β 42 aggregation. Biological evaluation shows that such compounds greatly exceed the anti‐neuroinflammatory and neuroprotective properties of their parent compounds.

... These parameters care mostly case specific and must be determined prior to the online robotic application. A straightforward approach for this would be the use of evolutionary algorithms within Python-based frameworks like DEAP [36], PyBrain [37] and PyEvolve [38]. ...

  • Julien Dupeyroux Julien Dupeyroux

The third generation of artificial intelligence (AI) introduced by neuromorphic computing is revolutionizing the way robots and autonomous systems can sense the world, process the information, and interact with their environment. The promises of high flexibility, energy efficiency, and robustness of neuromorphic systems is widely supported by software tools for simulating spiking neural networks, and hardware integration (neuromorphic processors). Yet, while efforts have been made on neuromorphic vision (event-based cameras), it is worth noting that most of the sensors available for robotics remain inherently incompatible with neuromorphic computing, where information is encoded into spikes. To facilitate the use of traditional sensors, we need to convert the output signals into streams of spikes, i.e., a series of events (+1, -1) along with their corresponding timestamps. In this paper, we propose a review of the coding algorithms from a robotics perspective and further supported by a benchmark to assess their performance. We also introduce a ROS (Robot Operating System) toolbox to encode and decode input signals coming from any type of sensor available on a robot. This initiative is meant to stimulate and facilitate robotic integration of neuromorphic AI, with the opportunity to adapt traditional off-the-shelf sensors to spiking neural nets within one of the most powerful robotic tools, ROS.

... The fitness function for each individual is its accuracy on the validation set. The implementation of GP is based on the Pyevolve library [37]. ...

Breast cancer is the second leading cause of cancer death in women worldwide. Nevertheless, there is evidence that early detection and treatment can increase the survival rate of breast cancer patients. This paper presents an intelligent decision support system (IDSS) for breast cancer diagnosis by using gene expression profiles. The proposed system first extracts significant features from the input patterns by using information gain and then employs deep genetic algorithm for feature reduction as well as for breast cancer diagnosis. The proposed system is evaluated by considering a benchmark microarray dataset and compared with the most recent systems. The results show that the proposed IDSS outperforms other systems in terms of diagnosis time and accuracy. The proposed system produces 100 % classification accuracy. In addition, the proposed system reduces the required memory space.

  • Zak E Hughes Zak E Hughes
  • Michelle A. Nguyen
  • Jialei Wang
  • Tiffany R. Walsh

Peptide sequence engineering can potentially deliver materials-selective binding capabilities, which would be highly attractive in numerous biotic and abiotic nanomaterials applications. However, the number of known materials-selective peptide sequences is small, and identification of new sequences is laborious and haphazard. Previous attempts have sought to use machine learning and other informatics approaches that rely on existing data sets to accelerate the discovery of materials-selective peptides, but too few materials-selective sequences are known to enable reliable prediction. Moreover, this knowledge base is expensive to expand. Here, we combine a comprehensive and integrated experimental and modeling effort and introduce a Bayesian Effective Search for Optimal Sequences (BESOS) approach to address this challenge. Through this combined approach, we significantly expand the data set of Au-selective peptide sequences and identify an additional Ag-selective peptide sequence. Analysis of the binding motifs for the Ag-binders offers a roadmap for future prediction with machine learning, which should guide identification of further Ag-selective sequences. These discoveries will enable wider and more versatile integration of Ag nanoparticles in biological platforms.

Context. A variety of laboratory ice spectra simulating different chemical environments, ice morphologies, and thermal and energetic processing are needed in order to provide an accurate interpretation of the infrared spectra of protostars. To decipher the combination of laboratory data that best fits the observations, an automated, statistics-based computational approach is necessary. Aims. We aim to introduce a new approach, based on evolutionary algorithms, to searching for molecules in ice mantles via spectral decomposition of infrared observational data with laboratory ice spectra. Methods. We introduce a publicly available and open-source fitting tool called ENIIGMA (dEcompositioN of Infrared Ice features using Genetic Modelling Algorithms). The tool has dedicated Python functions to carry out continuum determination of the protostellar spectra, silicate extraction, spectral decomposition, and statistical analysis to calculate confidence intervals and quantify degeneracy. We conducted fully blind and non-blind tests with known ice samples and constructed mixtures in order to asses the code. Additionally, we performed a complete analysis of the Elias 29 spectrum and compared our findings with previous results from the literature. Results. The ENIIGMA fitting tool can identify the correct ice samples and their fractions in all checks with known samples tested in this paper. In the cases where Gaussian noise was added to the experimental data, more robust genetic operators and more iterations became necessary. Concerning the Elias 29 spectrum, the broad spectral range between 2.5 and 20 μm was successfully decomposed after continuum determination and silicate extraction. This analysis allowed the identification of different molecules in the ice mantle, including a tentative detection of CH 3 CH 2 OH. Conclusions. The ENIIGMA is a toolbox for spectroscopy analysis of infrared spectra that is well-timed with the launch of the James Webb Space Telescope. Additionally, it allows different chemical environments and irradiation fields to be explored, allowing the user to correctly interpret astronomical observations.

Designing functional molecules and advanced materials requires complex design choices: tuning continuous process parameters such as temperatures or flow rates, while simultaneously selecting catalysts or solvents. To date, the development of data-driven experiment planning strategies for autonomous experimentation has largely focused on continuous process parameters, despite the urge to devise efficient strategies for the selection of categorical variables. Here, we introduce Gryffin, a general-purpose optimization framework for the autonomous selection of categorical variables driven by expert knowledge. Gryffin augments Bayesian optimization based on kernel density estimation with smooth approximations to categorical distributions. Leveraging domain knowledge in the form of physicochemical descriptors, Gryffin can significantly accelerate the search for promising molecules and materials. Gryffin can further highlight relevant correlations between the provided descriptors to inspire physical insights and foster scientific intuition. In addition to comprehensive benchmarks, we demonstrate the capabilities and performance of Gryffin on three examples in materials science and chemistry: (i) the discovery of non-fullerene acceptors for organic solar cells, (ii) the design of hybrid organic–inorganic perovskites for light-harvesting, and (iii) the identification of ligands and process parameters for Suzuki–Miyaura reactions. Our results suggest that Gryffin, in its simplest form, is competitive with state-of-the-art categorical optimization algorithms. However, when leveraging domain knowledge provided via descriptors, Gryffin outperforms other approaches while simultaneously refining this domain knowledge to promote scientific understanding.

  • Christian Hasse Christian Hasse
  • Paulo Debiagi
  • Xu Wen
  • Tiziano Faravelli

Coal is the most abundant fossil fuel and is widely used as an energy source for combustion and gasification. Both experimental methods and computational tools are required for the development of new advanced, innovative clean coal technologies and systems. In particular, 3D computational fluid dynamics (CFD) simulations can provide detailed local and global information on the interaction of fluid dynamics, mixing, and heterogeneous and homogeneous chemical reactions even for complex systems such as combustors, gasifiers, or chemical reactors. The predictive capabilities of CFD simulations depend directly on appropriate models and their mutual interactions. The current state of modeling is reviewed in this paper and the need for further improvements of both individual models and their respective coupling is addressed. In addition, to evaluate and validate the models and their interactions, systems with increasing complexity and well-defined boundary and operating conditions are required that can provide suitable experimental data. A number of reference burners and combustors, developed especially at universities and research institutions, are also presented and recent simulation data for these systems is reviewed.

  • Darrell Whitley Darrell Whitley
  • Keith E. Mathias
  • S. Rana
  • John Dzubera

We introduce basic guidelines for developing test suites for evolutionary algorithms and examine common test functions in terms of these guidelines. Two methods of designing test functions are introduced which address specific issues relevant to comparative studies of evolutionary algorithms. The first method produces representation invariant functions.

Python streamlines space shuttle mission design

  • G Daniel
  • Shafer

Daniel G. Shafer. Python streamlines space shuttle mission design; also available in http://www.python.org/about/success/usa/, 2003.

Published via lulu.com and freely available at www.gp-field-guide.org.uk, with contributions by

  • B William
  • Riccardo Langdon
  • Nicholas Freitag Poli
  • Mcphee

William B. Langdon Riccardo Poli and Nicholas Freitag McPhee. A field guide to genetic programming. Published via lulu.com and freely available at www.gp-field-guide.org.uk, with contributions by J. R. Koza, 2008.