Semi-Supervised Neural Architecture Search

Introduction

Neural architecture search (NAS) for automatic architecture design has been successfully applied in several tasks including image classification and language modeling . NAS typically contains two components, a controller (also called generator) that controls the generation of new architectures, and an evaluator that trains candidate architectures and evaluates their accuracyAlthough a variety of metrics including accuracy, model size, and inference speed have been used as search criterion, the accuracy of an architecture is the most important and costly one, and other metrics can be easily calculated with almost zero computation cost. Therefore, we focus on accuracy in this work.. The controller learns to generate relatively better architectures via a variety of techniques (e.g., reinforcement learning , evolution , gradient optimization , Bayesian optimization ), and plays an important role in NAS . To ensure the performance of the controller, a large number of high-quality pairs of architectures and their corresponding accuracy are required as the training data.

However, collecting such architecture-accuracy pairs is expensive, since it is costly for the evaluator to train each architecture to accurately get its accuracy, which incurs the highest computational cost in NAS. Popular methods usually consume hundreds to thousands of GPU days to discover eventually good architectures . To address this problem, one-shot NAS uses a supernet to include all candidate architectures via weight sharing and trains the supernet to reduce the training time. While greatly reducing the computational cost, the quality of the training data (architectures and their corresponding accuracy) for the controller is degraded , and thus these approaches suffer from accuracy decline on downstream tasks.

In various scenarios with limited labeled training data, semi-supervised learning is a popular approach to leverage unlabeled data to boost the training accuracy. In the scenario of NAS, unlabeled architectures can be obtained through random generation, mutation , or simply going through the whole search space , which incur nearly zero additional cost. Inspired by semi-supervised learning, in this paper, we propose SemiNAS, a semi-supervised approach for NAS that leverages a large number of unlabeled architectures. Specifically, SemiNAS 1) trains an initial accuracy predictor with a set of architecture-accuracy data pairs; 2) uses the trained accuracy predictor to predict the accuracy of a large number of unlabeled architectures; and 3) adds the generated architecture-accuracy pairs to the original data to further improve the accuracy predictor. The trained accuracy predictor can be incorporated to various NAS algorithms by predicting the accuracy of unseen architectures.

SemiNAS can be applied to many NAS algorithms. We take the neural architecture optimization (NAO) algorithm as an example, since NAO has the following advantages: 1) it takes architecture-accuracy pairs as training data to train a accuracy predictor to predict the accuracy of architectures, which can directly benefit from SemiNAS; 2) it supports both conventional methods which train each architecture from scratch and one-shot methods which train a supernet with weight sharing ; and 3) it is based on gradient optimization which has shown better effectiveness and efficiency. Although we implement SemiNAS on NAO, it is easy to be applied to other NAS methods, such as reinforcement learning based methods and evolutionary algorithm based methods .

SemiNAS shows advantages over both conventional NAS and one-shot NAS. Compared to conventional NAS, it can significantly reduce computational cost while achieving similar accuracy, and achieve better accuracy with similar cost. Specifically, on NASBench-101 benchmark, SemiNAS achieves similar accuracy ($93.89\%$) as gradient based methods using only $1/7$ architectures. Meanwhile it achieves $94.02\%$ mean test accuracy surpassing all the baselines when evaluating the same number of architectures (with the same computational cost). Compared to one-shot NAS, SemiNAS achieves higher accuracy using similar computational cost. For image classification, within $4$ GPU days for search, we achieve $23.5\%$ top-1 error rate on ImageNet under the mobile setting. For text to speech (TTS), using $4$ GPU days for search, SemiNAS achieves $97\%$ intelligibility rate in the low-resource setting and $15\%$ sentence error rate in the robustness setting, which outperforms human-designed model by $9$ and $7$ points respectively. To the best of our knowledge, we are the first to develop NAS algorithms on text to speech (TTS) task. We carefully design the search space and search metric for TTS, and achieve significant improvements compared to human-designed architectures. We believe that our designed search space and metric are helpful for future studies on NAS for TTS.

Related Work

From the perspective of the computational cost of training candidate architectures, previous works on NAS can be categorized into conventional NAS and one-shot NAS.

