id
stringlengths 12
15
| title
stringlengths 8
162
| content
stringlengths 1
17.6k
| prechunk_id
stringlengths 0
15
| postchunk_id
stringlengths 0
15
| arxiv_id
stringlengths 10
10
| references
sequencelengths 1
1
|
|---|---|---|---|---|---|---|
1603.05027#27 | Identity Mappings in Deep Residual Networks | This eï¬ ect is particularly obvious when training the 1001-layer ResNet. Fig. 1 shows the curves. Using the original design in [1], the training error is reduced very slowly at the beginning of training. For f = ReLU, the signal is impacted if it is negative, and when there are many Residual Units, this eï¬ ect becomes prominent and Eqn.(3) (so Eqn.(5)) is not a good approximation. On the other hand, when f is an identity mapping, the signal can be propagated directly between any two units. Our 1001-layer network reduces the training loss very quickly (Fig. 1). It also achieves the lowest loss among all models we investigated, suggesting the success of optimization. | 1603.05027#26 | 1603.05027#28 | 1603.05027 | [
"1602.07261"
] |
1603.05027#28 | Identity Mappings in Deep Residual Networks | We also ï¬ nd that the impact of f = ReLU is not severe when the ResNet has fewer layers (e.g., 164 in Fig. 6(right)). The training curve seems to suï¬ er a little bit at the beginning of training, but goes into a healthy status soon. By monitoring the responses we observe that this is because after some training, the weights are adjusted into a status such that yl in Eqn.(1) is more frequently above zero and f does not truncate it (xl is always non-negative due to the pre- vious ReLU, so yl is below zero only when the magnitude of F is very negative). The truncation, however, is more frequent when there are 1000 layers. | 1603.05027#27 | 1603.05027#29 | 1603.05027 | [
"1602.07261"
] |
1603.05027#29 | Identity Mappings in Deep Residual Networks | 11 12 Table 4. Comparisons with state-of-the-art methods on CIFAR-10 and CIFAR-100 using â moderate data augmentationâ (ï¬ ip/translation), except for ELU [12] with no augmentation. Better results of [13,14] have been reported using stronger data augmen- tation and ensembling. For the ResNets we also report the number of parameters. Our results are the median of 5 runs with mean±std in the brackets. All ResNets results are obtained with a mini-batch size of 128 except â with a mini-batch size of 64 (code available at https://github.com/KaimingHe/resnet-1k-layers). CIFAR-10 error (%) CIFAR-100 error (%) NIN [15] 8.81 NIN [15] 35.68 DSN [16] 8.22 DSN [16] 34.57 FitNet [17] 8.39 FitNet [17] 35.04 Highway [7] 7.72 Highway [7] 32.39 All-CNN [14] 7.25 All-CNN [14] 33.71 ELU [12] 6.55 ELU [12] 24.28 FitResNet, LSUV [18] 5.84 FitNet, LSUV [18] 27.66 ResNet-110 [1] (1.7M) 6.61 ResNet-164 [1] (1.7M) 25.16 ResNet-1202 [1] (19.4M) 7.93 ResNet-1001 [1] (10.2M) 27.82 ResNet-164 [ours] (1.7M) 5.46 ResNet-164 [ours] (1.7M) 24.33 4.92 (4.89±0.14) ResNet-1001 [ours] (10.2M) ResNet-1001 [ours] (10.2M)â 4.62 (4.69±0.20) ResNet-1001 [ours] (10.2M) 22.71 (22.68±0.22) | 1603.05027#28 | 1603.05027#30 | 1603.05027 | [
"1602.07261"
] |
1603.05027#30 | Identity Mappings in Deep Residual Networks | Reducing overï¬ tting. Another impact of using the proposed pre-activation unit is on regularization, as shown in Fig. 6 (right). The pre-activation ver- sion reaches slightly higher training loss at convergence, but produces lower test error. This phenomenon is observed on ResNet-110, ResNet-110(1-layer), and ResNet-164 on both CIFAR-10 and 100. This is presumably caused by BNâ s reg- ularization eï¬ ect [8]. In the original Residual Unit (Fig. 4(a)), although the BN normalizes the signal, this is soon added to the shortcut and thus the merged signal is not normalized. This unnormalized signal is then used as the input of the next weight layer. On the contrary, in our pre-activation version, the inputs to all weight layers have been normalized. | 1603.05027#29 | 1603.05027#31 | 1603.05027 | [
"1602.07261"
] |
1603.05027#31 | Identity Mappings in Deep Residual Networks | # 5 Results Comparisons on CIFAR-10/100. Table 4 compares the state-of-the-art meth- ods on CIFAR-10/100, where we achieve competitive results. We note that we do not specially tailor the network width or ï¬ lter sizes, nor use regularization techniques (such as dropout) which are very eï¬ ective for these small datasets. We obtain these results via a simple but essential concept â going deeper. These results demonstrate the potential of pushing the limits of depth. Comparisons on ImageNet. Next we report experimental results on the 1000- class ImageNet dataset [3]. We have done preliminary experiments using the skip connections studied in Fig. 2 & 3 on ImageNet with ResNet-101 [1], and observed similar optimization diï¬ | 1603.05027#30 | 1603.05027#32 | 1603.05027 | [
"1602.07261"
] |
1603.05027#32 | Identity Mappings in Deep Residual Networks | culties. The training error of these non-identity shortcut networks is obviously higher than the original ResNet at the ï¬ rst learning rate Table 5. Comparisons of single-crop error on the ILSVRC 2012 validation set. All ResNets are trained using the same hyper-parameters and implementations as [1]). Our Residual Units are the full pre-activation version (Fig. 4(e)). â : code/model avail- able at https://github.com/facebook/fb.resnet.torch/tree/master/pretrained, using scale and aspect ratio augmentation in [20]. method augmentation train crop test crop top-1 ResNet-152, original Residual Unit [1] ResNet-152, original Residual Unit [1] ResNet-152, pre-act Residual Unit ResNet-200, original Residual Unit [1] ResNet-200, pre-act Residual Unit ResNet-200, pre-act Residual Unit Inception v3 [19] 6.7 5.5 5.5 6.0 5.3 scale+asp ratio 224à 224 320à 320 20.1â 4.8â 5.6 scale+asp ratio 299à 299 299à 299 scale scale scale scale scale 23.0 224à 224 224à 224 21.3 224à 224 320à 320 21.1 224à 224 320à 320 224à 224 320à 320 21.8 224à 224 320à 320 20.7 21.2 top-5 | 1603.05027#31 | 1603.05027#33 | 1603.05027 | [
"1602.07261"
] |
1603.05027#33 | Identity Mappings in Deep Residual Networks | (similar to Fig. 3), and we decided to halt training due to limited resources. But we did ï¬ nish a â BN after additionâ version (Fig. 4(b)) of ResNet-101 on ImageNet and observed higher training loss and validation error. This modelâ s single-crop (224à 224) validation error is 24.6%/7.5%, vs. the original ResNet- 101â s 23.6%/7.1%. This is in line with the results on CIFAR in Fig. 6 (left). Table 5 shows the results of ResNet-152 [1] and ResNet-2003, all trained from scratch. We notice that the original ResNet paper [1] trained the models using scale jittering with shorter side s â [256, 480], and so the test of a 224à 224 crop on s = 256 (as did in [1]) is negatively biased. Instead, we test a single 320à 320 crop from s = 320, for all original and our ResNets. Even though the ResNets are trained on smaller crops, they can be easily tested on larger crops because the ResNets are fully convolutional by design. This size is also close to 299à 299 used by Inception v3 [19], allowing a fairer comparison. The original ResNet-152 [1] has top-1 error of 21.3% on a 320à 320 crop, and our pre-activation counterpart has 21.1%. The gain is not big on ResNet-152 because this model has not shown severe generalization diï¬ | 1603.05027#32 | 1603.05027#34 | 1603.05027 | [
"1602.07261"
] |
1603.05027#34 | Identity Mappings in Deep Residual Networks | culties. However, the original ResNet-200 has an error rate of 21.8%, higher than the baseline ResNet-152. But we ï¬ nd that the original ResNet-200 has lower training error than ResNet-152, suggesting that it suï¬ ers from overï¬ tting. Our pre-activation ResNet-200 has an error rate of 20.7%, which is 1.1% lower than the baseline ResNet-200 and also lower than the two versions of ResNet-152. When using the scale and aspect ratio augmentation of [20,19], our ResNet-200 has a result better than Inception v3 [19] (Table 5). Concurrent with our work, an Inception-ResNet-v2 model [21] achieves a single-crop result of 19.9%/4.9%. We expect our observations and the proposed Residual Unit will help this type and generally other types of ResNets. | 1603.05027#33 | 1603.05027#35 | 1603.05027 | [
"1602.07261"
] |
1603.05027#35 | Identity Mappings in Deep Residual Networks | Computational Cost. Our modelsâ computational complexity is linear on 3 The ResNet-200 has 16 more 3-layer bottleneck Residual Units than ResNet-152, which are added on the feature map of 28Ã 28. 13 14 depth (so a 1001-layer net is â ¼10Ã complex of a 100-layer net). On CIFAR, ResNet-1001 takes about 27 hours to train on 2 GPUs; on ImageNet, ResNet- 200 takes about 3 weeks to train on 8 GPUs (on par with VGG nets [22]). | 1603.05027#34 | 1603.05027#36 | 1603.05027 | [
"1602.07261"
] |
1603.05027#36 | Identity Mappings in Deep Residual Networks | # 6 Conclusions This paper investigates the propagation formulations behind the connection mechanisms of deep residual networks. Our derivations imply that identity short- cut connections and identity after-addition activation are essential for making information propagation smooth. Ablation experiments demonstrate phenom- ena that are consistent with our derivations. We also present 1000-layer deep networks that can be easily trained and achieve improved accuracy. Appendix: Implementation Details The implementation details and hyper- parameters are the same as those in [1]. On CIFAR we use only the translation and ï¬ ipping augmentation in [1] for training. The learning rate starts from 0.1, and is divided by 10 at 32k and 48k iterations. Following [1], for all CIFAR experiments we warm up the training by using a smaller learning rate of 0.01 at the beginning 400 iterations and go back to 0.1 after that, although we remark that this is not necessary for our proposed Residual Unit. The mini-batch size is 128 on 2 GPUs (64 each), the weight decay is 0.0001, the momentum is 0.9, and the weights are initialized as in [23]. On ImageNet, we train the models using the same data augmentation as in [1]. The learning rate starts from 0.1 (no warming up), and is divided by 10 at 30 and 60 epochs. The mini-batch size is 256 on 8 GPUs (32 each). The weight decay, momentum, and weight initialization are the same as above. When using the pre-activation Residual Units (Fig. 4(d)(e) and Fig. 5), we pay special attention to the ï¬ rst and the last Residual Units of the entire net- work. For the ï¬ rst Residual Unit (that follows a stand-alone convolutional layer, conv1), we adopt the ï¬ rst activation right after conv1 and before splitting into two paths; for the last Residual Unit (followed by average pooling and a fully- connected classiï¬ er), we adopt an extra activation right after its element-wise addition. These two special cases are the natural outcome when we obtain the pre-activation network via the modiï¬ cation procedure as shown in Fig. 5. | 1603.05027#35 | 1603.05027#37 | 1603.05027 | [
"1602.07261"
] |
1603.05027#37 | Identity Mappings in Deep Residual Networks | The bottleneck Residual Units (for ResNet-164/1001 on CIFAR) are con- structed following [1]. For example, a [x2 | unit in ResNet-110 is replaced witha 3x3 | unit in ResNet-164, both of which have roughly the same num- 1x1, 64 ber of parameters. For the bottleneck ResNets, when reducing the feature map size we use projection shortcuts [1] for increasing dimensions, and when pre- activation is used, these projection shortcuts are also with pre-activation. | 1603.05027#36 | 1603.05027#38 | 1603.05027 | [
"1602.07261"
] |
1603.05027#38 | Identity Mappings in Deep Residual Networks | # References 1. He, K., Zhang, X., Ren, S., Sun, J.: Deep residual learning for image recognition. In: CVPR. (2016) 2. Nair, V., Hinton, G.E.: Rectiï¬ ed linear units improve restricted boltzmann ma- chines. In: ICML. (2010) 3. Russakovsky, O., Deng, J., Su, H., Krause, J., Satheesh, S., Ma, S., Huang, Z., Karpathy, A., Khosla, A., Bernstein, M., Berg, A.C., Fei-Fei, L.: ImageNet Large Scale Visual Recognition Challenge. IJCV (2015) 4. Lin, T.Y., Maire, M., Belongie, S., Hays, J., Perona, P., Ramanan, D., Doll´ar, P., Zitnick, C.L.: Microsoft COCO: Common objects in context. In: ECCV. (2014) 5. Hochreiter, S., Schmidhuber, J.: Long short-term memory. Neural computation | 1603.05027#37 | 1603.05027#39 | 1603.05027 | [
"1602.07261"
] |
1603.05027#39 | Identity Mappings in Deep Residual Networks | (1997) 6. Srivastava, R.K., Greï¬ , K., Schmidhuber, J.: Highway networks. In: ICML work- shop. (2015) 7. Srivastava, R.K., Greï¬ , K., Schmidhuber, J.: Training very deep networks. NIPS. (2015) In: 8. Ioï¬ e, S., Szegedy, C.: Batch normalization: Accelerating deep network training by reducing internal covariate shift. | 1603.05027#38 | 1603.05027#40 | 1603.05027 | [
"1602.07261"
] |
1603.05027#40 | Identity Mappings in Deep Residual Networks | In: ICML. (2015) 9. LeCun, Y., Boser, B., Denker, J.S., Henderson, D., Howard, R.E., Hubbard, W., Jackel, L.D.: Backpropagation applied to handwritten zip code recognition. Neural computation (1989) 10. Krizhevsky, A.: Learning multiple layers of features from tiny images. Tech Report (2009) 11. Hinton, G.E., Srivastava, N., Krizhevsky, A., Sutskever, I., Salakhutdinov, R.R.: feature detectors. Improving neural networks by preventing co-adaptation of arXiv:1207.0580 (2012) | 1603.05027#39 | 1603.05027#41 | 1603.05027 | [
"1602.07261"
] |
1603.05027#41 | Identity Mappings in Deep Residual Networks | 12. Clevert, D.A., Unterthiner, T., Hochreiter, S.: Fast and accurate deep network learning by exponential linear units (ELUs). In: ICLR. (2016) 13. Graham, B.: Fractional max-pooling. arXiv:1412.6071 (2014) 14. Springenberg, J.T., Dosovitskiy, A., Brox, T., Riedmiller, M.: | 1603.05027#40 | 1603.05027#42 | 1603.05027 | [
"1602.07261"
] |
1603.05027#42 | Identity Mappings in Deep Residual Networks | Striving for simplic- ity: The all convolutional net. arXiv:1412.6806 (2014) 15. Lin, M., Chen, Q., Yan, S.: Network in network. In: ICLR. (2014) 16. Lee, C.Y., Xie, S., Gallagher, P., Zhang, Z., Tu, Z.: Deeply-supervised nets. In: AISTATS. (2015) 17. Romero, A., Ballas, N., Kahou, S.E., Chassang, A., Gatta, C., Bengio, Y.: Fitnets: Hints for thin deep nets. In: ICLR. (2015) 18. Mishkin, D., Matas, J.: | 1603.05027#41 | 1603.05027#43 | 1603.05027 | [
"1602.07261"
] |
1603.05027#43 | Identity Mappings in Deep Residual Networks | All you need is a good init. In: ICLR. (2016) 19. Szegedy, C., Vanhoucke, V., Ioï¬ e, S., Shlens, J., Wojna, Z.: Rethinking the incep- tion architecture for computer vision. In: CVPR. (2016) 20. Szegedy, C., Liu, W., Jia, Y., Sermanet, P., Reed, S., Anguelov, D., Erhan, D., Vanhoucke, V., Rabinovich, A.: Going deeper with convolutions. In: CVPR. (2015) 21. Szegedy, C., Ioï¬ e, S., Vanhoucke, V.: | 1603.05027#42 | 1603.05027#44 | 1603.05027 | [
"1602.07261"
] |
1603.05027#44 | Identity Mappings in Deep Residual Networks | Inception-v4, inception-resnet and the impact of residual connections on learning. arXiv:1602.07261 (2016) 22. Simonyan, K., Zisserman, A.: Very deep convolutional networks for large-scale image recognition. In: ICLR. (2015) 23. He, K., Zhang, X., Ren, S., Sun, J.: Delving deep into rectiï¬ ers: Surpassing human- level performance on imagenet classiï¬ cation. In: ICCV. (2015) 15 | 1603.05027#43 | 1603.05027 | [
"1602.07261"
] |
|
1603.04779#0 | Revisiting Batch Normalization For Practical Domain Adaptation | 6 1 0 2 v o N 8 ] V C . s c [ 4 v 9 7 7 4 0 . 3 0 6 1 : v i X r a # Under review as a conference paper at ICLR 2017 # REVISITING BATCH NORMALIZATION FOR PRACTICAL DOMAIN ADAPTATION Yanghao Li', Naiyan Wangâ , Jianping Shi°, Jiaying Liu', Xiaodi Hou* Â¥ Institute of Computer Science and Technology, Peking University *TuSimple ° SenseTime [email protected] [email protected] [email protected] [email protected] [email protected] # ° SenseTime # ABSTRACT Deep neural networks (DNN) have shown unprecedented success in various com- puter vision applications such as image classiï¬ cation and object detection. How- ever, it is still a common annoyance during the training phase, that one has to prepare at least thousands of labeled images to ï¬ | 1603.04779#1 | 1603.04779 | [
"1607.01719"
] |
|
1603.04779#1 | Revisiting Batch Normalization For Practical Domain Adaptation | ne-tune a network to a speciï¬ c domain. Recent study (Tommasi et al., 2015) shows that a DNN has strong de- pendency towards the training dataset, and the learned features cannot be easily transferred to a different but relevant task without ï¬ ne-tuning. In this paper, we propose a simple yet powerful remedy, called Adaptive Batch Normalization (Ad- aBN) to increase the generalization ability of a DNN. By modulating the statistics in all Batch Normalization layers across the network, our approach achieves deep adaptation effect for domain adaptation tasks. In contrary to other deep learning domain adaptation methods, our method does not require additional components, and is parameter-free. It archives state-of-the-art performance despite its surpris- ing simplicity. Furthermore, we demonstrate that our method is complementary with other existing methods. Combining AdaBN with existing domain adaptation treatments may further improve model performance. | 1603.04779#0 | 1603.04779#2 | 1603.04779 | [
"1607.01719"
] |
1603.04779#2 | Revisiting Batch Normalization For Practical Domain Adaptation | # INTRODUCTION Training a DNN for a new image recognition task is expensive. It requires a large amount of labeled training images that are not easy to obtain. One common practice is to use labeled data from other related source such as a different public dataset, or harvesting images by keywords from a search engine. Because 1) the distributions of the source domains (third party datasets or Internet images) are often different from the target domain (testing images); and 2) DNN is particularly good at capturing dataset bias in its internal representation (Torralba & Efros, 2011), which eventually leads to overï¬ tting, imperfectly paired training and testing sets usually leads to inferior performance. Known as domain adaptation, the effort to bridge the gap between training and testing data distribu- tions has been discussed several times under the context of deep learning (Tzeng et al., 2014; Long et al., 2015; Tzeng et al., 2015; Ganin & Lempitsky, 2015). To make the connection between the domain of training and the domain of testing, most of these methods require additional optimiza- tion steps and extra parameters. Such additional computational burden could greatly complicate the training of a DNN which is already intimidating enough for most people. In this paper, we propose a simple yet effective approach called AdaBN for batch normalized DNN domain adaptation. We hypothesize that the label related knowledge is stored in the weight matrix of each layer, whereas domain related knowledge is represented by the statistics of the Batch Nor- malization (BN) (Ioffe & Szegedy, 2015) layer. Therefore, we can easily transfer the trained model to a new domain by modulating the statistics in the BN layer. This approach is straightforward to implement, has zero parameter to tune, and requires minimal computational resources. Moreover, our AdaBN is ready to be extended to more sophisticated scenarios such as multi-source domain adaptation and semi-supervised settings. | 1603.04779#1 | 1603.04779#3 | 1603.04779 | [
"1607.01719"
] |
1603.04779#3 | Revisiting Batch Normalization For Practical Domain Adaptation | Fig. 1 illustrates the ï¬ owchart of AdaBN. To summarize, our contributions are as follows: 1 # Under review as a conference paper at ICLR 2017 Figure 1: Illustration of the proposed method. For each convolutional or fully connected layer, we use different bias/variance terms to perform batch normalization for the training domain and the test domain. The domain speciï¬ c normalization mitigates the domain shift issue. 1. We propose a novel domain adaptation technique called Adaptive Batch Normalization (AdaBN). We show that AdaBN can naturally dissociate bias and variance of a dataset, which is ideal for domain adaptation tasks. | 1603.04779#2 | 1603.04779#4 | 1603.04779 | [
"1607.01719"
] |
1603.04779#4 | Revisiting Batch Normalization For Practical Domain Adaptation | 2. We validate the effectiveness of our approach on standard benchmarks for both single source and multi-source domain adaptation. Our method outperforms the state-of-the-art methods. 3. We conduct experiments on the cloud detection for remote sensing images to further demonstrate the effectiveness of our approach in practical use. # 2 RELATED WORK Domain transfer in visual recognition tasks has gained increasing attention in recent literature (Bei- jbom, 2012; Patel et al., 2015). Often referred to as covariate shift (Shimodaira, 2000) or dataset bias (Torralba & Efros, 2011), this problem poses a great challenge to the generalization ability of a learned model. One key component of domain transfer is to model the difference between source and target distributions. In Khosla et al. (2012), the authors assign each dataset with an explicit bias vector, and train one discriminative model to handle multiple classiï¬ cation problems with different bias terms. A more explicit way to compute dataset difference is based on Maximum Mean Discrep- ancy (MMD) (Gretton et al., 2012). This approach projects each data sample into a Reproducing Kernel Hilbert Space, and then computes the difference of sample means. To reduce dataset discrep- ancies, many methods are proposed, including sample selections (Huang et al., 2006; Gong et al., 2013), explicit projection learning (Pan et al., 2011; Gopalan et al., 2011; Baktashmotlagh et al., 2013) and principal axes alignment (Fernando et al., 2013; Gong et al., 2012; Aljundi et al., 2015). All of these methods face the same challenge of constructing the domain transfer function â a high- dimensional non-linear function. Due to computational constraints, most of the proposed transfer functions are in the category of simple shallow projections, which are typically composed of kernel transformations and linear mapping functions. | 1603.04779#3 | 1603.04779#5 | 1603.04779 | [
"1607.01719"
] |
1603.04779#5 | Revisiting Batch Normalization For Practical Domain Adaptation | In the ï¬ eld of deep learning, feature transferability across different domains is a tantalizing yet generally unsolved topic (Yosinski et al., 2014; Tommasi et al., 2015). To transfer the learned representations to a new dataset, pre-training plus ï¬ ne-tuning (Donahue et al., 2014) have become de facto procedures. However, adaptation by ï¬ ne-tuning is far from perfect. It requires a considerable amount of labeled data from the target domain, and non-negligible computational resources to re- train the whole network. | 1603.04779#4 | 1603.04779#6 | 1603.04779 | [
"1607.01719"
] |
1603.04779#6 | Revisiting Batch Normalization For Practical Domain Adaptation | 2 # Under review as a conference paper at ICLR 2017 A series of progress has been made in DNN to facilitate domain transfer. Early works of domain adaptation either focus on reordering ï¬ ne-tuning samples (Chopra et al., 2013), or regularizing MMD (Gretton et al., 2012) in a shallow network (Ghifary et al., 2014). It is only until recently that the problem is directly attacked under the setting of classiï¬ cation of unlabeled target domain using modern convolutional neural network (CNN) architecture. DDC (Tzeng et al., 2014) used the classical MMD loss to regularize the representation in the last layer of CNN. DAN (Long et al., 2015) further extended the method to multiple kernel MMD and multiple layer adaptation. Be- sides adapting features using MMD, RTN (Long et al., 2016) also added a gated residual layer for classiï¬ er adaptation. RevGrad (Ganin & Lempitsky, 2015) devised a gradient reversal layer to com- pensate the back-propagated gradients that are domain speciï¬ c. Recently, by explicitly modeling both private and shared components of the domain representations in the network, Bousmalis et al. (2016) proposed a Domain Separation Network to extract better domain-invariant features. Another related work is CORAL (Sun et al., 2016). This model focuses on the last layer of CNN. CORAL whitens the data in source domain, and then re-correlates the source domain features to target domain. This operation aligns the second order statistics of source domain and target domain distributions. Surprisingly, such simple approach yields state-of-the-arts results in various text clas- siï¬ cation and visual recognition tasks. Recently, Deep CORAL (Sun & Saenko, 2016) also extends the method into DNN by incorporating a CORAL loss. | 1603.04779#5 | 1603.04779#7 | 1603.04779 | [
"1607.01719"
] |
1603.04779#7 | Revisiting Batch Normalization For Practical Domain Adaptation | 2.1 BATCH NORMALIZATION In this section, we brieï¬ y review Batch Normalization (BN) (Ioffe & Szegedy, 2015) which is closely related to our AdaBN. The BN layer is originally designed to alleviate the issue of internal covariate shifting â a common problem while training a very deep neural network. It ï¬ rst standard- izes each feature in a mini-batch, and then learns a common slope and bias for each mini-batch. Formally, given the input to a BN layer X â Rnà p, where n denotes the batch size, and p is the feature dimension, BN layer transforms a feature j â {1 . . . p} into: x; â E[X.;] Var[X.3] â (1) Yj = 3%; + Bj, where a; and y; are the input/output scalars of one neuron response in one data sample; X.; denotes the 7â column of the input data; and 7; and 3; are parameters to be learned. This transformation guarantees that the input distribution of each layer remains unchanged across different mini-batches. For Stochastic Gradient Descent (SGD) optimization, a stable input distribution could greatly facil- itate model convergence, leading to much faster training speed for CNN. Moreover, if training data are shuffled at each epoch, the same training sample will be applied with different transformations, or in other words, more comprehensively augmented throughout the training. During the testing phase, the global statistics of all training samples is used to normalize every mini-batch of test data. w= Extensive experiments have shown that Batch Normalization signiï¬ cantly reduces the number of iteration to converge, and improves the ï¬ | 1603.04779#6 | 1603.04779#8 | 1603.04779 | [
"1607.01719"
] |
1603.04779#8 | Revisiting Batch Normalization For Practical Domain Adaptation | nal performance at the same time. BN layer has become a standard component in recent top-performing CNN architectures, such as deep residual network (He et al., 2016), and Inception V3 (Szegedy et al., 2015). # 3 THE MODEL In Sec. 3.1, we ï¬ rst analyze the domain shift in deep neural network, and reveal two key observa- tions. Then in Sec. 3.2, we introduce our Adaptive Batch Normalization (AdaBN) method based on these observations. Finally, we analyze our method in-depth in Sec. 3.3. 3.1 A PILOT EXPERIMENT Although the Batch Normalization (BN) technique is originally proposed to help SGD optimization, its core idea is to align the distribution of training data. From this perspective, it is interesting to examine the BN parameters (batch-wise mean and variance) over different dataset at different layers of the network. | 1603.04779#7 | 1603.04779#9 | 1603.04779 | [
"1607.01719"
] |
1603.04779#9 | Revisiting Batch Normalization For Practical Domain Adaptation | 3 # Under review as a conference paper at ICLR 2017 In this pilot experiment, we use MXNet implementation (Chen et al., 2016b) of the Inception-BN model (Ioffe & Szegedy, 2015) pre-trained on ImageNet classiï¬ cation task (Russakovsky et al., 2015) as our baseline DNN model. Our image data are drawn from (Bergamo & Torresani, 2010), which contains the same classes of images from both Caltech-256 dataset (Grifï¬ n et al., 2007) and Bing image search results. For each mini-batch sampled from one dataset, we concatenate the mean and variance of all neurons from one layer to form a feature vector. Using linear SVM, we can almost perfectly classify whether the mini-batch feature vector is from Caltech-256 or Bing dataset. Fig. 2 visualizes the distributions of mini-batch feature vectors from two datasets in 2D. It is clear that BN statistics from different domains are separated into clusters. (a) Shallow layer distributions (b) Deep layer distributions Figure 2: t-SNE (Van der Maaten & Hinton, 2008) visualization of the mini-batch BN feature vector distributions in both shallow and deep layers, across different datasets. Each point represents the BN statistics in one mini-batch. Red dots come from Bing domain, while the blue ones are from Caltech-256 domain. The size of each mini-batch is 64. | 1603.04779#8 | 1603.04779#10 | 1603.04779 | [
"1607.01719"
] |
1603.04779#10 | Revisiting Batch Normalization For Practical Domain Adaptation | This pilot experiment suggests: 1. Both shallow layers and deep layers of the DNN are inï¬ uenced by domain shift. Domain adaptation by manipulating the output layer alone is not enough. 2. The statistics of BN layer contain the traits of the data domain. Both observations motivate us to adapt the representation across different domains by BN layer. 3.2 ADAPTIVE BATCH NORMALIZATION Given the pre-trained DNN model and a target domain, our Adaptive Batch Normalization algorithm is as follows1: # Algorithm 1 Adaptive Batch Normalization (AdaBN) for neuron j in DNN do Concatenate neuron responses on all images of tar- get domain t: x; = [...,2;(m),...] Compute the mean and variance of the target do- main: pi = E(x}), of = Var(x!). end for for neuron j in DNN, testing image m in target domain do (©; (m)-n') Compute BN output y;(m) := 7; a + B; end for # end for 1In practice we adopt an online algorithm (Donald, 1999) to efï¬ ciently estimate the mean and variance. | 1603.04779#9 | 1603.04779#11 | 1603.04779 | [
"1607.01719"
] |
1603.04779#11 | Revisiting Batch Normalization For Practical Domain Adaptation | 4 # Under review as a conference paper at ICLR 2017 The intuition behind our method is straightforward: The standardization of each layer by domain ensures that each layer receives data from a similar distribution, no matter it comes from the source domain or the target domain. For K domain adaptation where K > 2, we standardize each sample by the statistics in its own domain. During training, the statistics are calculated for every mini-batch, the only thing that we need to make sure is that the samples in every mini-batch are from the same domain. For (semi-)supervised domain adaptation, we may use the labeled data to ï¬ ne-tune the weights as well. As a result, our method could ï¬ t in all different settings of domain adaptation with minimal effort. 3.3 FURTHER THOUGHTS ABOUT ADABN The simplicity of AdaBN is in sharp contrast to the complication of the domain shift problem. One natural question to ask is whether such simple translation and scaling operations could approximate the intrinsically non-linear domain transfer function. Consider a simple neural network with input x â Rp1à 1. It has one BN layer with mean and variance of each feature being µi and Ï 2 i (i â {1 . . . p2}), one fully connected layer with weight matrix W â Rp1à p2 and bias b â Rp2à 1, and a non-linear transformation layer f (·), where p1 and p2 correspond to the input and output feature size. The output of this network is f (Wax + ba), where Wa = WT Σâ 1, ba = â WT Σâ 1µ + b, Σ = diag(Ï 1, ..., Ï p1 ), µ = (µ1, ..., µp1 ). (2) The output without BN is simply f (WT x + b). We can see that the transformation is highly non- linear even for a simple network with one computation layer. As CNN architecture goes deeper, it will gain increasing power to represent more complicated transformations. Another question is why we transform the neuron responses independently, not decorrelate and then re-correlate the responses as suggested in Sun et al. (2016). Under certain conditions, decorrelation could improve the performance. | 1603.04779#10 | 1603.04779#12 | 1603.04779 | [
"1607.01719"
] |
1603.04779#12 | Revisiting Batch Normalization For Practical Domain Adaptation | However, in CNN, the mini-batch size is usually smaller than the feature dimension, leading to singular covariance matrices that is hard to be inversed. As a result, the covariance matrix is always singular. In addition, decorrelation requires to compute the inverse of the covariance matrix which is computationally intensive, especially if we plan to apply AdaBN to all layers of the network. # 4 EXPERIMENTS In this section, we demonstrate the effectiveness of AdaBN on standard domain adaptation datasets, and empirically analyze the adapted features. We also evaluation our method on a practical applica- tion with remote sensing images. 4.1 EXPERIMENTAL SETTINGS | 1603.04779#11 | 1603.04779#13 | 1603.04779 | [
"1607.01719"
] |
1603.04779#13 | Revisiting Batch Normalization For Practical Domain Adaptation | We ï¬ rst introduce our experiments on two standard datasets: Ofï¬ ce (Saenko et al., 2010) and Caltech-Bing (Bergamo & Torresani, 2010). Ofï¬ ce (Saenko et al., 2010) is a standard benchmark for domain adaptation, which is a collection of 4652 images in 31 classes from three different domains: Amazon(A), DSRL(D) and Webcam(W). Similar to (Tzeng et al., 2014; Sun et al., 2016; Long et al., 2015), we evaluate the pairwise do- main adaption performance of AdaBN on all six pairs of domains. For the multi-source setting, we evaluate our method on three transfer tasks {A, W} â D, {A, D} â W, {D, W} â A. | 1603.04779#12 | 1603.04779#14 | 1603.04779 | [
"1607.01719"
] |
1603.04779#14 | Revisiting Batch Normalization For Practical Domain Adaptation | Caltech-Bing (Bergamo & Torresani, 2010) is a much larger domain adaptation dataset, which con- tains 30,607 and 121,730 images in 256 categories from two domains Caltech-256(C) and Bing(B). The images in the Bing set are collected from Bing image search engine by keyword search. Ap- parently Bing data contains noise, and its data distribution is dramatically different from that of Caltech-256. 5 # Under review as a conference paper at ICLR 2017 Method AlexNet (Krizhevsky et al., 2012) DDC (Tzeng et al., 2014) DAN (Long et al., 2015) Deep CORAL (Sun & Saenko, 2016) RevGrad (Ganin & Lempitsky, 2015) Inception BN (Ioffe & Szegedy, 2015) SA (Fernando et al., 2013) GFK (Gong et al., 2012) LSSA (Aljundi et al., 2015) CORAL (Sun et al., 2016) AdaBN AdaBN + CORAL A â | 1603.04779#13 | 1603.04779#15 | 1603.04779 | [
"1607.01719"
] |
1603.04779#15 | Revisiting Batch Normalization For Practical Domain Adaptation | W D â W W â D A â D D â A W â A Avg 70.1 70.6 72.9 72.1 - 75.5 75.3 74.7 74.9 76.3 76.7 77.2 61.6 61.8 68.5 66.4 67.3 70.3 69.8 66.7 67.7 70.9 74.2 75.4 95.4 95.0 96.0 95.7 94.0 94.3 95.5 97.0 96.1 95.7 95.7 96.2 99.0 98.5 99.0 99.2 93.7 100 99.0 99.4 98.4 99.8 99.8 99.6 63.8 64.4 67.0 66.8 - 70.5 71.3 70.1 71.3 71.9 73.1 72.7 51.1 52.1 54.0 52.8 - 60.1 59.4 58.0 57.8 59.0 59.8 59.0 49.8 52.2 53.1 51.5 - 57.9 56.9 56.9 57.8 60.2 57.4 60.5 Table 1: Single source domain adaptation results on Ofï¬ ce-31 (Saenko et al., 2010) dataset with standard unsupervised adaptation protocol. We compare our approach with a variety of methods, including four shallow methods: SA (Fernando et al., 2013), LSSA (Aljundi et al., 2015), GFK (Gong et al., 2012), CORAL (Sun et al., 2016), and four deep methods: DDC (Tzeng et al., 2014), DAN (Long et al., 2015), RevGrad (Ganin & Lempitsky, 2015), Deep CORAL (Sun & Saenko, 2016). | 1603.04779#14 | 1603.04779#16 | 1603.04779 | [
"1607.01719"
] |
1603.04779#16 | Revisiting Batch Normalization For Practical Domain Adaptation | Speciï¬ cally, GFK models domain shift by integrating an inï¬ nite number of subspaces that characterize changes in statistical properties from the source to the target domain. SA, LSSA and CORAL align the source and target subspaces by explicit feature space transformations that would map source distribution into the target one. DDC and DAN are deep learning based methods which maximize domain invariance by adding to AlexNet one or several adaptation layers using MMD. RevGrad incorporates a gradient reversal layer in the deep model to encourage learning domain-invariant features. Deep CORAL extends CORAL to perform end-to-end adaptation in DNN. It should be noted that these deep learning methods have the adaptation layers on top of the output layers of DNNs, which is a sharp contrast to our method that delves into early convolution layers as well with the help of BN layers. We follow the full protocol (Donahue et al., 2014) for the single source setting; while for multiple sources setting, we use all the samples in the source domains as training data, and use all the samples in the target domain as testing data. | 1603.04779#15 | 1603.04779#17 | 1603.04779 | [
"1607.01719"
] |
1603.04779#17 | Revisiting Batch Normalization For Practical Domain Adaptation | We ï¬ ne-tune the Inception-BN (Ioffe & Szegedy, 2015) model on source domain in each task for 100 epochs. The learning rate is set to 0.01 initially, and then is dropped by a factor 0.1 every 40 epochs. Since the ofï¬ ce dataset is quite small, following the best practice in Long et al. (2015), we freeze the ï¬ rst three groups of Inception modules, and set the learning rate of fourth and ï¬ fth group one tenth of the base learning rate to avoid overï¬ tting. For Caltech-Bing dataset, we ï¬ ne-tune the whole model with the same base learning rate. 4.2 RESULTS 4.2.1 OFFICE DATASET Our results on Ofï¬ ce dataset is reported in Table 1 and Table 2 for single/multi source(s), respec- tively. Note that the ï¬ rst 5 models of the Table 1 are pre-trained on AlexNet (Krizhevsky et al., 2012) instead of the Inception-BN (Ioffe & Szegedy, 2015) model, due to the lack of publicly available pre-trained Inception BN model in Caffe (Jia et al., 2014). Thus, the relative improvements over the baseline (AlexNet/Inception BN) make more sense than the absolute numbers of each algorithm. | 1603.04779#16 | 1603.04779#18 | 1603.04779 | [
"1607.01719"
] |
1603.04779#18 | Revisiting Batch Normalization For Practical Domain Adaptation | From Table 1, we ï¬ rst notice that the Inception-BN indeed improves over the AlexNet on average, which means that the CNN pre-trained on ImageNet has learned general features, the improvements on ImageNet can be transferred to new tasks. Among the methods based on Inception-BN features, our method improves the most over the baseline. Moreover, since our method is complementary to other methods, we can simply apply CORAL on the top of AdaBN. Not surprisingly, this simple combination exhibits 0.5% increase in performance. This preliminary test reveals further potential of AdaBN if combined with other advanced domain adaptation methods. Finally, we could improve 1.7% over the baseline, and advance the state-of-the-art results for this dataset. | 1603.04779#17 | 1603.04779#19 | 1603.04779 | [
"1607.01719"
] |
1603.04779#19 | Revisiting Batch Normalization For Practical Domain Adaptation | 6 # Under review as a conference paper at ICLR 2017 None of the compared methods has reported their performance on multi-source domain adaptation. To demonstrate the capacity of AdaBN under multi-domain settings, we compare it against CORAL, which is the best performing algorithm in the single source setting. The result is reported in Table 2. We ï¬ nd that simply combining two domains does not lead to better performance. The result is generally worse compared to the best performing single domain between the two. This phenomenon suggests that if we cannot properly cope with domain bias, the increase of training samples may be reversely affect to the testing performance. This result conï¬ rms the necessity of domain adaptation. In this more challenging setting, AdaBN still outperforms the baseline and CORAL on average. Again, when combined with CORAL, our method demonstrates further improvements. At last, our method archives 2.3% gain over the baseline. Method Inception BN (Ioffe & Szegedy, 2015) CORAL (Sun et al., 2016) AdaBN AdaBN + CORAL A, D â W A, W â D D, W â | 1603.04779#18 | 1603.04779#20 | 1603.04779 | [
"1607.01719"
] |
1603.04779#20 | Revisiting Batch Normalization For Practical Domain Adaptation | A Avg 82.1 83.3 83.6 84.4 90.8 92.1 94.2 95.0 95.4 96.4 97.2 97.8 60.2 61.4 59.3 60.5 Table 2: Multi-source domain adaptation results on Ofï¬ ce-31 (Saenko et al., 2010) dataset with standard unsupervised adaptation protocol. # 4.2.2 CALTECH-BING DATASET To further evaluate our method on the large-scale dataset, we show our results on Caltech-Bing Dataset in Table 3. Compared with CORAL, AdaBN achieves better performance, which improves 1.8% over the baseline. Note that all the domain adaptation methods show minor improvements over the baseline in the task C â B. One of the hypotheses to this relatively small improvement is that the images in Bing dataset are collected from Internet, which are more diverse and noisier (Bergamo & Torresani, 2010). Thus, it is not easy to adapt on the Bing dataset from the relatively clean dataset Caltech-256. Combining CORAL with our method does not offer further improvements. This might be explained by the noise of the Bing dataset and the imbalance of the number of images in the two domains. Method Inception BN (Ioffe & Szegedy, 2015) CORAL (Sun et al., 2016) AdaBN AdaBN + CORAL C â B B â C Avg 49.9 51.3 51.7 51.2 35.1 35.3 35.2 35.0 64.6 67.2 68.1 67.5 Table 3: Single source domain adaptation results on Caltech-Bing (Bergamo & Torresani, 2010) dataset. 4.3 EMPIRICAL ANALYSIS In this section, we empirically analyze the features adapted by our method and investigate the inï¬ u- ence of the number of samples in target domain to the performance. # 4.3.1 ANALYSIS OF FEATURE DIVERGENCE. | 1603.04779#19 | 1603.04779#21 | 1603.04779 | [
"1607.01719"
] |
1603.04779#21 | Revisiting Batch Normalization For Practical Domain Adaptation | In this experiment, we analyze the statistics of the output of one shallow layer (the output of second convolution layer) and one deep layer (the output of last Inception module before ReLU) in the network. In particular, we compute the distance of source domain distribution and target domain distribution before and after adaptation. We denote each feature i as Fi, and assume that the output of each feature generally follows a Gaussian distribution with mean µi and variance Ï 2 i . Then we use the symmetric KL divergence as our metric: D(Fi || Fj) = KL(Fi || Fj) + KL(Fj || Fi), KL(Fi || Fj) = log Ï j Ï i + Ï 2 i + (µi â µj)2 2Ï 2 j â 1 2 . (3) 7 | 1603.04779#20 | 1603.04779#22 | 1603.04779 | [
"1607.01719"
] |
1603.04779#22 | Revisiting Batch Normalization For Practical Domain Adaptation | # Under review as a conference paper at ICLR 2017 We plot the distribution of the distances in Fig. 3. Our method reduces the domain discrepancy in both shallow layer and deep layer. We also report the quantitative results in Table. 4. This experiment once again veriï¬ es the effectiveness of the proposed method. 109} 7] â Bilbeerore Adaptation After Adaptation eo (Hi Aer Adapt eo} 0} Ed % 02 04 06 08 4 500; [iiibetore Adaptation 5 Adapiaton â oo Titer Acaptt 300] 200] 109} % of 02 08 04 05 109; 7] [ilibefore Adaptation ir Adaptation el Titer Adeptat ©} 20} 20} % 02 04 06 08 1 500) â Bilbeerore Adaptation After Adaptation â eo (Hi Aer Adapt 300] 200] 100} % of 02 03 04 05 (a) A â W, shallow layer (b) A â W, deep layer (c) A â D, shallow layer (d) A â D, deep layer Figure 3: Distribution of the symmetric KL divergence of the outputs in shallow layer and deep layer. | 1603.04779#21 | 1603.04779#23 | 1603.04779 | [
"1607.01719"
] |
1603.04779#23 | Revisiting Batch Normalization For Practical Domain Adaptation | Best viewed in color. Before Adapt After Adapt A â W A â W A â D A â D shallow 0.0716 0.0227 deep 0.0614 0.0134 shallow deep 0.0502 0.2307 0.0140 0.0266 Table 4: The average symmetric KL divergence of the outputs in shallow layer and deep layer, respectively. 4.3.2 SENSITIVITY TO TARGET DOMAIN SIZE. Since the key of our method is to calculate the mean and variance of the target domain on different BN layers, it is very natural to ask how many target images is necessary to obtain stable statistics. In this experiment, we randomly select a subset of images in target domain to calculate the statistics and then evaluate the performance on the whole target set. Fig. 4 illustrates the effect of using different number of batches. The results demonstrate that our method can obtain good results when using only a small part of the target examples. It should also be noted that in the extremal case of one batch of target images, our method still achieves better results than the baseline. This is valuable in practical use since a large number of target images are often not available. | 1603.04779#22 | 1603.04779#24 | 1603.04779 | [
"1607.01719"
] |
1603.04779#24 | Revisiting Batch Normalization For Practical Domain Adaptation | 076 Mil Adapt BN Inception BN 2 4 6 8 10 1 O71; o7- 0.69" Ml Adapt BN Inception BN 0.68 0.67 0.66| cr er i: ir 0) (a) A â W (b) B â C Figure 4: Accuracy when varying the number of mini-batches used for calculating the statistics of BN layers in A â W and B â C, respectively. For B â C, we only show the results of using less than 100 batches, since the results are very stable when adding more examples. The batch size is 64 in this experiment. | 1603.04779#23 | 1603.04779#25 | 1603.04779 | [
"1607.01719"
] |
1603.04779#25 | Revisiting Batch Normalization For Practical Domain Adaptation | 8 # Under review as a conference paper at ICLR 2017 4.4 PRACTICAL APPLICATION FOR CLOUD DETECTION IN REMOTE SENSING IMAGES In this section, we further demonstrate the effectiveness of AdaBN on a practical problem: Cloud Detection in Remote Sensing Images. Since remote sensing images are taken by different satellites with different sensors and resolutions, the captured images are visually different in texture, color, and value range distributions, as shown in Fig. 5. How to adapt a model trained on one satellite to another satellite images is naturally a domain adaptation problem. Our task here is to identify cloud from the remote sensing images, which can be regarded as a semantic segmentation task. The experiment is taken under a self-collected dataset, which includes three image sets, from GF2, GF1 and Tianhui satellites. Each image set contains 635, 324 and 113 images with resolution over 6000x6000 pixels respectively. We name the three different datasets following the satellite names. GF2 dataset is used as the training dataset while GF1 and Tianhui datasets are for testing. We use a state-of-art semantic segmentation method (Chen et al., 2016a) as our baseline model. Method Tianhui GF1 Baseline 38.95% 14.54% AdaBN 64.50% 29.66% Table 5: Domain adaptation results (mIOU) on GF1 and Tianhui datasets training on GF2 datasets. The results on GF1 and Tianhui datasets are shown in Table 5. The relatively low results of the baseline method indicate that there exists large distribution disparity among images from different satellites. | 1603.04779#24 | 1603.04779#26 | 1603.04779 | [
"1607.01719"
] |
1603.04779#26 | Revisiting Batch Normalization For Practical Domain Adaptation | Thus, the signiï¬ cant improvement after applying AdaBN reveals the effectiveness of our method. Some of the visual results are shown in Fig. 6. Since other domain adaptation methods require either additional optimization steps and extra components (e.g. MMD) or post-processing distribution alignment (like CORAL), it is very hard to apply these methods from image classiï¬ - cation to this large-size (6000x6000) segmentation problem. Comparatively, besides the effective performance, our method needs no extra parameters and very few computations over the whole adaptation process. (a) GF1 image (b) GF2 image (c) Tianhui image Figure 5: Remote sensing images in different domains. # 5 CONCLUSION AND FUTURE WORKS In this paper, we have introduced a simple yet effective approach for domain adaptation on batch normalized neural networks. Besides its original uses, we have exploited another functionality of Batch Normalization (BN) layer: domain adaptation. The main idea is to replace the statistics of each BN layer in source domain with those in target domain. The proposed method is easy to implement and parameter-free, and it takes almost no effort to extend to multiple source domains and semi-supervised settings. Our method established new state-of-the-art results on both single and multiple source(s) domain adaptation settings on standard benchmarks. At last, the experiments on | 1603.04779#25 | 1603.04779#27 | 1603.04779 | [
"1607.01719"
] |
1603.04779#27 | Revisiting Batch Normalization For Practical Domain Adaptation | 9 # Under review as a conference paper at ICLR 2017 (a) Original image (b) Without AdaBN (c) AdaBN (a) Original image (b) Without AdaBN (c) AdaBN ~~ Figure 6: Visual cloud detection results on GF1 dataset. White pixels in (b) and (c) represent the detected cloud regions. cloud detection for large-size remote sensing images further demonstrate the effectiveness of our method in practical use. We believe our method opens up a new direction for domain adaptation. In contrary to other methods that use Maximum Mean Discrepancy (MMD) or domain confusion loss to update the weights in CNN for domain adaptation, our method only modiï¬ es the statistics of BN layer. Therefore, our method is fully complementary to other existing deep learning based methods. It is interesting to see how these different methods can be uniï¬ ed under one framework. # REFERENCES Rahaf Aljundi, R´emi Emonet, Damien Muselet, and Marc Sebban. | 1603.04779#26 | 1603.04779#28 | 1603.04779 | [
"1607.01719"
] |
1603.04779#28 | Revisiting Batch Normalization For Practical Domain Adaptation | Landmarks-based kernelized subspace alignment for unsupervised domain adaptation. In CVPR, 2015. Mahsa Baktashmotlagh, Mehrtash Harandi, Brian Lovell, and Mathieu Salzmann. Unsupervised domain adaptation by domain invariant projection. In ICCV, pp. 769â 776, 2013. Oscar Beijbom. Domain adaptations for computer vision applications. arXiv preprint arXiv:1211.4860, 2012. Alessandro Bergamo and Lorenzo Torresani. Exploiting weakly-labeled web images to improve object classiï¬ cation: a domain adaptation approach. In NIPS, pp. 181â 189, 2010. Konstantinos Bousmalis, George Trigeorgis, Nathan Silberman, Dilip Krishnan, and Dumitru Erhan. | 1603.04779#27 | 1603.04779#29 | 1603.04779 | [
"1607.01719"
] |
1603.04779#29 | Revisiting Batch Normalization For Practical Domain Adaptation | Domain separation networks. NIPS, 2016. Liang-Chieh Chen, George Papandreou, Iasonas Kokkinos, Kevin Murphy, and Alan L Yuille. Deeplab: Semantic image segmentation with deep convolutional nets, atrous convolution, and fully connected crfs. arXiv preprint arXiv:1606.00915, 2016a. 10 # Under review as a conference paper at ICLR 2017 Tianqi Chen, Mu Li, Yutian Li, Min Lin, Naiyan Wang, Minjie Wang, Tianjun Xiao, Bing Xu, Chiyuan Zhang, and Zheng Zhang. MXNet: | 1603.04779#28 | 1603.04779#30 | 1603.04779 | [
"1607.01719"
] |
1603.04779#30 | Revisiting Batch Normalization For Practical Domain Adaptation | A ï¬ exible and efï¬ cient machine learning library for heterogeneous distributed systems. NIPS Workshop on Machine Learning Systems, 2016b. Sumit Chopra, Suhrid Balakrishnan, and Raghuraman Gopalan. DLID: Deep learning for domain adaptation by interpolating between domains. In ICML Workshop on Challenges in Representa- tion Learning, volume 2, 2013. Jeff Donahue, Yangqing Jia, Oriol Vinyals, Judy Hoffman, Ning Zhang, Eric Tzeng, and Trevor Darrell. DeCAF: A deep convolutional activation feature for generic visual recognition. In ICML, pp. 647â 655, 2014. E Knuth Donald. The art of computer programming. Sorting and searching, 3:426â 458, 1999. Basura Fernando, Amaury Habrard, Marc Sebban, and Tinne Tuytelaars. | 1603.04779#29 | 1603.04779#31 | 1603.04779 | [
"1607.01719"
] |
1603.04779#31 | Revisiting Batch Normalization For Practical Domain Adaptation | Unsupervised visual do- main adaptation using subspace alignment. In ICCV, pp. 2960â 2967, 2013. Yaroslav Ganin and Victor Lempitsky. Unsupervised domain adaptation by backpropagation. In ICML, pp. 1180â 1189, 2015. Muhammad Ghifary, W Bastiaan Kleijn, and Mengjie Zhang. Domain adaptive neural networks for object recognition. In PRICAI: Trends in Artiï¬ cial Intelligence, pp. 898â 904. 2014. | 1603.04779#30 | 1603.04779#32 | 1603.04779 | [
"1607.01719"
] |
1603.04779#32 | Revisiting Batch Normalization For Practical Domain Adaptation | Boqing Gong, Yuan Shi, Fei Sha, and Kristen Grauman. Geodesic ï¬ ow kernel for unsupervised domain adaptation. In CVPR, pp. 2066â 2073, 2012. Boqing Gong, Kristen Grauman, and Fei Sha. Connecting the dots with landmarks: Discriminatively learning domain-invariant features for unsupervised domain adaptation. In ICML, pp. 222â 230, 2013. Raghuraman Gopalan, Ruonan Li, and Rama Chellappa. Domain adaptation for object recognition: An unsupervised approach. In ICCV, pp. 999â 1006, 2011. Arthur Gretton, Karsten M Borgwardt, Malte J Rasch, Bernhard Sch¨olkopf, and Alexander Smola. A kernel two-sample test. The Journal of Machine Learning Research, 13(1):723â 773, 2012. | 1603.04779#31 | 1603.04779#33 | 1603.04779 | [
"1607.01719"
] |
1603.04779#33 | Revisiting Batch Normalization For Practical Domain Adaptation | Gregory Grifï¬ n, Alex Holub, and Pietro Perona. Caltech-256 object category dataset. 2007. Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recog- nition. CVPR, 2016. Jiayuan Huang, Arthur Gretton, Karsten M Borgwardt, Bernhard Sch¨olkopf, and Alex J Smola. Correcting sample selection bias by unlabeled data. In NIPS, pp. 601â 608, 2006. Sergey Ioffe and Christian Szegedy. | 1603.04779#32 | 1603.04779#34 | 1603.04779 | [
"1607.01719"
] |
1603.04779#34 | Revisiting Batch Normalization For Practical Domain Adaptation | Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, pp. 448â 456, 2015. Yangqing Jia, Evan Shelhamer, Jeff Donahue, Sergey Karayev, Jonathan Long, Ross Girshick, Ser- gio Guadarrama, and Trevor Darrell. Caffe: Convolutional architecture for fast feature embed- ding. In ACM MM, pp. 675â 678, 2014. Aditya Khosla, Tinghui Zhou, Tomasz Malisiewicz, Alexei A Efros, and Antonio Torralba. | 1603.04779#33 | 1603.04779#35 | 1603.04779 | [
"1607.01719"
] |
1603.04779#35 | Revisiting Batch Normalization For Practical Domain Adaptation | Undoing the damage of dataset bias. In ECCV, pp. 158â 171. 2012. Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classiï¬ cation with deep convo- lutional neural networks. In NIPS, pp. 1097â 1105, 2012. Mingsheng Long, Yue Cao, Jianmin Wang, and Michael Jordan. Learning transferable features with deep adaptation networks. In ICML, pp. 97â 105, 2015. Mingsheng Long, Jianmin Wang, and Michael I Jordan. | 1603.04779#34 | 1603.04779#36 | 1603.04779 | [
"1607.01719"
] |
1603.04779#36 | Revisiting Batch Normalization For Practical Domain Adaptation | Unsupervised domain adaptation with residual transfer networks. In NIPS, 2016. Sinno Jialin Pan, Ivor W Tsang, James T Kwok, and Qiang Yang. Domain adaptation via transfer component analysis. IEEE Transactions on Neural Networks, 22(2):199â 210, 2011. 11 # Under review as a conference paper at ICLR 2017 Vishal M Patel, Raghuraman Gopalan, Ruonan Li, and Rama Chellappa. Visual domain adaptation: A survey of recent advances. IEEE Signal Processing Magazine, 32(3):53â 69, 2015. Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. ImageNet large scale visual recognition challenge. International Journal of Computer Vision, 115(3):211â 252, 2015. | 1603.04779#35 | 1603.04779#37 | 1603.04779 | [
"1607.01719"
] |
1603.04779#37 | Revisiting Batch Normalization For Practical Domain Adaptation | Kate Saenko, Brian Kulis, Mario Fritz, and Trevor Darrell. Adapting visual category models to new domains. In ECCV, pp. 213â 226. 2010. Hidetoshi Shimodaira. Improving predictive inference under covariate shift by weighting the log- likelihood function. Journal of statistical planning and inference, 90(2):227â 244, 2000. Baochen Sun and Kate Saenko. Deep coral: Correlation alignment for deep domain adaptation. arXiv preprint arXiv:1607.01719, 2016. | 1603.04779#36 | 1603.04779#38 | 1603.04779 | [
"1607.01719"
] |
1603.04779#38 | Revisiting Batch Normalization For Practical Domain Adaptation | Baochen Sun, Jiashi Feng, and Kate Saenko. Return of frustratingly easy domain adaptation. AAAI, 2016. Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens, and Zbigniew Wojna. Re- thinking the inception architecture for computer vision. arXiv preprint arXiv:1512.00567, 2015. Tatiana Tommasi, Novi Patricia, Barbara Caputo, and Tinne Tuytelaars. A deeper look at dataset bias. German Conference on Pattern Recognition, 2015. Antonio Torralba and Alexei A Efros. Unbiased look at dataset bias. In CVPR, pp. 1521â 1528, 2011. Eric Tzeng, Judy Hoffman, Ning Zhang, Kate Saenko, and Trevor Darrell. Deep domain confusion: Maximizing for domain invariance. arXiv preprint arXiv:1412.3474, 2014. | 1603.04779#37 | 1603.04779#39 | 1603.04779 | [
"1607.01719"
] |
1603.04779#39 | Revisiting Batch Normalization For Practical Domain Adaptation | Eric Tzeng, Judy Hoffman, Trevor Darrell, and Kate Saenko. Simultaneous deep transfer across domains and tasks. In ICCV, pp. 4068â 4076, 2015. Laurens Van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of Machine Learning Research, 9(2579-2605):85, 2008. Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In NIPS, pp. 3320â 3328, 2014. 12 | 1603.04779#38 | 1603.04779 | [
"1607.01719"
] |
|
1603.04467#0 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | 6 1 0 2 r a M 6 1 ] C D . s c [ 2 v 7 6 4 4 0 . 3 0 6 1 : v i X r a TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems (Preliminary White Paper, November 9, 2015) Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dan Man´e, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Vi´egas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng # Google Researchâ # Abstract | 1603.04467#1 | 1603.04467 | [
"1502.02072"
] |
|
1603.04467#1 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow [1] is an interface for expressing machine learn- ing algorithms, and an implementation for executing such al- gorithms. A computation expressed using TensorFlow can be executed with little or no change on a wide variety of hetero- geneous systems, ranging from mobile devices such as phones and tablets up to large-scale distributed systems of hundreds of machines and thousands of computational devices such as GPU cards. The system is ï¬ exible and can be used to express a wide variety of algorithms, including training and inference algorithms for deep neural network models, and it has been used for conducting research and for deploying machine learn- ing systems into production across more than a dozen areas of computer science and other ï¬ elds, including speech recogni- tion, computer vision, robotics, information retrieval, natural language processing, geographic information extraction, and computational drug discovery. This paper describes the Ten- sorFlow interface and an implementation of that interface that we have built at Google. The TensorFlow API and a reference implementation were released as an open-source package under the Apache 2.0 license in November, 2015 and are available at www.tensorï¬ | 1603.04467#0 | 1603.04467#2 | 1603.04467 | [
"1502.02072"
] |
1603.04467#2 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | ow.org. 1 # 1 Introduction The Google Brain project started in 2011 to explore the use of very-large-scale deep neural networks, both for research and for use in Googleâ s products. As part of the early work in this project, we built DistBelief, our ï¬ rst-generation scalable distributed training and infer- ence system [14], and this system has served us well. We and others at Google have performed a wide variety of re- search using DistBelief including work on unsupervised learning [31], language representation [35, 52], models for image classiï¬ cation and object detection [16, 48], video classiï¬ cation [27], speech recognition [56, 21, 20], sequence prediction [47], move selection for Go [34], pedestrian detection [2], reinforcement learning [38], and other areas [17, 5]. In addition, often in close collab- oration with the Google Brain team, more than 50 teams at Google and other Alphabet companies have deployed deep neural networks using DistBelief in a wide variety of products, including Google Search [11], our advertis- ing products, our speech recognition systems [50, 6, 46], Google Photos [43], Google Maps and StreetView [19], Google Translate [18], YouTube, and many others. Based on our experience with DistBelief and a more complete understanding of the desirable system proper- ties and requirements for training and using neural net- works, we have built TensorFlow, our second-generation system for the implementation and deployment of large- scale machine learning models. TensorFlow takes com- putations described using a dataï¬ ow-like model and maps them onto a wide variety of different hardware platforms, ranging from running inference on mobile device platforms such as Android and iOS to modest- sized training and inference systems using single ma- chines containing one or many GPU cards to large-scale training systems running on hundreds of specialized ma- chines with thousands of GPUs. Having a single system that can span such a broad range of platforms signiï¬ - cantly simpliï¬ es the real-world use of machine learning system, as we have found that having separate systems for large-scale training and small-scale deployment leads to signiï¬ cant maintenance burdens and leaky abstrac- tions. TensorFlow computations are expressed as stateful dataï¬ | 1603.04467#1 | 1603.04467#3 | 1603.04467 | [
"1502.02072"
] |
1603.04467#3 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | ow graphs (described in more detail in Section 2), and we have focused on making the system both ï¬ exible enough for quickly experimenting with new models for research purposes and sufï¬ ciently high performance and robust for production training and deployment of ma- chine learning models. For scaling neural network train- ing to larger deployments, TensorFlow allows clients to easily express various kinds of parallelism through repli- cation and parallel execution of a core model dataï¬ ow â | 1603.04467#2 | 1603.04467#4 | 1603.04467 | [
"1502.02072"
] |
1603.04467#4 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | Corresponding authors: Jeffrey Dean and Rajat Monga: {jeff,rajatmonga}@google.com 1 graph, with many different computational devices all col- laborating to update a set of shared parameters or other state. Modest changes in the description of the com- putation allow a wide variety of different approaches to parallelism to be achieved and tried with low effort [14, 29, 42]. Some TensorFlow uses allow some ï¬ exibil- ity in terms of the consistency of parameter updates, and we can easily express and take advantage of these relaxed synchronization requirements in some of our larger de- ployments. Compared to DistBelief, TensorFlowâ s pro- gramming model is more ï¬ exible, its performance is sig- niï¬ cantly better, and it supports training and using a broader range of models on a wider variety of hetero- geneous hardware platforms. Dozens of our internal clients of DistBelief have al- ready switched to TensorFlow. These clients rely on TensorFlow for research and production, with tasks as diverse as running inference for computer vision mod- els on mobile phones to large-scale training of deep neural networks with hundreds of billions of parame- ters on hundreds of billions of example records using many hundreds of machines [11, 47, 48, 18, 53, 41]. Although these applications have concentrated on ma- chine learning and deep neural networks in particular, we expect that TensorFlowâ s abstractions will be useful in a variety of other domains, including other kinds of machine learning algorithms, and possibly other kinds of numerical computations. We have open-sourced the TensorFlow API and a reference implementation under the Apache 2.0 license in November, 2015, available at www.tensorï¬ | 1603.04467#3 | 1603.04467#5 | 1603.04467 | [
"1502.02072"
] |
1603.04467#5 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | ow.org. The rest of this paper describes TensorFlow in more detail. Section 2 describes the programming model and basic concepts of the TensorFlow interface, and Section 3 describes both our single machine and distributed imple- mentations. Section 4 describes several extensions to the basic programming model, and Section 5 describes several optimizations to the basic implementations. Sec- tion 6 describes some of our experiences in using Ten- sorFlow, Section 7 describes several programming id- ioms we have found helpful when using TensorFlow, and Section 9 describes several auxiliary tools we have built around the core TensorFlow system. Sections 10 and 11 discuss future and related work, respectively, and Sec- tion 12 offers concluding thoughts. # 2 Programming Model and Basic Concepts | 1603.04467#4 | 1603.04467#6 | 1603.04467 | [
"1502.02072"
] |
1603.04467#6 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | A TensorFlow computation is described by a directed graph, which is composed of a set of nodes. The graph represents a dataï¬ ow computation, with extensions for allowing some kinds of nodes to maintain and update persistent state and for branching and looping control 2 structures within the graph in a manner similar to Naiad [36]. Clients typically construct a computational graph using one of the supported frontend languages (C++ or Python). An example fragment to construct and then ex- ecute a TensorFlow graph using the Python front end is shown in Figure 1, and the resulting computation graph in Figure 2. In a TensorFlow graph, each node has zero or more in- puts and zero or more outputs, and represents the instan- tiation of an operation. | 1603.04467#5 | 1603.04467#7 | 1603.04467 | [
"1502.02072"
] |
1603.04467#7 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | Values that ï¬ ow along normal edges in the graph (from outputs to inputs) are tensors, arbitrary dimensionality arrays where the underlying el- ement type is speciï¬ ed or inferred at graph-construction time. Special edges, called control dependencies, can also exist in the graph: no data ï¬ ows along such edges, but they indicate that the source node for the control de- pendence must ï¬ nish executing before the destination node for the control dependence starts executing. Since our model includes mutable state, control dependencies can be used directly by clients to enforce happens before relationships. Our implementation also sometimes in- serts control dependencies to enforce orderings between otherwise independent operations as a way of, for exam- ple, controlling the peak memory usage. # Operations and Kernels An operation has a name and represents an abstract com- putation (e.g., â matrix multiplyâ , or â addâ ). | 1603.04467#6 | 1603.04467#8 | 1603.04467 | [
"1502.02072"
] |
1603.04467#8 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | An opera- tion can have attributes, and all attributes must be pro- vided or inferred at graph-construction time in order to instantiate a node to perform the operation. One com- mon use of attributes is to make operations polymorphic over different tensor element types (e.g., add of two ten- sors of type ï¬ oat versus add of two tensors of type int32). A kernel is a particular implementation of an operation that can be run on a particular type of device (e.g., CPU or GPU). A TensorFlow binary deï¬ nes the sets of opera- tions and kernels available via a registration mechanism, and this set can be extended by linking in additional op- eration and/or kernel deï¬ nitions/registrations. Table 1 shows some of the kinds of operations built into the core TensorFlow library. # Sessions Clients programs interact with the TensorFlow system by creating a Session. To create a computation graph, the Session interface supports an Extend method to augment the current graph managed by the session with additional nodes and edges (the initial graph when a session is cre- ated is empty). | 1603.04467#7 | 1603.04467#9 | 1603.04467 | [
"1502.02072"
] |
1603.04467#9 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | The other primary operation supported # import tensorflow as tf b = tf.Variable(tf.zeros([100])) W = tf.Variable(tf.random_uniform([784,100],-1,1)) # 784x100 matrix w/rnd vals x = tf.placeholder(name="x") relu = tf.nn.relu(tf.matmul(W, x) + b) C = [...] # s = tf.Session() for step in xrange(0, 10): input = ...construct 100-D input array ... result = s.run(C, feed_dict={x: input}) print step, result # Create 100-d vector for input # Fetch cost, feeding x=input | 1603.04467#8 | 1603.04467#10 | 1603.04467 | [
"1502.02072"
] |
1603.04467#10 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | Figure 1: Example TensorFlow code fragment ©) = Add # Figure 2: Corresponding computation graph for Figure 1 Examples Category Element-wise mathematical operations Add, Sub, Mul, Div, Exp, Log, Greater, Less, Equal, ... Concat, Slice, Split, Constant, Rank, Shape, Shufï¬ e, ... Array operations MatMul, MatrixInverse, MatrixDeterminant, ... Matrix operations Variable, Assign, AssignAdd, ... Stateful operations SoftMax, Sigmoid, ReLU, Convolution2D, MaxPool, ... Neural-net building blocks Save, Restore Checkpointing operations Enqueue, Dequeue, MutexAcquire, MutexRelease, ... Queue and synchronization operations Merge, Switch, Enter, Leave, NextIteration Control ï¬ ow operations Table 1: Example TensorFlow operation types by the session interface is Run, which takes a set of out- put names that need to be computed, as well as an op- tional set of tensors to be fed into the graph in place of certain outputs of nodes. Using the arguments to Run, the TensorFlow implementation can compute the transi- tive closure of all nodes that must be executed in order to compute the outputs that were requested, and can then arrange to execute the appropriate nodes in an order that respects their dependencies (as described in more detail in 3.1). Most of our uses of TensorFlow set up a Session with a graph once, and then execute the full graph or a few distinct subgraphs thousands or millions of times via Run calls. | 1603.04467#9 | 1603.04467#11 | 1603.04467 | [
"1502.02072"
] |
1603.04467#11 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | 3 # Variables In most computations a graph is executed multiple times. Most tensors do not survive past a single execution of the graph. However, a Variable is a special kind of opera- tion that returns a handle to a persistent mutable tensor that survives across executions of a graph. Handles to these persistent mutable tensors can be passed to a hand- ful of special operations, such as Assign and AssignAdd (equivalent to +=) that mutate the referenced tensor. For machine learning applications of TensorFlow, the param- eters of the model are typically stored in tensors held in variables, and are updated as part of the Run of the train- ing graph for the model. | 1603.04467#10 | 1603.04467#12 | 1603.04467 | [
"1502.02072"
] |
1603.04467#12 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | # Implementation The main components in a TensorFlow system are the client, which uses the Session interface to communicate with the master, and one or more worker processes, with each worker process responsible for arbitrating access to one or more computational devices (such as CPU cores or GPU cards) and for executing graph nodes on those devices as instructed by the master. We have both lo- cal and distributed implementations of the TensorFlow interface. The local implementation is used when the client, the master, and the worker all run on a single ma- chine in the context of a single operating system process (possibly with multiple devices, if for example, the ma- chine has many GPU cards installed). The distributed implementation shares most of the code with the local implementation, but extends it with support for an en- vironment where the client, the master, and the workers can all be in different processes on different machines. In our distributed environment, these different tasks are containers in jobs managed by a cluster scheduling sys- tem [51]. These two different modes are illustrated in Figure 3. Most of the rest of this section discusses is- sues that are common to both implementations, while Section 3.3 discusses some issues that are particular to the distributed implementation. # Devices Devices are the computational heart of TensorFlow. Each worker is responsible for one or more devices, and each device has a device type, and a name. Device names are composed of pieces that identify the de- viceâ s type, the deviceâ s index within the worker, and, in our distributed setting, an identiï¬ cation of the job and task of the worker (or localhost for the case where the devices are local to the process). Example device names are "/job:localhost/device:cpu:0" or "/job:worker/task:17/device:gpu:3". | 1603.04467#11 | 1603.04467#13 | 1603.04467 | [
"1502.02072"
] |
1603.04467#13 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | We 4 have implementations of our Device interface for CPUs and GPUs, and new device implementations for other de- vice types can be provided via a registration mechanism. Each device object is responsible for managing alloca- tion and deallocation of device memory, and for arrang- ing for the execution of any kernels that are requested by higher levels in the TensorFlow implementation. # Tensors A tensor in our implementation is a typed, multi- dimensional array. We support a variety of tensor ele- ment types, including signed and unsigned integers rang- ing in size from 8 bits to 64 bits, IEEE ï¬ oat and double types, a complex number type, and a string type (an ar- bitrary byte array). Backing store of the appropriate size is managed by an allocator that is speciï¬ c to the device on which the tensor resides. Tensor backing store buffers are reference counted and are deallocated when no refer- ences remain. # 3.1 Single-Device Execution | 1603.04467#12 | 1603.04467#14 | 1603.04467 | [
"1502.02072"
] |
1603.04467#14 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | Letâ s ï¬ rst consider the simplest execution scenario: a sin- gle worker process with a single device. The nodes of the graph are executed in an order that respects the depen- dencies between nodes. In particular, we keep track of a count per node of the number of dependencies of that node that have not yet been executed. Once this count drops to zero, the node is eligible for execution and is added to a ready queue. The ready queue is processed in some unspeciï¬ ed order, delegating execution of the ker- nel for a node to the device object. When a node has ï¬ nished executing, the counts of all nodes that depend on the completed node are decremented. # 3.2 Multi-Device Execution Once a system has multiple devices, there are two main complications: deciding which device to place the com- putation for each node in the graph, and then managing the required communication of data across device bound- aries implied by these placement decisions. This subsec- tion discusses these two issues. # 3.2.1 Node Placement | 1603.04467#13 | 1603.04467#15 | 1603.04467 | [
"1502.02072"
] |
1603.04467#15 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | Given a computation graph, one of the main responsi- bilities of the TensorFlow implementation is to map the computation onto the set of available devices. A sim- pliï¬ ed version of this algorithm is presented here. See Section 4.3 for extensions supported by this algorithm. One input to the placement algorithm is a cost model, which contains estimates of the sizes (in bytes) of the single process â _â â session, ole run execute subgraph master session \_P run execute subgraph worker worker worker process 1 process 2 process 3 (Geue) =) GS Gees (pur) (CPUs (Gpur) (CPUs) } | (GPU) (CPUs } Figure 3: Single machine and distributed system structure | 1603.04467#14 | 1603.04467#16 | 1603.04467 | [
"1502.02072"
] |
1603.04467#16 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | input and output tensors for each graph node, along with estimates of the computation time required for each node when presented with its input tensors. This cost model is either statically estimated based on heuristics associated with different operation types, or is measured based on an actual set of placement decisions for earlier execu- tions of the graph. The placement algorithm ï¬ rst runs a simulated execu- tion of the graph. The simulation is described below and ends up picking a device for each node in the graph using greedy heuristics. The node to device placement gener- ated by this simulation is also used as the placement for the real execution. The placement algorithm starts with the sources of the computation graph, and simulates the activity on each device in the system as it progresses. For each node that is reached in this traversal, the set of feasible devices is considered (a device may not be feasible if the device does not provide a kernel that implements the particular operation). For nodes with multiple feasible devices, the placement algorithm uses a greedy heuristic that exam- ines the effects on the completion time of the node of placing the node on each possible device. This heuristic takes into account the estimated or measured execution time of the operation on that kind of device from the cost model, and also includes the costs of any communica- tion that would be introduced in order to transmit inputs to this node from other devices to the considered device. The device where the nodeâ s operation would ï¬ nish the soonest is selected as the device for that operation, and the placement process then continues onwards to make placement decisions for other nodes in the graph, includ- ing downstream nodes that are now ready for their own simulated execution. Section 4.3 describes some exten- sions that allow users to provide hints and partial con- straints to guide the placement algorithm. The placement algorithm is an area of ongoing development within the system. | 1603.04467#15 | 1603.04467#17 | 1603.04467 | [
"1502.02072"
] |
1603.04467#17 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | # 3.2.2 Cross-Device Communication Once the node placement has been computed, the graph is partitioned into a set of subgraphs, one per device. Any cross-device edge from x to y is removed and replaced by an edge from x to a new Send node in xâ s subgraph and an edge from a corresponding Receive node to y in yâ s subgraph. See Figure 4 for an example of this graph transformation. Device B Device B @ ot > | Device A Device A Figure 4: Before & after insertion of Send/Receive nodes At runtime, the implementations of the Send and Re- ceive nodes coordinate to transfer data across devices. This allows us to isolate all communication inside Send and Receive implementations, which simpliï¬ es the rest of the runtime. When we insert Send and Receive nodes, we canoni- calize all users of a particular tensor on a particular de- vice to use a single Receive node, rather than one Re- ceive node per downstream user on a particular device. This ensures that the data for the needed tensor is only transmitted once between a source device â destination device pair, and that memory for the tensor on the desti- nation device is only allocated once, rather than multiple times (e.g., see nodes b and c in Figure 4) By handling communication in this manner, we also allow the scheduling of individual nodes of the graph on different devices to be decentralized into the work- the Send and Receive nodes impart the necessary ers: | 1603.04467#16 | 1603.04467#18 | 1603.04467 | [
"1502.02072"
] |
1603.04467#18 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | 5 synchronization between different workers and devices, and the master only needs to issue a single Run request per graph execution to each worker that has any nodes for the graph, rather than being involved in the scheduling of every node or every cross-device communication. This makes the system much more scalable and allows much ï¬ ner-granularity node executions than if the scheduling were forced to be done by the master. # 3.3 Distributed Execution Distributed execution of a graph is very similar to multi- device execution. After device placement, a subgraph is created per device. Send/Receive node pairs that com- municate across worker processes use remote communi- cation mechanisms such as TCP or RDMA to move data across machine boundaries. # Fault Tolerance Failures in a distributed execution can be detected in a variety of places. The main ones we rely on are (a) an error in a communication between a Send and Receive node pair, and (b) periodic health-checks from the master process to every worker process. When a failure is detected, the entire graph execution is aborted and restarted from scratch. Recall however that Variable nodes refer to tensors that persist across ex- ecutions of the graph. We support consistent checkpoint- ing and recovery of this state on a restart. In partcular, each Variable node is connected to a Save node. These Save nodes are executed periodically, say once every N iterations, or once every N seconds. When they execute, the contents of the variables are written to persistent stor- age, e.g., a distributed ï¬ le system. Similarly each Vari- able is connected to a Restore node that is only enabled in the ï¬ rst iteration after a restart. See Section 4.2 for details on how some nodes can only be enabled on some executions of the graph. # 4 Extensions In this section we describe several more advanced fea- tures of the basic programming model that was intro- duced in Section 2. # 4.1 Gradient Computation Many optimization algorithms, including common ma- chine learning training algorithms like stochastic gradi- ent descent [45], compute the gradient of a cost function with respect to a set of inputs. | 1603.04467#17 | 1603.04467#19 | 1603.04467 | [
"1502.02072"
] |
1603.04467#19 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | Because this is such a 6 @ Y dReLU y mt Cad) _, fatwa) Oa AS Figure 5: Gradients computed for graph in Figure 2 common need, TensorFlow has built-in support for au- If a tensor C in a Ten- tomatic gradient computation. sorFlow graph depends, perhaps through a complex sub- graph of operations, on some set of tensors {Xk}, then there is a built-in function that will return the tensors {dC/dXk}. Gradient tensors are computed, like other tensors, by extending the TensorFlow graph, using the following procedure. When TensorFlow needs to compute the gradient of a tensor C with respect to some tensor I on which C depends, it ï¬ | 1603.04467#18 | 1603.04467#20 | 1603.04467 | [
"1502.02072"
] |
1603.04467#20 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | rst ï¬ nds the path in the computation graph from I to C. Then it backtracks from C to I, and for each operation on the backward path it adds a node to the TensorFlow graph, composing the partial gradients along the backwards path using the chain rule. The newly added node computes the â gradient functionâ for the cor- responding operation in the forward path. A gradient function may be registered by any operation. This func- tion takes as input not only the partial gradients com- puted already along the backward path, but also, option- ally, the inputs and outputs of the forward operation. Fig- ure 5 shows gradients for a cost computed from the ex- ample of Figure 2. Grey arrows show potential inputs to gradient functions that are not used for the particular operations shown. The addition needed to Figure 1 to compute these gradients is: [db,dW,dx] = tf.gradients(C, [b,W,x]) | 1603.04467#19 | 1603.04467#21 | 1603.04467 | [
"1502.02072"
] |
1603.04467#21 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | In general an operation may have multiple outputs, and C may only depend on some of them. If, for example, operation O has two outputs y1 and y2, and C only de- pends on y2, then the ï¬ rst input to Oâ s gradient function is set to 0 since dC/dy1 = 0. Automatic gradient computation complicates opti- mization, particularly of memory usage. When execut- ing â forwardâ computation subgraphs, i.e., those that are explicitly constructed by the user, a sensible heuristic breaks ties when deciding which node to execute next by observing the order in which the graph was constructed. This generally means that temporary outputs are con- sumed soon after being constructed, so their memory can be reused quickly. When the heuristic is ineffective, the user can change the order of graph construction, or add control dependencies as described in Section 5. When gradient nodes are automatically added to the graph, the user has less control, and the heuristics may break down. In particular, because gradients reverse the forward com- putation order, tensors that are used early in a graphâ s execution are frequently needed again near the end of a gradient computation. Such tensors can hold on to a lot of scarce GPU memory and unnecessarily limit the size of computations. We are actively working on improve- ments to memory management to deal better with such cases. Options include using more sophisticated heuris- tics to determine the order of graph execution, recom- puting tensors instead of retaining them in memory, and swapping out long-lived tensors from GPU memory to more plentiful host CPU memory. # 4.2 Partial Execution Often a client wants to execute just a subgraph of the entire execution graph. To support this, once the client has set up a computation graph in a Session, our Run method allows them to execute an arbitrary subgraph of the whole graph, and to inject arbitrary data along any edge in the graph, and to retrieve data ï¬ owing along any edge in the graph. Each node in the graph has a name, and each output of a node is identiï¬ ed by the source node name and the out- put port from the node, numbered from 0 (e.g., â bar:0â refers to the 1st output of the â barâ node, while â bar:1â refers to the 2nd output). | 1603.04467#20 | 1603.04467#22 | 1603.04467 | [
"1502.02072"
] |
1603.04467#22 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | Two arguments to the Run call help deï¬ ne the exact subgraph of the computation graph that will be executed. First, the Run call accepts inputs, an optional mapping of name:port names to â fedâ tensors values. Second, the Run call accepts output names, a list of output name[:port] speciï¬ cations indicating which nodes should be executed, and, if the port portion is present in a name, that that particular output tensor value for the node should be returned to the client if the Run call completes successfully. The graph is transformed based on the values of in- puts and outputs. Each node:port speciï¬ ed in inputs is replaced with a feed node, which will pick up the pro- vided input tensor from specially-initialized entries in a Rendezvous object used for the Run call. Similarly, each output name with a port is connected to a special fetch node that arranges to save the output tensor and return it to the client when the Run call is complete. Finally, once the graph has been rewritten with the insertion of these | 1603.04467#21 | 1603.04467#23 | 1603.04467 | [
"1502.02072"
] |
1603.04467#23 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | 7 +o @ Q@ O Figure 6: Before and after graph transformation for par- tial execution special feed and fetch nodes, the set of nodes to execute can be determined by starting at each of the nodes named by any output and working backwards in the graph using the graph dependencies to determine the full set of nodes that must be executed in the rewritten graph in order to compute the outputs. Figure 6 shows an original graph on the left, and the transformed graph that results when Run is invoked with inputs=={b} and outputs=={f:0}. Since we only need to compute the output of node f, we will not execute nodes d and e, since they have no con- tribution to the output of f. | 1603.04467#22 | 1603.04467#24 | 1603.04467 | [
"1502.02072"
] |
1603.04467#24 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | # 4.3 Device Constraints TensorFlow clients can control the placement of nodes on devices by providing partial constraints for a node about which devices it can execute on. For ex- type ample, â only place this node on a device of GPUâ , or â this node can be placed on any device in /job:worker/task:17â , or â Colocate this node with the node named variable13â . Within the con- ï¬ nes of these constraints, the placement algorithm is re- sponsible for choosing an assignment of nodes to de- vices that provides fast execution of the computation and also satisï¬ es various constraints imposed by the devices themselves, such as limiting the total amount of memory needed on a device in order to execute its subset of graph nodes. Supporting such constraints requires changes to the placement algorithm described in Section 3.2.1. | 1603.04467#23 | 1603.04467#25 | 1603.04467 | [
"1502.02072"
] |
1603.04467#25 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | We ï¬ rst compute the feasible set of devices for each node, and then use union-ï¬ nd on the graph of colocation constraints to compute the graph components that must be placed together. For each such component, we compute the in- tersection of the feasible device sets. The computed fea- sible device set per node ï¬ ts easily into the placement algorithmâ s simulator. # 4.4 Control Flow Although dataï¬ ow graphs without any explicit control ï¬ ow are quite expressive, we have observed a number of cases where supporting conditionals and loops can lead to more concise and efï¬ cient representations of machine learning algorithms. Much as in the dataï¬ ow-machine approach described by Arvind [3], we introduce a small set of primitive con- trol ï¬ ow operators into TensorFlow and generalize Ten- sorFlow to handle cyclic dataï¬ ow graphs. The Switch and Merge operators allow us to skip the execution of an entire subgraph based on the value of a boolean ten- sor. The Enter, Leave, and NextIteration operators allow us to express iteration. High-level programming con- structs such as if-conditionals and while-loops can be easily compiled into dataï¬ ow graphs with these control ï¬ ow operators. | 1603.04467#24 | 1603.04467#26 | 1603.04467 | [
"1502.02072"
] |
1603.04467#26 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | The TensorFlow runtime implements a notion of tags and frames conceptually similar to the MIT Tagged- Token machine [4]. Each iteration of a loop is uniquely identiï¬ ed by a tag, and its execution state is represented by a frame. An input can enter an iteration whenever it becomes available; thus, multiple iterations can be exe- cuted concurrently. TensorFlow uses a distributed coordination mecha- nism to execute graphs with control ï¬ ow. In general, a loop can contain nodes that are assigned to many dif- ferent devices. Therefore, managing the state of a loop becomes a problem of distributed termination detection. | 1603.04467#25 | 1603.04467#27 | 1603.04467 | [
"1502.02072"
] |
1603.04467#27 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlowâ s solution is based on graph rewriting. Dur- ing the graph partitioning, we automatically add control nodes to each partition. These nodes implement a small state machine that orchestrates the start and termination of each iteration, and decides the termination of the loop. For each iteration, the device that owns the loop termi- nation predicate sends a tiny control message to every participating device. As explained above, we often train machine learning models by gradient descent, and represent gradient com- putations as part of dataï¬ | 1603.04467#26 | 1603.04467#28 | 1603.04467 | [
"1502.02072"
] |
1603.04467#28 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | ow graphs. When a model includes control-ï¬ ow operations, we must account for them in the corresponding gradient computation. For ex- ample, the gradient computation for a model with an if- conditional will need to know which branch of the con- ditional was taken, then apply the gradient logic to this branch. Similarly, the gradient computation for a model with a while-loop will need to know how many iterations were taken, and will also rely on the intermediate values computed during those iterations. The basic technique is to rewrite the graph so to memorize the values needed for the gradient computation. We omit the somewhat intri- cate details of this encoding. | 1603.04467#27 | 1603.04467#29 | 1603.04467 | [
"1502.02072"
] |
1603.04467#29 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | 8 # Input Operations Although input data can be provided to a computation via feed nodes, another common mechanism used for train- ing large-scale machine learning models is to have spe- cial input operation nodes in the graph, which are typi- cally conï¬ gured with a set of ï¬ lenames and which yield a tensor containing one or more examples from the data stored in that set of ï¬ les each time they are executed. This allows data to be read directly from the underlying storage system into the memory of the machine that will perform subsequent processing on the data. | 1603.04467#28 | 1603.04467#30 | 1603.04467 | [
"1502.02072"
] |
1603.04467#30 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | In conï¬ gura- tions where the client process is separate from the worker process, if the data were fed, it typically would require an extra network hop (from the storage system to the client and then from the client to the worker vs. directly from the storage system to ther worker when using an input node). # 4.6 Queues Queues are a useful feature that we have added to Ten- sorFlow. They allow different portions of the graph to execute asynchronously, possibly at different candences, and to hand off data through Enqueue and Dequeue op- erations. Enqueue operations can block until space be- comes available in the queue, and Dequeue operations can block until a desired minimum number of elements are available in the queue. One use of queues is to allow input data to be prefetched from disk ï¬ les while a previ- ous batch of data is still being processed by the compu- tational portion of a machine learning model. They can also be used for other kinds of grouping, including accu- mulating many gradients in order to compute some more complex combination of gradients over a larger batch, or to group different input sentences for recurrent lan- guage models into bins of sentences that are approxi- mately the same length, which can then be processed more efï¬ ciently. In addition to normal FIFO queues, we have also im- plemented a shufï¬ ing queue, which randomly shufï¬ es its elements within a large in-memory buffer. This shufï¬ | 1603.04467#29 | 1603.04467#31 | 1603.04467 | [
"1502.02072"
] |
1603.04467#31 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | ing functionality is useful for machine learning algorithms that want to randomize the order in which they process examples, for example. # 4.7 Containers A Container is the mechanism within TensorFlow for managing longer-lived mutable state. The backing store for a Variable lives in a container. The default con- tainer is one that persists until the process terminates, but we also allow other named containers. A container can be reset by clearing it of its contents entirely. Us- ing containers, it is possible to share state even across completely disjoint computation graphs associated with different Sessions. | 1603.04467#30 | 1603.04467#32 | 1603.04467 | [
"1502.02072"
] |
1603.04467#32 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | # 5 Optimizations In this section, we describe some of the optimizations in the TensorFlow implementation that improve perfor- mance or resource usage of the system. # 5.1 Common Subexpression Elimination Since the construction of computation graphs is often done by many different layers of abstractions in the client code, computation graphs can easily end up with redun- dant copies of the same computation. To handle this, we have implemented a common subexpression pass similar to the algorithm described by Click [12] that runs over the computation graph and canonicalizes multiple copies of operations with identical inputs and operation types to just a single one of these nodes, and redirects graph edges appropriately to reï¬ ect this canonicalization. | 1603.04467#31 | 1603.04467#33 | 1603.04467 | [
"1502.02072"
] |
1603.04467#33 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | # 5.2 Controlling Data Communication and Memory Usage Careful scheduling of TensorFlow operations can result in better performance of the system, in particular with respect to data transfers and memory usage. Speciï¬ cally, scheduling can reduce the time window during which intermediate results need to be kept in memory in be- tween operations and hence the peak memory consump- tion. This reduction is particularly important for GPU devices where memory is scarce. Furthermore, orches- trating the communication of data across devices can re- duce contention for network resources. While there are many opportunities for scheduling op- timizations, here we focus on one that we found partic- ularly necessary and effective. It concerns the schedul- ing of Receive nodes for reading remote values. If no precautions are taken, these nodes may start much ear- lier than necessary, possibly all at once when execution starts. By performing an as-soon-as-possible/as-late-as- possible (ASAP/ALAP) calculation, of the kind common in operations research, we analyze the critical paths of graphs, in order to estimate when to start the Receive nodes. We then insert control edges with the aim of de- laying the start of these nodes until just before their re- sults are needed. | 1603.04467#32 | 1603.04467#34 | 1603.04467 | [
"1502.02072"
] |
1603.04467#34 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | 9 # 5.3 Asynchronous Kernels In addition to normal synchronous kernels that complete their execution at the end of the Compute method, our framework also supports non-blocking kernels. Such non-blocking kernels use a slightly different interface whereby the Compute method is passed a continuation that should be invoked when the kernelâ s execution is complete. This is an optimization for environments where having many active threads is relatively expensive in terms of memory usage or other resources, and allows us to avoid tying up an execution thread for unbounded periods of time while waiting for I/O or other events to occur. Examples of asynchronous kernels include the Receive kernel, and the Enqueue and Dequeue kernels (which might need to block if queue space is not avail- able or if no data is available to be read, respectively). # 5.4 Optimized Libraries for Kernel Imple- mentations We often make use of pre-existing highly-optimized nu- merical libraries to implement kernels for some opera- tions. For example, there are a number of optimized li- braries for performing matrix multiplies on different de- vices, including BLAS [15] and cuBLAS [39], or GPU libraries for convolutional kernels for deep neural nets such as cuda-convnet [28] and cuDNN [9]. Many of our kernel implementations are relatively thin wrappers around such optimized libraries. We make fairly extensive use of the open-source Eigen linear algebra library [25] for many of the kernel imple- mentations in the system. As one part of the develop- ment of TensorFlow, our team (primarily Benoit Steiner) has extended the open source Eigen library with support for arbitrary dimensionality tensor operations. | 1603.04467#33 | 1603.04467#35 | 1603.04467 | [
"1502.02072"
] |
1603.04467#35 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | # 5.5 Lossy Compression Some machine learning algorithms, including those typ- ically used for training neural networks, are tolerant of noise and reduced precision arithmetic. In a manner sim- ilar to the DistBelief system [14], we often use lossy compression of higher precision internal representations when sending data between devices (sometimes within the same machine but especially across machine bound- aries). For example, we often insert special conversion nodes that convert 32-bit ï¬ oating point representations into a 16-bit ï¬ oating point representation (not the pro- posed IEEE 16-bit ï¬ oating point standard, but rather just a 32-bit IEEE 794 ï¬ oat format, but with 16 bits less pre- cision in the mantissa), and then convert back to a 32- bit representation on the other side of the communica- tion channel (by just ï¬ lling in zeroes for the lost portion of the mantissa, since thatâ s less computationally expen- sive than doing the mathematically correct probabilistic rounding when doing this 32 â 16 â 32-bit conver- sion). # 6 Status and Experience | 1603.04467#34 | 1603.04467#36 | 1603.04467 | [
"1502.02072"
] |
1603.04467#36 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | The TensorFlow interface and a reference implemen- tation have been open sourced under an Apache 2.0 license, and the system is available for download at www.tensorï¬ ow.org. The system includes detailed docu- mentation, a number of tutorials, and a number of exam- ples demonstrating how to use the system for a variety of different machine learning tasks. The examples in- clude models for classifying hand-written digits from the MNIST dataset (the â hello worldâ of machine learning algorithms) [32], classifying images from the CIFAR- 10 dataset [30], doing language modeling using a recur- rent LSTM [22] network, training word embedding vec- tors [35] and more. The system includes front-ends for specifying Tensor- Flow computations in Python and C++, and we expect other front-ends to be added over time in response to the desires of both internal Google users and the broader open-source community. We have quite a few machine learning models in our previous DistBelief system [14] that we have migrated over to TensorFlow. The rest of this section discusses some lessons we have learned that are generalizable for any such migration of machine learning models from one system to another, and therefore may be valuable to oth- ers. In particular, we focus on our lessons from porting a state-of-the-art convolutional neural network for image recognition termed Inception [23]. This image recogni- tion system classiï¬ | 1603.04467#35 | 1603.04467#37 | 1603.04467 | [
"1502.02072"
] |
1603.04467#37 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | es 224 Ã 224 pixel images into one of 1000 labels (e.g., â cheetahâ , â garbage truckâ , etc.). Such a model comprises 13.6 million learnable parame- ters and 36,000 operations when expressed as a Tensor- Flow graph. Running inference on a single image re- quires 2 billion multiply-add operations. After building all necessary mathematical operations in TensorFlow, assembling and debugging all 36,000 op- erations into the correct graph structure proved challeng- ing. | 1603.04467#36 | 1603.04467#38 | 1603.04467 | [
"1502.02072"
] |
1603.04467#38 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | Validating correctness is a difï¬ cult enterprise be- cause the system is inherently stochastic and only in- tended to behave in a certain way in expectation â po- tentially after hours of computation. Given these cir- cumstances, we found the following strategies critical for porting the Inception model to TensorFlow: 1. Build tools to gain insight into the exact number of parameters in a given model. Such tools demon- 10 strated subtle ï¬ aws in a complex network architec- ture speciï¬ cation. In particular we were able to identify operations and variables instantiated incor- rectly due to automatic broadcasting in a mathemat- ical operation across a dimension. 2. | 1603.04467#37 | 1603.04467#39 | 1603.04467 | [
"1502.02072"
] |
1603.04467#39 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | Start small and scale up. The ï¬ rst convolutional neural network that we ported from our previ- ous system was a small network employed on the CIFAR-10 data set [30]. Debugging such a network elucidated subtle edge cases in individual opera- tions (e.g., max-pooling) within the machine learn- ing system that would have been practically indeci- pherable in more complex models. 3. Always ensure that the objective (loss function) matches between machine learning systems when learning is turned off. Setting the learning rate to be zero helped us identify unexpected behavior in how we had randomly initialized variables in a model. | 1603.04467#38 | 1603.04467#40 | 1603.04467 | [
"1502.02072"
] |
1603.04467#40 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | Such an error would have been difï¬ cult to identify in a dynamic, training network. 4. Make a single machine implementation match be- fore debugging a distributed implementation. This strategy helped us delineate and debug discrep- ancies in training performance between machine learning system. In particular, we identiï¬ ed bugs due to race conditions and non-atomic operations incorrectly assumed to be atomic. 5. Guard against numerical errors. Numerical li- braries are inconsistent in how they handle non- ï¬ nite ï¬ oating point values. | 1603.04467#39 | 1603.04467#41 | 1603.04467 | [
"1502.02072"
] |
1603.04467#41 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | Convolutional neu- ral networks are particularly susceptible to numer- ical instability and will tend to diverge quite regu- larly during experimentation and debugging phases. Guarding against this behavior by checking for non- ï¬ nite ï¬ oating point values allows one to detect er- rors in real time as opposed to identifying divergent behavior post-hoc. 6. Analyze pieces of a network and understand the magnitude of numerical error. Running subsec- tions of a neural network in parallel on two machine learning systems provides a precise method to en- sure that a numerical algorithm is identical across two systems. Given that such algorithms run with ï¬ oating point precision, it is important to predict and understand the magnitude of expected numer- ical error in order to judge whether a given compo- nent is correctly implemented (e.g., distinguishing between â within 1e-2, great!â and â within 1e-2: why is it so incorrect?!â ). Parameter Device(s) Device A Device B Device C model $ model Parameter Device(s) AP. Synchronous Data Parallelism } Device A Device B Device C model 3 3 model g model Data Parallelism Asynchronous Data Parallelism | 1603.04467#40 | 1603.04467#42 | 1603.04467 | [
"1502.02072"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.