Regularized Evolutionary Algorithm for Dynamic Neural Topology Search

TL;DR

This paper introduces a memory-efficient regularized evolutionary algorithm for neural architecture search, capable of evolving dynamic image classifiers with a small population, achieving competitive results on digit recognition datasets.

Contribution

A novel low-memory regularized evolutionary algorithm with custom operators for neural architecture search in image classification.

Findings

Achieves competitive accuracy on MNIST, USPS, SVHN datasets.

Uses a micro-population of only 10 individuals.

Demonstrates effectiveness of regularized evolution in neural architecture search.

Abstract

Designing neural networks for object recognition requires considerable architecture engineering. As a remedy, neuro-evolutionary network architecture search, which automatically searches for optimal network architectures using evolutionary algorithms, has recently become very popular. Although very effective, evolutionary algorithms rely heavily on having a large population of individuals (i.e., network architectures) and is therefore memory expensive. In this work, we propose a Regularized Evolutionary Algorithm with low memory footprint to evolve a dynamic image classifier. In details, we introduce novel custom operators that regularize the evolutionary process of a micro-population of 10 individuals. We conduct experiments on three different digits datasets (MNIST, USPS, SVHN) and show that our evolutionary method obtains competitive results with the current state-of-the-art.

Tables

Table 1. Figure 1: (a) The full outer architecture used during the search phase; (b) Example of an evolved cell’s internal structure and the depiction of a hidden node’s structure.

(a)	(b)

Table 2. Figure 2: Architecture of the best cells of EvoA found using MNIST: (a) Normal cell; (b) Reduction cell. The inputs “0” and “1” are the output states from the previous cells. The output “FINAL” is the concatenation operation resulting from the remaining hidden nodes inside the cell. The blocks in cyan represent a pairwise combination of operations and their concatenation. Note that the colour corresponds to Fig.  1 b.

(a)	(b)

Table 3. Table 1: Ablation study comparing the classification accuracy of our best evolved networks EvoA and EvoB with networks having fixed B 𝐵 B hidden nodes inside cells.

Model	EvoA	EvoB	Model-A	Model-B
Hidden States	Variable	Variable	3	4
Final Accuracy	99.59	99.55	99.47	99.49

Table 4. Table 2: Digits test set results for EvoA and EvoB when compared with baselines.

Model	MNIST		SVHN
	# Parameters	Accuracy (%)	# Parameters	Accuracy (%)
ResNet18 [5]	11.18M	99.56	11.18M	92.00
DeepSwarm [23]	0.34M	99.53	0.34M	93.15
EvoB (ours)	0.21M	99.55	0.37M	91.56
EvoA (Ours)	0.22M	99.59	0.39M	91.80

Table 5. Table 3: Classification accuracy on USPS with networks trained only on MNIST.

Model	ResNet18 [5]	DeepSwarm [23]	EvoB (Ours)	EvoA (Ours)
Accuracy (%)	89.08	61.56	96.72	96.40

Table 6. Figure 7: Architecture of the best cells of EvoB found using MNIST: (a) Normal cell; (b) Reduction cell. The inputs “0” and “1” are the output states from the previous cells. The output “FINAL” is the concatenation operation resulting from the remaining hidden nodes inside the cell. The blocks in cyan represent a pairwise combination of operations and their concatenation. Note that the colour corresponds to Fig.  1 b.

(a)	(b)

Equations

$$H_j^{off}=\{\begin{array}{ll}{H}_j^{P_1}& \text{if p≤τcross}\\ H_j^{P_2}& \text{otherwise}\end{array}$$

Full text

1 Introduction

Deep Learning has made a remarkable progress in a multitude of computer vision tasks, such as object recognition [1, 2], object detection [3], semantic segmentation [4], etc. The success of deep neural networks (DNNs) has been attributed to the ability to learn hierarchical features from massive amounts of data in an end-to-end fashion. Despite the breakthroughs of manually designed networks, such as Residual Networks [5] and Inception Net [6], these networks suffer from two major drawbacks: i) the skeleton of the architectures is not tailored for a dataset at hand; and ii) it requires expert knowledge to design high-performance architectures. To circumvent the cumbersome network architecture design process, there has been lately an increased interest in automatic design through Neural Architecture Search [7] (NAS). The objective of NAS is to find an optimal network architecture for a given task in a data-driven way. In spite of being in its nascent stages, NAS has consistently outperformed hand-engineered network architectures on some common tasks such as object recognition [8], object detection [8] and semantic segmentation [9].