Conventional NAS includes , which achieve significant improvements on several benchmark datasets. Obtaining the accuracy of the candidate architectures is expensive in conventional NAS, since they train every single architecture from scratch and usually require thousands of architectures to train. The total cost is usually more than hundreds of GPU days .

To reduce the huge cost in NAS, one-shot NAS was proposed with the help of weight sharing mechanism. proposes to include all candidate operations in the search space within a supernet and share parameters among candidate architectures. Each candidate architecture is a sub-graph in the supernet and only activates the parameters associated with it. The algorithm trains the supernet and then evaluates the accuracy of candidate architectures by the corresponding sub-graphs in the supernet. also leverage the one-shot idea to perform efficient search while using different search algorithms. Such weight sharing mechanism successfully cuts down the computational cost to less than $10$ GPU days . However, the supernet requires careful design and the training of supernet needs careful tuning. Moreover, it shows inferior performance and reproducibility compared to conventional NAS. One main cause is the short training time and inadequate update of individual architecture , which leads to an inaccurate ranking of the architectures, and provides relatively low-quality architecture-accuracy pairs for the controller.

To sum up, there exists a trade-off between computational cost and accuracy. We formalize the computational cost of the evaluator by $C=N\times T$, where $N$ is the number of architecture-accuracy pairs for the controller to learn, and $T$ is the training time of each candidate architecture. In conventional NAS, the evaluator trains each architecture from scratch and the $T$ is typically several epochsOne epoch means training on the whole dataset for once. to ensure the accuracy of the evaluation, leading to large $C$. In one-shot NAS, the $T$ is reduced to a few mini-batches, which is inadequate for training and therefore produces low-quality architecture-accuracy pairs. Our SemiNAS handles this computation and accuracy trade-off from a new perspective which reduces $N$ by leveraging a large number of unlabeled architectures.

SemiNAS

In this section, we first describe the semi-supervised training of the accuracy predictor, and then introduce the implementation of the proposed SemiNAS algorithm.

To learn from both labeled architecture-accuracy pairs and unlabeled architectures without corresponding accuracy numbers, SemiNAS trains an accuracy predictor via semi-supervised learning. Specifically, we utilize a large number of unevaluated architectures ($M$) to improve the accuracy predictor. To utilize numerous unlabeled data, we leverage self-supervised learning by predicting the accuracy of unevaluated architectures and then combine them with ground-truth data to further improve the accuracy predictor. Following , we apply dropout as noise during the training.

However, a simple accuracy predictor is hard to learn information from architectures with pseudo labels via regression task although with techniques in . Inspired by , we use an accuracy predictor framework consisting of an encoder $f_{e}$, a predictor $f_{p}$ and a decoder $f_{d}$. The encoder is implemented as an LSTM network to map the discrete architecture $x$ to continuous embedding representations $e_{x}$, and the predictor uses fully connected layers to predict the accuracy of the architecture taking the continuous embedding $e_{x}$ as input. The decoder is an LSTM to decode the continuous embedding back to discrete architecture in an auto-regressive manner. The three components are trained jointly via the regression task and the reconstruction task. The semi-supervised learning of the accuracy predictor can be decomposed into $3$ steps:

Train the encoder $f_{e}$, predictor $f_{p}$ and the decoder $f_{d}$ with $N$ architecture-accuracy pairs where each architecture is trained and evaluated.

Generate $M$ unlabeled architectures and use the trained encoder $f_{e}$ and predictor $f_{p}$ to predict their accuracy.

Use both the $N$ architecture-accuracy pairs and the $M$ self-labeled pairs together to train a better accuracy predictor.

The accuracy predictor learns information from limited number of architecture-accuracy pairs, while there are still numerous unseen architectures. With the help of the decoder, the encoder and the decoder together act like an autoencoder to learn the hidden representation of architectures. Therefore it is able for the whole framework to learn the information of architectures in an unsupervised way without the requirement of ground-truth labels (evaluated accuracy), and further improves the accuracy predictor as the three components are trained jointly. The trained accuracy predictor can be incorporated to various NAS algorithms by predicting the accuracy of unseen architectures for them.

