Title: MANAS: MULTI-AGENT NEURAL ARCHITECTURE SEARCH

Abstract: The Neural Architecture Search (NAS) problem is typically formulated as a graph search problem where the goal is to learn the optimal operations over edges in order to maximize a graph-level global objective. Due to the large architecture parameter space, efficiency is a key bottleneck preventing NAS from its practical use. In this paper, we address the issue by framing NAS as a multi-agent problem where agents control a subset of the network and coordinate to reach optimal architectures. We provide two distinct lightweight implementations, with reduced memory requirements (1/8th of state-of-the-art), and performances above those of much more computationally expensive methods. Theoretically, we demonstrate vanishing regrets of the form O( √ T ), with T being the total number of rounds. Finally, aware that random search is an (often ignored) effective baseline we perform additional experiments on 3 alternative datasets and 2 network configurations, and achieve favorable results in comparison with this baseline and other methods.

1. INTRODUCTION:

Determining an optimal architecture is key to accurate deep neural networks (DNNs) with good generalisation properties (Szegedy et al., 2017; Huang et al., 2017; He et al., 2016; Han et al., 2017; Conneau et al., 2017; Merity et al., 2018) . Neural architecture search (NAS), which has been formulated as a graph search problem, can potentially reduce the need for application-specific expert designers allowing for a wide-adoption of sophisticated networks in various industries. Zoph and Le (2017) presented the first modern algorithm automating structure design, and showed that resulting architectures can indeed outperform human-designed state-of-the-art convolutional networks (Ko, 2019; Liu et al., 2019) . However, even in the current settings where flexibility is limited by expertlydesigned search spaces, NAS problems are computationally very intensive with early methods requiring hundreds or thousands of GPU-days to discover state-of-the-art architectures (Zoph and Le, 2017; Real et al., 2017; Liu et al., 2018a; b) .

Researchers have used a wealth of techniques ranging from reinforcement learning, where a controller network is trained to sample promising architectures (Zoph and Le, 2017; Zoph et al., 2018; Pham et al., 2018) , to evolutionary algorithms that evolve a population of networks for optimal DNN design (Real et al., 2018; Liu et al., 2018b) . Alas, these approaches are inefficient and can be extremely computationally and/or memory intensive as some require all tested architectures to be trained from scratch. Weight-sharing, introduced in ENAS (Pham et al., 2018) , can alleviate this problem. Even so, these techniques cannot easily scale to large datasets, e.g., ImageNet. More recently, gradient-based frameworks enabled efficient solutions by introducing a continuous relaxation of the search space. For example, DARTS (Liu et al., 2019) uses this relaxation to optimise architecture parameters using gradient descent in a bi-level optimisation problem, while SNAS (Xie et al., 2019) updates architecture parameters and network weights under one generic loss. Still, due to memory constraints the search has to be performed on 8 cells, which are then stacked 20 times for the final architecture. This solution is a coarse approximation to the original problem as show in Section 6 of this work and in Doe (2019) . In fact, we show that searching directly over 20 cells leads to a reduction in test error (0.24 p.p.; 8% relative to Liu et al., 2019) . ProxylessNAS (Cai et al., 2019) is one exception, as it can search for the final models directly; nonetheless they still require twice the amount of memory used by our proposed algorithm.

To enable the possibility of large-scale joint optimisation of deep architectures we contribute MANAS, the first multi-agent learning algorithm for neural architecture search. Our algorithm combines the memory and computational efficiency of multi-agent systems, which is achieved through action coordination with the theoretical rigour of online machine learning, allowing us to balance exploration versus exploitation optimally. Due to its distributed nature, MANAS enables large-scale optimisation of deeper networks while learning different operations per cell. Theoretically, we demonstrate that MANAS implicitly coordinates learners to recover vanishing regrets, guaranteeing convergence. Empirically, we show that our method achieves state-of-the-art accuracy results among methods using the same evaluation protocol but with significant reductions in memory (1/8th of Liu et al., 2019) and search time (70% of Liu et al., 2019) .

The multi-agent (MA) framework is inherently scalable and allows us to tackle an optimization problem that would be extremely challenging to solve efficiently otherwise: the search space of a single cell is 8 14 and there is no fast way of learning the joint distribution, as needed by a single controller. More cells to learn exacerbates the problem, and this is why MA is required, as for each agent the size of the search space is always constant.