Among NAS methods, neuro-evolutionary algorithms [21, 24, 13, 14] have recently resurfaced that use bio-inspired evolutionary principles for finding optimized neural architectures. A promising work in this direction was conducted by Real et al. [13], who proposed an aging-based evolutionary algorithm and demonstrated that favouring younger individuals (i.e., network architectures) against the best individuals in a population is beneficial in terms of convergence to better network architectures.

The performance of neuro-evolutionary methods is, however, heavily dependent on the population size (i.e, the number of individuals in the current population) and as a result on the availability of computational resources. For instance, Real et al. [13] used a population of 100 individuals evaluated in parallel on 450 GPUs. In this work, we propose an improved evolutionary algorithm, named Regularized Evolutionary Algorithm, to accomplish NAS in limited computational settings. Specifically, our method is based on the regularized algorithm by Real et al. [13] with various modifications that can be summarized as follows: i) an evolving cell with a variable number of hidden nodes where each node (see Fig. 1b) can be thought of as a pairwise combination of common operations (such as convolution, pooling, etc); ii) a custom crossover operation that allows recombination between two parent individuals in a population, to accelerate the evolutionary search; iii) a custom mutation mechanism, to generate new architectures by randomly modifying their hidden states, operations and number of hidden nodes inside a cell; and iv) a stagnation avoidance mechanism to avoid premature convergence. More details on the algorithm can be found in the Supplementary Material available at https://arxiv.org/abs/1905.06252. Noticeable is the implicit regularization performed by the stagnation avoidance and the mutation of $B$, as shown in details in Sec. 3.2.

As we show in our experiments conducted on three different digits datasets, the proposed modifications improve on the exploratory capability of the evolutionary algorithm when very limited memory and computational resources are at disposal during training. In our experiments, we used a micro-population of 10 individuals evaluated on a single GPU, obtaining competitive results when compared with much larger computational setups such as those used in [13].

2 Background

The recent successes of NAS algorithms [11, 12, 17, 10, 16, 8, 13, 14] have opened new doors in the field of Deep Learning by outperforming traditional DNNs [1, 5] that are manually designed. Mostly, the NAS algorithms differ in the way they explore the search space of the neural architectures. The search strategy can be broadly divided into three different categories. The first category of methods [11, 12] use Bayesian optimization techniques to search for optimal network architectures and have led to some early successes before reinforcement learning (RL) based methods [17, 10, 8] became mainstream, which is the second predominant category. In RL based methods the agent’s action can be considered as the generation of a neural architecture within a given search space, whereas the agent’s reward is the performance of the trained architecture on the validation set. Zoph et al. [10] used a recurrent neural network to sample a set of operations for the network architecture. In another work, the best performing network, dubbed as NASNet [8], is searched by using Proximal Policy Optimization.

The final category of NAS algorithms leverage evolutionary algorithms for finding the optimal network architectures. Surprisingly, the first work on using genetic algorithm for searching network architectures [18] dates back several decades ago. Since then, there have been several works [19, 20] which use evolutionary algorithm both to search network architectures and to optimize the weights of the proposed networks. However, in practice Stochastic Gradient Descent (SGD) based optimization of network weights works better than evolution based optimization. Therefore, a series of methods [21, 13, 14] have been proposed which restrict the usage of evolutionary algorithm just to guide architecture search, while using SGD for network weight optimization. The evolution based NAS methods differ in the way the sampling of parents are done, the update policy of the population, and how the offspring are generated. For instance, in [13] parents are selected according to a tournament selection [15], while in [22] this is accomplished through a multi-objective Pareto selection. The variations in the population update can be noticed in [21] and [13] where the former removes the worst individual and the latter removes the oldest individual from a population, respectively. Similar to [21], but differently from [13], in this work we propose a $\mu+\lambda$ methodology to remove the worst individuals from the population, where $\mu$ and $\lambda$ is the population size and number of offspring, respectively. With our approach, the best individual is preserved in the population (elitism). Furthermore, as opposed to [21, 13] who only considered mutation as the sole offspring generation process, here we additionally consider a crossover operator whose purpose is to accelerate the evolutionary process by recombining “building blocks” obtained by the parents undergoing crossover.