SemiNAS brings advantages over both conventional NAS and one-shot NAS, which can be illustrated under the computational cost formulation $C=N\times T$. Compared to conventional NAS which is costly, SemiNAS can reduce the computational cost $C$ with smaller $N$ but using more additional unlabeled architectures to avoid accuracy drop, and can also further improve the performance with same computational cost. Compared to one-shot NAS which has inferior accuracy, SemiNAS can improve the accuracy by using more unlabeled architectures under the same computational cost $C$. Specifically, in order to get more accurate evaluation of architectures and improve the quality of architecture-accuracy pairs, we can extend the average training time $T$ for each individual architecture. Meanwhile, we reduce the number of architectures to be trained (i.e., $N$) to keep the total budget $C$ unchanged.

2 The Implementation of SemiNAS

We now describe the implementation of our SemiNAS algorithm. We take NAO as our implementation since it has following advantages: 1) it contains an encoder-predictor-decoder framework, where the encoder and the predictor can predict the accuracy for large number of architectures without evaluation, and is straightforward to incorporate our method; 2) it performs architecture search by applying gradient ascent which has shown better effectiveness and efficiency; 3) it can incorporate both conventional NAS (whose evaluator trains each architecture from scratch) and one-shot NAS (whose evaluator builds a supernet to train all the architectures via weight sharing).

NAO uses an encoder-predictor-decoder framework as the controller, where the encoder $f_{e}$ maps the discrete architecture representation $x$ into continuous representation $e_{x}=f_{e}(x)$ and uses the predictor $f_{p}$ to predict its accuracy $\hat{y}=f_{p}({e_{x}})$. Then it uses a decoder $f_{d}$ that is implemented based on a multi-layer LSTM to reconstruct the original discrete architecture from the continuous representation $x=f_{d}(e_{x})$ in an auto-regressive manner.

After the controller is trained, for any given architecture $x$ as the input, NAO moves its representation $e_{x}$ towards the direction of the gradient ascent of the accuracy prediction $f_{p}(e_{x})$ to get a new and better continuous representation $e^{\prime}_{x}$ as follows: $e_{x}^{\prime}=e_{x}+\eta\frac{\partial f_{p}(e_{x})}{\partial e_{x}}$, where $\eta$ is a step size. $e^{\prime}_{x}$ can get higher prediction accuracy $f_{p}(e^{\prime}_{x})$ after gradient ascent. Then it uses the decoder $f_{d}$ to decode $e_{x}^{\prime}$ into a new architecture $x^{\prime}$, which is supposed to be better than architecture $x$. The process of the architecture optimization is performed for $L$ iterations, where newly generated architectures at the end of each iteration are added to the architecture pool for evaluation and further used to train the controller in the next iteration. Finally, the best performing architecture in the architecture pool is selected out as the final result.

With the semi-supervised method proposed in Section 3.1, we propose our SemiNAS as shown in Alg. 1. First we train the encoder-predictor-decoder on limited number ($N$) of architecture-accuracy pairs (line 5). Then we train the encoder-predictor-decoder with additional $M$ unlabeled architectures (line 6-8). Finally, we perform the step of generating new architectures as the same in (line9-10).

3 Discussions

Although our SemiNAS is mainly implemented based on NAO in this paper, the key idea of utilizing the trained encoder $f_{e}$ and predictor $f_{p}$ to predict the accuracy of numerous unlabeled architectures can be extended to a variety of NAS methods. For reinforcement learning based algorithms where the controller is usually an RNN model, we can predict the accuracy of the architectures generated by the RNN and take the predicted accuracy as the reward to train the controller. For evolution based methods , we can predict the accuracy of the architectures generated through mutation and crossover, and then take the predicted accuracy as the fitness of the generated architectures.

Application to Image Classification

In this section, we demonstrate the effectiveness of SemiNAS on image classification tasks. We first conduct experiments on NASBench-101 and then on the commonly used large-scale ImageNet.

NASBench-101 designs a cell-based search space following the common practice . It includes $423,624$ CNN architectures and trains each architecture CIFAR-10 for $3$ times. Querying the accuracy of an architecture from the dataset is equivalent to training and evaluating the architecture. We hope to discover comparable architectures with less computational cost or better architectures with comparable computational cost. Specifically, on this dataset, reducing the computational cost can be regarded as decreasing the number of queries.

