1 Introduction
Gradientbased optimization methods, such as SGD with momentum or Adam (Kingma and Ba, 2014)
, have become standard tools in the deep learning toolbox. While they are very effective for optimizing differentiable parameters, there is an interest in developing other efficient learning techniques that are complementary to gradientbased optimization. Evolution Strategies
(ES, Wierstra et al., 2014)is one such technique that has been used as an SGD alternative and has shown promising results on smallscale problems in reinforcement learning
(Igel, 2003; Salimans et al., 2017) and supervised learning (Mandischer, 2002; Lehman et al., 2018; Zhang et al., 2017; Varelas et al., 2018). ES is a blackbox method and does not require the parameters to be differentiable. As such, it can potentially be applied to a much larger family of models than standard SGD. Additionally, as ES only requires inference, it allows for training neural nets on inferenceonly hardware (although we do not make use of this property here). The goal of this paper is to explore how ES can be scaled up to larger and more complex models, from both an algorithmic and implementation perspective, and how it can be used in combination with SGD for training sparse neural networks.
We begin with investigating whether it is possible to train CIFAR10 classification ConvNets with ES (Section 3). This is a harder task than training MNIST classification MLPs (as in Zhang et al., 2017), and to address it with ES we develop a more efficient execution model which we call semiupdates. As a result, ES reaches competitive accuracy compared to SGD on CIFAR10, although this comes at the cost of significantly worse computational efficiency. In Section 4 we then turn our attention to more practical applications (texttospeech raw audio generation) and the use of ES alongside SGD for training large sparse models. Instead of relying on handcrafted methods for training such models by pruning weights (Narang et al., 2017; Zhu and Gupta, 2017), we employ ES to learn the weight sparsity masks (i.e. which weight should be used in the final sparse model), while SGD is responsible for learning the values of the weights, and is performed in parallel with ES. It turns out that unlike the ES for weights, the ES for sparsity patterns needs significantly fewer parameter samples which makes this approach computationally feasible. Beyond the scientific interest in the feasibility of such hybrid learning techniques, one practical advantage of this approach is that it enables joint training of weights together with their sparsity mask, thus avoiding the need to first train a dense model (which might be too large to fit into memory), and then prune it. The experiments on the stateoftheart sparse texttospeech model show that ES achieves comparable performance to SGD with pruning.
In summary, our contributions are threefold: (i) we propose a new execution model of ES which allows us to scale it up to more complex ConvNets on CIFAR10; (ii) we perform empirical analysis of the hyperparameter selection for the ES training; (iii) we show how ES can be used in combination with SGD for hybrid training of sparse models, where the nondifferentiable sparsity masks are learned by ES, and the differentiable weights by SGD.
Related work
Prior works on hybrid SGDES methods mostly use ES for network structure and SGD to train the differentiable parameters of each sampled architecture Yao (1999); Igel and Sendhoff (2009); Real et al. (2018). This severely limits the size of the models where this method is practical as for each architecture sample the network has to be retrained. Instead of metalearning of the model, our goal is to optimize the model’s nondifferentiable and differentiable parameters jointly. Recent works compare the relation between the SGD gradients and ES updates, either on synthetic landscapes Lehman et al. (2018) or MNIST models Zhang et al. (2017), while Maheswaranathan et al. (2018) uses SGD gradients to guide the sampler’s search direction. Instead of combining them, we use SGD and ES for two different training tasks  SGD for the continuous, differentiable parameters and ES for modelling the sparsity mask distribution.
Sparse models, where a subset of the model parameters are set to exactly zero, offer a faster execution and compact storage in sparsematrix formats. This typically reduces the model performance but allows deployment to resourceconstrained environments Kalchbrenner et al. (2018); Theis et al. (2018). Training unstructured sparse supervised models can be traced back at least to LeCun et al. (1990), which used second order information to prune weights. More tractable efforts can be traced at least to Ström (1997), which pruned weights based on the magnitude and then retrained. That was more recently extended in Han et al. (2016) where the pruning and retraining process was carried out in multiple rounds. The pruning process was further refined in Narang et al. (2017) where the pruning gradually occurred during the first pass of training so that it took no longer to find a pruned model than to train the original dense model. Finally, the number of hyperparameters involved in the procedure was reduced in Zhu and Gupta (2017) and Bellec et al. (2017) uses random walk for obtaining the sparsity mask. Additionally a number of Bayesian approaches have been proposed, such as Variational Dropout (VD) Molchanov et al. (2017) or L0 regularization Louizos et al. (2018). VD uses reparametrization trick, while we learn directly the multinomial distribution with ES. As indicated in Gale et al. (2019), VD and L0 regularization tends to perform not better than Narang et al. (2017) we compare against.
2 Preliminaries
2.1 Natural Evolution Strategies
Blackbox optimization methods are characterized by treating the objective function as a black box, and thus do not require it to be differentiable with respect to its parameters
. Broadly speaking, they fall into three categories: populationbased methods like genetic algorithms that maintain and adapt a set of parameters, distributionbased methods that maintain and adapt a distribution over the parameters
, and Bayesian optimization methods that model the function , using a Gaussian Process for example.Natural evolution strategies (NES, Wierstra et al., 2008, 2014)
are an instance of the second type. NES proceeds by sampling a batch of n parameter vectors
, evaluating the objective for each () and then updating the parameters of the distribution to maximize the objective , that is, the expectation of under . The attribute ‘natural’ refers to the fact that NES follows the natural gradient w.r.t. instead of the steepest (vanilla) gradient.In its most common instantiation, NES is used to optimize unconstrained continuous parameters
, and employs a Gaussian distribution
with mean and covariance matrix . For large , estimating, updating and sampling from the full covariance matrix is too expensive, so here we use its diagonal approximationwith elementwise variance terms
; this variant is called Separable NES (SNES, Schaul et al., 2011), and similar to (Ros and Hansen, 2008). The sampled parameters are constructed as . where is elementwise (Hadamard) product, from standard normal samples . The natural gradient with respect to is given by:and the updates are
(1) 
where and are learning rates of the distribution’s mean and variance parameters respectively, and is a transformation of the fitness (fitnessshaping, Section 2.2). Note that the multiplicative update on is guaranteed to preserve positive variances.
The more restricted case of constant variance (), where the natural gradient coincides with the vanilla gradient, was advocated by Salimans et al. (2017), and it is sometimes referred to as simply ‘Evolution Strategies’ (ES), even though it is subtly different from classic Evolution Strategies (Rechenberg, 1973): it matches the classic nonelitist ES only if the fitness shaping function is a top threshold function.
2.2 Fitness shaping functions
It is often desirable to make evolution strategies more robust and scaleinvariant by transforming the raw evaluation into a normalized utility ; this mapping is called fitness shaping (Hansen and Ostermeier, 2001; Wierstra et al., 2014). A common one is based on the rank of within the current batch, where is a hyperparameter:
(2) 
For , this method sets a constant utility to the lowest of the fitnesses, which we use in our experiments.
3 Scaling up SNES for supervised models
In this section we propose a novel method of distributing the evaluation of SNES updates. In Section 3.1 we present the semiupdates method, which allows for better distribution of random number generation, fitness evaluation, and update computation among multiple workers. This allows us to train large supervised models with millions of parameters without creating a bottleneck on the master that holds the distribution parameters. Further on, in Section 3.2 we investigate various hyperparameter selections for obtaining competitive results.
3.1 Speeding up SNES with semiupdates
In practice, SNES training of a model with parameters requires a large amount of weight samples per generation (generation size ) that grows with the dimension of its parameters . A standard execution model for SNES is to draw the parameter samples at the master process, which looks after distribution parameters , and to distribute them among worker processes. Even with smaller models, the main bottleneck is generating random values which are needed for computing the weighted sums (Section 2.1).
One possible improvement is to send only the initial distribution parameters and a random seed to the workers to let each worker generate parameter samples and exchange set of fitness scalars, similar to Salimans et al. (2017); we refer to this method as batched execution. This significantly reduces the amount of data communicated between the workers, however to perform an update, a worker which performs the ES update still needs to generate all random parameter samples, which is slow for large generations and models.
We propose to use semiupdates execution model. It is similar to the batched method as each worker obtains only the distribution parameters , however instead of sending back the fitness scalars for each sample, it computes the update on the batch of parameter samples according to Equations 2.1 and 1, and sends it back to the master. Even though the standard ES execution model performs fitness shaping based on the rank of all the parameter samples of a generation, doing it on only parameter samples within each worker has a surprisingly little effect on the final performance. The main advantage of this method is that each worker now has to generate only parameter samples while the master performs only a simple average over semiupdates. However, contrary to the batched method, the new distribution parameters has to be communicated to each worker.
3.2 Experiments
In this section we perform experiments with different variants of the SNES algorithm. In Section 3.3.1, we investigate the processing speed of different execution models defined in Section 3.1. Later on, in Section 3.4 we investigate what is needed for being able to learn ConvNet models for CIFAR10 classification with SNES. Finally, in Section 3.5, we investigate the dependence of accuracy on the generation size.
We use SNES for supervised classification models and the objective function is the minibatch loglikelihood^{1}^{1}1It is possible to use accuracy, however it underperforms due to quantization of the minibatch accuracy.. For all experiments we optimize all model parameters
with a single normal distribution. The distribution parameters are updated with learning rates
and (Wierstra et al., 2014, p. 33). The mean is initialized using the truncated normal initializer Glorot and Bengio (2010), and the variances are initialized to .We perform experiments on MNIST (LeCun et al., 1998) and CIFAR10 (Krizhevsky and Hinton, 2009) datasets using ConvNet models, which are described in Section 3.3
. Selected models differ mainly in the number of parameters, which is controlled by the number of hidden representations. For CIFAR10 models, we train on random
crops and flips from the training images. At test time, we process the full test images and averagepool the activations before the classification layer. To reduce the parameter count, we use the Separable Convolution (Chollet, 2016).3.3 Selected MNIST and CIFAR models
In table Table 1 we provide details of the investigated MNIST and CIFAR models. For the MNIST models, stands for convolution filters of size ,
for max pooling, and
for a fully connected layer with input features and output features. The MNIST30k model is identical to the model by Zhang et al. (2017).Each CIFAR10 model consists of a set of
separable or standard convolutions where the number of filters per layer is specified in the column ‘Layers’. Layers with stride 2 are denoted as
. The convolutional layers are followed by global average pooling and a fully connected layer with 10 outputs. The column ‘Sep’ specifies whether separable or dense convolutions are used.3.3.1 Semiupdates
In Fig. 1left we compare the speed of different execution modes introduced in Section 3.1. The median time per generation is computed on a MNIST500k model on 110 workers where each worker has up to 10 CPU cores available, thus for each generation size , the amount of computational resources is constant. As it can be seen, the semiupdates provide a significant speedup.
3.4 Training on CIFAR10 with SNES
We have found that using SNES for training models on CIFAR10 dataset requires a careful selection of hyperparameters. To achieve 99% test set accuracy on MNIST with SNES, it is typically sufficient to use a large number of parameter samples . But for CIFAR10, it turned out to be challenging to achieve performance comparable to SGD.
Due to the computational complexity, we perform most of the hyperparameter selection experiments on a relatively small model with approx. 300k parameters – CIF300k, and train it for 10k steps. It uses a parameterefficient architecture based on separable convolutions (Chollet, 2016). This model is bigger than MNIST30k, but smaller than MNIST3M. Each experiment is run on 50 Tesla P4 GPU workers and the average processing time is 20s per generation. For all the experiments, the results are computed over a generation size . Each generation is by default evaluated on a batch of 256 training images.
Batch normalization
Somewhat surprisingly, batch normalization (BN)
(Ioffe and Szegedy, 2015), is crucial for obtaining competitive results with SNES. BN is often seen as an architectural block to simplify training with SGD, but it turns out that it is even more important for SNES training, as shown in Fig. 1right. Similar effect has also been observed for RL ES models (Salimans et al., 2017; Mania et al., 2018).Fixed versus variable batch
For MNIST experiments, using a different batch of training examples in each sample of a generation provides better results than using the same fixed batch, as first noted in Zhang et al. (2017). However, this does not hold for the CIFAR10 experiments where we have consistently observed that it is important to evaluate each SNES sample within a generation on the same training batch, as shown in Fig. 1middle. We hypothesize that this could be due to the higher complexity of CIFAR10 classification task compared to MNIST, which leads to increased variance of the fitness values when using different batches.
With semiupdates, fitness is computed individually by each worker, so it is important to fix the training data only within each worker for each semiupdate. In fact, fixed batch per semiupdate, WFixB, obtains slightly better performance than FixB (Fig. 1middle) due to more training data per generation. It also allows for a simpler implementation as the training data does not have to be synchronized among the workers.
3.5 Convergence and generation size
Finally, we test the SNES performance versus the number of parameter samples per generation. In all experiments which we have performed with SNES, this has proven to be the most important parameter for improving performance, as observed in Zhang et al. (2017). For the MNIST models, we have run the training for 10k steps. Results are shown in Table 2left. For the MNIST30k model, it is possible to achieve a slightly better accuracy of at 10k steps vs in Zhang et al. (2017). For the MNIST3M we are able to achieve higher performance ( test set acc.) than Zhang et al. (2017) mainly due to larger number of training steps, which was facilitated by the more efficient semiupdates execution model.