Finally, the choice of population size plays a very crucial role in the exploration of the search space of network architectures. For instance, the availability of mammoth computing power (450 GPUs) allowed [13] to use a population size $P=100$, as opposed to our experiments which use a micro-population of size $P=10$. Thus, we compensate the lack of computational resources with various modifications to the evolution process, so to allow an efficient exploration of the search space with a very limited computational budget.

3 Method

In this section we present our method by first introducing the search space, and then describing in detail the proposed Regularized Evolutionary Algorithm.

3.1 Search space

We consider the NASNet search space, introduced in [8], comprised of image classifiers that have a fixed structure (see Fig. 1a), each one composed of repeated motifs called cells, similar to Inception-like modules in [6]. Each architecture is composed of two building-block cells called normal cell and reduction cell. By design, all the normal and reduction cells should have the same architecture, but the internal structure of a normal cell could vary from the reduction cell (see Sec. 4.3). Another fundamental difference between the two is that the reduction cell is followed by an average pooling operation with a $2\times 2$ kernel and stride of 2, whereas the normal cells preserve the size.

As seen from Fig. 1b and borrowing the taxonomy from [8], each cell is composed of two input states (designated as “0” and “1”), an output state (designated as “final”) and a variable number of $B$ hidden nodes. Excluding the input and output states, each intermediate hidden node is constructed by a pairwise combination of two independent operations (or op) on two inputs, followed by the concatenation of their corresponding outputs. We refer to each hidden node’s output as hidden states.

In total, each cell has a maximum of $B+3$ states. Ops consist of commonly used convnet operations, essentially only a subset of [8], defined as: identity layer; $3\times 3$ convolution; $5\times 5$ convolution; $7\times 7$ convolution; $3\times 3$ max pooling; $3\times 3$ average pooling. For example, in Fig. 1b, the zoomed-in hidden node is constructed by two unique 3 $\times$ 3 convolution operations on the input state “1”, followed by concatenation of resulting feature maps to yield another hidden state. It is worth noting that in [13, 8] $B$ is fixed for both the normal and reduction cell, while in our method we treat $B$ as a parameter which is also optimized during the evolution, thus allowing different $B$ (where $B\in[B_{min},B_{max}]$) for normal and reduction cells. In details, the input state is composed of a $1\times 1$ convolutional layer with stride 1, to preserve the number of input channels, while the output state is composed of a concatenation of the activations coming from the previous unused hidden states. The inputs to each intermediate hidden node can come from any of the previous states, including duplicates, while the output from a hidden node can be connected to any of the following states. Finally, the hidden states that are not connected with any (unused) op are concatenated in the output hidden state.

Given a normal and a reduction cell, the architecture is built by alternating these motifs as in [13], with the major difference that we avoid the use of skip-connections and thus reduce the number of repetitions, in order to obtain a simpler and faster training procedure. As in [13], we keep the same number of feature maps inside each cell fixed, while this number is multiplied by a factor $K$ after each reduction cell. A sample overall architecture structure is reported in Fig. 1a. The final goal of the NAS process is to find optimal architectures for normal and reduction cells. Once their architectures have been chosen by the algorithm, there are two hyper-parameters that need to be determined: the number of normal cells ($N$) and the number of output features or filters ($D$).

3.2 Regularized Evolutionary Algorithm

The proposed Regularized Evolutionary Algorithm, see Algorithm 1, is based on a micro-population of $P$ = 10 individuals (i.e., network architectures). Each individual represents a solution in the NASNet space, which as said is further composed of normal and reduction cells. During evolution the population is evolved in order to maximize the classification accuracy on a hold out validation set. In the following, we describe in details each step of the proposed algorithm.

Population initialization. In this initial step $P$ individuals with random cells are initialized and evaluated. Since we use a small value of $P$, the population is strongly affected by badly initialized solutions. To solve this problem we initialize all individuals with $B$ hidden nodes (with $B$ randomly selected in the range [$B_{min}$, $B_{max}/2$]), in order to allow the algorithm to optimize and gradually increase $B$ during the evolution.

Offspring generation. At each generation $F$ offspring (i.e., new network architectures) are generated and inserted into the population. More specifically, for each i-th offspring to generate, 1 $\leq$ $i\leq F$, a sample of $S$ individuals is selected randomly from the population $P$. From these $S$ individuals, two are selected as parents for the i-th offspring: the best individual in the sample, $P_{1}$ (this is equivalent to a tournament selection), and another individual $P_{2}$, which is instead randomly selected from the sample. $P_{1}$ and $P_{2}$ are then used to generate the offspring through crossover and mutation.

