Question: Represent the article for finding a single-sentence TLDR

Question: While much of the work in the design of convolutional networks over the last five years has revolved around the empirical investigation of the importance of depth, filter sizes, and number of feature channels, recent studies have shown that branching, i.e., splitting the computation along parallel but distinct threads and then aggregating their outputs, represents a new promising dimension for significant improvements in performance. To combat the complexity of design choices in multi-branch architectures, prior work has adopted simple strategies, such as a fixed branching factor, the same input being fed to all parallel branches, and an additive combination of the outputs produced by all branches at aggregation points. In this work we remove these predefined choices and propose an algorithm to learn the connections between branches in the network. Instead of being chosen a priori by the human designer, the multi-branch connectivity is learned simultaneously with the weights of the network by optimizing a single loss function defined with respect to the end task. We demonstrate our approach on the problem of multi-class image classification using four different datasets where it yields consistently higher accuracy compared to the state-of-the-art ``ResNeXt'' multi-branch network given the same learning capacity. Deep neural networks have emerged as one of the most prominent models for problems that require the learning of complex functions and that involve large amounts of training data. While deep learning has recently enabled dramatic performance improvements in many application domains, the design of deep architectures is still a challenging and time-consuming endeavor. The difficulty lies in the many architecture choices that impact-often significantly-the performance of the system. In the specific domain of image categorization, which is the focus of this paper, significant research effort has been invested in the empirical study of how depth, filter sizes, number of feature maps, and choice of nonlinearities affect performance BID8 BID17 BID24 BID19;. Recently, several authors have proposed to simplify the architecture design by defining convolutional neural networks (CNNs) in terms of combinations of basic building blocks. This strategy was arguably first popularized by the VGG networks BID25 which were built by stacking a series of convolutional layers having identical filter size (3 × 3). The idea of modularized CNN design was made even more explicit in residual networks (ResNets) BID13, which are constructed by combining residual blocks of fixed topology. While in ResNets residual blocks are stacked one on top of each other to form very deep networks, the recently introduced ResNeXt models BID31 have shown that it is also beneficial to arrange these building blocks in parallel to build multi-branch convolutional networks. The modular component of ResNeXt then consists of C parallel branches, corresponding to residual blocks with identical topology but distinct parameters. Network built by stacking these multi-branch components have been shown to lead to better than single-thread ResNets of the same capacity. While the principle of modularized design has greatly simplified the challenge of building effective architectures for image analysis, the choice of how to combine and aggregate the computations of these building blocks still rests on the shoulders of the human designer. In order to avoid a combinatorial explosion of options, prior work has relied on simple, uniform rules of aggregation DISPLAYFORM0 Submitted to 31st Conference on Neural Information Processing Systems (NIPS 2017). Do not distribute. While much of the work in the design of convolutional networks over the last 1 five years has revolved around the empirical investigation of the importance of 2 depth, filter sizes, and number of feature channels, recent studies have shown that 3 branching, i.e., splitting the computation along parallel but distinct threads and then 4 aggregating their outputs, represents a new promising dimension for significant 5 improvements in performance. To combat the complexity of design choices in 6 multi-branch architectures, prior work has adopted simple strategies, such as a 7 fixed branching factor, the same input being fed to all parallel branches, and an 8 additive combination of the outputs produced by all branches at aggregation points. In this work we remove these predefined choices and propose an algorithm to learn 10 the connections between branches in the network. Instead of being chosen a priori 11 by the human designer, the multi-branch connectivity is learned simultaneously 12 with the weights of the network by optimizing a single loss function defined with 13 respect to the end task. We demonstrate our approach on the problem of multi-class 14 image classification where it yields absolute improvements of over 3% with respect to the state-of-the-art "ResNeXt" multi-branch architecture given the same learning Submitted to 31st Conference on Neural Information Processing Systems (NIPS 2017). Do not distribute. five years has revolved around the empirical investigation of the importance of 2 depth, filter sizes, and number of feature channels, recent studies have shown that 3 branching, i.e., splitting the computation along parallel but distinct threads and then 4 aggregating their outputs, represents a new promising dimension for significant 5 improvements in performance. To combat the complexity of design choices in 6 multi-branch architectures, prior work has adopted simple strategies, such as a 7 fixed branching factor, the same input being fed to all parallel branches, and an 8 additive combination of the outputs produced by all branches at aggregation points. In this work we remove these predefined choices and propose an algorithm to learn 10 the connections between branches in the network. DISPLAYFORM0 Submitted to 31st Conference on Neural Information Processing Systems (NIPS 2017). Do not distribute.aggregating their outputs, represents a new promising dimension for 5 improvements in performance. To combat the complexity of design 6 multi-branch architectures, prior work has adopted simple strategies 7 fixed branching factor, the same input being fed to all parallel branch 8 additive combination of the outputs produced by all branches at aggrega 9In this work we remove these predefined choices and propose an algorit 10 the connections between branches in the network. DISPLAYFORM1 Submitted to 31st Conference on Neural Information Processing Systems (NIPS 2017).five years has revolved around the empirical investigation of the importance of 2 depth, filter sizes, and number of feature channels, recent studies have shown that 3 branching, i.e., splitting the computation along parallel but distinct threads and then 4 aggregating their outputs, represents a new promising dimension for significant 5 improvements in performance. To combat the complexity of design choices in 6 multi-branch architectures, prior work has adopted simple strategies, such as a 7 fixed branching factor, the same input being fed to all parallel branches, and an 8 additive combination of the outputs produced by all branches at aggregation points. In this work we remove these predefined choices and propose an algorithm to learn 10 the connections between branches in the network. DISPLAYFORM0 Submitted to 31st Conference on Neural Information Processing Systems (NIPS 2017). Do not distribute.capacity. DISPLAYFORM1 Submitted to 31st Conference on Neural Information Processing Systems (NIPS 2017). Do not distribute. DISPLAYFORM2 Figure 1: Different types of building blocks for modular network design: (a) a prototypical residual block with bottleneck convolutional layers BID13; (b) the multi-branch RexNeXt module consisting of C parallel residual blocks BID31; (c) our approach replaces the fixed aggregation points of RexNeXt with learnable masks m defining the input connections for each individual residual block.and composition. For example, ResNeXt models BID31 are based on the following set of simplifying assumptions: the branching factor C (also referred to as cardinality) is fixed to the same constant in all layers of the network, all branches of a module are fed the same input, and the outputs of parallel branches are aggregated by a simple additive operation that provides the input to the next module. In this paper we remove these predefined choices and propose an algorithm that learns to combine and aggregate building blocks of a neural network. In this new regime, the network connectivity naturally arises as a of the training optimization rather than being hand-defined by the human designer. We demonstrate our approach using residual blocks as our modular components, but we take inspiration from ResNeXt by arranging these modules in a multi-branch architecture. Rather than predefining the input connections and aggregation pathways of each branch, we let the algorithm discover the optimal way to combine and connect residual blocks with respect to the end learning objective. This is achieved by means of masks, i.e., learned binary parameters that act as "switches" determining the final connectivity in our network. The masks are learned together with the convolutional weights of the network, as part of a joint optimization via backpropagation with respect to a traditional multi-class classification objective. We demonstrate that, given the same budget of residual blocks (and parameters), our learned architecture consistently outperforms the predefined ResNeXt network in all our experiments. An interesting byproduct of our approach is that it can automatically identify residual blocks that are superfluous, i.e., unnecessary or detrimental for the end objective. At the end of the optimization, these unused residual blocks can be pruned away without any impact on the learned hypothesis while yielding substantial savings in number of parameters to store and in test-time computation.2 TECHNICAL APPROACH We begin by providing a brief review of residual blocks BID13, which represent the modular components of our architecture. We then discuss ResNeXt BID31, which inspired the multi-branch structure of our networks. Finally, we present our approach to learning the connectivity of multi-branch architectures using binary masks. Residual Learning. The framework of residual learning was introduced by He et al. BID13 as a strategy to cope with the challenging optimization of deep models. The approach was inspired by the observation that deeper neural networks, despite having larger learning capacity than shallower models, often yield higher training error, due to the difficulty of optimization posed by increasing depth. Yet, given any arbitrary shallow network, it is trivially possible to reproduce its function using a deeper model, e.g., by copying the shallow network into the top portion of the deep model and by setting the remaining layers to implement identity functions. This simple yet revealing intuition inspired the authors to introduce residual blocks, which learn residual functions with reference to the layer input. Figure 1 (a) illustrates an example of these modular components where the 3 layers in the block implement a residual function F(x). A shortcut connections aggregates the residual block output F(x) with its input x, thus computing F(x) + x, which becomes the input to the next block. The point of this module is that if at any depth in the network the representation x is already optimal, then F(x) can be trivially set to be the zero function, which is easier to learn than an identity mapping. In fact, it was shown BID13 ) that reformulating the layers as learning residuals eases optimization and enables the effective training of networks that are substantially deeper than previously possible. Since we are interested in applying our approach to image categorization, in this paper we use convolutional residual blocks using the bottleneck BID13 shown in Figure 1 (a). The first 1 × 1 layer projects the input feature maps onto a lower dimensional embedding, the second applies 3 × 3 filters, and the third restores the original feature map dimensionality. As in BID13, Batch Normalization BID15 and ReLU BID17 are applied after each layer, and a ReLU is used after each aggregation. The multi-branch architecture of ResNeXt. Recent work BID31 has shown that it is beneficial to arrange residual blocks not only along the depth dimension but also to implement parallel multiple threads of computation feeding from the same input layer. The outputs of the parallel residual blocks are then summed up together with the original input and passed on to the next module. The ing multi-branch module is illustrated in Figure 1 (b). More formally, let F(x; θ (i) j ) be the transformation implemented by the j-th residual block in module i-th of the network, where j = 1,..., C and i = 1,..., L, with L denoting the total number of modules stacked on top of each other to form the complete network. The hyperparameter C is called the cardinality of the module and defines the number of parallel branches within each module. The hyperparameter L controls the total depth of the network: under the assumption of 3 layers per residual block (as shown in the figure), the total depth of the network is given by D = 2 + 3L (an initial convolutional layer and an output fully-connected layers add 2 layers). Note that in ResNeXt all residual blocks in a module have the same topology (F) but each block has its own parameters (θ (i) j denotes the parameters of residual block j in module i). Then, the output of the i-th module is computed as: DISPLAYFORM0 Tensor y represents the input to the (i + 1)-th module. Note that the ResNeXt module effectively implements a split-transform-merge strategy that perfoms a projection of the input into separate lower-dimensional embeddings (via bottlenecks), a separate transformation within each embedding, a projection back to the high-dimensional space and a final aggregation via addition. It can be shown that the solutions that can be implemented by such module are a strict subspace of the solutions of a single layer operating on the high-dimensional embedding but at a considerably lower cost in terms of computational complexity and number of parameters. In BID31 it was experimentally shown that increasing the cardinality C is a more effective way of improving accuracy compared to increasing depth or the number of filters. In other words, given a fixed budget of parameters, ResNeXt multi-branch networks were shown to consistently outperform single-branch ResNets of the same learning capacity. We note, however, that in an attempt to ease network design, several restrictive limitations were embedded in the architecture of ResNeXt modules: each ResNeXt module implements C parallel feature extractors that operate on the same input; furthermore, the number of active branches is constant at all depth levels of the network. In the next subsection we present an approach that removes these restrictions without adding any significant burden on the process of manual network design (with the exception of a single additional integer hyperparameter for the entire network).Our masked multi-branch architecture. As in ResNeXt, our proposed architecture consists of a stack of L multi-branch modules, each containing C parallel feature extractors. However, differently from ResNeXt, each branch in a module can take a different input. The input pathway of each branch is controlled by a binary mask vector that is learned jointly with the weights of the network. Let m DISPLAYFORM1 C be the binary mask vector defining the active input connections feeding the j-th residual block in module i. If m (i) j,k = 1, then the activation volume produced by the k-th branch in module (i − 1) is fed as input to the j-th residual block of module i. If DISPLAYFORM2 j,k = 0, then the output from the k-th branch in the previous module is ignored by the j-th residual block of the current module. Thus, if we denote with y (i−1) k the output activation tensor computed by the k-th branch in module (i − 1), the input x (i) j to the j-th residual block in module i will be given by the following equation: DISPLAYFORM3 Then, the output of this block will be obtained through the usual residual computation, i.e., DISPLAYFORM4 We note that under this model we no longer have fixed aggregation nodes summing up all outputs computed from a module. Instead, the mask m (i) j now determines selectively for each block which branches from the previous module will be aggregated and provided as input to the block. Under this scheme, the parallel branches in a module receive different inputs and as such are likely to yield more diverse features. We point out that depending on the constraints posed over m (i) j, different interesting models can be realized. For example, by introducing the constraint that k m (i) j,k = 1 for all blocks j, then each residual block will receive input from only one branch (since each m (i) j,k must be either 0 or 1). It can be noted that at the other end of the spectrum, if we set m (i) j,k = 1 for all blocks j, k in each module i, then all connections would be active and we would obtain again the fixed ResNeXt architecture. In our experiments we will demonstrate that the best are achieved for a middle ground between these two extremes, i.e., by connecting each block to K branches where K is an integer-valued hyperparameter such that 1 < K < C. We refer to this hyperparameter as the fan-in of a block. As discussed in the next section, the mask vector m (i) j for each block is learned simultaneously with all the other weights in the network via backpropagation. Finally, we note that it may be possible for a residual block in the network to become unused. This happens when, as a of the optimization, block k in module (i − 1) is such that m (i) jk = 0 for all j = 1,..., C. In this case, at the end of the optimization, we prune the block in order to reduce the number of parameters to store and to speed up inference (note that this does not affect the function computed by the network). Thus, at any point in the network the total number of active parallel threads can be any number smaller than or equal to C. This implies that a variable branching factor is learned adaptively for the different depths in the network. We refer to our learning algorithm as MASKCONNECT. It performs joint optimization of a given learning objective with respect to both the weights of the network (θ) as well as the masks (m). Since in this paper we apply our method to the problem of image categorization, we use the traditional multi-class cross-entropy objective for the loss. However, our approach can be applied without change to other loss functions as well as to other tasks benefitting from a multi-branch architecture. In MASKCONNECT the weights have real values, as in traditional networks, while the branch masks have binary values. This renders the optimization more challenging. To learn these binary parameters, we adopt a modified version of backpropagation, inspired by the algorithm proposed by Courbariaux et al. BID3 to train neural networks with binary weights. During training we store and update a real-valued versionm DISPLAYFORM0 C of the branch masks, with entries clipped to lie in the continuous interval from 0 to 1.In general, the training via backpropagation consists of three steps: 1) forward propagation, 2) backward propagation, and 3) parameters update. At each iteration, we stochastically binarize the real-valued branch masks into binary-valued vectors m (i) j ∈ {0, 1} C which are then used for the forward propagation and backward propagation (steps 1 and 2). Instead, during the parameters update (step 3), the method updates the real-valued branch masksm (i) j. The weights θ of the convolutional and fully connected layers are optimized using standard backpropagation. We discuss below the details of our mask training procedure, under the constraint that at any time there can be only K active entries in the binary branch mask m (i) j, where K is a predefined integer hyperparameter with 1 ≤ K ≤ C. In other words, we impose the following constraints: DISPLAYFORM1.., C} and ∀i ∈ {1, . . ., L}.These constraints imply that each residual block receives input from exactly K branches of the previous module. Forward Propagation. During the forward propagation, our algorithm first normalizes the C real-valued branch masks for each block j to sum up to 1, i.e., such that C k=1m (i) j,k = 1. This is done so that Mult(m DISPLAYFORM2 j,C) defines a proper multinomial distribution over the C branch connections feeding into block j. Then, the binary branch mask m (i) j is stochastically generated by drawing K distinct samples a 1, a 2,..., a K ∈ {1, . . ., C} from the multinomial distribution over the branch connections. Finally, the entries corresponding to the K samples are activated in the binary branch mask vector, i.e., m DISPLAYFORM3 The input activation volume to the residual block j is then computed according to Eq. 2 from the sampled binary branch masks. We note that the sampling from the Multinomial distribution ensures that the connections with largestm (i) j,k values will be more likely to be chosen, while at the same time the stochasticity of this process allows different connectivities to be explored, particularly during early stages of the learning when the real-valued masks have still fairly uniform values. Backward Propagation. In the backward propagation step, the gradient ∂ /∂y Mask Update. In the parameter update step our algorithm computes the gradient with respect to the binary branch masks for each branch. Then, using these computed gradients and the given learning rate, it updates the real-valued branch masks via gradient descent. At this time we clip the updated real-valued branch masks to constrain them to remain within the valid interval. The same clipping strategy was adopted for the binary weights in the work of BID3.As discussed in the supplementary material, after joint training over θ and m, we have found beneficial to fine-tune the weights θ of the network with fixed binary masks (connectivity), by setting as active connections for each block j in module i those corresponding to the K largest values iñ DISPLAYFORM4 j. Pseudocode for our training procedure is given in the supplementary material. We tested our approach on the task of image categorization using several benchmarks: CIFAR-10 , CIFAR-100 BID16 ), Mini-ImageNet BID29, as well as the full ImageNet BID4. In this section we discuss achieved on CIFAR-100 and ImageNet BID4, while the for CIFAR-10 (BID16 and Mini-ImageNet BID29 can be found in the Appendix. CIFAR-100 is a dataset of color images of size 32x32. It consists of 50,000 training images and 10,000 test images. Each image in CIFAR-100 is categorized into one of 100 possible classes. Effect of fan-in (K). We start by studying the effect of the fan-in hyperparameter (K) on the performance of models built and trained using our proposed approach. The fan-in defines the number of active branches feeding each residual block. For this experiment we use a model obtained by stacking L = 6 multi-branch residual modules, each having cardinality C = 8 (number of branches in each module). We use residual blocks consisting of 3 convolutional layers with a bottleneck implementing dimensionality reduction on the number of feature channels, as shown in Figure 1. The bottleneck for this experiment was set to w = 4. Since each residual block consists of 3 layers, the total depth of the network in terms of learnable layers is D = 2 + 3L = 20.We trained and tested this architecture using different fan-in values: K = 1,.., 8. Note that varying K does not affect the number of parameters. Thus, all these models have the same learning capacity. (left) versus the connectivity learned by our method (right) using (K = 1). Each green square is a residual block, each row of C = 8 square is a multibranch module. The network consists of a stack of L = 9 modules. Arrows indicate pathways connecting residual blocks of adjacent modules. In each net, the top red circle is a convolutional layer, the bottom circle is the final fully-connected layer. It can be noticed that MASKCONNECT learns sparse connections. The squares without in/out edges are those deemed superfluous by our algorithm and can be pruned at the end of learning. This gives rise to a branching factor that varies along the depth of the net. The are shown in FIG5. We can see that the best accuracy is achieved by connecting each residual block to K = 4 branches out of the total C = 8 in each module. Using a very low or very high fan-in yields lower accuracy. Note that when setting K = C, there is no need to learn the masks. In this case each mask is simply replaced by an element-wise addition of the outputs from all the branches. This renders the model equivalent to ResNeXt BID31, which has fixed connectivity. Based on the of FIG5, in all our experiments below we use K = 4, since it gives the best accuracy, but also K = 1, since it gives high sparsity which, as we will see shortly, implies savings in number of parameters. Varying the architectures. In Table 1 we show the classification accuracy achieved with different architectures (the details of each architecture are listed in the Appendix). For each architecture we report obtained using MASKCONNECT with fan-in K = 1 and K = 4. We also include the accuracy achieved with full (as opposed to learned) connectivity, which corresponds to ResNeXt. These show that learning the connectivity produces consistently higher accuracy than using fixed connectivity, with accuracy gains of up 2.2% compared to the state-of-the-art ResNeXt model. We note that these improvements in accuracy come at little computational training cost: the average training time overhead for learning masks and weights is about 39% using our unoptimized implementation compared to learning only the weights given a fixed connectivity. Additionally, for each architecture we include models trained using sparse random connectivity (Fixed-Random). For these models, each mask is set to have K = 4 randomly-chosen active connections, and the connectivity is kept fixed during learning of the parameters. We can notice that the accuracy of these nets is considerably lower compared to our models, despite having the same connectivity density (K = 4). This shows that the improvements of our approach over ResNeXt are not due to sparser connectivity but they are rather due to learned connectivity. Parameter savings. Our proposed approach provides the benefit of automatically identifying during training residual blocks that are unnecessary. At the end of the training, the unused residual blocks can be pruned away. This yields savings in the number of parameters to store and in testtime computation. In Table 1, columns Train and Test under Params show the original number of parameters (used during training) and the number of parameters after pruning (used at test-time). Note that for the biggest architecture, our approach using K = 1 yields a parameter saving of 40% compared to ResNeXt with full connectivity (20.5M vs 34.4M), while achieving the same accuracy. Thus, in summary, using fan-in K = 4 gives models that have the same number of parameters as ResNeXt but they yield higher accuracy; using fan-in K = 1 gives a significant saving in number of parameters and accuracy on par with ResNeXt. Model with real-valued masks. We have also attempted to learn our models using real-valued masks by computing tensors in the forward and backward propagation with respect to masks DISPLAYFORM0 C rather than the binary vectors m DISPLAYFORM1 C. However, we found this variant to Table 1: CIFAR-100 accuracies (single crop) achieved by different architectures trained using the predefined full connectivity of ResNeXt (Fixed-Full) versus the connectivity learned by our algorithm (Learned). We also include models trained using random, fixed connectivity (Fixed-Random) defined by setting K = 4 random active connections per branch. Each model was trained 4 times, using different random initializations. For each model we report the best test performance as well as the mean test performance computed from the 4 runs. For our method, we report performance using K = 1 as well as K = 4. We also list the number of parameters used during training (Params-Train) and the number of parameters obtained after pruning the unused blocks (Params-Test). Our learned connectivity using K = 4 produces accuracy gains of up 2.2% compared to the strong ResNeXt model, while using K = 1 yields equivalent to ResNeXt but it induces a significant reduction in number of parameters at test time (a saving of 40% for model {29,64,8}). Connectivity Params Accuracy (%) DISPLAYFORM0 Fixed-Full, K=8 BID31 yield consistently lower compared to our models using binary masks. For example, for model {D = 29, w = 8, C = 8} the best accuracy achieved with real-valued masks is 1.93% worse compared to that obtained with binary masks. In particular we observed that for this variant, the real-valued masks change little over training even when using large learning rates. Conversely, performing the forward and backward propagation using stochastically-sampled binary masks yields a larger exploration of connectivities and in bigger changes of the auxiliary real-valued masks leading to better connectivity learning. Visualization of the learned connectivity. FIG6 provides an illustration of the connectivity learned by MASKCONNECT for K = 1 versus the fixed connectivity of ResNeXt for model {D = 29, w = 8, C = 8}. While ResNeXt feeds the same input to all blocks of a module, our algorithm learns different input pathways for each block and yields a branching factor that varies along depth. Finally, we evaluate our approach on the large-scale ImageNet 2012 dataset BID4, which includes images of 1000 classes. We train our approach on the training set (1.28M images) and evaluate it on the validation set (50K images). In TAB4, we report the Top-1 and Top-5 accuracies for three different architectures. For these experiments we set K = C/2. We can observe that for all three architectures, our learned connectivity yields an improvement in accuracy over the fixed connectivity of ResNeXt BID31. We invite the reader to review achieved on CIFAR-10 & Mini-ImageNet in the Appendix. Also on these datasets our algorithm consistently outperforms the ResNeXt models based on fixed connectivity, with accuracy gains of up to 3.8%. Despite their wide adoption, deep networks often require laborious model search in order to yield good . As a , significant research effort has been devoted to the design of algorithms for automatic model selection. However, most of this prior work falls within the genre of hyper- parameter optimization BID2 BID26 rather than architecture or connectivity learning. Evolutionary search has been proposed as an interesting framework to learn both the structure as well as the connections in a neural network BID30 BID6 BID22. Architecture search has also been recently formulated as a reinforcement learning problem with impressive . Unlike these approaches, our method is limited to learning the connectivity within a predefined architecture but it does so efficiently by gradient descent optimization of the learning objective as opposed to more costly procedures such as evolutionary search or reinforcement learning. Several authors have proposed learning connectivity by pruning unimportant weights from the network BID18 BID10 BID31 BID9 BID12. However, these prior methods operate in stages where initially the network with full connectivity is learned and then connections are greedily removed according to an importance criterion. In PathNet BID5, the connectivity within a given architecture was searched via evolution. Compare to these prior approaches, our work provides the advantage of learning the connectivity by direct global optimization of the loss function of the problem at hand rather than by greedy optimization of a proxy criterion or by evolution. Our technical approach shares similarities with the "Shake-Shake" regularization recently introduced in unpublished work BID7. This procedure was demonstrated on two-branch ResNeXt models and consists in randomly scaling tensors produced by parallel branches during each training iteration while at test time the network uses uniform weighting of tensors. Conversely, our algorithm learns an optimal binary scaling of the parallel tensors with respect to the training objective and uses the ing network with sparse connectivity at test time. Our work is also related to approaches that learn a hierarchical structure in the last one or two layers of a network in order to obtain distinct features for different categories BID20 BID1. Differently from these methods, our algorithm learns efficiently connections at all depths in the network, thus optimizing over a much larger family of connectivity models. While our algorithm is limited to optimizing the connectivity structure within a predefined architecture, Adams et al. BID0 proposed a nonparametric Bayesian approach that searches over an infinite network using MCMC. Saxena and Verbeek BID23 introduced convolutional neural fabric which are learnable 3D trellises that locally connect response maps at different layers of a CNN. Similarly to our work, they enable optimization over an exponentially large family of connectivities, albeit different from those considered here. In this paper we introduced an algorithm to learn the connectivity of deep multi-branch networks. The problem is formulated as a single joint optimization over the weights and the branch connections of the model. We tested our approach on challenging image categorization benchmarks where it led to significant accuracy improvements over the state-of-the-art ResNeXt model. An added benefit of our approach is that it can automatically identify superfluous blocks, which can be pruned without impact on accuracy for more efficient testing and for reducing the number of parameters to store. While our experiments were focused on a particular multi-branch architecture (ResNeXt) and a specific form of building block (residual block), we expect the benefits of our approach to extend to other modules and network structures. For example, it could be applied to learn the connectivity of skip-connections in DenseNets BID14, which are currently based on predefined connectivity rules. In this paper, our masks perform non-parametric additive aggregation of the branch outputs. It would be interesting to experiment with learnable (parametric) aggregations of the outputs from the individual branches. Our approach is limited to learning connectivity within a given, fixed architecture. Future work will explore the use of learnable masks for architecture discovery. Normalize the real-valued mask to sum up to 1:m DISPLAYFORM0 Set active binary mask based on drawn samples: DISPLAYFORM1 j of the mask, given branch activations y DISPLAYFORM2 and y DISPLAYFORM3 The CIFAR-10 dataset consists of color images of size 32x32. The training set contains 50,000 images, the testing set 10,000 images. Each image in CIFAR-10 is categorized into one of 10 possible classes. In Table 3, we report the performance of different models trained on CIFAR-10. From these we can observe that our models using learned connectivity achieve consistently better performance over the equivalent models trained with the fixed connectivity BID31. Table 3: CIFAR-10 accuracies (single crop) achieved by different multi-branch architectures trained using the predefined connectivity of ResNeXt (Fixed-Full) versus the connectivity learned by our algorithm (Learned). Each model was trained 4 times, using different random initializations. For each model we report the best test performance as well as the mean test performance computed from the 4 runs. Fixed-Full K=8 BID31 91.39 (91.13±0.11) Learned K=4 92.85 (92.76±0.10) Fixed-Full K=8 BID31 Mini-ImageNet is a subset of the full ImageNet BID4 dataset. It was used in BID29 BID21. It is created by randomly selecting 100 classes from the full ImageNet BID4 ). For each class, 600 images are randomly selected. We use 500 examples per class for training, and the other 100 examples per class for testing. The selected images are resized to size 84x84 pixels as in BID29 BID21. The advantage of this dataset is that it poses the recognition challenges typical of the ImageNet photos but at the same time it does not need require the powerful resources needed to train on the full ImageNet dataset. This allows to include the additional baselines involving random fixed connectivity (Fixed-Random).We report the performance of different models trained on Mini-ImageNet in TAB6. From these , we see that our models using learned connectivity with fan-in K=4 yield a nice accuracy gain over the same models trained with the fixed full connectivity of ResNeXt BID31. The absolute improvement (in Top-1 accuracy) is 3.87% for the 20-layer network and 3.17% for the 29-layer network. We can notice that the accuracy of the models with fixed random connectivity (Fixed-Random) is considerably lower compared to our nets with learned connectivity, despite having the same connectivity density (K = 4). This shows that the improvement of our approach over ResNeXt is not due to sparser connectivity but it is rather due to learned connectivity. The plot in FIG9 shows how the number of active branches varies as a function of the module depth for model {D = 29, w = 4, C = 8} trained on CIFAR-100. For K = 1, we can observe that the number of active branches tends to be larger for deep modules (closer to the output layer) compared to early modules (closer to the input). We observed this phenomenon consistently for all architectures. This suggests that having many parallel threads of computation is particularly important in deep layers of the network. Conversely, the setting K = 4 tends to produce a fairly uniform number of active branches across the modules and the number is quite close to the maximum value C. For this reason, there is little saving in terms of number of parameters when using K = 4, as there are rarely unused blocks. The plot in FIG10 shows the number of active branches as a function of module depth for model {D = 50, w = 4, C = 32} trained on ImageNet, using K = 16. Inside the brackets we specify the residual block used in each multi-branch module by listing the number of input channels, the size of the convolutional filters, as well as the number of filters (number of output channels). To the right of each bracket we list the cardinality (i.e., the number of parallel branches in the module). ×2 means that the same multi-branch module is stacked twice. The first layer for all models is a convolutional layer with 16 filters of size 3 × 3. The last layer performs global average pooling followed by a softmax. The specifications of the architectures used in all our experiments on CIFAR-10 and CIFAR-100 are given in TAB7.Several of these architectures are those presented in the original ResNeXt paper BID31 and are trained using the same setup, including the data augmentation strategy. Four pixels are padded on each side of the input image, and a 32x32 crop is randomly sampled from the padded image or its horizontal flip, with per-pixel mean subtracted BID17. For testing, we use the original 32x32 image. The stacks have output feature map of size 32, 16, and 8 respectively. The models are trained on 8 GPUs with a mini-batch size of 128 (16 per GPU), with a weight decay of 0.0005 and momentum of 0.9. We adopt four incremental training phases with a total of 320 epochs. In phase 1 we train the model for 120 epochs with a learning rate of 0.1 for the convolutional and fully-connected layers, and a learning rate of 0.2 for the masks. In phase 2 we freeze the connectivity by setting as active connections for each block those corresponding to its top-K values in the masks. With these fixed learned connectivity, we finetune the model from phase 1 for 100 epochs with a learning rate of 0.1 for the weights. Then, in phase 3 we finetune the weights of the model from phase 2 for 50 epochs with a learning rate of 0.01 using again the fixed learned connectivity from phase 1. Finally, in phase 4 we finetune the weights of the model from phase 3 for 50 epochs with a learning rate of 0.001. The architectures for our ImageNet experiments are those specified in the original ResNeXt paper BID31. Table 6: Mini-ImageNet architectures with varying depth (D), and bottleneck width (w). Inside the brackets we specify the residual block used in each multi-branch module by listing the number of input channels, the size of the convolutional filters, as well as the number of filters (number of output channels). To the right of each bracket we list the cardinality (C) (i.e., the number of parallel branches in the module). ×2 means that the same multi-branch module is stacked twice. Also for these experiments, we follow the data augmentation strategy described in BID31. The input image has size 224x224 and it is randomly cropped from the resized original image. We use a mini-batch size of 256 on 8 GPUs (32 per GPU), with a weight decay of 0.0001 and a momentum of 0.9. We use four incremental training phases with a total of 120 epochs. In phase 1 we train the model for 30 epochs with a learning rate of 0.1 for the convolutional and fully-connected layers, and a learning rate of 0.2 for the masks. In phase 2 we finetune the model from phase 1 for another 30 epochs with a learning rate of 0.1 and a learning rate of 0.0 for the masks (i.e., we use the fixed connectivity learned in phase 1). In phase 3 we finetune the weights from phase 2 for 30 epochs with a learning rate of 0.01 and the learning rate of the masks is 0.0. Finally, in phase 4 we finetune the weights from phase 3 for 30 epochs with a learning rate of 0.001 while the learning rate of the masks is still set to 0.0. For the experiments on the Mini-ImageNet dataset, a 64x64 crop is randomly sampled from the scaled 84x84 image or its horizontal flip, with per-pixel mean subtracted BID17. For testing, we use the center 64x64 crop. The specifications of the models are identical to the CIFAR-100 models used in the previous subsection, except that the first input convolutional layer in the network is followed by a max pooling layer. The models are trained on 8 GPUs with a mini-batch size of 256 (32 per GPU), with a weight decay of 0.0005 and momentum of 0.9. Similar to training CIFAR-100 dataset, we also adopt four incremental training phases with a total of 320 epochs.