In Table 2right, we show the accuracy obtained with SNES for the CIFAR10 models. The models use batch normalization, fixed minibatch of 256 training images per worker (WFixB). Similarly to the MNIST models, it is possible to reach performance comparable to SGD with a sufficient number of parameter samples.
Number of training samples per evaluation
Similarly to SGD Smith et al. (2017), SNES performance can be improved by evaluating fitness function on more training examples (batch size), as can be seen in Table 3. We hypothesize that this is due to reduced variance of the fitness values. However, in our experiments generation size tended to have a larger effect on the final performance.
Batch Size  128  256  512 
Val Acc  
Gen [s]  13.31  20.05  33.3 
3.6 Discussion
The empirical results show that with the right algorithmic and engineering changes, it is possible to scale up SNES and tackle tasks of higher complexity. We believe that with sufficient effort SNES can be scaled to even larger models than we have shown. Compared to standard SGD, SNES only needs to infer the model, which has a potential to enable training neural nets on inferenceonly or inferenceoptimized hardware.
4 Hybrid ES for sparse supervised models
We have shown that it is possible to use ES for learning differentiable parameters of large supervised models. However, a key advantage of blackbox optimization algorithms is that they are able to train models with nondifferentiable parameters. In this section we show that it is indeed possible to combine conventional SGD optimization with ES for learning weight sparsity masks of sparse neural networks. We use SGD to train the differentiable weights, and ES for learning the masks at the same time. This leads to CES, a hybrid ESSGD scheme which works as follows. At each training step, a generation of mask samples is drawn from the sparsity mask distribution. Each mask sample zeroes out a subset of model weights, and the resulting sparse weights are then evaluated to obtain the mask fitness, used to compute the mask update with ES. Simultaneously, each worker performs gradient descent w.r.t. its current nonzero weights, and the weight gradients are then averaged across all workers to perform a step of SGD with momentum. The algorithm is specified in Algorithm 1.
This method, similarly to DropConnect (Wan et al., 2013)
, randomly zeroes model parameters. However, we replace the constant uniform distribution with a distribution optimized by ES.
4.1 Sparsity mask distributions
Mask samples , are modelled with a multinomial distribution. To sample a mask, we draw repeatedly indices from a categorical distribution , where
controls the number of nonmasked weights. We model the distribution probabilities
with a softmax function where is temperature and is a vector of distribution parameters, learned with ES. For each sample , we set , i.e. we sample which model parameters are retained (not zeroed out), and the model is evaluated with .We approximate the derivatives of the multinomial distribution with derivatives of the ’s PMF :
(3) 
and an ES update from mask samples is approximated as:
(4) 
where is the utility of sample . We do not use natural gradients. The sparsity mask distribution parameters are updated with with learning rate .
An alternative way of modelling weight sparsity is using separate Bernoulli distribution for each differentiable parameter
(Williams, 1992). However, it does not allow for controlling the overall sparsity of the network, as the sparsity of each weight is learned independently from the others. Although it might be possible to control the sparsity of Bernoulliparameterized masks using a special form of regularization as in (Louizos et al., 2018), in this work we opted for modelling the sparsity masks with a multinomial distribution as described above, as it allows for a direct control over the sparsity. Details about sampling without replacement are in the following section.4.2 Sampling from multinomial distributions
A mask , sampled from a multinomial distribution, is an outcome of draws from a categorical distribution . We have observed that the implementation of the mask sampler is crucial. Not only it does affect the ability to scale to large models, but it also has a significant influence on the final performance.
The standard multinomial sampler, referred to as MSwR, implements sampling from categorical distribution with replacement. For this method, as the number of sampler invocations increases, fewer unique indices are sampled due to the increased number of collisions, i.e. .
Fixed sparsity can achieved with various methods. As a baseline which achieves , we sample additional unique nonzero indices, uniformly from the nonmasked ones. This method is referred to as MSwR+u. This method does not sample exactly from the original distribution but gives uniform mass to the remaining samples.
However, in our experiments sampling exactly indices without replacement tends to yield better results. Unfortunately, we have not found any computationally efficient GPU implementation of this, so instead we consider two different approximations. The first, MSwoRb, splits into batches. For each batch we sample indices using MSwR and remove them from the distribution. This method has the advantage that for , it converges to exact sampling without replacement, while for small it is more computationally efficient. However, unless , it does not guarantee .
In the other approximation, MStN, we sample indices from the categorical distribution (where is a sufficiently large number), accumulate the sampled indices in a histogram and use its top indices to form the mask. To break possible ties, we add small uniform noise to the histogram^{2}^{2}2Stable sort, used in many topN implementations, is by definition biased towards lower indices..
Fast sampler implementations
An efficient implementation of the random sampler for
is crucial for the execution speed. The current multinomial sampler in Tensorflow is based on Gumbelsoftmax sampling
(Maddison et al., 2017; Jang et al., 2017). The downsides are that it requires generating random values and the same amount of storage. When is in the order of millions and itself is a tenth of that size (for sparse models), the product is prohibitively large, both in terms of the computation cost and memory. A more efficient strategy is to use inverse CDF sampling. It computes the CDF of the distribution using a prefix sum Blelloch (1990); Harris et al. (2007) in time, then generates random numbers and performs a sorted binary search into the CDF in with storage requirements only . We employ CUB^{3}^{3}3https://nvlabs.github.io/cub/ to implement fast prefix sums, and use existing fast GPU RNG generators to implement a fast GPU binary search similar to the one in Thrust Bell and Hoberock (2012).4.3 Experimental results
In this section we evaluate CES for training sparse feedforward and recurrent models. First, we deploy the proposed method on feedforward CIFAR10 classification models CIF300k and CIF8M (see Section 3.3), and sparsify all layers apart from the last, fully connected layer. We then show that CES is also applicable to a different kind of models, and use it to train SparseWaveRNN Kalchbrenner et al. (2018), which is a stateoftheart recurrent texttospeech model.
4.3.1 Feedforward models
In this section we show results for the feedforward image classification models. First we investigate hyperparameter selection, and then we compare the results against the pruning baseline Narang et al. (2017) which progressively masks model parameters with magnitude close to zero. By default, in all the following experiments with CES training, the models are trained from the start with an initial sparsity . The ES learning rate is set to and softmax temperature is set to and . We use a single CES distribution for all weights. At test time, the mask is formed by the top indices from .
Sampling methods
In Table 4 we show results for different sampling methods introduced in Section 4.2. This experiment is performed on the CIF300k for ( sparsity), which is trained for 10k training steps. As can be seen, MSwR, which does not ensure constant sparsity, reaches the worst performance. With MSwR+u, where we sample additional indices from a uniform distribution, the final accuracy is considerably improved. The variants of MSwoRb increase the accuracy even further, and the best performing method is MStN. We believe this is due to the fact that this method amplifies higher probabilities, and keeps a constant number of nonzero weights while still sampling model parameters with lower mask probabilities from the distribution.
Test Acc  wR  wR+u  woRb, m=  tN, M=  
CIF300k 
In all experiments of the main text, we use MStN approximation with .
CES and generation size
Empirically, we have observed that the generation size has a surprisingly limited effect on CES training, as can be seen in Table 5. As ConvNets are often trained with DropOut Srivastava et al. (2014) or its close variant DropConnect Wan et al. (2013) as a form of regularization, they are known to be robust against randomly dropped weights or activations. We hypothesize that because of this robustness, finding a sparsity mask distribution for a current local optima of the differentiable weights, towards which the SGD converges, is a considerably simpler task. Conveniently, small allows us to make use of standard pipelines for multiGPU SGD training.
Test Acc  Generation Size  
2  5  10  50  100  200  
CIF300k  87.33  88.13  88.48  88.54  88.32  88.72 
Comparison to pruning
In this section we compare CES against a more conventional pruningbased method for training sparse models Narang et al. (2017). For CES, the update of the distribution is computed over 9 parameter samples per generation. We use a similar sparsity schedule for both algorithms: the models are trained for steps with the initial sparsity ( for pruning and for CES), and then the sparsity is decreased monotonically until it reaches the final sparsity at step 50k. Overall, training is performed for 80k steps, and we use SGD with momentum, weight decay, and the learning rate follows a schedule^{4}^{4}4 for 40k steps, then , and for the last 20k steps..
The results of the CES and pruning methods and the execution speed are summarized in Table 6left. Generally, CES provides competitive results to the pruning baseline. As CES allows us to train sparse models from the first training step, we test different initial sparsities in Table 6right, which shows that CES is remarkably stable across initial sparsities even for models trained with only dense weights from scratch. In this experiment we additionally compare against a model trained with a fixed mask distribution – “FixMask”– where we set the ES learning rate to zero. It shows that training of sparse overparameterised models, such as CIF8M is possible even with a fixed sparsity mask, however it fails for models with fewer parameters where learning the mask is important.
4.3.2 Recurrent models
In this section we show the results on a large sparse recurrent network, SparseWaveRNN Kalchbrenner et al. (2018) for texttospeech task. We trained it on a dataset of 44 hours of North American English speech recorded by a professional speaker. The generation is conditioned on conventional linguistic features and pitch information. All compared models synthesize raw audio at 24 kHz in 16bit format. The evaluation is carried out on a heldout test set. We perform experiments on two models – one with 448 (WR448) and another with 1792 hidden state variables (WR1792). As in Kalchbrenner et al. (2018), we do not sparsify the 1D convolutions at the network input, which has approximately parameters. In total, the WR448 has and WR1792 masked parameters.
For all experiments with the CES training, models are trained with an initial sparsity and generation size on 8 GPUs. The sparsity decreases after 40k steps and reaches the final sparsity after 251k steps. Model parameters are trained with ADAM optimizer and a constant learning rate . Otherwise, we use the same CES hyperparameters as in Section 4.3.1
. We use a separate mask distribution per each parameter tensor which offers slightly better execution speeds. As noted in
Kalchbrenner et al. (2018), in practical applications it might be beneficial to have the sparsity pattern in the form of contiguous blocks, so we train the models with different sparsity block widths (width corresponds to unconstrained sparsity pattern as in the experiments above). This is implemented by using the same sparsity mask value for several contiguous weights.The results are shown in Table 7. The computational overhead of CES is approximately equal to the generation size, however CES is easily parallelizable over multiple computational devices. With each mask sample being evaluated on a single GPU, the execution speed is comparable to pruning, even though more than 57M random numbers have to be generated per training step on each GPU. In all cases, the CES method is competitive with the pruning baseline. In general, it performs better for larger block widths due to the reduced number of CES parameters. However, contrary to pruning, CES allows us to train the sparse model from scratch – as shown in Table 7right, which opens up possibilities for using accelerated sparse training, even though we have not investigated this further here. Contrary to feedforward models, a fixed mask distribution (“FixMask”) does not work well for high initial sparsities. Additionally, CES might allow for optimizing such nondifferentiable factors as execution speed.
5 Conclusion
In this work we have investigated the applicability of Evolution Strategies to training more complex supervised models. We have shown that using appropriate “tricks of the trade” it is possible to train such models to the accuracy comparable to SGD. Additionally, we have shown that hybrid ES is a viable alternative for training sparsity masks, allowing for training sparse models from scratch in the same time as the dense models when the ES samples are parallelized across multiple computation devices. Considering that ES is often seen as a prohibitively slow method only applicable to small problems, the significance of our results is that ES should be seriously considered as a complementary tool in the DL practitioner’s toolbox, which could be useful for training nondifferentiable parameters (sparsity masks and beyond) in combination with SGD. We hope that our results, albeit not the state of the art, will further reinvigorate the interest in ES and blackbox methods in general.
Acknowledgements
We would like to thank David Choi and Jakub Sygnowski for their help developing the infrastructure used by this work.
References
 Bell and Hoberock (2012) Nathan Bell and Jared Hoberock. Thrust: A productivityoriented library for cuda. In GPU computing gems, Jade edition, pages 359–371. Elsevier, 2012.
 Bellec et al. (2017) Guillaume Bellec, David Kappel, Wolfgang Maass, and Robert Legenstein. Deep rewiring: Training very sparse deep networks. arXiv preprint arXiv:1711.05136, 2017.
 Blelloch (1990) Guy E Blelloch. Prefix sums and their applications. Technical report, 1990.
 Buchlovsky et al. (2019) Peter Buchlovsky, David Budden, Dominik Grewe, Chris Jones, John Aslanides, Frederic Besse, Andy Brock, Aidan Clark, Sergio Gómez Colmenarejo, Aedan Pope, Fabio Viola, and Dan Belov. TFReplicator: Distributed machine learning for researchers. arXiv preprint arXiv:1902.00465, 2019.
 Chollet (2016) François Chollet. Xception: Deep learning with depthwise separable convolutions. CoRR, 2016.
 Gale et al. (2019) Trevor Gale, Erich Elsen, and Sara Hooker. The state of sparsity in deep neural networks. CoRR, abs/1902.09574, 2019. URL http://arxiv.org/abs/1902.09574.