Both the encoder and the decoder consist of a single layer LSTM with a hidden size of $16$, and the predictor is a three-layer fully connected network with hidden sizes of $16,64,1$ respectively. We use Adam optimizer with a learning rate of $0.001$. During search, only valid accuracy is used. After search, we report the mean test accuracy of the selected architecture over the $3$ runs. We report two settings of SemiNAS. For the first setting, we use $N=100,M=10000$ and up-sample $N$ labeled data by $100$x (directly duplicate the labeled data). We generate $100$ new architectures based on top $K=100$ architectures following line 9 in Alg. 1 at each iteration and run for $L=2$ iterations. The algorithm totally evaluates $100+100\times 2=300$ architectures. For the second setting, we set $N=1100,M=10000$ and up-sample $N$ labeled data by $10$x. We generate $300$ new architectures based on top $K=100$ architectures at each iteration and run for $L=3$ iterations. The algorithm totally queries $1100+300\times 3=2000$ architectures. For comparison, we evaluate random search, regularized evolution (RE) and NAO as baselines, where RE is validated as the best-performing algorithm in the NASBench-101 publication. We limit the number of queries of the baselines to be $2000$ for fair comparison. Particularly, we run NAO with two settings using $300$ and $2000$ architectures for better comparison considering our SemiNAS is mainly implemented based on NAO in this paper. Additionally, we also combine our semi-supervised trained accuracy predictor with RE and name it SemiNAS (RE) for comparison to show the potential of SemiNAS. All the experiments are conducted for $500$ times and we report the averaged results. Since the best test accuracy in the dataset is $94.32\%$ and several algorithms are reaching it, we also report test regret (gap to $94.32\%$) following the guide by and the ranking of the accuracy number among the whole dataset to better illustrate the improvements of our method.

All the results are listed in Table 1. Random search achieves $93.64\%$ test accuracy with a confidence interval of $[93.61\%,93.67\%]$ (alpha=$99\%$). This implies that even $0.1\%$ is a significant difference and there exists a large margin for improvement. We can see that, when using the same number of architectures-accuracy pairs ($2000$), SemiNAS outperforms all the baselines with $94.02\%$ test accuracy and corresponding $0.30\%$ test regret, which ranks top $43$ in the whole space. SemiNAS with only $300$ architectures achieves $93.89\%$ test accuracy and $0.63\%$ test regret which is on par with NAO with $2000$ architectures. Moreover, NAO using $300$ architectures only achieves $93.69\%$ which is merely better than random search. This demonstrates that with the help of unlabeled data, SemiNAS indeed outperforms baselines when using the same number of labeled architectures, and can achieve similar performance while using much less resources. Further, SemiNAS (RE) achieves $93.97\%$ which is on par with baseline RE while using only a half number of labeled architectures, and outperforms RE with $94.03\%$ when using same number of labeled architectures (2000). This implies the potential of using semi-supervised learning in NAS for speeding up the search and applying to various NAS algorithms. We also conduct experiments to study the effect of different number of unlabeled architectures ($M$) and up-sampling ratio in SemiNAS, and the results are in Section 7.2.

2 ImageNet

Previous experiments on NASBench-101 dataset verify the effectiveness and efficiency of SemiNAS in a well-controlled environment. We further evaluate our approach to the large-scale ImageNet dataset.

We adopt a MobileNet-v2 based search space following ProxylessNAS . It consists of multiple stacked layers. We search the operation of each layer. Candidate operations include mobile inverted bottleneck convolution layers with various kernel sizes $\{3,5,7\}$ and expansion ratios $\{3,6\}$, as well as zero-out layer.

