MANAS: MULTI-AGENT NEURAL ARCHITECTURE SEARCH
Year: 2019

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.

text: 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.

heading: 1 INTRODUCTION
text: 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 814 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.

heading: 2 RELATED WORK
text: 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.

heading: 3 PRELIMINARY: NEURAL ARCHITECTURE SEARCH
text: 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 = {ok(·)}Kk=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 ō(i,j)(x) as
ō(i,j)(x) = K∑ k=1 eα (i,j) k∑K k′=1 e α (i,j) k′ · o(i,j)k (x) (1)
in which α encodes the network architecture. The optimal choice of architecture is defined by
α? = min α L(val)(α,w?(α)) s.t. w?(α) = arg min w L(train)(α,w). (2)
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.
4 ONLINE MULTI-AGENT LEARNING FOR AUTOML
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(NK) 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 Zt, one would like to compute L(val)t (Zt,w?t ) where w?t = arg minw L (train) t (w,Zt). DARTS, uses weight sharing that updates wt once per architecture, with the hope of trackingw?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(NK) to O(N); and online learning enables rigorous understanding of the effect of tracking w?t over rounds.

heading: 4.1 NAS AS A MULTI-AGENT PROBLEM
text: 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 (Zt,w?t ) by L(val)t (Zt,wt). 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 ν = {L1, . . . ,LT } we adopt an adversarial online learning framework.
Algorithm 1 GENERAL FRAMEWORK: [steps with asterisks (*) are specified in section 5] 1: Initialize: πi1 is uniform random over all j ∈ {1, . . . N}. And random w1 weights. 2: For t = 1, . . . , T 3: * Agent Ai samples ait ∼ πit(ait) for all i ∈ {1, . . . , N}, forming architecture Zt. 4: Compute the training loss L(train)t (at) = L (train) t (Zt,wt)
5: Update wt+1 for all operation ait in Zt from wt using back-propagation. 6: Compute the validation loss L(val)t (at) = L (val) t (Zt,wt+1) 7: * Update πit+1 for all i ∈ {1, . . . N} using Z1, . . . ,Zt and L (val) 1 , . . . ,L (val) t . 8: Recommend ZT+1, after round T , where aiT+1 ∼ πiT+1(aiT+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, A1, . . . ,AN (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) ajt ∼ π j t , for all j ∈ {1, . . . , N} with a j t ∈ {1, . . . ,K}. These operations have corresponding operational weightswt that are learned in parallel. Altogether, these choices at = a1t , . . . ,a N t define a sparse graph/architecture Zt ≡ at for which a validation loss L (val) t (Zt,wt) is computed and used by the agents to update their policies. After T rounds, an architecture is recommended by sampling ajT+1 ∼ π j T+1, for all j ∈ {1, . . . , N}. These dynamics resemble bandit algorithms where the actions for an agent Aj 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 Lt(at)−min a T∑ t=1 Lt(a), r?T,π= sup ν E T∑ t=1 Lt(aT+1)−min a T∑ t=1 Lt(a) (3)
where the expectation is taken over both the losses and policy distributions and a = {a(Aj)}Nj=1 denotes a joint action profile. The simple regret leads to minimising the loss of the recommended architecture aT+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 bywt. We let Lt(at) be potentially adversarilly designed to account for the difference between w?t and wt and make no assumption on its convergence. Our models and solutions in Section 5 are designed to be robust to arbitrary Lt(at).

heading: 5 SOLUTION METHODS
text: 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 KN . 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 Ai, a quantity B̃it[k] (similar to α in Section 3) that quantifies the contribution of the operation to the observed losses.

heading: 5.1 MANAS-LS
text: Linear Decomposition of the Loss. A simple credit assignment strategy is to approximate edgeimportance (or edge-weight) by a vector βs ∈ RKN 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 ws 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 = βTsZs (4)
where Zs ∈ {0, 1}KN is a vectorised version of the architecture Zs containing all action choices. After evaluating S architectures, at round t we estimate β by solving the following via least-squares:
Credit assignment: B̃t = min β S∑ s=1 ( L(val)s − βTZs )2 . (5)
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 RiT ( πi, νi ) defined in the appendix: R?T = supν RT (π, ν) ⇐⇒ supνi RiT ( πi, νi ) , i = 1, . . . , N . This decomposition allows us to significantly reduce the search space and apply upcoming sampling techniques for each agent Ai in a completely parallel fashion. Zipf Sampling for r?T,π . Ai samples an operation k proportionally to the inverse of its estimated rank 〈̃k〉 i
t, where 〈̃k〉 i t is computed by sorting the operations of agent Ai w.r.t B̃it[k], as
Sampling policy: πit+1[k] = 1 / 〈̃k〉 i tlogK where logK = 1 + 1/2 + . . .+ 1/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).