Glorot and Bengio (2010)
Xavier Glorot and Yoshua Bengio.
Understanding the difficulty of training deep feedforward neural
networks.
In
Proceedings of the thirteenth international conference on artificial intelligence and statistics
, pages 249–256, 2010.  Han et al. (2016) Song Han, Xingyu Liu, Huizi Mao, Jing Pu, Ardavan Pedram, Mark A. Horowitz, and William J. Dally. EIE: efficient inference engine on compressed deep neural network. CoRR, 2016.
 Hansen and Ostermeier (2001) Nikolaus Hansen and Andreas Ostermeier. Completely derandomized selfadaptation in evolution strategies. Evolutionary computation, 9(2):159–195, 2001.
 Harris et al. (2007) Mark Harris, Shubhabrata Sengupta, and John D Owens. Parallel prefix sum (scan) with cuda. GPU gems, 3(39):851–876, 2007.
 Igel (2003) Christian Igel. Neuroevolution for reinforcement learning using evolution strategies. In The 2003 Congress on Evolutionary Computation, 2003. CEC’03., volume 4, pages 2588–2595. IEEE, 2003.
 Igel and Sendhoff (2009) Christian Igel and Bernhard Sendhoff. Genesis of organic computing systems: Coupling evolution and learning. In Organic Computing, pages 141–166. Springer, 2009.
 Ioffe and Szegedy (2015) Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. CoRR, 2015.
 Jang et al. (2017) Eric Jang, Shixiang Gu, and Ben Poole. Categorical reparameterization with gumbelsoftmax. In International Conference on Learning Representations, 2017.