Crossover. The crossover operation aims at merging two parent individuals, thus enabling inheritance through generations. Let us assume that $P_{1}$ and $P_{2}$ have $B_{1}$ and $B_{2}$ hidden nodes, respectively. The offspring cell, derived from $P_{1}$ and $P_{2}$, will have $B_{temp}=max(B_{1},B_{2})$ intermediate hidden nodes. The hidden nodes of the parent cells are then merged through sequential random selection with probability $\tau_{cross}$, as follows. For the sake of generality we assume $B_{1}\neq B_{2}$. The first $min(B_{1},B_{2})$ intermediate hidden nodes $H^{off}_{j}$ in the offspring network, 1 $\leq$ $j\leq min(B_{1},B_{2})$, are set as:

[TABLE]

where $p$ is a uniform random number drawn in $[0,1)$ and $\tau_{cross}$ is the crossover probability threshold. This threshold plays an important role in the exploration/exploitation balance in the algorithm, allowing to inherit the hidden nodes either from $P_{1}$ if $p$ $\leq\tau_{cross}$ (more exploitation), or from $P_{2}$ if $p>\tau_{cross}$ (more exploration). In our experiments, we set $\tau_{cross}=0.6$ to have a higher probability of inheriting the hidden nodes from the best individual in the sample ($P_{1}$), rather than from a random individual $P_{2}$. The remaining intermediate hidden nodes $H^{off}_{j}$, $min(B_{1},B_{2})<j\leq B_{temp}$, are then derived directly from the corresponding j-th node in the parent which has higher $B$. The edges of each hidden node in the offspring are inherited from the parent without modifications.

Mutation. The mutation operation is a key ingredient in the evolution process, as it allows the search to explore new areas of the search space but also refine the search around the current solutions. Apart from the op mutation and hidden state mutation introduced in [13], here we additionally introduce a specific mutation for tuning the number of hidden nodes $B$. The first step is the op mutation which requires a random choice to be made in order to select either the normal cell or the reduction cell $C$. Once selected, the mutation operation will select one of the $B$ pairwise combinations (or hidden nodes) at random. From the chosen pairwise combination, one of the two ops is replaced, with a probability $\tau_{m-op}$, by another op allowed in the search space. Following op mutation, hidden state mutation is performed which, akin to op mutation, also oversees random choice of cells, one of the $B$ pairwise combinations and one of the two elements in a combination. However, hidden state mutation differs from op mutation in that it replaces (with probability $\tau_{m-edge}$) the incoming hidden state or cell input, which corresponds to the chosen element, with another one that is inside $C$, instead of the op itself. It is important to notice that the new input is chosen from the previous hidden nodes or cell inputs to ensure the feed-forward nature of a cell. Finally, to encourage further exploration a third mutation allows to increment the parameter $B$ of $C$ by 1, with probability $\tau_{b}$, such that a new node with index $B+1$ is introduced with random weights, if $B<B_{max}$. It is to be noted that all unused states are concatenated at the end of the cell. Finally, the offspring individual is evaluated and added to the population.

Survivor selection. The survivor selection is conducted at the end of each generation. It is crucial since it permits the removal of the worst solutions from the population and facilitates the convergence of the evolutionary search. In this phase, the selection and removal of the worst individuals is conducted according to a $\mu+\lambda$ selection scheme, where based on the symbols we have used so far $\mu=P$ is the population size and $\lambda=F$ is the number of generated offspring. Therefore, at each step $F$ worst individuals are removed from the set of $P+F$ individuals, so that the parent population for the next generations has a fixed size of $P$ individuals. It should be noted that, compared to other survivor selection schemes, this scheme is implicitly elitist (i.e., it always preserves the best individuals found so far) and also allows inter-generational competition between parents and offspring.

Stagnation avoidance. To avoid premature convergence of the population to a local minimum we propose two stagnation avoidance mechanisms: soft and hard stagnation avoidance. When stagnation occurs (i.e., the best accuracy does not improve for more than $A_{stag}$ generations, as detected in the method StagnationDetected() in Algorithm 1), the mutation probabilities $\tau_{m-op}$ and $\tau_{m-edge}$ are increased to $\tau_{m-op-avoid}$ and $\tau_{m-edge-avoid}$, respectively, where $\tau_{m-op-avoid}$ and $\tau_{m-edge-avoid}$ denote increased mutation probabilities (such that $\tau_{m-op-avoid}>\tau_{m-op}$ and $\tau_{m-edge-avoid}>\tau_{m-edge}$). The choice to increase $\tau_{m-op}$ and $\tau_{m-edge}$ is due to the fact that higher mutation probabilities, in general, allow a higher exploration of the search space. On the other hand, $\tau_{b}$ is not increased because the addition of more hidden nodes (which would likely follow from a higher mutation probability) would increase the complexity of the cell and does not alleviate stagnation. Finally, the hard stagnation avoidance is a brute force remedy to stagnation. Specifically, if soft stagnation avoidance fails, $P-1$ worst solutions are replaced by $P-1$ individuals with random cells, while retaining the best solution found so far.