In short, our contributions can be summarised as: (1) framing NAS as a multi-agent learning problem (MANAS) where each agent supervises a subset of the network; agents coordinate through a credit assignment technique which infers the quality of each operation in the network, without suffering from the combinatorial explosion of potential solutions. (2) Proposing two lightweight implementations of our framework that are theoretically grounded. The algorithms are computationally and memory efficient, and achieve state-of-the-art results on Cifar-10 and ImageNet when compared with competing methods. Furthermore, MANAS allows search directly on large datasets (e.g. ImageNet).

(3) Presenting 3 news datasets for NAS evaluation to minimise algorithmic overfitting; and offering a fair comparison with a random baseline.

2. RELATED WORK:

MANAS derives its search space from DARTS (Liu et al., 2019) and is therefore most related to other gradient-based NAS methods that use the same search space. SNAS (Xie et al., 2019 ) appears similar at a high level, but has important differences: 1) it uses GD to learn the architecture parameters. This requires a differentiable objective (MANAS does not) and leads to 2) having to forward all operations (see their Eqs.5,6), thus negating any memory advantages (which MANAS has), and effectively requiring repeated cells and preventing search on ImageNet. ENAS (Pham et al., 2018) is also very different: its use of RL implies dependence on past states (the previous operations in the cell). It explores not only the stochastic reward function but also the relationship between states, which is where most of the complexity lies. Furthermore, RL has to balance exploration and exploitation by relying on sub-optimal heuristics, while MANAS, due to its theoretically optimal approach from online learning, is more sample efficient. Finally, ENAS uses a single LSTM (which adds complexity and problems such as exploding/vanishing gradients) to control the entire process, and is thus following a monolithic approach. Indeed, at a high level, our multi-agent framework can be seen as a way of decomposing the monolithic controller into a set of simpler, independent sub-policies. This provides a more scalable and memory efficient approach that leads to higher accuracy, as confirmed by our experiments.

3. PRELIMINARY: NEURAL ARCHITECTURE SEARCH:

We consider the NAS problem as formalised in DARTS (Liu et al., 2019) . At a higher level, the architecture is composed of a computation cell that is a building block to be learned and stacked in the network. The cell is represented by a directed acyclic graph with V nodes and N edges; edges connect all nodes i, j from i to j where i < j. Each vertex x (i) is a latent representation for i ∈ {1, . . . , V }. Each directed edge (i, j) (with i < j) is associated with an operation o (i,j) that transforms x (i) . Intermediate node values are computed based on all of its predecessors as x (j) = i<j o (i,j) (x (i) ). For each edge, an architect needs to intelligently select one operation o (i,j) from a finite set of K operations, O = {o k (•)} K k=1 , where operations represents some function to be applied to x (i) to compute x (j) , e.g., convolutions or pooling layers. To each o (i,j) k (•) is associated a set of operational weights w (i,j) k that needs to be learned (e.g. the weights of a convolution filter). Additionally, a parameter α (i,j) k ∈ R characterises the importance of operation k within the pool O for edge (i, j). The sets of all the operational weights {w (i,j) k } and architecture parameters {α (i,j) k } are denoted by w and α, respectively. DARTS defined the operation ō(i,j) (x) as

EQUATION

in which α encodes the network architecture. The optimal choice of architecture is defined by

EQUATION

)

The final objective is to obtain a sparse architecture Z = {Z (i,j) }, ∀i, j where

Z (i,j) = [z (i,j) 1 , . . . , z (i,j) K ] with z (i,j) k

= 1 for k corresponding to the best operation and 0 otherwise. That is, for each pair (i, j) a single operation is selected. according to π (i) . Feedback from the validation loss is used to update the policy.

NAS suffers from a combinatorial explosion in its search space. A recently proposed approach to tackle this problem is to approximate the discrete optimisation variables (i.e., edges in our case) with continuous counterparts and then use gradient-based optimisation methods. DARTS (Liu et al., 2019) introduced this method for NAS, though it suffers from two important drawbacks. First, the algorithm is memory and computationally intensive (O(N K) with K being total number of operations between a pair of nodes and N the number of nodes) as they require loading all operation parameters into GPU memory. As a result, DARTS only optimises over a small subset of 8 cells, which are then stacked together to form a deep network of 20. Naturally, such an approximation is bound to be sub-optimal. Second, evaluating an architecture amounts to a prediction on a validation set using the optimal set of network parameters. Learning these, unfortunately, is highly demanding since for an architecture Z t , one would like to compute L (val) t (Z t , w t ) where w t = arg min w L (train) t (w, Z t ). DARTS, uses weight sharing that updates w t once per architecture, with the hope of tracking w t over learning rounds. Although this technique leads to significant speed up in computation, it is not clear how this approximation affects the validation loss function.