We randomly sample $50,000$ images from the training data as valid set for architecture search. Since training ImageNet is too expensive, we adopt weight sharing mechanism to perform one-shot search. We train the supernet on $4$ GPUs for $20000$ steps with a batch size of $128$ per card. We set $N=100,M=4000$ and run the search process for $L=3$ iterations. In each iteration, $100$ new better architectures are generated based on top $K=100$ architectures following line 9 in Alg. 1. The search runs for $1$ day on $4$ V100 GPUs. To fairly compare with other works, we limit the FLOPS of the discovered architecture to be less than $600$M. The discovered architecture is trained for $300$ epochs with a total batch size of $256$. We use the SGD optimizer with an initial learning rate of $0.05$ and a cosine learning rate schedule . More training details are in Section 7.1. For NAO, we use the open source code https://github.com/renqianluo/NAO_pytorch and train it on the same search space used in this paper. In both SemiNAS and NAO, we train the supernet for $20000$ steps at each iteration to keep the same cost while NAO uses larger $N=1000$. For ProxylessNAS, since it also optimizes latency as additional target, for fair comparison, we use their open source code https://github.com/mit-han-lab/proxylessnas and rerun the search while optimizing accuracy without considering latency. We limit the FLOPS of discovered architecture to be less than $600$M. We run all the experiments for $5$ times.

From the results in Table 2, SemiNAS achieves $23.5\%$ top-1 test error rate on ImageNet under the $600$M FLOPS constraint, which outperforms all the other NAS works. Specifically, it significantly outperforms the baseline algorithm NAO based on which SemiNAS is mainly implemented by $1.0\%$, and outperforms ProxylessNAS where our search space is based on by $0.5\%$. The discovered architecture is depicted in Section 7.3.

Application to Text to Speech

In this section, we further explore the application of SemiNAS to a new task: text to speech.

Text to speech (TTS) is an import task aiming to synthesize intelligible and natural speech from text. The encoder-decoder based neural TTS has achieved significant improvements. However, due to the different modalities between the input (text) and the output (speech), popular TTS models are still complicated and require many human experiences when designing the model architecture. Moreover, unlike many other sequence learning tasks (e.g., neural machine translation) where the Transformer model is the dominate architecture, RNN based Tacotron , CNN based Deep Voice , and Transformer based models show comparable accuracy in TTS, without one being exclusively better than others.

The complexity of the model architecture in TTS indicates great potential of NAS on this task. However, applying NAS on TTS task also has challenges, mainly in two aspects: 1) Current TTS model architectures are complicated, including many human designed components. It is difficult but important to design the network bone and the corresponding search space for NAS. 2) Unlike other tasks (e.g., image classification) whose evaluation is objective and automatic, the evaluation of a TTS model requires subject judgement and human evaluation in the loop (e.g., intelligibility rate for understandability and mean opinion score for naturalness). It is impractical to use human evaluation for thousands of architectures in NAS. Thus, it is difficult but also important to design a specific and appropriate objective metric as the reward of an architecture during the search process. Next, we design the search space and evaluation metric for NAS on TTS, and apply SemiNAS on two specific TTS settings: low-resource setting and robustness setting.

After surveying the previous neural TTS models, we choose a multi-layer encoder-decoder based network as the network backbone for TTS. We search the operation of each layer of the encoder and the decoder. The search space includes $11$ candidate operations in total: convolution layer with kernel size $\{1,5,9,13,17,21,25\}$, Transformer layer with number of heads of $\{2,4,8\}$ and LSTM layer. Specifically, we use unidirectional LSTM layer, causal convolution layer, causal self-attention layer in the decoder to avoid seeing the information in future positions. Besides, every decoder layer is inserted with an additional encoder-decoder-attention layer to catch the relationship between the source and target sequence, where the dot-product multi-head attention in Transformer is adopted.

Current TTS systems are capable of achieving near human-parity quality when trained on adequate data and tested on regular sentences . However, current TTS models have poor performance on two specific TTS settings: 1) low-resource setting, where only few paired speech and text data is available. 2) Robustness setting, where the test sentences are not regular (e.g., too short, too long, or contain many word pieces that have the same pronunciations). Under these two settings, the synthesized speech of a human-designed TTS model is usually not accurate and robust (i.e., some words are skipped or repeated). Thus we apply SemiNAS on these two settings to improve the accuracy and robustness. We conduct experiments on the LJSpeech dataset which contains $13100$ text and speech data pairs with approximately $24$ hours of speech audio.

2 Results on Low-Resource Setting