heading: 5.2 MANAS
text: 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 (at). This results in obtaining all the agents performing a coordinated descent approach to the problem. Each agent updates for operation k its B̃it[k] as
Credit assignment: B̃it[k] = B̃ i t−1[k] + L (val) t 1ait=k /πit[k]. (6)
Softmax Sampling for R?T,π . Based on EXP3 (Auer et al., 2002), samples are from a softmax distribution (with temperature η) w.r.t. B̃it[k] and the aim is to always pull the best operation as
Sampling policy: πit+1[k] = exp ( ηB̃it[k] )/ K∑ j=1 exp ( ηB̃it[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.

heading: 5.3 THEORETICAL GUARANTEES
text: 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 (√ TK logK ) which sums over agents to O ( N √ TK logK ) . 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(minj 6=k?i ,1≤i≤N}B i T [j] − BiT [k?i ]), where k?i = min1≤j≤K BiT [j]) and BiT [j] =∑T
t=1 β (Ai) t [j]. The proof in given in Appendix D.1.

heading: 6 EXPERIMENTS RESULTS
text: 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.

heading: 6.1 RESULTS ON CIFAR-10
text: 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
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).

heading: 6.2 RESULTS ON IMAGENET
text: 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).

heading: 6.3 RESULTS ON NEW DATASETS: SPORT-8, CALTECH-101, MIT-67
text: 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 8112 and 8280 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.

heading: 7 CONCLUSIONS
text: 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.

heading: A DATASETS
text: 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.
B IMPLEMENTATION DETAILS
B.1 METHODS
MANAS. Our code is based on a modified variant of Liu et al. (2019). To set the temperature and gamma, we used as starting estimates the values suggested by Bubeck et al. (2012): t = 1η with η = 0.95 √ ln(K)
nK (K number of actions, n number of architectures seen in the whole training). γ = 1.05K ln(K)n . We then tuned them to increase validation accuracy during the search.
MANAS-LS. 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 = ( ZZT )† 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.

heading: C FACTORIZING THE REGRET
text: Factorizing the Regret: Let us firstly formulate the multi-agent combinatorial online learning in a more formal way. Recall, at each round, agent Ai samples an action from a fixed discrete collection {a(Ai)j }Kj=1. Therefore, after each agent makes a choice of its action at round t, the resulting network architecture Zt is described by joint action profile ~at = [ a (A1),[t] j1 , . . . ,a (AN ),[t] jN
] and thus, we will use Zt and ~at interchangeably. Due to the discrete nature of the joint action space, the validation loss vector at round t is given by ~L (val) t = ( L(val)t ( Z(1)t ) , . . . ,L(val)t ( Z(K N ) t )) and
for the environment one can write ν = ( ~L (val) 1 , . . . , ~L (val) T ) . The interconnection between joint policy π and an environment ν works in a sequential manner as follows: at round t, the architecture Zt ∼ πt(·|Z1,L(val)1 , . . . ,Zt−1,L (val) t−1 ) is sampled and validation loss L (val) t = L (val) t (Zt) is observed1. As we mentioned previously, assuming linear contribution of each individual actions to the validating loss, one goal is to find a policy π that keeps the regret:
RT (π, ν) = E [ T∑ t=1 βTt Zt − min Z∈F [ T∑ t=1 βTt Z ]] (7)
small with respect to all possible forms of environment ν. We reason here with the cumulative regret the reasoning applies as well to the simple regret. Here, βt ∈ RKN+ is a contribution vector of all actions and Zt is binary representation of architecture Zt and F ⊂ [0, 1]KN is set of all feasible architectures2. In other words, the quality of the policy is defined with respect to worst-case regret:
R∗T = sup ν RT (π, ν) (8)
Notice, that linear decomposition of the validation loss allows to rewrite the total regret (7) as a sum of agent-specific regret expressionsR(Ai)T ( π(Ai), ν(Ai) ) for i = 1, . . . , N :
RT (π, ν) = E  T∑ t=1  N∑ i=1 β (Ai),T t Z (Ai) t − N∑ i=1 min Z(Ai)∈B(K)||·||0,1(0) [ T∑ t=1 β (Ai),T t Z (Ai) ] =
N∑ i=1 E  T∑ t=1 β (Ai),T t Z (Ai) t − min Z(Ai)∈B(K)||·||0,1(0) [ T∑ t=1 β (Ai),T t Z (Ai) ] =
N∑ i=1 R(Ai)T ( π(Ai), ν(Ai) ) where βt = [ βA1,Tt , . . . ,β AN ,T t ]T and Zt = [ Z (A1),T t , . . . ,Z (AN ),T t
]T , Z =[
Z(A1),T, . . . ,Z(AN ),T ]T
are decomposition of the corresponding vectors on agent-specific parts, joint policy π(·) = ∏N i=1 π (Ai)(·), and joint environment ν = ∏N i=1 ν
(Ai), and B(K)||·||0,1(0) is unit ball with respect to || · ||0 norm centered at 0 in [0, 1]K . Moreover, the worst-case regret (8) also can be decomposed into agent-specific form:
R?T = sup ν RT (π, ν) ⇐⇒ sup ν(Ai) R(Ai)T
( π(Ai), ν(Ai) ) , i = 1, . . . , N.
This decomposition allows us to significantly reduce the search space and apply the two following algorithms for each agent Ai in a completely parallel fashion.