Next, we detail a novel methodology based on a combination of multi-agent and online learning to tackle the above two problems (Figure 1 ). Multi-agent learning scales our algorithm, reducing memory consumption by an order of magnitude from O(N K) to O(N ); and online learning enables rigorous understanding of the effect of tracking w t over rounds.

4.1. NAS AS A MULTI-AGENT PROBLEM:

To address the computational complexity we use the weight sharing technique of DARTS. However, we try to handle in a more theoretically grounded way the effect of approximation of

L (val) t (Z t , w t ) by L (val) t (Z t , w t )

. Indeed, such an approximation can lead to arbitrary bad solutions due to the uncontrollable weight component. To analyse the learning problem with no stochastic assumptions on the process generating ν = {L 1 , . . . , L T } we adopt an adversarial online learning framework.

Algorithm 1 GENERAL FRAMEWORK: [steps with asterisks (*) are specified in section 5] 1: Initialize: π i 1 is uniform random over all j ∈ {1, . . . N }. And random w 1 weights. 2: For t = 1, . . . , T 3:

* Agent A i samples a i t ∼ π i t (a i t ) for all i ∈ {1, . . . , N }, forming architecture Z t . 4: Compute the training loss L (train) t (a t ) = L (train) t (Z t , w t ) 5:

Update w t+1 for all operation a i t in Z t from w t using back-propagation.

6::

Compute the validation loss

L (val) t (a t ) = L (val) t (Z t , w t+1 ) 7: * Update π i t+1 for all i ∈ {1, . . . N } using Z 1 , . . . , Z t and L (val) 1 , . . . , L (val) t . 8: Recommend Z T +1 , after round T , where a i T +1 ∼ π i T +1 (a i T +1

) for all i ∈ {1, . . . , N }.

NAS as Multi-Agent Combinatorial Online Learning. In Section 3, we defined a NAS problem where one out of K operations needs to be recommended for each pair of nodes (i, j) in a DAG. In this section, we associate each pair of nodes with an agent in charge of exploring and quantifying the quality of these K operations, to ultimately recommend one. However, the only feedback for each agent is the loss that is associated with a global architecture Z, which depends on all agents' choices.

We introduce N decision makers, A 1 , . . . , A N (see Figure 1 and Algorithm 1). At training round t, each agent chooses an operation (e.g., convolution or pooling filter) according to its local actiondistribution (or policy) a j t ∼ π j t , for all j ∈ {1, . . . , N } with a j t ∈ {1, . . . , K}. These operations have corresponding operational weights w t that are learned in parallel. Altogether, these choices a t = a 1 t , . . . , a N t define a sparse graph/architecture Z t ≡ a t for which a validation loss L (val) t (Z t , w t ) is computed and used by the agents to update their policies. After T rounds, an architecture is recommended by sampling a j T +1 ∼ π j T +1 , for all j ∈ {1, . . . , N }. These dynamics resemble bandit algorithms where the actions for an agent A j are viewed as separate arms. This framework leaves open the design of 1) the sampling strategy π j and 2) how π j is updated from the observed loss.

Minimization of worst-case regret under any loss. The following two notions of regret motivate our proposed NAS method. Given a policy π the cumulative regret R T,π and the simple regret r T,π after T rounds and under the worst possible environment ν, are:

R T,π = sup ν E T t=1 L t (a t ) -min a T t=1 L t (a), r T,π = sup ν E T t=1 L t (a T +1 ) -min a T t=1 L t (a) (3)

where the expectation is taken over both the losses and policy distributions and a = {a (Aj ) } N j=1 denotes a joint action profile. The simple regret leads to minimising the loss of the recommended architecture a T +1 , while minimising the cumulative regret adds the extra requirement of having to sample, at any time t, architectures with close-to-optimal losses. We discuss in the appendix E how this requirement could improve in practice the tracking of w t by w t . We let L t (a t ) be potentially adversarilly designed to account for the difference between w t and w t and make no assumption on its convergence. Our models and solutions in Section 5 are designed to be robust to arbitrary L t (a t ).

5. SOLUTION METHODS:

This section elaborates our solution methods for NAS when considering adversarial losses. We propose two algorithms, MANAS and MANAS-LS, that implement two different credit assignment techniques specifying the update rule in line 7 of Algorithm 1. The first approximates the validation loss as a linear combination of edge weights, while the second handles non-linear loss. We propose two associated sampling techniques that specify line 3 of Algorithm 1, one minimising the simple regret r T,π and one targeting the cumulative regret R T,π , (3).