To simulate the low-resource scenario, we randomly split out $1500$ paired speech and text samples as the training set, where the total audio length is less than $3$ hours. We use $N=100,M=4000,T=3$. We adopt the weight sharing mechanism and train the supernet on 4 GPUs for $1000$ epochs. The search runs for $1$ day on 4 P40 GPUs. Besides, we train vanilla NAO as a baseline where $N=1000$. The discovered architecture is trained on the training set for $80$k steps on 4 GPUs, with a batch size of $30$K speech frames on each GPU. More details are provided in Section 7.1. In the inference process, the output mel-spectrograms are transformed into audio samples using Griffin-Lim . We run all the experiments for $5$ times.

We test the performance of SemiNAS, NAO and Transformer TTS (following ) on the $100$ test sentences and report the results in Table 3. We measure the performances in terms of word level intelligibility rate (IR), which is a commonly used metric to evaluate the quality of generated audio . IR is defined as the percentage of test words whose pronunciation is considered to be correct and clear by human. It is shown that SemiNAS achieves $97\%$ IR, with significant improvements of $9$ points over human designed Transformer TTS and $3$ points over NAO. We also list the DFR metric for each method in Table 3, where SemiNAS outperforms Transformer TTS and NAO in terms of DFR, which is consistent with the results on IR and indicates that our proposed search metric DFR can indeed guide NAS algorithms to achieve better accuracy. We also use MOS (mean opinion score) to evaluate the naturalness of the synthesized speech. Using Griffin-Lim as the vocoder to synthesize the speech, the ground-truth mel-spectrograms achieves $3.26$ MOS, Transformer TTS achieves $2.25$, NAO achieves $2.60$ and SemiNAS achieves $2.66$. SemiNAS outperforms other methods in terms of MOS, which also demonstrates the advantages of SemiNAS. We also attach the discovered architecture by SemiNAS in Section 7.3.

3 Results on Robustness Setting

We train on the whole LJSpeech dataset as the training data. For robustness test, we select the $100$ sentences as used in (attached in Section 7.4) that are found hard for TTS models. Training details follow the same as in the low-resource TTS experiment. We also attach the discovered architecture in Section 7.3. We run all the experiments for $5$ times.

We report the results in Table 4, including the DFR, the number of sentences with repeating and skipping words, and the sentence level error rate. A sentence is counted as an error if it contains a repeating or skipping word. SemiNAS is better than Transformer TTS and NAO on all the metrics. It reduces the error rate by $7\%$ and $4\%$ compared to Transformer TTS structure designed by human experts and the searched architecture by NAO respectively.

Conclusion

High-quality architecture-accuracy pairs are critical to NAS; however, accurately evaluating the accuracy of an architecture is costly. In this paper, we proposed SemiNAS, a semi-supervised learning method for NAS. It leverages a small set of high-quality architecture-accuracy pairs to train an initial accuracy predictor, and then utilizes a large number of unlabeled architectures to further improve the accuracy predictor. Experiments on image classification tasks (NASBench-101 and ImageNet) and text to speech tasks (the low-resource setting and robustness setting) demonstrate 1) the efficiency of SemiNAS on reducing the computation cost over conventional NAS while achieving similar accuracy and 2) its effectiveness on improving the accuracy of both conventional NAS and one-shot NAS under similar computational cost. In the future, we will apply SemiNAS to more tasks such as automatic speech recognition, text summarization, etc. Furthermore, we will explore advanced semi-supervised learning methods to improve SemiNAS.

Broader Impact

This work focuses on neural architecture search. It has the following potential positive impact in the society: 1) Improve the performance of neural networks for better applications. 2) Reduce the human efforts in designing neural architectures. At the same time, it may have some negative consequences because architecture search may cost many resources.

References

Appendix

In the first setting where $N=100,M=10000$, $100$ new architectures are generated based on top $K=100$ architectures at each iteration. In the second setting where $N=1100,M=10000$, $300$ new architectures are generated based on top $K=100$ architectures at each iteration. We use $\lambda=0.8$ as the trade-off parameter to balance the regression loss and the reconstruction loss.

1.2 ImageNet

