φ-evo relies on an evolutionary algorithm acting on a population of networks, to explore the space of possible biochemical networks implementing a particular function of interest [14].

There are two levels in the algorithm: the individual level (white box on Fig 1C) where genotype, phenotype and evolutionary fitness of individuals are defined and computed, and the population level (green boxes on Fig 1C), where the evolutionary process is actually performed. All objects (biochemical interactions, networks, populations) are defined using customized Python classes, and explicit numerical calculations are compiled on the fly and performed in C for faster performance. A complete documentation for all Python classes enriched with examples is included and can be automatically (re)generated.

Individual networks in a population are represented as Python objects called Mutable_Network. This class encodes the topology of the network considered, the different parameters corresponding to biochemical species and their interactions, and all the methods that will be used at the individual level, including fitness computation and mutations of the network.

We evolve a population of networks as defined above using a classical evolutionary algorithm. By default, rounds of selection, expansion and mutation are performed as depicted in Fig 1A.

At each generation, we compute the fitness of each network, and impose a strict elitist selection [19] where the worst half of the population is discarded, and the best half is selected and duplicated. Mutation operators act on every individual in the duplicated half population. Mutation rates are predefined by the user, and by default are rescaled at each generation to maintain on average a fixed number of mutations per network per generation (typically one or two). This prevents uncontrolled mutations due to combinatorial explosion, and fits the phenomenological Drake’s rule (a scaling relation of mutation rates with genome size) observed in real evolution [20].

We also include a Pareto version of our algorithm as proposed in [21]. In summary, Pareto evolution aims at optimizing simultaneously several constraints to circumvent the problem of building an ad-hoc fitness combining those. To rank the networks prior to selection, one sequentially computes so-called Pareto-ranks. The networks of rank 0 are those which are not dominated by any other network on all constraints. Rank 1 networks are only dominated by rank 0 networks, and so on. We then perform elitist selection based on ranks of networks. A fitness sharing option is also available to promote diversity in the population [21].

Since all individual networks can be integrated independently, φ-evo can be easily parallelized, and by default multi-threading is used. We routinely run φ-evo on modern multi-core machines or small clusters, with population of a few dozens individuals, so that each generation takes at most a few seconds of computation for examples presented here. Running time of the algorithm almost directly scales with the size of the problem studied, and in particular is proportional to the network size and to the number of cells simulated in an embryo. Small networks with few nodes such as the ones displayed on Fig 2 can evolve in less than a couple hundreds of generations and thus a successful run can be obtained in less than half an hour on a modern laptop (not all evolutionary runs are successful, but results presented here are “typical” in the sense that runs are more often succesful than not). More complex simulations have been done for embryonic patterning and typically require several thousands of generations to converge and give bigger networks (e.g. 10 to 15 node-networks were routinely obtained in [9]); this requires running times of several hours to a day.

Evolutionary simulations in φ-evo are run via command line. C files corresponding to a specific evolutionary simulation (such as fitness, initial conditions, etc…) should be provided by the user. Evolutionary parameters (such as mutation rates, initial network) are encoded in a file called initialization.py. Those files should be put together in a common directory (called in the following Simulation) and an evolutionary simulation is started with

A known difficulty in evolutionary simulations is “code-bloat”, where combinatorial explosion and genetic drift can hinder the core structure of a working network. For this reason, we can also run new evolutionary simulations initialized with an evolved network of interest, while forbidding the addition of new nodes. This isolates the “core” working network, and allows for a better understanding of network dynamics.

We have developed two Jupyter -notebooks to make φ-evo more user-friendly. The ProjectCreator notebook allows to define all simulation parameters (e.g. mutation rates) in specific widgets, as well as to define initial topologies for evolution if needed (e.g. to bias evolution with a specific network architecture). The AnalyzeRun Notebook allows to visualize results of simulations in a web browser. This is illustrated in Fig 2 with two simulations reproducing results from [22] and [23]. Users can identify interesting evolved networks, check their topology, simulate them on the fly, and do simple changes such as node removals.

We first use φ-evo to recover the regulatory logic of the classical lac operon, discovered by Jacob and Monod [24]. The lac operon allows for regulation of the enzymes digesting lactose in E. Coli. It is activated when two conditions are realized: presence of lactose and absence of glucose. The lac Repressor (lacR) represses transcription of the operon while the CAP protein is responsible for its activation. When present, lactose is translocated by permease inside the cell and binds to lacR, which relieves the repression. In the absence of glucose, cAMP is produced in burst, then binds to CAP turning it into an activator. This regulatory mechanism is presented in Fig 3A.

φ-evo is available as a Python package hosted on github at the following link: https://github.com/phievo/phievo

The program documentation is hosted on readthedocs: http://phievo.readthedocs.io/en/latest/

A tutorial video is available here (clickable link) to illustrate how to run φ-evo on the example of vertebrate segmentation similar to [23]. We include two other tutorial videos illustrating how to use the ProjectCreator Notebook to initialize and bias an evolutionary simulation here (clickable link), and other features such as node removal here (clickable link).

The algorithm was first developed using Python 2 and the current version runs under Python 3. It can be installed locally using pip. It requires only a C compiler such as gcc as an extra dependency. The algorithm has been developed and optimized in a Unix/Linux environment and has been tested on both Mac OS X and Windows. More details on the implementation and on the examples are given in the Supplement.

Future directions will include automatic model reduction using Fitness Based Asymptotic Parameter reduction (ϕ ¯ [26]), implementation of practical problems such as data fitting, and of networks transitory forms similar to [27].