Agent coordination, combinatorial explosion and approximate credit assignment. Our set-up introduces multiple agents in need of coordination. Centralised critics use explicit coordination and learn the value of coordinated actions across all agents (Rashid et al., 2018) , but the complexity of the problem grows exponentially with the number of possible architectures Z, which equals K N . We argue instead for an implicit approach where coordination is achieved through a joint loss function depending on the actions of all agents. This approach is scalable as each agent searches its local action space-small and finite-for optimal action-selection rules. Both credit assignment methods below learn, for each operation k belonging to an agent A i , a quantity B i t [k] (similar to α in Section 3) that quantifies the contribution of the operation to the observed losses.

5.1. MANAS-LS:

Linear Decomposition of the Loss. A simple credit assignment strategy is to approximate edgeimportance (or edge-weight) by a vector β s ∈ R KN representing the importance of all K operations for each of the N agents. β s is an arbitrary, potentially adversarially-chosen vector and varies with time s to account for the fact that the operational weights w s are learned online and to avoid any restrictive assumption on their convergence. The relation between the observed loss L (val) s and the architecture selected at each sampling stage s is modeled through a linear combination of the architecture's edges (agents' actions) as

L (val) s = β T s Z s (4)

where Z s ∈ {0, 1} KN is a vectorised version of the architecture Z s containing all action choices. After evaluating S architectures, at round t we estimate β by solving the following via least-squares:

Credit assignment:

EQUATION

)

Though simple, the solution gives an efficient way for agents to update their corresponding actionselection rules which they implicitly coordinate. Indeed, in Appendix C we demonstrate that the worst-case regret R T (3) can actually be decomposed into an agent-specific form R i T π i , ν i defined in the appendix:

R T = sup ν R T (π, ν) ⇐⇒ sup ν i R i T π i , ν i , i = 1, . . . , N

. This decomposition allows us to significantly reduce the search space and apply upcoming sampling techniques for each agent A i in a completely parallel fashion.

Zipf Sampling for r T,π . A i samples an operation k proportionally to the inverse of its estimated rank k Zipf explores efficiently as, up to log factors, for 1 ≤ m ≤ K, the m estimated best operations are picked uniformly ignoring the remaining K -m operations: All operations are explored almost as in uniform exploration while the estimated best is picked almost all the time. The Zipf law is anytime, parameter free, minimises optimally the simple regret in multi-armed bandits when the losses are adversarially designed and adapts optimally to stationary losses (Abbasi-Yadkori et al., 2018) .

5.2. MANAS:

Coordinated Descent for Non-Linear Losses. As the linear approximation is likely to be crude, an alternative is to make no assumption on the loss function and have each agent directly associate the quality of their action with the loss L (val) t (a t ). This results in obtaining all the agents performing a coordinated descent approach to the problem. Each agent updates for operation k its

EQUATION

Softmax Sampling for R T,π . Based on EXP3 (Auer et al., 2002) , samples are from a softmax distribution (with temperature η) w.r.t. Bi t [k] and the aim is to always pull the best operation as Sampling policy:

π i t+1 [k] = exp η Bi t [k] K j=1 exp η Bi t [j] for k = 1, . . . , K.

Comments on credit assignment. Our MA formulation provides a gradient-free, credit assignment strategy. Gradient methods are more susceptible to bad initialisation and can get trapped in local minima more easily than our approach, which, not only explores more widely the search space, but makes this search in an optimal way, given by the multi-armed bandit/multi-agent framework.

Concretely, MANAS can easily escape from local minima as the reward is scaled by the probability of selecting an action (Eq. 6). Thus, the algorithm has a higher chance of revising its estimate of the quality of a solution based on new evidence. This is important as one-shot methods (such as MANAS and DARTS) change the network-and thus the environment-throughout the search process. Put differently, MANAS' optimal exploration-exploitation allows the algorithm to move away from 'good' solutions towards 'very good' solutions that do not live in the former's proximity; in contrast, gradient methods will tend to stay in the vicinity of a 'good' discovered solution.

5.3. THEORETICAL GUARANTEES:

MANAS. This algorithms runs EXP3 (Auer et al., 2002) for each agent in parallel. If the regret of each agent is computed by considering the rest of the agent as fixed, then each agent has regret O √ T K log K which sums over agents to O N √ T K log K . The proof in given in Appendix D.2.

MANAS-LS.:

We prove for this new algorithm an exponentially decreasing simple regret r T = O e -T /H , where H is a measure of the complexity for discriminating sub-optimal solutions as H = N (min

j =k i ,1≤i≤N } B i T [j] -B i T [k i ]), where k i = min 1≤j≤K B i T [j]) and B i T [j] = T t=1 β (Ai) t [j].

The proof in given in Appendix D.1.

6. EXPERIMENTS RESULTS:

This section, we (1) compare MANAS against existing NAS methods on the well established Cifar-10 dataset.

(2) evaluate MANAS on ImageNet.

(3) compare MANAS, DARTS and random sampling on 3 new datasets. Descriptions of the datasets and details of the search are provided in the Appendix. We report the performance of two algorithms, MANAS and MANAS-LS, described in Section 5.

Search Spaces: we use the same CNN search space as Liu et al. (2019) . Since MANAS is memory efficient, it can search for the final architecture without needing to stack a posteriori repeated cells, and so our cells are unique. For fair comparison, we use 20 cells on Cifar-10 and 14 on ImageNet. Experiments on Sport-8, Caltech-101 and MIT-67 in Section 6.3 use both 8 and 14 cell networks. Search Protocols: for datasets other than ImageNet, we use 500 epochs during the search phase for architectures with 20 cells, 400 epochs for 14 cells, and 50 epochs for 8 cells. All other hyperparameters are as in Liu et al. (2019) . For ImageNet, we use 14 cells and 100 epochs during search. In our experiments on the three new datasets we rerun the DARTS code to optimise an 8 cell architecture; for 14 cells we simply stacked the best cells for the appropriate number of times.

Synthetic experiment. To illustrate the theoretical properties of MANAS we apply it to the Gaussian Squeeze Domain experiment, a problem where agents must coordinate their actions in order to optimize a Gaussian objective function (Colby et al., 2015) . MANAS progresses steadily towards zero regret while the Random Search baseline struggles to move beyond the initial starting point. Details and results are provided in Appendix F.

6.1. RESULTS ON CIFAR-10:

Evaluation. To evaluate our NAS algorithm, we follow DARTS's protocol: we run MANAS 4 times with different random seeds and pick the best architecture based on its validation performance. We then randomly reinitialize the weights and retrain for 600 epochs. During search we use half of the training set as validation. To fairly compare with more recent methods, we also re-train the best searched architecture using AutoAugment and Extended Training (Cubuk et al., 2018) .

Results. Both MANAS implementations perform well on this dataset (Table 1 ). Our algorithm is designed to perform comparably to Liu et al. (2019) but with an order of magnitude less memory. However, MANAS actually achieves higher accuracy. The reason for this is that DARTS is forced to search for an 8 cell architecture and subsequently stack the same cells 20 times; MANAS, on the other hand, can directly search on the final number of cells leading to better results. We also report our results when using only 8 cells: even though the network is much smaller, it still performs (Real et al., 2018) 2.55 2.8 3150 evolution PNAS (Liu et al., 2018a) 3.41 3.2 225 SMBO ENAS (Pham et al., 2018) 2.89 4.6 0.5 RL SNAS (Xie et al., 2019) 2.85 2.8 1.5 gradient DARTS, 1st order (Liu et al., 2019) 3.00 3.3 1.5 † gradient DARTS, 2nd order (Liu et al., 2019) 2.76 3.3 4 † gradient Random + cutout (Liu et al., 2019) 3 (Real et al., 2018) 24.3 6.4 3150 evolution PNAS (Liu et al., 2018a) 25.8 5.1 225 SMBO SNAS (Xie et al., 2019) 27.3 4.3 1.5 gradient DARTS (Liu et al., 2019) 26 competitively with 1st-order 20-cell DARTS. This is explored in more depth in Section 6.3. Cai et al. ( 2019) is another method designed as an efficient alternative to DARTS; unfortunately the authors decided to a) use a different search space (PyramidNet backbone; Han et al., 2017) and b) offer no comparison to random sampling in the given search space. For these reasons we feel a numerical comparison to be unfair. Furthermore our algorithm uses half the GPU memory (they sample 2 paths at a time) and does not require the reward to be differentiable. Lastly, we observe similar gains when training the best MANAS/MANAS-LS architectures with an extended protocol (AutoAugment + 1500 Epochs + 50 Channels, in addition to the DARTS protocol).

6.2. RESULTS ON IMAGENET:

Evaluation. To evaluate the results on ImageNet we train the final architecture for 250 epochs. We report the result of the best architecture out of 4, as chosen on the validation set for a fair comparison with competing methods. As search and augmentation are very expensive we use only MANAS and not MANAS-LS, as the former is computationally cheaper and performs slightly better on average. Results. We provide results for networks searched both on Cifar-10 and directly on ImageNet, which is made possible by the computational efficiency of MANAS (Table 2 ). When compared to SNAS and DARTS-currently the most efficient methods, using the same search space, available-MANAS achieves state-of-the-art results both with architectures searched directly on ImageNet (0.85 p.p. improvement) and also with architectures transferred from Cifar-10 (0.55 p.p. improvement). We observe similar gains when training the best MANAS architecture with an extended training protocol (AutoAugment + 600 Epochs + 60 Channels, in addition to the DARTS protocol).

6.3 RESULTS ON NEW DATASETS: SPORT-8, CALTECH-101, MIT-67

Evaluation. The idea behind NAS is that of finding the optimal architecture, given any sets of data and labels. Limiting the evaluation of current methods to Cifar-10 and ImageNet could potentially lead to algorithmic overfitting. Indeed, recent results suggest that the search space was engineered in a way that makes it very hard to find a a bad architecture (Li and Talwalkar, 2019; Sciuto et al., 2019) . To mitigate this, we propose testing NAS algorithms on 3 datasets (composed of regular sized images) that were never before used in this setting, but have been historically used in the CV field: Sport-8, Caltech-101 and MIT-67, described briefly in the Appendix. For these set of experiments we run the algorithm 8 times and report mean and std. We perform this both for 8 and 14 cells; we do the same with DARTS (which, due to memory constraints can only search for 8 cells). For our random baseline we sample uniformly 8 architectures from the search space. Each proposed architecture is then trained from scratch for 600 epochs as in the previous section.

Results. For these experiments can be found in Figure 2 . MANAS manages to outperform the random baseline and significantly outperform DARTS, especially on 14 cells. It can be clearly seen from our experiments, that the optimal cell architecture for 8 cells is not the optimal one for 14 cells.

Discussion on Random Search. Clearly, in specific settings, random sampling performs very competitively. On one hand, since the search space is very large (between 8 112 and 8 280 architectures exist in the DARTS experiments; Liu et al., 2019) , finding the global optimum is practically impossible. Why is it then that the randomly sampled architectures are able to deliver nearly state-of-the-art results? Previous experiments (Sciuto et al., 2019; Li and Talwalkar, 2019) together with the results presented here seem to indicate that the available operations and meta-structure have been carefully chosen and, as a consequence, most architectures in this space generate meaningful results. This suggests that human effort has simply transitioned from finding a good architecture to finding a good search space -a problem that needs careful consideration in future work.

7. CONCLUSIONS:

We presented MANAS, a theoretically grounded multi-agent online learning framework for NAS.

We then proposed two extremely lightweight implementations that, within the same search space, outperform state-of-the-art while reducing memory consumption by an order of magnitude compared to Liu et al. (2019) . We provide vanishing regret proofs for our algorithms. Furthermore, we evaluate MANAS on 3 new datasets, empirically showing its effectiveness in a variety of settings. Finally, we confirm concerns raised in recent works (Sciuto et al., 2019; Li and Talwalkar, 2019; Doe, 2019) claiming that NAS algorithms often achieve minor gains over random architectures. We however demonstrate, that MANAS still produces competitive results with limited computational budgets.

A DATASETS:

Cifar-10. The CIFAR-10 dataset (Krizhevsky, 2009) is a dataset of 10 classes and consists of 50, 000 training images and 10, 000 test images of size 32×32. We use standard data pre-processing and augmentation techniques, i.e. subtracting the channel mean and dividing the channel standard deviation; centrally padding the training images to 40×40 and randomly cropping them back to 32×32; and randomly flipping them horizontally.

ImageNet. The ImageNet dataset (Deng et al., 2009) is a dataset of 1000 classes and consists of 1, 281, 167 training images and 50, 000 test images of different sizes. We use standard data pre-processing and augmentation techniques, i.e. subtracting the channel mean and dividing the channel standard deviation, cropping the training images to random size and aspect ratio, resizing them to 224×224, and randomly changing their brightness, contrast, and saturation, while resizing test images to 256×256 and cropping them at the center.

Sport-8. This is an action recognition dataset containing 8 sport event categories and a total of 1579 images (Li and Fei-Fei, 2007) . The tiny size of this dataset stresses the generalization capabilities of any NAS method applied to it.