We build the supernet following . We train the supernet on $4$ GPUs for $20000$ steps with a batch size of $128$ per card. We use SGD optimizer with a learning rate of $1.6$ and decay the learning rate by a factor of 0.97 per epoch. The discovered architecture is trained on 4 P40 cards for $300$ epochs with a batch size of $64$ per card. We use the SGD optimizer with an initial learning rate of $0.05$ and a cosine learning rate schedule .

1.3 TTS

We adopt the weight sharing mechanism for search and train the supernet on 4 GPUs. The discovered architecture is trained on the training set for $80$k steps on 4 GPUs, with a batch size of $30$K speech frames on each GPU. We use the Adam optimizer with $\beta_{1}=0.9,\beta_{2}=0.98,\epsilon=1e-9$ and follow the same learning rate schedule in with $4000$ warmup steps.

2 Study of SemiNAS

In this section, we conduct experiments on NASBench-101 to study SemiNAS, including the number of unlabeled architectures $M$ and the up-sampling ratio of labeled architectures.

We study the effect of different $M$ on SemiNAS. Given $N=100$, we range $M$ within $\{0,100,200,500,1000,2000,5000,10000\}$, and plot the results in Fig. 1. Notice that $M=0$ is equivalent to NAO without using any additional evaluated architectures. We can see that the test accuracy increases as $M$ increases, indicating that utilizing unlabeled architectures indeed helps the training of the controller and generating better architectures.

Since $N$ is much smaller than $M$, we do up-sampling to balance the data. We study how the up-sampling ratio affects the effectiveness of SemiNAS on NASBench-101. We set $N=100,M=10000$ and range the up-sampling ratio in $\{1,2,5,10,20,50,100\}$ where $1$ means no up-sampling. The results are depicted in Figure 1. We can see that the final accuracy would benefit from up-sampling but will not continue to improve when the ratio is high (e.g., larger than $10$).

3 Discovered Architectures

We show the discovered architectures for the tasks by SemiNAS.

We adopt the ProxylessNAS search space which is built on the MobileNet-V2 backbone. It contains several different stages and each stage consists of multiple layers. We search the operation of each individual layer. There are $7$ candidate operations in the search space:

where MBConv is mobile inverted bottleneck convolution, k is the kernel size and r is the expansion ratio . Our discovered architecture for ImageNet is depicted in Fig. 2

3.2 TTS

We adopt encoder-decoder based architecture as the backbone, and search the operation of each layer. Candidate operations include:

The discovered architecture by SemiNAS for low-resource setting is shown in Fig. 3

The discovered architecture by SemiNAS for robustness setting is shown in Fig. 4

4 Robustness Test Sentences