4 Experiments results

In this section we describe the datasets and report the experimental setup used in the evolutionary algorithm and network training. Finally, we report our experimental evaluation on the considered datasets.

4.1 Datasets

We conducted all our experiments on the well-known MNIST, USPS and SVHN datasets, all consisting of digits ranging from 0 to 9. MNIST and USPS are taken from U.S. Envelopes and consist of grayscale handwritten digits. The SVHN is a real-world dataset of coloured digits taken from Google Street View.

4.2 Experimental setup

As mentioned in Sec. 2, our proposed method belongs to the category of neuro-evolutionary methods where the optimal network is searched by an evolutionary algorithm while the weights of the networks are trained with gradient descent algorithm. Hence, we separately provide details about the chosen experimental setup for the evolutionary algorithm and the network architecture and training. For the experiments we used a Linux workstation equipped with a CPU Intel(R) Core(TM) i9-7940X and a TITAN Xp GPU. The lack of massive computation resource has led us to the following choice of parameters.

Evolutionary algorithm. The experiments were conducted with $P=10$, $F=10$, $B_{min}=2$, $B_{max}=6$ and ran for $G=200$ generations. A sample size $S=2$ has been used to have a low selection pressure. For the crossover operation, $\tau_{cross}=0.6$ was used to allow a higher probability of exploitation of the best solutions in the populations. Instead, in the mutation phase, the probabilities $\tau_{m-op}$, $\tau_{m-edge}$ and $\tau_{b}$ were set to 0.4, 0.4 and 0.2, respectively, to allow both a moderate exploration of the search space without significantly increasing the complexity of the cells. Finally, the stagnation check has been enabled after 50 generations and the evolution is considered to be stagnating if the same best result (in terms of accuracy) is provided for at least $A_{stag}=40$ generations. In that case, $\tau_{m-op-avoid}$ and $\tau_{m-edge-avoid}$ were both set to 0.6.

Network architecture. The network architectures which conform to the overall structure in Fig. 1a were trained during the experiments. Due to limited memory, the initial channels $D$ in the normal cell was set to 24 and then subsequently multiplied by a factor $K=2$ after each reduction cell, with a total of 3 normal cells and 2 reduction cells. During the search phase, each individual has been trained for 15 epochs with mini-batches of size 64 using an Adam optimizer having an initial learning rate of 1e-4 with exponential decay. Dropout layer with drop probability of 0.2 has been used in the final softmax classifier. To further reduce the computations, our cells take duplicated output states $H_{prev}$ from the previous cell instead of $H_{prev}$ and $H_{prev-1}$, thereby eliminating skip connections between cells unlike [8, 13]. At the end of the search phase, when the final best individual has been retrieved by the evolutionary algorithm, a training has been performed with that best individual for 100 epochs with the same previous parameters but with an initial learning rate of 1e-3. Batch normalization layers were also inserted after each convolutional layer. Standard cross-entropy loss was used for training the networks.

4.3 Results

Since the exploration in the NASNet search space is time consuming and also memory intensive, the best cells were searched only using the MNIST dataset due to its small size and reduced complexity. This has led to the evolution of a best normal cell and a best reduction cell, which collectively form the best network, dubbed as EvoA. The second best network is called EvoB.

To show the benefit of having variable $B$ hidden nodes in a cell, we considered the following baselines: i) EvoA, our best network with variable $B$; and ii) EvoB, our second best network also with variable $B$; iii) Model-A with $B=3$; and iv) Model-B with $B=4$. As seen from Tab. 1, EvoA, the network found by our proposed method, outperforms all baselines which consider fixed $B$. This highlights the advantage of keeping $B$ variable.