Kalchbrenner et al. (2018)
Nal Kalchbrenner, Erich Elsen, Karen Simonyan, Seb Noury, Norman Casagrande,
Edward Lockhart, Florian Stimberg, Aaron van den Oord, Sander Dieleman, and
Koray Kavukcuoglu.
Efficient neural audio synthesis.
In
Proceedings of the 35th International Conference on Machine Learning
, volume 80 of Proceedings of Machine Learning Research, pages 2410–2419, 2018.  Kingma and Ba (2014) Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, 2014.
 Krizhevsky and Hinton (2009) Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.
 LeCun et al. (1998) Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradientbased learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
 LeCun et al. (1990) Yann LeCun, John S. Denker, and Sara A. Solla. Optimal brain damage. In Advances in Neural Information Processing Systems, pages 598–605, 1990.
 Lehman et al. (2018) Joel Lehman, Jay Chen, Jeff Clune, and Kenneth O. Stanley. Es is more than just a traditional finitedifference approximator. In Proceedings of the Genetic and Evolutionary Computation Conference, pages 450–457. ACM, 2018.
 Louizos et al. (2018) Christos Louizos, Max Welling, and Diederik P. Kingma. Learning sparse neural networks through l0 regularization. In International Conference on Learning Representations, 2018.

Maddison et al. (2017)
Chris J. Maddison, Andriy Mnih, and Yee Whye Teh.
The Concrete Distribution: A Continuous Relaxation of Discrete Random Variables.
In International Conference on Learning Representations, 2017. 
Maheswaranathan et al. (2018)
Niru Maheswaranathan, Luke Metz, George Tucker, and Jascha SohlDickstein.
Guided evolutionary strategies: escaping the curse of dimensionality in random search.
CoRR, 2018. 
Mandischer (2002)
Martin Mandischer.
A comparison of evolution strategies and backpropagation for neural network training.
Neurocomputing, 42(14):87–117, 2002.  Mania et al. (2018) Horia Mania, Aurelia Guy, and Benjamin Recht. Simple random search provides a competitive approach to reinforcement learning. CoRR, 2018.
 Molchanov et al. (2017) Dmitry Molchanov, Arsenii Ashukha, and Dmitry Vetrov. Variational dropout sparsifies deep neural networks. In Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pages 2498–2507, 2017.