We list the 100 sentences we use for robustness setting: a b c. x y z. hurry. warehouse. referendum. is it free? justifiable. environment. a debt runs. gravitational. cardboard film. person thinking. prepared killer. aircraft torture. allergic trouser. strategic conduct. worrying literature. christmas is coming. a pet dilemma thinks. how was the math test? good to the last drop. an m b a agent listens. a compromise disappears. an axis of x y or z freezers. she did her best to help him. a backbone contests the chaos. two a greater than two n nine. don’t step on the broken glass. a damned flips into the patient. a trade purges within the b b c. i’d rather be a bird than a fish. i hear that nancy is very pretty. i want more detailed information. please wait outside of the house. n a s a exposure tunes the waffle. a mist dictates within the monster. a sketch ropes the middle ceremony. every farewell explodes the career. she folded here handkerchief neatly. against the steam chooses the studio. rock music approaches at high velocity. nine adam baye study on the two pieces. an unfriendly decay conveys the outcome. abstraction is often one floor above you. a played lady ranks any publicized preview. he told us a very exciting adventure story. on august twenty eight mary plays the piano. into a controller beams a concrete terrorist. i often see the time eleven eleven on clocks. it was getting dark and we weren’t there yet. against every rhyme starves a choral apparatus. everyone was busy so i went to the movie alone. i checked to make sure that he was still alive. a dominant vegetarian shies away from the g o p. joe made the sugar cookies susan decorated them. i want to buy a onesie but know it won’t suit me. a former override of q w e r t y outside the pope. f b i says that c i a says i’ll stay way from it. any climbing dish listens to a cumbersome formula. she wrote him a long letter but he didn’t read it. dear beauty is in the heat not physical i love you. an appeal on january fifth duplicates a sharp queen. a farewell solos on march twenty third shakes north. he ran out of money so he had to stop playing poker. for example a newspaper has only regional distribution t. i currently have four windows open up and i don’t know why. next to my indirect vocal declines every unbearable academic. opposite her sounding bag is a m c’s configured thoroughfare. from april eighth to the present i only smoke four cigarettes. i will never be this young again every oh damn i just got older. a generous continuum of amazon dot com is the conflicting worker. she advised him to come back at once the wife lectures the blast. a song can make or ruin a person’s day if they let it get to them. she did not cheat on the test for it was not the right thing to do. he said he was not there yesterday however many people saw him there. should we start class now or should we wait for everyone to get here? if purple people eaters are real where do they find purple people to eat? on november eighteenth eighteen twenty one a glittering gem is not enough. a rocket from space x interacts with the individual beneath the soft flaw. malls are great places to shop i can find everything i need under one roof. i think i will buy the red car or i will lease the blue one the faith nests. italy is my favorite country in fact i plan to spend two weeks there next year. i would have gotten w w w w dot google dot com but my attendance wasn’t good enough. nineteen twenty is when we are unique together until we realise we are all the same. my mum tries to be cool by saying h t t p colon slash slash w w w b a i d u dot com. he turned in the research paper on friday otherwise he emailed a s d f at yahoo dot org. she works two jobs to make ends meet at least that was her reason for no having time to join us. a remarkable well promotes the alphabet into the adjusted luck the dress dodges across my assault. a b c d e f g h i j k l m n o p q r s t u v w x y z one two three four five six seven eight nine ten. across the waste persists the wrong pacifier the washed passenger parades under the incorrect computer. if the easter bunny and the tooth fairy had babies would they take your teeth and leave chocolate for you? sometimes all you need to do is completely make an ass of yourself and laugh it off to realise that life isn’t so bad after all. she borrowed the book from him many years ago and hasn’t yet returned it why won’t the distinguishing love jump with the juvenile? last friday in three week’s time i saw a spotted striped blue worm shake hands with a legless lizard the lake is a long way from here. i was very proud of my nickname throughout high school but today i couldn’t be any different to what my nickname was the metal lusts the ranging captain charters the link. i am happy to take your donation any amount will be greatly appreciated the waves were crashing on the shore it was a lovely sight the paradox sticks this bowl on top of a spontaneous tea. a purple pig and a green donkey flew a kite in the middle of the night and ended up sunburn the contained error poses as a logical target the divorce attacks near a missing doom the opera fines the daily examiner into a murderer. as the most famous singer-songwriter jay chou gave a perfect performance in beijing on may twenty fourth twenty fifth and twenty sixth twenty three all the fans thought highly of him and took pride in him all the tickets were sold out. if you like tuna and tomato sauce try combining the two it’s really not as bad as it sounds the body may perhaps compensates for the loss of a true metaphysics the clock within this blog and the clock on my laptop are on hour different from each other. someone i know recently combined maple syrup and buttered popcorn thinking it would taste like caramel popcorn it didn’t and they don’t recommend anyone else do it either the gentleman marches around the principal the divorce attacks near a missing doom the color misprints a circular worry across the controversy.

5 Demo of TTS

We provide demo for both low-resource setting and robustness setting of TTS experiments. Specifically, we provide 10 test cases for each setting respectively and provide their ground-truth audio (if exist), generated audio by Transformer TTS and generated audio by SemiNAS. We provide the demo at this linkhttps://speechresearch.github.io/seminas which is a web page and one can directly listen to the audio samples.

6 Implementation Details

We implement all the code in Pytorch [pytorch] with version 1.2. We implement the core architecture search algorithm following NAO https://github.com/renqianluo/NAO_pytorch. For downstream tasks, we implement the code following corresponding baselines. For ImageNet experiment, we build our code based on ProxylessNAS implementation https://github.com/mit-han-lab/proxylessnas. For TTS experiment, we build the code following Transformer TTS which is originally in Tensorflow.