In Fig. 2 the architectures of EvoA’s internal cells, both normal and reduction, are presented. As it can be observed, normal cells in EvoA have $B$=5 hidden nodes whereas the reduction cell has $B$=6. While the input states “0” and “1” are duplicates of each other, unlike [8, 13], we still observed good performance without using skip connections.

We have compared our method with the following baselines: i) ResNet18 [5] and ii) DeepSwarm [23], a NAS algorithm based on Ant Colony Optimization. Due to the lack of availability of code from our closest competitor [13], we re-implemented their aging-based evolution but the solutions never converged due to the small size of our population, caused by limited memory and GPU availability. This resonates the fact that [13] is feasible only when large compute resources are available. As seen from Tab. 2, EvoA outperforms all baselines on MNIST, with the lowest number of tunable parameters. Importantly, for the SVHN experiments we used an augmented architecture (with $N=4$, $D=32$ and each normal cell repeated thrice), composed of already evolved cells obtained from the search phase with MNIST. The network, despite not being evolved with SVHN, produced competitive results (slighly worse than ResNet18 and DeepSwarm).

Transfer learning. We also investigated the transferability of the trained networks on unseen target data. In details, we trained EvoA and EvoB on MNIST and used the trained weights to classify USPS test images. As seen from Tab. 3, our EvoA and EvoB networks outperform all the baselines. Notably, while DeepSwarm outperforms both EvoA and EvoB on SVHN (as seen in Tab. 2), it performs significantly worse when used for transfer learning. On the other hand, our networks achieve near target test accuracy on unseen data.

5 Conclusions

In this work we have addressed Neural Architecture Search through a Regularized Evolutionary Algorithm. The proposed algorithm is especially useful when limited memory and limited computational resources are at disposal. Our main contributions can be summarized as follows: i) an evolving cell topology with variable number of hidden nodes; ii) ad hoc crossover and mutation operators for improved exploration; and iii) a novel stagnation avoidance for better convergence. We have conducted experiments on three different digits datasets and obtained competitive results. As a future work, we plan to scale our method to larger populations of individuals (parallelized on multiple GPUs) and test it on more complex datasets, also including videos.

Acknowledgments

We gratefully acknowledge the support of NVIDIA Corporation with the donation of the TITAN Xp GPU used for this research.

Supplementary Material

Supplement A

In this supplement, we further explain the novel operations introduced in Sec. 3.2 also including explanatory images.

Crossover

The crossover operator allows to exploit the existing solutions in the population. As previously said, we crossover two individuals by merging them at node level then inheriting the interconnections from the selected parents. Let us assume P1 and P2 are the best and randomly selected parents in Fig. 3. As it can be seen, the parent P1 has $B=3$ while P2 has $B=2$ so, since $max(3,2)=3$, the resulting child will have $B=3$. At this point, the firsts two nodes, since $min(3,2)=2$, are randomly selected between P1 and P2 with $\tau_{cross}$ while the last node is selected from P1. Finally, each node inherits the interconnections from the origin cell, see Fig. 3.

Operation mutation

The operation mutation consists in mutating a random operation in one of the child cells. Starting from the child cell in Fig. 4, that has been randomly selected between normal and reduction cells, firstly a random node is selected (in this case the bottom right node among all the child nodes). Secondly, a random operation is selected as a replacement. In the example, the average pooling op has been selected in the previously extracted node, see Fig. 4 highlighted in green. Finally, the operation is substituted with another randomly picked operation, in this case a $5\times 5$ convolution, from the allowed ops in the search space.

Hidden State mutation

The hidden state mutation is similar to the operation mutation. Here, instead of mutating an operation, we mutate a connection between nodes. For the sake of generality, let us assume that the child in Fig. 5 is the obtained child from the previous crossover and mutation steps. At this point, one node is randomly selected among the $B=3$ nodes of the child. Finally, one of the input connection of the selected node is moved to another previous node. In the example, the top node is first selected and finally the right input connection is moved from the right node to the input state cell 1.

B mutation

The mutation of B consists in appending a hidden node to the child cell thus moving the child from having $B$ to $B+1$ hidden nodes. Let us assume the child to be mutated is the one reported in Fig. 6 with an initial $B=2$. After the mutation of B, an additional hidden node has been appended, highlighted in green in the example, to the previous nodes with random connections. At this point, the mutated child has a final $B=3$.

Supplement B

In this supplement we provide the internal structures of EvoB, the second best architecture evolved as reported in Sec. 4.3. The cells reported in Fig. 7 have been obtained following the same procedure of EvoA.