Narang et al. (2017)
Sharan Narang, Erich Elsen Gregory F. Diamos, and Shubho Sengupta.
Exploring sparsity in recurrent neural networks.
CoRR, 2017.  Real et al. (2018) Esteban Real, Alok Aggarwal, Yanping Huang, and Quoc V Le. Regularized evolution for image classifier architecture search. arXiv preprint arXiv:1802.01548, 2018.
 Rechenberg (1973) Ingo Rechenberg. Evolutionsstrategie–optimierung technisher systeme nach prinzipien der biologischen evolution. 1973.
 Reynolds et al. (2017) Malcolm Reynolds, Gabriel BarthMaron, Frederic Besse, Diego de Las Casas, Andreas Fidjeland, Tim Green, Adrià Puigdomènech, Sébastien Racanière, Jack Rae, and Fabio Viola. Open sourcing Sonnet  a new library for constructing neural networks. https://deepmind.com/blog/opensourcingsonnet/, 2017.
 Ros and Hansen (2008) Raymond Ros and Nikolaus Hansen. A simple modification in cmaes achieving linear time and space complexity. In International Conference on Parallel Problem Solving from Nature, pages 296–305. Springer, 2008.
 Salimans et al. (2017) Tim Salimans, Jonathan Ho, Xi Chen, Szymon Sidor, and Ilya Sutskever. Evolution strategies as a scalable alternative to reinforcement learning. CoRR, 2017.
 Schaul et al. (2011) Tom Schaul, Tobias Glasmachers, and Jürgen Schmidhuber. High dimensions and heavy tails for natural evolution strategies. In Proceedings of the 13th annual conference on Genetic and evolutionary computation, pages 845–852. ACM, 2011.
 Smith et al. (2017) Samuel L Smith, PieterJan Kindermans, Chris Ying, and Quoc V Le. Don’t Decay the Learning Rate, Increase the Batch Size. CoRR, 2017.
 Srivastava et al. (2014) Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15:1929–1958, 2014.
 Ström (1997) Nikko Ström. Sparse connection and pruning in large dynamic artificial neural networks. In Fifth European Conference on Speech Communication and Technology, 1997.
 Theis et al. (2018) Lucas Theis, Iryna Korshunova, Alykhan Tejani, and Ferenc Huszár. Faster gaze prediction with dense networks and fisher pruning. CoRR, abs/1801.05787, 2018.
 Varelas et al. (2018) Konstantinos Varelas, Anne Auger, Dimo Brockhoff, Nikolaus Hansen, Ouassim Ait ElHara, Yann Semet, Rami Kassab, and Frédéric Barbaresco. A comparative study of largescale variants of cmaes. In International Conference on Parallel Problem Solving from Nature, pages 3–15. Springer, 2018.
 Wan et al. (2013) Li Wan, Matthew Zeiler, Sixin Zhang, Yann Le Cun, and Rob Fergus. Regularization of neural networks using dropconnect. In International Conference on Machine Learning, pages 1058–1066, 2013.
 Wierstra et al. (2008) Daan Wierstra, Tom Schaul, Jan Peters, and Juergen Schmidhuber. Natural evolution strategies. In Evolutionary Computation, 2008. CEC 2008., pages 3381–3387. IEEE, 2008.
 Wierstra et al. (2014) Daan Wierstra, Tom Schaul, Tobias Glasmachers, Yi Sun, Jan Peters, and Jürgen Schmidhuber. Natural evolution strategies. JMLR, 15(1):949–980, 2014.
 Williams (1992) Ronald J. Williams. Simple statistical gradientfollowing algorithms for connectionist reinforcement learning. Machine Learning, 8(3):229–256, 1992.
 Yao (1999) Xin Yao. Evolving artificial neural networks. Proceedings of the IEEE, 87(9):1423–1447, 1999.

Zhang et al. (2017)
Xingwen Zhang, Jeff Clune, and Kenneth O. Stanley.
On the relationship between the openai evolution strategy and stochastic gradient descent.
CoRR, 2017.  Zhu and Gupta (2017) Michael Zhu and Suyog Gupta. To prune, or not to prune: exploring the efficacy of pruning for model compression. CoRR, 2017.
Comments
There are no comments yet.