In this paper we introduced an algorithm to learn the connectivity of deep multi-branch networks. The approach is evaluated on image categorization where it consistently yields accuracy gains over state-of-the-art models that use fixed connectivity.

represent the short summary for finding the corresponding scientific article (long).

Neural networks can be trained to modify their own connectivity, improving their online learning performance on challenging tasks.


Question: Represent the article for finding a single-sentence TLDR.

Question: Although deep convolutional networks have achieved improved performance in many natural language tasks, they have been treated as black boxes because they are difficult to interpret. Especially, little is known about how they represent language in their intermediate layers. In an attempt to understand the representations of deep convolutional networks trained on language tasks, we show that individual units are selectively responsive to specific morphemes, words, and phrases, rather than responding to arbitrary and uninterpretable patterns. In order to quantitatively analyze such intriguing phenomenon, we propose a concept alignment method based on how units respond to replicated text. We conduct analyses with different architectures on multiple datasets for classification and translation tasks and provide new insights into how deep models understand natural language. Understanding and interpreting how deep neural networks process natural language is a crucial and challenging problem. While deep neural networks have achieved state-of-the-art performances in neural machine translation (NMT) BID18;; BID21, sentiment classification tasks BID23 ) and many more, the sequence of non-linear transformations makes it difficult for users to make sense of any part of the whole model. Because of their lack of interpretability, deep models are often regarded as hard to debug and unreliable for deployment, not to mention that they also prevent the user from learning about how to make better decisions based on the model's outputs. An important research direction toward interpretable deep networks is to understand what their hidden representations learn and how they encode informative factors when solving the target task. Some studies including;; BID8 have researched on what information is captured by individual or multiple units in visual representations learned for image recognition tasks. These studies showed that some of the individual units are selectively responsive to specific visual concepts, as opposed to getting activated in an uninterpretable manner. By analyzing individual units of deep networks, not only were they able to obtain more fine-grained insights about the representations than analyzing representations as a whole, but they were also able to find meaningful connections to various problems such as generalization of network BID5, generating explanations for the decision of the model BID25 BID9 BID26 and controlling the output of generative model .Since these studies of unit-level representations have mainly been conducted on models learned for computer vision-oriented tasks, little is known about the representation of models learned from natural language processing (NLP) tasks. Several studies that have previously analyzed individual units of natural language representations assumed that they align a predefined set of specific concepts, such as sentiment present in the text BID12 ), text lengths, quotes and brackets . They discovered the emergence of certain units that selectively activate to those specific concepts. Building upon these lines of research, we consider the following question: What natural language concepts are captured by each unit in the representations learned from NLP tasks? FIG11: We discover the most activated sentences and aligned concepts to the units in hidden representations of deep convolutional networks. Aligned concepts appear frequently in most activated sentences, implying that those units respond selectively to specific natural language concepts. To answer this question, we newly propose a simple but highly effective concept alignment method that can discover which natural language concepts are aligned to each unit in the representation. Here we use the term unit to refer to each channel in convolutional representation, and natural language concepts to refer to the grammatical units of natural language that preserve meanings; i.e. morphemes, words, and phrases. Our approach first identifies the most activated sentences per unit and breaks those sentences into these natural language concepts. It then aligns specific concepts to each unit by measuring activation value of replicated text that indicates how much each concept contributes to the unit activation. This method also allows us to systematically analyze the concepts carried by units in diverse settings, including depth of layers, the form of supervision, and dataspecific or task-specific dependencies. The contributions of this work can be summarized as follows:• We show that the units of deep CNNs learned in NLP tasks could act as a natural language concept detector. Without any additional labeled data or re-training process, we can discover, for each unit of the CNN, natural language concepts including morphemes, words and phrases that are present in the training data.• We systematically analyze what information is captured by units in representation across multiple settings by varying network architectures, tasks, and datasets. We use VD-CNN for sentiment and topic classification tasks on Yelp Reviews, AG News BID23, and DBpedia ontology dataset BID4 and ByteNet for translation tasks on Europarl BID3 and News Commentary BID20 datasets.• We also analyze how aligned natural language concepts evolve as they get represented in deeper layers. As part of our analysis, we show that our interpretation of learned representations could be utilized at designing network architectures with fewer parameters but with comparable performance to baseline models. Recent works on interpreting hidden representations at unit-level were mostly motivated by their counterparts in computer vision. In the computer vision community, BID24 retrieved image samples with the highest unit activation, for each of units in a CNN trained on image recognition tasks. They used these retrieved samples to show that visual concepts like color, texture and object parts are aligned to specific units, and the concepts were aligned to units by human annotators. introduced BRODEN dataset, which consists of pixel-level segmentation labels for diverse visual concepts and then analyzed the correlation between activation of each unit and such visual concepts. In their work, although aligning concepts which absent from BRODEN dataset requires additional labeled images or human annotation, they quantitatively showed that some individual units respond to specific visual concepts. On the other hand,; BID8; BID16 discovered visual concepts aligned to each unit by optimizing a random initial image to maximize the unit activation by gradient descent. In these cases, the ing interpretation of each unit is in the form of optimized images, and not in the natural language form as the aforementioned ones. However, these continuous interpretation make it hard for further quantitative analyses of discrete properties of representations, such as quantifying characteristics of representations with layer depth and correlations between the interpretability of a unit and regularization BID25. Nevertheless, these methods have the advantage that the are not constrained to a predefined set of concepts, giving flexibility as to which concepts are captured by each unit. In the NLP domain, studies including; BID19 BID11; BID14 analyzed the internal mechanisms of deep models used for NLP and found intriguing properties that appear in units of hidden representations. Among those studies, the closest one to ours is BID12, who defined a unit as each element in the representation of an LSTM learned for language modeling and found that the concept of sentiment was aligned to a particular unit. Compared with these previous studies, we focus on discovering a much wider variety of natural language concepts, including any morphemes, words, and phrases all found in the training data. To the best our knowledge, this is the first attempt to discover concepts among all that exist in the form of natural language from the training corpus. By extending the scope of detected concepts to meaningful building blocks of natural language, we provide insights into how various linguistic features are encoded by the hidden units of deep representations. Most previous work that analyzes the learned representation of NLP tasks focused on constructing downstream tasks that predict concepts of interest. A common approach is to measure the performance of a classification model that predicts the concept of interest to see whether those concepts are encoded in representation of a input sentence. For example,;; BID27 proposed several probing tasks to test whether the (non-)linear regression model can predict well the syntactic or semantic information from the representation learned on translation tasks or the skip-thought or word embedding vectors. BID15 constructed regression tasks that predict labels such as voice, tense, part-of-speech tag, and morpheme from the encoder representation of the learned model in translation task. Compared with previous work, our contributions can be summarized as follows. FORMULA1 By identifying the role of the individual units, rather than analyzing the representation as a whole, we provide more fine-grained understanding of how the representations encode informative factors in training data. Rather than limiting the linguistic features within the representation to be discovered, we focus on covering concepts of fundamental building blocks of natural language (morphemes, words, and phrases) present in the training data, providing more flexible interpretation without relying on a predefined set of concepts. Our concept alignment method does not need any additional labeled data or re-training process, so it can always provide deterministic interpretation using only the training data. We focus on convolutional neural networks (CNNs), particularly their character-level variants. CNNs have shown great success on various natural language applications, including translation and sentence classification (; ; BID23). Compared to deep architectures based on fully connected layers, CNNs are natural candidates for unit-level analysis because their channel-level representations are reported to work as templates for detecting concepts .Our approach for aligning natural language concepts to units is summarized as follows. We first train a CNN model for each natural language task (e.g. translation and classification) and retrieve training sentences that highly activate specific units. Interestingly, we discover morphemes, words and phrases that appear dominantly within these retrieved sentences, implying that those concepts have a significant impact on the activation value of the unit. Then, we find a set of concepts which attribute a lot to the unit activation by measuring activation value of each replicated candidate concept, and align them to unit. Once we train a CNN model for a given task, we feed again all sentences S in the training set to the CNN model and record their activations. Given a layer and sentence s ∈ S, let A DISPLAYFORM0, where Z is a normalizer. We then retrieve top K training sentences per unit with the highest mean activation a u. Interestingly, some natural language patterns such as morphemes, words, phrases frequently appear in the retrieved sentences (see FIG11, implying that those concepts might have a large attribution to the activation value of that unit. We propose a simple approach for identifying the concepts as follows. For constructing candidate concepts, we parse each of top K sentences with a constituency parser BID2 . Within the constituency-based parse tree, we define candidate concepts as all terminal and nonterminal nodes (e.g. from sentence John hit the balls, we obtain candidate concepts as {John, hit, the, balls, the balls, hit the balls, John hit the balls}). We also break each word into morphemes using a morphological analysis tool BID22 and add them to candidate concepts (e.g. from word balls, we obtain morphemes {ball, s}). We repeat this process for every top K sentence and build a set of candidate concepts for unit u, which is denoted as C u = {c 1, ..., c N}, where N is the number of candidate concepts of the unit. Next, we measure how each candidate concept contributes to the unit's activation value. For normalizing the degree of an input signal to the unit activation, we create a synthetic sentence by replicating each candidate concept so that its length is identical to the average length of all training sentences (e.g. candidate concept the ball is replicated as the ball the ball the ball...). Replicated sentences are denoted as R = {r 1, ..., r N}, and each r n ∈ R is forwarded to CNN, and their activation value of unit u is measured as a u (r n) ∈ R, which is averaged over l entries. Finally, the degree of alignment (DoA) between a candidate concept c n and a unit u is defined as follows: DISPLAYFORM0 In short, the DoA 1 measures the extent to unit u's activation is sensitive to the presence of candidate concept c n. If a candidate concept c n appears in the top K sentences and unit's activation value a u is responsive to c n a lot, then DoA u,cn gets large, suggesting that candidate concept c n is strongly aligned to unit u. Finally, for each unit u, we define a set of its aligned concepts C * u = {c * 1, ..., c * M} as M candidate concepts with the largest DoA values in C u. Depending on how we set M, we can detect different numbers of concepts per unit. In this experiment, we set M to 3. We analyze representations learned on three classification and four translation datasets shown in Table 1. Training details for each dataset are available in Appendix B. We then focus on the representations in each encoder layer of ByteNet and convolutional layer of VDCNN, because as BID6 pointed out, the representation of the decoder (the output layer in the case of classification) is specialized for predicting the output of the target task rather than for learning the semantics of the input text. To quantitatively evaluate how well our approach aligns concepts, we measure how selectively each unit responds to the aligned concept. Motivated by BID5, we define the concept selectivity of a unit u, to a set of concepts C * u that our alignment method detects, as follows: DISPLAYFORM0 where S denotes all sentences in training set, and µ + = 1 |S+| s∈S+ a u (s) is the average value of unit activation when forwarding a set of sentences S +, which is defined as one of the following:• replicate: S + contains the sentences created by replicating each concept in C * u. As before, the sentence length is set as the average length of all training sentences for fair comparison.• one instance: S + contains just one instance of each concept in C * u. Thus, the input sentence length is shorter than those of others in general.• inclusion: S + contains the training sentences that include at least one concept in C * u.• random: S + contains randomly sampled sentences from the training data. DISPLAYFORM1 is the average value of unit activation when forwarding S −, which consists of training sentences that do not include any concept in C * u. Intuitively, if unit u's activation is highly sensitive to C * u (i.e. those found by our alignment method) and if it is not to other factors, then Sel u gets large; otherwise, Sel u is near 0. FIG0 shows the mean and variance of selectivity values for all units learned in each dataset for the four S + categories. Consistent with our intuition, in all datasets, the mean selectivity of the replicate set is the highest with a significant margin, that of one instance, inclusion set is the runner-up, and that of the random set is the lowest. These support our claims that units are selectively responsive to specific concepts and our method is successful to align such concepts to units. Moreover, the mean selectivity of the replicate set is higher than that of the one instance set, which implies that a unit's activation increases as its concepts appear more often in the input text. FIG2 shows examples of the top K sentences and the aligned concepts that are discovered by our method, for selected units. For each unit, we find the top K = 10 sentences that activate the most in several encoding layers of ByteNet and VDCNN, and select some of them (only up to five sentences are shown due to space constraints). We observe that some patterns appear frequently within the top K sentences. For example, in the top K sentences that activate unit 124 of 0th layer of ByteNet, the concepts of'(', ')','-' appear in common, while the concepts of soft, software, wi appear frequently in the sentences for unit 19 of 1st layer of VDCNN. These qualitatively show that individual units are selectively responsive to specific natural language concepts. More interestingly, we discover that many units could capture specific meanings or syntactic roles beyond superficial, low-level patterns. For example, unit 690 of the 14th layer in ByteNet captures (what, who, where) concepts, all of which play a similar grammatical role. On the other hand, unit 224 of the 14th layer in ByteNet and unit 53 of the 0th layer in VDCNN each captures semantically similar concepts, with the ByteNet unit detecting the meaning of certainty in knowledge (sure, know, aware) and the VDCNN unit detecting years. This suggests that, although we train character-level CNNs with feeding sentences as the form of discrete symbols (i.e. character indices), individual units could capture natural language concepts sharing a similar semantic or grammatical role. More quantitative analyses for such concepts are available in Appendix E.• That is not the subject of this communication.• That is the purpose of this communication.• I would like to ask the Commissioner for a reply.• This is impossible without increasing efficiency.• Will we be able to achieve this, Commissioner?Layer 06, Unit 396: of this communication, will, communication• qualcomm has inked a licensing agreement with Microsoft • peoplesoft wants its customers to get aggressive with software upgrades to increase efficiency.• provide its customers with access to wi-fi hotspots around.. • realnetworks altered the software for market-leading ipod.• apple lost one war to microsoft by not licensing its mac… • They know that and we know that.• I am sure you will understand.• I am sure you will do this.• I am confident that we will find a solution. We note that there are units that detect concepts more abstract than just morphemes, words, or phrases, and for these units, our method tends to align relevant lower-level concepts. For example, in unit 244 of the 3rd layer in VDCNN, while each aligned concept emerges only once in the top K sentences, all top K sentences have similar nuances like positive sentiments. In this case, our method does capture relevant phrase-level concepts (e.g., very disappointing, absolute worst place), indicating that the higher-level nuance (e.g., negativity) is indirectly captured. We note that, because the number of morphemes, words, and phrases present in training corpus is usually much greater than the number of units per layer, we do not expect to always align any natural language concepts in the corpus to one of the units. Our approach thus tends to find concepts that are frequent in training data or considered as more important than others for solving the target task. Overall, these suggest how input sentences are represented in the hidden layers of the CNN:• Several units in the CNN learned on NLP tasks respond selectively to specific natural language concepts, rather than getting activated in an uninterpretable way. This means that these units can serve as detectors for specific natural language concepts.• There are units capturing syntactically or semantically related concepts, suggesting that they model the meaning or grammatical role shared between those concepts, as opposed to superficially modeling each natural language symbol. Using the concept alignments found earlier, we can visualize how concepts are distributed across layers. FIG3 shows the concepts of the units in the 0th, 1st, 3rd layer of VDCNN learned on AGNews dataset, and 0th, 4th, and 14th layer of the ByteNet encoder learned on English-to-German Europarl dataset with their number of aligned units. For each layer, we sort concepts in decreasing order by the number of aligned units and show 30 concepts most aligned. Recall that, since we align concepts for each unit, there are concepts aligned to multiple units simultaneously. Concept distribution for other datasets are available in Appendix G.Overall, we find that data and task-specific concepts are likely to be aligned to many units. In AG News, since the task is to classify given sentences into following categories; World, Sports, Business and Science/Tech, concepts related to these topics commonly emerge. Similarly, we can see that units learned for Europarl dataset focus to encode some key words (e.g. vote, propose, environment) in the training corpus. In computer vision tasks, visual concepts captured by units in CNN representations learned for image recognition tasks evolve with layer depths; color, texture concepts are emergent in earlier layers and more abstract concepts like parts and objects are emergent in deeper layers. To confirm that it also holds for representations learned in NLP tasks, we divide granularity of natural language concepts to the morpheme, word and N -gram phrase (N = 2, 3, 4, 5), and observe the number of units that they are aligned in different layers. FIG4 shows this trend, where in lower layers such as the 0th layer, fewer phrase concepts but more morphemes and words are detected. This is because we use a character-level CNN, whose receptive fields of convolution may not be large enough to detect lengthy phrases. Further, interestingly in translation cases, we observe that concepts significantly change in shallower layers (e.g. from the 0th to the 4th), but do not change much from middle to deeper layers (e.g. from the 5th to the 14th).Thus, it remains for us to answer the following question: for the representations learned on translation datasets, why does concept granularity not evolve much in deeper layers? One possibility is that the capacity of the network is large enough so that the representations in the middle layers could be sufficiently informative to solve the task. To validate this hypothesis, we re-train ByteNet from scratch while varying only layer depth of the encoder and fixing other conditions. We record their BLEU scores on the validation data as shown in FIG5. The performance of the translation model does not change much with more than six encoder layers, but it significantly drops at the models with fewer than 4 encoder layers. This trend coincides with the from FIG4 that the evolution of concept granularity stops around middle-to-higher layers. This shared pattern suggests that about six encoder layers are enough to encode informative factors in the given datasets to perform optimally on the translation task. In deeper models, this may suggest that the middle layer's representation may be already informative enough to encode the input text, and our may partly coincide with that of BID6, which shows that representation of intermediate layers is more transferable than that of deeper layers in language tasks, unlike in computer vision where deeper layers are usually more useful and discriminative. We show how many units each concept is aligned per layer in Section 4.4 and Appendix G. We observe that the concepts do not appear uniformly; some concepts are aligned to many units, while others are aligned to few or even no units. Then, the following question arises: What makes certain concepts emerge more than others?Two possible hypotheses may explain the emergence of dominant concepts. First, the concepts with a higher frequency in training data may be aligned to more units. FIG6 -(a) shows the correlation between the frequency of each concept in the training corpus and the number of units where each concept is aligned in the last layer of the topic classification model learned on AG News dataset. Second, the concepts that have more influence on the objective function (expected loss) may be aligned to more units. We can measure the effect of concept c on the task performance as Delta of Expected Loss (DEL) as follows: DISPLAYFORM0 where S is a set of training sentences, and Y is the set of ground-truths, and L(s, y) is the loss function for the input sentence s and label y. Occ c (s) is an occlusion of concept c in sentence s, where we replace concept c by dummy character tokens that have no meaning. If sentence s does not include concept c, Occ c (s) equals to original sentence s. As a , DEL(c) measures the impact of concept c on the loss function, where a large positive value implies that concept c has an important role for solving the target task. We proposed a simple but highly effective concept alignment method for character-level CNNs to confirm that each unit of the hidden layers serves as detectors of natural language concepts. Using this method, we analyzed the characteristics of units with multiple datasets on classification and translation tasks. Consequently, we shed light on how deep representations capture the natural language, and how they vary with various conditions. An interesting future direction is to extend the concept coverage from natural language to more abstract forms such as sentence structure, nuance, and tone. Another direction is to quantify the properties of individual units in other models widely used in NLP tasks. In particular, combining our definition of concepts with the attention mechanism (e.g. Bahdanau et al. FORMULA1) could be a promising direction, because it can reveal how the representations are attended by the model to capture concepts, helping us better understand the decision-making process of popular deep models. In section 3.2, we define Degree of Alignment (DoA) between concept c n and unit u as activation value of unit u for replication of c n. We tried lots of stuff while we were working on DoA metrics, but a lot of it gives biased concept alignment for several reasons. We here provide the things we tried and their reasons for failure. Point-wise Mutual Information (PMI) is a measure of association used in information theory and statistics. The PMI of a pair of samples x and y sampled from random variables X and Y quantifies the discrepancy between the probability of their coincidence as follows: DISPLAYFORM0 We then define DoA between candidate concept c n and unit u by using PMI as follow: DISPLAYFORM1, where (5a) DISPLAYFORM2 DISPLAYFORM3 DISPLAYFORM4 However, this metric has a bias of always preferring lengthy concepts even in earlier layers, which is not possible considering the receptive field of the convolution. Our intuition for this bias is consistent with BID13, where it is a well-known problem with PMI, which is its tendency to give very high association scores to pairs involving low-frequency ones, as the denominator is small in such cases. If certain concept c n in top K sentences is very lengthy, then its frequency in the corpus p(c n) would get very small, and pmi(u, c n) would be large with regardless of correlation between u and c n. We tested concept alignments with the following concept occlusion method. For each of the top K sentences, we replace a c n by dummy character tokens which have no meaning, forward it to the model, and measure the reduction of the unit activation value. We repeat this for every candidate concept in the sentences -as a , we can identify which candidate concept greatly reduce unit activation values. We thus define concepts aligned to each unit as the candidate concept that consistently lower the unit activation across the top K sentences. More formally, for each unit u, let S = {s 1, ..., s K} be top K activated sentences. Since we occlude each candidate concept in sentences, we define the set of candidate concept C = {c 1, ..., c N}, obtained from parsing each sentence in S.We define the degree of alignment (DoA) between a concept c ∈ C and a unit u as: DISPLAYFORM0 where Z is a normalizing factor, and a u indicates the mean activation of unit u, Occ cn (s) is a sentence s where candidate concept c n is occluded, and 1(c n ∈ s) is an indicator of whether c n is included in the sentence s. In short, the DoA measures how much a candidate concept contributes to the activation of the unit's top K sentences. If a candidate concept c n appears in the top K sentences S and greatly reduces the activation of unit u, then DoA u,cn gets large, implying that the c n is strongly aligned to unit u. Unfortunately, this metric could not fairly compare the attribution of several candidate concepts. For example, consider the following two concepts c 1 = hit, c 2 = hit the ball are included in one sentence. Occluding c 2 might gives relatively large decrement in unit activation value than that of c 1, since c 1 includes c 2. For this reason, the occlusion based metric is unnecessarily dependant of the length of concept, rather than it's attribution. Note that inclusion selectivity in section 4.2 is also used as DoA. Recall that inclusion selectivity is calculated as equation 2. In this case, µ + = 1 |S+| s∈S+ a u (s) is the average value of unit activation when forwarding a set of sentences S +, where S + denotes that sentences including candidate concept c n.However, it induces a bias which is similar to section A.1. It always prefers lengthy phrases since those lengthy concepts occur few times in entire corpus. For example, assume that the activation value of unit u for the sentence including specific lengthy phase is very high. If such a phrase occurs only one time over the entire corpus, µ + is equal to the activation value of the sentence, which is relatively very high than µ + for other candidate concepts. This error could be alleviated on a very large corpus where every candidate concept occurs enough in the corpus so that estimation of µ + get relatively accurate, which is practically not possible. In Section 3.2, we replicate each candidate concept into the input sentence for computing DoA in Eq.. Since each unit works as a concept detector whose activation value increases with the length of the input sentence (Section 4.2), it is essential to normalize the length of input for fair comparison of DoA values between the concepts that have different lengths one another. Without the lengthnormalization (i.e. each input sentence consists of just one instance of the candidate concept), the DoA metric has a bias to prefer lengthy concepts (e.g. phrases) because they typically have more signals that affect the unit activation than short candidate concepts (e.g. single words). In this work, we trained a ByteNet for the translation tasks and a VDCNN for the classification tasks, both to analyze properties of representations for language. Training details are as follows., 3, 5, 10], where M is the number of selected concepts per unit. In all settings, the selectivity of replicate ones is the highest, that of one instance ones is runner-up, and that of random is the lowest near 0.CNN was learned with the same structure and hyperparameters. Our code is based on a TensorFlow implementation of VDCNN found in https://github.com/zonetrooper32/VDCNN. In Section 3.2, we set M = 3. Although M is used as a threshold to set how many concepts per unit are considered, different M values have little influence on quantitative such as selectivity in Section 4.2. FIG8 shows the mean and variance of selectivity values with different M =, where there is little variants in the overall trend; the sensitivity of the replicate set is the highest, and that of one instance is runner-up, and that of random is the lowest. Whereas some units are sensitive to specific natural language concepts as shown in Section 4.3, other unites are not sensitive to any concepts at all. We call such units as non-interpretable units, which deserve to be explored. We first define the unit interpretability for unit u as follows: DISPLAYFORM0 where S is the set of training sentences, a u (s) is the activation value of unit u, and r i is the activation value of the sentence that is made up of replicating concept c i. We define unit u as interpretable when its Interpretability(u) equals to 1, and otherwise as non-interpretable. The intuition is that if a replicated sentence that is composed of only one concept has a less activation value than the top-activated sentences, the unit is not sensitive to the concept compared to a sequence of different words. Figure 9 shows the ratio of the interpretable units in each layer on several datasets. We observe that more than 90% of units are interpretable across all layers and all datasets. • At some point, the party is going to end.• At the other extreme are Chile, Costa Rica, and Uruguay.• You gather data, do experiments, read, and write.• Cashews, shrimp, and cocaine.• Scotland has a parliament, Wales an assembly.• What would it cost the organic producers?• So what exactly were Parliament' s requirements?• I must also thank the authors of the amendments.• We have to recognise the difficult cases.• I shall therefore vote against the proposals. align concepts that are out of natural language form. For example, in unit 001 in the left of FIG11, we discover that sentence structure involves many commas in top activated sentences. Since we limit the candidate concepts to only the form of morpheme, word and phrase, such punctuation concepts are hard to be detected. Another possibility is that some units may be so-called dead units that are not sensitive to any concept at all. For example, unit 260 in the right of FIG11 has no pattern that appears consistently in top activated sentences. We introduce some units whose concepts have the shared meaning in Section 4.3. We here refer concept cluster to the concepts that are aligned to the same unit and have similar semantics or grammatical roles. We analyze how clusters are formed in the units and how they vary with the target task and layer depth. FORMULA1; we define the distance between two concepts as the Euclidean distance of their vector space embedding. We use fastText pretrained on Wikipedia dataset to project each concept into the vector space. Since fastText is a character-level N -gram based word embedding, we can universally obtain the embedding for morphemes as well as words or phrases. For phrase embedding, we split it to words, project each of them and average their embeddings. The distance between two clusters is defined as the distance between their centroids. Each central heat map represents the number of times each concept pair is aligned to the same unit. Since the concepts in the x, y-axes are ordered by the clustering , if the diagonal blocks (concept clusters) emerge more strongly, the concepts in the same unit are more likely to have the similar meanings. In FIG11, the units learned in the classification tasks tend to have stronger concept clusters than those learned in the translation tasks. Particularly, the concept clusters are highly evident in the units learned in DBpedia and AG News dataset. Our intuition is that units might have more benefits to FIG11: Concept clusters of the last layer representations learned in each task. The more distinct the diagonal blocks are, the stronger the tendency that concepts aligned to the same unit share similar meanings or semantics. See Appendix E for details. solve the task by clustering similar concepts in the classification than the translation. That is, in the classification, input sentences that have the similar concepts tend to belong to the same class label, while in the translation, different concepts should be translated to different words or phrases even if they have similar meanings in general. We analyze how concept clusters change by layer in each task. We compute the averaged pairwise distance between the concepts in each layer. We project each concept to the vector space using the three pretrained embeddings: Glove BID10, ConceptNet BID17, FORMULA4 fastText. Glove and fastText embeddings are pretrained on Wikipedia dataset, and ConcpetNet is pretrained based on the ConceptNet graph structure. FIG0 shows the averaged pairwise distances in each layer. In all tasks, there is a tendency that the concepts in the same unit become closer in the vector space as the layer goes deeper. It indicates that individual units in earlier layers tend to capture more basic text patterns or symbols, while units in deeper layers capture more abstract semantics. We investigate why certain concepts emerge more than others at Section 4.6 when the ByteNet is trained on English-to-French news dataset. Here, FIG3 shows more in other datasets. Consistent with our intuition, in all datasets, both the document frequency and the delta of expected loss are closely related to the number of units per concept. It concludes that the representations are learned for identifying not only the frequent concepts in the training set and but also the important concepts for solving the target task. In section 4.4, we visualized how concepts are distributed across layers, where the model is trained on AG News dataset and English-to-German Europarl dataset. Here, FIG4 shows concept distribution in other datasets noted in Table 1.In the classification tasks, we expect to find more concepts that are directly related to predicting the output label, as opposed to the translation tasks where the representations may have to include information on most of the words for an accurate translation. While our goal is not to relate each concept to one of the labels, we find several concepts that are more predictive to a particular label than others. Consistent with section 4.4, there are data-specific and task-specific concepts aligned in each layer; i.e. {worst, 2 stars, awful} at Yelp Review, {film, ship, school} at DBpedia, and some key words at translation datasets. Note that Yelp Review and DBpedia is a classification dataset, where the model is required to predict the polarity (i.e. +1 or -1) or ontology (i.e. Company, Educational Institution, Artist, Athlete, Officeholder, Mean of Transportation, Building, Natural Place, Village, Animal, Plant, Album, Film, Written Work) for given sentence in supervised setting. FIG5 shows the number of occurrences of each concept at different layers. We count how many times each concept appears across all layers and sort them in decreasing order. We select two concepts in the translation model and seven concepts in the classification model, as to their number of occurrences. For example, since there are 15 encoder layers in the ByteNet translation model, we select 30 concepts in total. Although task and data specific concepts emerge at different layers, there is no strong pattern between the concepts and their occurrences at multiple layers. FIG5: Aligned concepts per each task and their number of occurrences over multiple layers. See Appendix H for more details.

Represent the TLDR for finding the corresponding scientific article

We show that individual units in CNN representations learned in NLP tasks are selectively responsive to natural language concepts.

We provide insightful understanding of sequence-labeling NER and propose to use two types of cross structures, both of which bring theoretical and empirical improvements.