heading: D THEORETICAL GUARANTEES
text: D.1 MANAS-LS
First, we need to be more specific on the way to obtain the estimates β̃(Ai)t [k]. 1Please notice, the observed reward is actually a random variable 2We assume that architecture is feasible if and only if each agent chooses exactly one action.
In order to obtain theoretical guaranties we considered the least-square estimates as in Cesa-Bianchi and Lugosi (2012) as
β̃t = L(val)t P †Zt where P = E [ ZZT ] with Z has law πt(·) = N∏ i=1 π (Ai) t (·) (9)
Our analysis is under the assumption that each βt ∈ RKN belongs to the linear space spanned by the space of sparse architecture Z . This is not a strong assumption as the only condition on a sparse architecture comes with the sole restriction that one operation for each agent is active.
Theorem 1. 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-LS achieves joint policy {πt}Tt=1 with expected simple regret (Equation 3) bounded by O ( e−T/H ) in any adversarial environment with complexity bounded by H = N(minj 6=k?i ,i∈{1,...,N}B (Ai) T [j]− B (Ai) T [k ? i ]), where k ? i = minj∈{1,...,K}B (Ai) T [j].
Proof. In Equation 9 we use the same constructions of estimates β̃t as in ComBand. Using Corollary 14 in Cesa-Bianchi and Lugosi (2012) we then have that B̃t is an unbiased estimates ofBt.
Given the adversary losses, the random variables β̃t can be dependent of each other and t ∈ [T ] as πt depends on previous observations at previous rounds. Therefore, we use the Azuma inequality for martingale differences by Freedman (1975).
Without loss of generality we assume that the loss L(val)t are bounded such that L (val) t ∈ [0, 1] for all t. Therefore we can bound the simple regret of each agent by the probability of misidentifying of the best operation P (k?i 6= a Ai T+1).
We consider a fixed adversary of complexity bounded by H . For simplicity, and without loss of generality, we order the operations from such that B(Ai)T [1] < B (Ai) T [2] ≤ . . . ≤ B (Ai) T [K] for all agents.
We denote for k > 1, ∆k = B (Ai) T [k]−B (Ai) T [k ? i ] and ∆1 = ∆2.
We also have λmin as the smallest nonzero eigenvalue ofM whereM isM = E[ZZT ] whereZ is a random vector representing a sparse architecture distributed according to the uniform distribution.
P (k?i 6= a Ai T+1) = P ( ∃k ∈ {1, . . . ,K} : B̃(Ai)T [1] ≥ B̃ (Ai) T [k] ) ≤ P ( ∃k ∈ {1, . . . ,K} : B(Ai)T [k]− B̃ (Ai) T [k] ≥
T∆k 2 or B̃(Ai)T [1]−B (Ai) T [1] ≥ T∆1 2 ) ≤ P ( B̃
(Ai) T [1]−B (Ai) T [1] ≥ T∆1 2
) + K∑ k=2 P ( B (Ai) T [k]− B̃ (Ai) T [k] ≥ T∆k 2 ) (a) ≤
K∑ k=1 exp ( − (∆k) 2T 2Nlog(K)/λmin ) ≤ K exp ( − (∆1) 2T
2Nlog(K)/λmin
) ,
where (a) is using Azuma’s inequality for martingales applied to the sum of the random variables with mean zero that are β̃k,t − βk,t for which we have the following bounds on the range. The range of β̃k,t is [0, Nlog(K)/λmin]. Indeed our sampling policy is uniform with probability 1/log(K) therefore one can bound β̃k,t as in (Cesa-Bianchi and Lugosi, 2012, Theorem 1) Therefore we have |β̃k,t − βk,t| ≤ Nlog(K)/λmin. We recover the result with a union bound on all agents.
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?,iT (π (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 Ai for the T rounds of the game and ν contains all the losses as ν = {L(val)t (a)}t∈{1,...,T},a∈{1,...,KN}. We then can prove the following bound for that new notion of regret. Theorem 2. Let us consider neural architecture search problem in a multi-agent combinatorial online learning form withN agents such that each agent hasK actions. Then after T rounds, MANAS achieves joint policy {πt}Tt=1 with expected cumulative regret bounded by O ( N √ TK logK ) .
Proof. First we look at the problem for each given agent Ai and we define and look at
R?,iT (π (Ai),a−i) = sup ν 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) ]] ,
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 (at) is a function of at that can take KN arbitrary values. When we fix a−i, L(val)t (a (Ai) t ,a−i) is a function of a (Ai) t that can only take K arbitrary values.
One can redefine L@,(val)t (a (Ai) t ) = L (val) t (a (Ai) t ,a−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 (a (Ai) t ). Said differently this defines a game where the new ν
′ contains all the losses as ν′ = {L@,(val)t (a(Ai))}t∈{1,...,T},a(Ai)∈{1,...,K}.
For all a−i R?,iT (EXP3,a−i) ≤ 2 √ TK log(K)
Then we have R?,iT (EXP3) ≤ sup
a−i
2 √ TK log(K)
= 2 √ TK log(K)
Then we have N∑ i=1 R?,iT (EXP3) ≤ 2N √ TK log(K)

heading: E RELATION BETWEEN WEIGHT SHARING AND CUMULATIVE REGRET
text: Ideally we would like to obtain for any given architecture Z the value Lval(Z,w?(Z)). However obtaining w?(Z) = arg minw Ltrain(w,Z) for any given fixed Z would already require heavy computations. In our approach the wt that we compute and update is actually common to all Zt as wt replaces w?(Zt). This is a simplification that leads to learning a weight wt that tend to minimise the loss EZ∼πt [Lval(Z,w(Z)] instead of minimising Lval(Zt,w(Zt). If πt is concentrated on a fixed Z then these two previous expressions would be close. Moreover when πt is concentrated on Z then wt 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 aswt might not have learned well enough to compute accurately the loss of other and potentially better architectures.

heading: F GAUSSIAN SQUEEZE DOMAIN EXPERIMENT

Review summaries:
In this paper, the authors proposed MANAS, which is based on DARTS, by approximating the problem space by factorizing them into smaller spaces, which will be solved by multiple agents. The authors claimed that this can simplified the search space so that the joint search can be more efficient to enable us to search a larger space faster. While the overall idea seems simple but the coordinating among agents can be difficult, where the authors proposed credit assignment techniques to address the issue. The final algorithm is evaluated on CV datasets as well as 3 new datasets. 

This work built on top of DARTS. In their setting, each edge on the DAG (same as the one proposed in DARTS) has one agent associated with it and every agent maintains weights to propose operations. The author introduced two ways to update these weights: 1) solving a least squares assuming the validation loss decomposes linearly on the operations (MANAS-LS); 2) only update the weights for the activated operations (MANAS). Due to the usage of bandit framework, theoretical guarantees on the regret can be derived.