Caltech-101. This dataset contains 101 categories, each with 40 to 800 images of size roughly 300×200 (Fei-Fei et al., 2007) .

MIT-67. This is a dataset of 67 classes representing different indoor scenes and consists of 15, 620 images of different sizes (Quattoni and Torralba, 2009) .

In experiments on Sport-8, Caltech-101 and MIT-67, we split each dataset into a training set containing 80% of the data and a test set containing 20% of the data. For each of them, we use the same data pre-processing techniques as for ImageNet. (K number of actions, n number of architectures seen in the whole training). γ = 1.05 K ln(K) n . We then tuned them to increase validation accuracy during the search.

For our Least-Squares solution, we alternate between one epoch of training (in which all β are frozen and the ω are updated) and one or more epochs in which we build the Z matrix from Section 4 (in which both β and ω are frozen). The exact number of iterations we perform in this latter step is dependant on the size of both the dataset and the searched architecture: our goal is simply to have a number of rows greater than the number of columns for Z. We then solve B t = ZZ T † ZL, and repeat the whole procedure until the end of training. This method requires no additional meta-parameters.

Number of agents.:

In both MANAS variants, the number of agents is defined by the search space and thus is not tuned. Specifically, for the image datasets, there exists one agent for each pair of nodes, tasked with selecting the optimal operation. As there are 14 pairs in each cell, the total number of agents is 14 × C, with C being the number of cells (8, 14 or 20, depending on the experiment).

B.2 COMPUTATIONAL RESOURCES:

ImageNet experiments were performed on multi-GPU machines loaded with 8× Nvidia Tesla V100 16GB GPUs (used in parallel). All other experiments were performed on single-GPU machines loaded with 1× GeForce GTX 1080 8GB GPU.

D.2 MANAS:

We consider a simplified notion of regret that is a regret per agent where each agent is considering the rest of the agents as part of the adversarial environment. Let us fix our new objective as to minimise

N i=1 R ,i T (π (Ai) ) = N i=1 sup a-i,ν E T t=1 L (val) t (a (Ai) t , a -i ) -min a∈{1,...,K} T t=1 L (val) t (a, a -i ) ,

where a -i is a fixed set of actions played by all agents to the exception of agent A i for the T rounds of the game and ν contains all the losses as ν = {L (val) t

(a)} t∈{1,...,T },a∈{1,...,K N } .

We then can prove the following bound for that new notion of regret. We want to relate that the game that agent i plays against an adversary when the actions of all the other agents are fixed to a -i to the vanilla EXP3 setting. To be more precise on why this is the EXP3 setting, first we have that L (val) t (a t ) is a function of a t that can take K N arbitrary values. When we fix a -i , L ). Said differently this defines a game where the new ν contains all the losses as ν = {L @,(val) t (a (Ai) )} t∈{1,...,T },a (A i ) ∈{1,...,K} .

For all a -i R ,i T (EXP 3, a -i ) ≤ 2 T K log(K)

Then we have R ,i T (EXP 3) ≤ sup a-i 2 T K log(K) = 2 T K log(K)

Then we have

N i=1 R ,i T (EXP 3) ≤ 2N T K log(K)

E RELATION BETWEEN WEIGHT SHARING AND CUMULATIVE REGRET:

Ideally we would like to obtain for any given architecture Z the value L val (Z, w (Z)). However obtaining w (Z) = arg min w L train (w, Z) for any given fixed Z would already require heavy computations. In our approach the w t that we compute and update is actually common to all Z t as w t replaces w (Z t ). This is a simplification that leads to learning a weight w t that tend to minimise the loss E Z∼πt [L val (Z, w(Z)] instead of minimising L val (Z t , w(Z t ). If π t is concentrated on a fixed Z then these two previous expressions would be close. Moreover when π t is concentrated on Z then w t will approximate accurately w (Z) after a few steps. Note that this gives an argument for using sampling algorithm that minimise the cumulative regret as they naturally tend to play almost all the time one specific architecture. However there is a potential pitfall of converging to a local minimal solution as w t might not have learned well enough to compute accurately the loss of other and potentially better architectures. 

:



Figures and Tables:

Figure1: MANAS with single cell. Between each pair of nodes, an agent A i selects action a (i) according to π(i) . Feedback from the validation loss is used to update the policy.

by sorting the operations of agent A i w.r.t Bi t [k], as Sampling policy: π i t+1 [k] = 1 k i t logK where logK = 1 + 1/2 + . . . + 1/K.

Figure 2: Comparing MANAS, random sampling and DARTS (Liu et al., 2019) on 8 and 14 cells. Average results of 8 runs. Note that DARTS was only optimised for 8 cells due to memory constraints.

Our code is based on a modified variant ofLiu et al. (2019). To set the temperature and gamma, we used as starting estimates the values suggested byBubeck et al. (2012):

i ) and then the game boils down to the vanilla adversarial multi-arm bandit where each time the learner plays a (Ai) t ∈ {1, . . . , K} and observes/incur the loss L @,(val) t

Figure 3: Regret for the Gaussian Squeeze Domain experiment with 100 agents, 10 actions, µ = 1, σ = 10.

Figure 4: Theoretical bound for the MANAS cumulative regret (2N √ T K log K; see Appendix D.2) and the observed counterpart for the Gaussian Squeeze Domain experiment with 100 agents, 10 actions, µ = 1, σ = 10.

Comparison with state-of-the-art image classifiers on Cifar-10. The four row blocks represent: human-designed, NAS, MANAS search with DARTS training protocol and best searched MANAS retrained with extended protocol (AutoAugment + 1500 Epochs + 50 Channels).

Table content: <table><tr><td>Architecture</td><td>Test Error</td><td>Params</td><td>Search Cost</td><td>Search</td></tr><tr><td/><td>(%)</td><td>(M)</td><td>(GPU days)</td><td>Method</td></tr><tr><td>DenseNet-BC (Huang et al., 2017)</td><td>3.46</td><td>25.6</td><td>-</td><td>manual</td></tr><tr><td>NASNet-A (Zoph et al., 2018)</td><td>2.65</td><td>3.3</td><td>1800</td><td>RL</td></tr><tr><td>AmoebaNet-B</td><td/><td/><td/><td/></tr></table>

Comparison with state-of-the-art image classifiers on ImageNet (mobile setting). The four row blocks represent: human-designed, NAS, MANAS search with DARTS training protocol and best searched MANAS retrained with extended protocol (AutoAugment + 600 Epochs + 60 Channels).

Table content: <table><tr><td>Architecture</td><td>Test Error</td><td>Params</td><td>Search Cost</td><td>Search</td></tr><tr><td/><td>(%)</td><td>(M)</td><td>(GPU days)</td><td>Method</td></tr><tr><td>ShuffleNet 2x (v2) (Zhang et al., 2018)</td><td>26.3</td><td>5</td><td>-</td><td>manual</td></tr><tr><td>NASNet-A (Zoph et al., 2018)</td><td>26.0</td><td>5.3</td><td>1800</td><td>RL</td></tr><tr><td>AmoebatNet-C</td><td/><td/><td/><td/></tr></table>

Theorem 2. Let us consider neural architecture search problem in a multi-agent combinatorial online learning form with N agents such that each agent has K actions. Then after T rounds, MANAS achieves joint policy {π t } T t=1 with expected cumulative regret bounded by O N √ T K log K .Proof. First we look at the problem for each given agent A i and we define and look atR ,i T (π (Ai) , a -i ) = sup

Table content: <table><tr><td/><td/><td>T</td><td/><td/><td/><td>T</td><td/></tr><tr><td>ν</td><td>E</td><td>t=1</td><td>L (val) t</td><td>(a (Ai) t</td><td>, a -i ) -min a∈{1,...,K}</td><td>t=1</td><td>(val) L t</td></tr></table>

Peer review (iclr2020):
In this paper, the authors pay attention on the bottleneck in the NAS of its large architecture space which cause low efficiency. They introduce the multi agent reinforcement learning method to take the neural architecture search as a multi agent reinforcement learning problem. Main contribution is :(1) Framing the MAS as a multi agent problem. (2)Purpose two lightweight implementation. (3) Presenting 3 new datasets for NAS evaluation to minimize algorithmic over-fitting. It seems like that it is the first work to combine multi agent reinforcement learning with NAS, and you have make complete proof about the algorithm*s efficiency both mathematically and empirically. But from the view of multi agent reinforcement learning, there are also some points which make me confused. The main problem is coordination, and I understand it as the agents in your work aim to get a joint action and the training process of them are independent, but we all know that in multi agent problems, the changing of agent*s policy will cause change of the environment, so it will bring the instability, so I want to know that how you deal with the instability or whether the instability influence a lot in your work? Another problem may be not a theoretically problem that I want to know that have you made the guarantee of the consistency of agents* policies when using parallel training (May be the framework in coding process guarantee it ?) or the consistency is unnecessary to talk because it doesn*t influence the result?