doi
stringlengths 10
10
| chunk-id
int64 0
936
| chunk
stringlengths 401
2.02k
| id
stringlengths 12
14
| title
stringlengths 8
162
| summary
stringlengths 228
1.92k
| source
stringlengths 31
31
| authors
stringlengths 7
6.97k
| categories
stringlengths 5
107
| comment
stringlengths 4
398
⌀ | journal_ref
stringlengths 8
194
⌀ | primary_category
stringlengths 5
17
| published
stringlengths 8
8
| updated
stringlengths 8
8
| references
list |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1603.05279 | 53 | 39. Wan, L., Zeiler, M., Zhang, S., Cun, Y.L., Fergus, R.: Regularization of neural networks us- ing dropconnect. In: Proceedings of the 30th International Conference on Machine Learning (ICML-13). (2013) 1058â1066 5
40. Baldassi, C., Ingrosso, A., Lucibello, C., Saglietti, L., Zecchina, R.: Subdominant dense clusters allow for simple learning and high computational performance in neural networks with discrete synapses. Physical review letters 115(12) (2015) 128101 5
41. Kim, M., Smaragdis, P.: Bitwise neural networks. arXiv preprint arXiv:1601.06071 (2016) 5
XNOR-Net: ImageNet Classiï¬cation Using Binary Convolutional Neural Networks
42. Kingma, D., Ba, J.: Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980 (2014) 6, 12
43. Ioffe, S., Szegedy, C.: Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167 (2015) 9, 11 | 1603.05279#53 | XNOR-Net: ImageNet Classification Using Binary Convolutional Neural Networks | We propose two efficient approximations to standard convolutional neural
networks: Binary-Weight-Networks and XNOR-Networks. In Binary-Weight-Networks,
the filters are approximated with binary values resulting in 32x memory saving.
In XNOR-Networks, both the filters and the input to convolutional layers are
binary. XNOR-Networks approximate convolutions using primarily binary
operations. This results in 58x faster convolutional operations and 32x memory
savings. XNOR-Nets offer the possibility of running state-of-the-art networks
on CPUs (rather than GPUs) in real-time. Our binary networks are simple,
accurate, efficient, and work on challenging visual tasks. We evaluate our
approach on the ImageNet classification task. The classification accuracy with
a Binary-Weight-Network version of AlexNet is only 2.9% less than the
full-precision AlexNet (in top-1 measure). We compare our method with recent
network binarization methods, BinaryConnect and BinaryNets, and outperform
these methods by large margins on ImageNet, more than 16% in top-1 accuracy. | http://arxiv.org/pdf/1603.05279 | Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, Ali Farhadi | cs.CV | null | null | cs.CV | 20160316 | 20160802 | [
{
"id": "1602.07360"
},
{
"id": "1502.03167"
},
{
"id": "1510.03009"
},
{
"id": "1504.04788"
},
{
"id": "1601.06071"
},
{
"id": "1510.00149"
}
] |
1603.04779 | 0 | 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 | 1603.04779#0 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 1 | # ° 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 ï¬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.
# INTRODUCTION | 1603.04779#1 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 2 | # 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. | 1603.04779#2 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 3 | 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. Fig. 1 illustrates the ï¬owchart of AdaBN. To summarize, our contributions are as follows:
1
# Under review as a conference paper at ICLR 2017 | 1603.04779#3 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 4 | 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.
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 | 1603.04779#4 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 5 | # 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). | 1603.04779#5 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 6 | 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.
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.
2
# Under review as a conference paper at ICLR 2017 | 1603.04779#6 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 7 | 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. | 1603.04779#7 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 8 | 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.
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: | 1603.04779#8 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 9 | 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 ï¬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 | 1603.04779#9 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 10 | # 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.
3
# Under review as a conference paper at ICLR 2017 | 1603.04779#10 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 11 | 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. | 1603.04779#11 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 12 | (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.
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) | 1603.04779#12 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 13 | # 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.
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. | 1603.04779#13 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 14 | 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) | 1603.04779#14 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 15 | 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. 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
We ï¬rst introduce our experiments on two standard datasets: Ofï¬ce (Saenko et al., 2010) and Caltech-Bing (Bergamo & Torresani, 2010). | 1603.04779#15 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 16 | 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.
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 | 1603.04779#16 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 17 | 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 â 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 | 1603.04779#17 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 20 | 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). 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. | 1603.04779#20 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 21 | 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. 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 | 1603.04779#21 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 22 | 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#22 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 23 | 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.
6
# Under review as a conference paper at ICLR 2017 | 1603.04779#23 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 24 | 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 â 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 | 1603.04779#24 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 25 | 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 | 1603.04779#25 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 26 | 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.
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
# Under review as a conference paper at ICLR 2017 | 1603.04779#26 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 27 | 7
# 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. Best viewed in color. | 1603.04779#27 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 28 | Figure 3: Distribution of the symmetric KL divergence of the outputs in shallow layer and deep layer. 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.
076 Mil Adapt BN Inception BN 2 4 6 8 10 1 | 1603.04779#28 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 29 | 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.
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. | 1603.04779#29 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 30 | 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. | 1603.04779#30 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 31 | 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. 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 | 1603.04779#31 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 32 | 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
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
~~ | 1603.04779#32 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 33 | 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. 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. | 1603.04779#33 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 34 | 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. 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: A ï¬exible and efï¬cient machine learning library for heterogeneous distributed systems. NIPS Workshop on Machine Learning Systems, 2016b. | 1603.04779#34 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 35 | 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. 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#35 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 36 | 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.
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. | 1603.04779#36 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 37 | 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. 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. Undoing the damage of dataset bias. In ECCV, pp. 158â171. 2012. | 1603.04779#37 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 38 | 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. 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. | 1603.04779#38 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 39 | 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.
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.
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. | 1603.04779#39 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04779 | 40 | 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.
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#40 | Revisiting Batch Normalization For Practical Domain Adaptation | Deep neural networks (DNN) have shown unprecedented success in various
computer vision applications such as image classification and object detection.
However, it is still a common annoyance during the training phase, that one has
to prepare at least thousands of labeled images to fine-tune a network to a
specific domain. Recent study (Tommasi et al. 2015) shows that a DNN has strong
dependency towards the training dataset, and the learned features cannot be
easily transferred to a different but relevant task without fine-tuning. In
this paper, we propose a simple yet powerful remedy, called Adaptive Batch
Normalization (AdaBN) 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 surprising 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. | http://arxiv.org/pdf/1603.04779 | Yanghao Li, Naiyan Wang, Jianping Shi, Jiaying Liu, Xiaodi Hou | cs.CV, cs.LG | null | null | cs.CV | 20160315 | 20161108 | [
{
"id": "1607.01719"
},
{
"id": "1606.00915"
},
{
"id": "1512.00567"
}
] |
1603.04467 | 0 | 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#0 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 1 | # Google Researchâ
# Abstract
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ï¬ow.org.
1
# 1 Introduction | 1603.04467#1 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 2 | 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. | 1603.04467#2 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 3 | 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ï¬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 | 1603.04467#3 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 4 | dataï¬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#4 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 5 | â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. | 1603.04467#5 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 6 | 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ï¬ow.org. | 1603.04467#6 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 7 | 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
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. | 1603.04467#7 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 8 | 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. 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 | 1603.04467#8 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 9 | # Operations and Kernels
An operation has a name and represents an abstract com- putation (e.g., âmatrix multiplyâ, or âaddâ). 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). The other primary operation supported
# import tensorflow as tf | 1603.04467#9 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 10 | # 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
Figure 1: Example TensorFlow code fragment
©) = Add
# Figure 2: Corresponding computation graph for Figure 1 | 1603.04467#10 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 11 | 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 | 1603.04467#11 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 12 | 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.
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.
# Implementation | 1603.04467#12 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 13 | # 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 | 1603.04467#13 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 14 | # 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". 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 | 1603.04467#14 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 15 | # 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
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 | 1603.04467#15 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 16 | # 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
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#16 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 17 | Figure 3: Single machine and distributed system structure
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. | 1603.04467#17 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 18 | 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.
# 3.2.2 Cross-Device Communication | 1603.04467#18 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 19 | # 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) | 1603.04467#19 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 20 | 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:
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. | 1603.04467#20 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 21 | 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. Because this is such a
6
@ Y dReLU y mt Cad) _, fatwa) Oa AS
Figure 5: Gradients computed for graph in Figure 2 | 1603.04467#21 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 22 | 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. | 1603.04467#22 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 23 | When TensorFlow needs to compute the gradient of a tensor C with respect to some tensor I on which C depends, it ï¬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#23 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 24 | [db,dW,dx] = tf.gradients(C, [b,W,x])
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. | 1603.04467#24 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 25 | 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. | 1603.04467#25 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 26 | 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).
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. | 1603.04467#26 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 27 | 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
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.
# 4.3 Device Constraints | 1603.04467#27 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 28 | # 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. 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 | 1603.04467#28 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 29 | # 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.
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. | 1603.04467#29 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 30 | 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. 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. | 1603.04467#30 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 31 | As explained above, we often train machine learning models by gradient descent, and represent gradient com- putations as part of dataï¬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.
8
# Input Operations | 1603.04467#31 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 32 | 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. 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 | 1603.04467#32 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 33 | # 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ï¬ing functionality is useful for machine learning algorithms that want to randomize the order in which they process examples, for example.
# 4.7 Containers | 1603.04467#33 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 34 | # 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.
# 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.
# 5.2 Controlling Data Communication and Memory Usage | 1603.04467#34 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 35 | # 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.
9
# 5.3 Asynchronous Kernels | 1603.04467#35 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 36 | 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. | 1603.04467#36 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 37 | 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.
# 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 | 1603.04467#37 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 38 | 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
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. | 1603.04467#38 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 39 | 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ï¬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. 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: | 1603.04467#39 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 40 | 1. Build tools to gain insight into the exact number of parameters in a given model. Such tools demon10
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. 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. Such an error would have been difï¬cult to identify in a dynamic, training network. | 1603.04467#40 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 41 | 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. 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. | 1603.04467#41 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 42 | 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
Figure 7: Synchronous and asynchronous data parallel training | 1603.04467#42 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 43 | Asynchronous Data Parallelism
Figure 7: Synchronous and asynchronous data parallel training
Validating complex mathematical operations in the presence of an inherently stochastic system is quite chal- lenging. The strategies outlined above proved invaluable in gaining conï¬dence in the system and ultimately in in- stantiating the Inception model in TensorFlow. The end result of these efforts resulted in a 6-fold speed improve- ment in training time versus our existing DistBelief im- plementation of the model and such speed gains proved indispensable in training a new class of larger-scale im- age recognition models.
# 7 Common Programming Idioms
TensorFlowâs basic dataï¬ow graph model can be used in a variety of ways for machine learning applications. One domain we care about is speeding up training of com- putationally intensive neural network models on large datasets. This section describes several techniques that we and others have developed in order to accomplish this, and illustrates how to use TensorFlow to realize these various approaches.
The approaches in this subsection assume that the model is being trained using stochastic gradient descent (SGD) with relatively modest-sized mini-batches of 100 to 1000 examples.
# Data Parallel Training | 1603.04467#43 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 44 | # Data Parallel Training
One simple technique for speeding up SGD is to paral- lelize the computation of the gradient for a mini-batch across mini-batch elements. For example, if we are us- ing a mini-batch size of 1000 elements, we can use 10 replicas of the model to each compute the gradient for 100 elements, and then combine the gradients and apply updates to the parameters synchronously, in order to be- have exactly as if we were running the sequential SGD algorithm with a batch size of 1000 elements. In this case, the TensorFlow graph simply has many replicas of the portion of the graph that does the bulk of the model computation, and a single client thread drives the entire training loop for this large graph. This is illustrated in the top portion of Figure 7.
This approach can also be made asynchronous, where the TensorFlow graph has many replicas of the portion of the graph that does the bulk of the model computation, and each one of these replicas also applies the parame- ter updates to the model parameters asynchronously. In this conï¬guration, there is one client thread for each of the graph replicas. This is illustrated in the bottom por- tion of Figure 7. This asynchronous approach was also described in [14].
11 | 1603.04467#44 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 45 | 11
Device 3 â_ @/os = Ec 3-⬠c gt aL Eee e. A y A P| ab(a | a)
Figure 8: Model parallel training
pdate ines imodel § inoie} ( @> f Gnput) im Gnput) ler
Figure 9: Concurrent steps
# Model Parallel Training
Model parallel training, where different portions of the model computation are done on different computational devices simultaneously for the same batch of examples, is also easy to express in TensorFlow. Figure 8 shows an example of a recurrent, deep LSTM model used for sequence to sequence learning (see [47]), parallelized across three different devices.
# Concurrent Steps for Model Computation Pipelining
Another common way to get better utilization for train- ing deep neural networks is to pipeline the computation of the model within the same devices, by running a small number of concurrent steps within the same set of de- vices. This is shown in Figure 9. It is somewhat similar to asynchronous data parallelism, except that the paral- lelism occurs within the same device(s), rather than repli- cating the computation graph on different devices. This allows âï¬lling in the gapsâ where computation of a sin- gle batch of examples might not be able to fully utilize the full parallelism on all devices at all times during a single step.
12
# 8 Performance | 1603.04467#45 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 46 | 12
# 8 Performance
A future version of this white paper will have a compre- hensive performance evaluation section of both the sin- gle machine and distributed implementations.
# 9 Tools
This section describes some tools we have developed that sit alongside the core TensorFlow graph execution en- gine.
# 9.1 TensorBoard: Visualization of graph structures and summary statistics
In order to help users understand the structure of their computation graphs and also to understand the overall behavior of machine learning models, we have built Ten- sorBoard, a companion visualization tool for TensorFlow that is included in the open source release.
# Visualization of Computation Graphs
Many of the computation graphs for deep neural net- works can be quite complex. For example, the computa- tion graph for training a model similar to Googleâs Incep- tion model [48], a deep convolutional neural net that had the best classiï¬cation performance in the ImageNet 2014 contest, has over 36,000 nodes in its TensorFlow compu- tation graph, and some deep recurrent LSTM models for language modeling have more than 15,000 nodes. | 1603.04467#46 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 47 | Due to the size and topology of these graphs, naive vi- sualization techniques often produce cluttered and over- whelming diagrams. To help users see the underlying organization of the graphs, the algorithms in Tensor- Board collapse nodes into high-level blocks, highlighting groups with identical structures. The system also sep- arates out high-degree nodes, which often serve book- keeping functions, into a separate area of the screen. Do- ing so reduces visual clutter and focuses attention on the core sections of the computation graph.
The entire visualization is interactive: users can pan, zoom, and expand grouped nodes to drill down for de- tails. An example of the visualization for the graph of a deep convolutional image model is shown in Figure 10.
# Visualization of Summary Data
When training machine learning models, users often want to be able to examine the state of various aspects of the model, and how this state changes over time. To this end, TensorFlow supports a collection of different Summary operations that can be inserted into the graph, | 1603.04467#47 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 48 | total_lo... train group_de... total_loss count [lif scetersu. Const O- gradient... global-s... 00%} globals. softmax global-s... total_lo... ore global_s. sgd LabelClasses total_lo... moving_a... -O old_grad... softmax_linear init init global_s... 8 more sgd moving_a... local4 group_de... init init 9 more sgd moving_a... local3 group_de... init init «9 more
Figure 10: TensorBoard graph visualization of a convolutional neural network model
nn1/biases nn1/biases:gradient nn1/weights 0,600 0,300 0,400 2,0000-4 0,200 0,200 0.00 0.100 0.00 0.00 -0.200 -2.0000-4 -0.100 -0.400 -0.200 -0.600 -4,0000-4 -0.300 ra ra ra Be 0.000 100.0k 200.0k 300.0k we 0.000 30.00k 60.00k + 90.00k Be 0.000 20.00k 40.00k 60.00k 80.00k
Figure 11: TensorBoard graphical display of model summary statistics time series data | 1603.04467#48 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 49 | Figure 11: TensorBoard graphical display of model summary statistics time series data
including scalar summaries (e.g., for examining overall properties of the model, such as the value of the loss function averaged across a collection of examples, or the time taken to execute the computation graph), histogram- based summaries (e.g., the distribution of weight values in a neural network layer), or image-based summaries (e.g., a visualization of the ï¬lter weights learned in a convolutional neural network). Typically computation graphs are set up so that Summary nodes are included to monitor various interesting values, and every so often during execution of the training graph, the set of sum- mary nodes are also executed, in addition to the normal set of nodes that are executed, and the client driver pro- gram writes the summary data to a log ï¬le associated with the model training. The TensorBoard program is then conï¬gured to watch this log ï¬le for new summary | 1603.04467#49 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 50 | records, and can display this summary information and how it changes over time (with the ability to select the measurement of âtimeâ to be relative wall time since the beginning of the execution of the TensorFlow pro- gram, absolute time, or âstepsâ, a numeric measure of the number of graph executions that have occurred since the beginning of execution of the TensorFlow program). A screen shot of the visualization of summary values in TensorBoard is shown in Figure 11.
# 9.2 Performance Tracing
We also have an internal tool called EEG (not included in the initial open source release in November, 2015) that we use to collect and visualize very ï¬ne-grained informa- tion about the exact ordering and performance character13
istics of the execution of TensorFlow graphs. This tool works in both our single machine and distributed imple- mentations, and is very useful for understanding the bot- tlenecks in the computation and communication patterns of a TensorFlow program.
Traces are collected simultaneously on each machine in the system from a variety of sources including Linux kernel ftrace, our own lightweight thread tracing tools and the CUDA Proï¬ling Tools Interface (CUPTI). With these logs we can reconstruct the execution of a dis- tributed training step with microsecond-level details of every thread-switch, CUDA kernel launch and DMA op- eration. | 1603.04467#50 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 51 | Traces are combined in a visualization server which is designed to rapidly extract events in a speciï¬ed timerange and summarize at appropriate detail level for the user-interface resolution. Any signiï¬cant delays due to communication, synchronization or DMA-related stalls are identiï¬ed and highlighted using arrows in the visualization. Initially the UI provides an overview of the entire trace, with only the most signiï¬cant performance artifacts highlighted. As the user progressively zooms in, increasingly ï¬ne resolution details are rendered. | 1603.04467#51 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 52 | Figure 12 shows an example EEG visualization of a model being trained on a multi-core CPU platform. The top third of the screenshot shows TensorFlow operations being dispatched in parallel, according to the dataï¬ow constraints. The bottom section of the trace shows how most operations are decomposed into multiple work- items which are executed concurrently in a thread pool. The diagonal arrows on the right hand size show where queueing delay is building up in the thread pool. Fig- ure 13 shows another EEG visualization with compu- tation mainly happening on the GPU. Host threads can be seen enqueuing TensorFlow GPU operations as they become runnable (the light blue thread pool), and back- ground housekeeping threads can be seen in other col- ors being migrated across processor cores. Once again, arrows show where threads are stalled on GPU to CPU transfers, or where ops experience signiï¬cant queueing delay.
Finally, Figure 14 shows a more detailed view which allows us to examine how Tensorï¬ow GPU operators are assigned to multiple GPU streams. Whenever the dataï¬ow graph allows parallel execution or data trans- fer we endeavour to expose the ordering constraints to the GPU device using streams and stream dependency primitives.
# 10 Future Work
We have several different directions for future work. We will continue to use TensorFlow to develop new and in14 | 1603.04467#52 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 53 | # 10 Future Work
We have several different directions for future work. We will continue to use TensorFlow to develop new and in14
teresting machine learning models for artiï¬cial intelli- gence, and in the course of doing this, we may discover ways in which we will need to extend the basic Ten- sorFlow system. The open source community may also come up with new and interesting directions for the Ten- sorFlow implementation.
One extension to the basic programming model that we are considering is a function mechanism, whereby a user can specify an entire subgraph of a TensorFlow computation to be a reusable component. In the imple- mentation we have designed, these functions can become reusable components even across different front-end lan- guages for TensorFlow, so that a user could deï¬ne a func- tion using the Python front end, but then use that func- tion as a basic building block from within the C++ front- end. We are hopeful that this cross-language reusability will bootstrap a vibrant community of machine learning researchers publishing not just whole examples of their research, but also small reusable components from their work that can be reused in other contexts. | 1603.04467#53 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 54 | We also have a number of concrete directions to im- prove the performance of TensorFlow. One such direc- tion is our initial work on a just-in-time compiler that can take a subgraph of a TensorFlow execution, perhaps with some runtime proï¬ling information about the typi- cal sizes and shapes of tensors, and can generate an op- timized routine for this subgraph. This compiler will un- derstand the semantics of perform a number of optimiza- tions such as loop fusion, blocking and tiling for locality, specialization for particular shapes and sizes, etc.
We also imagine that a signiï¬cant area for future work will be in improving the placement and node scheduling algorithms used to decide where different nodes will exe- cute, and when they should start executing. We have cur- rently implemented a number of heuristics in these sub- systems, and weâd like to have the system instead learn to make good placement decisions (perhaps using a deep neural network, combined with a reinforcement learning objective function).
# 11 Related Work | 1603.04467#54 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 55 | # 11 Related Work
There are many other systems that are comparable in various ways with TensorFlow. Theano [7], Torch [13], Caffe [26], Chainer [49] and the Computational Network Toolkit [54] are a few systems designed primarily for the training of neural networks. Each of these systems maps the computation onto a single machine, unlike the dis- tributed TensorFlow implementation. Like Theano and Chainer, TensorFlow supports symbolic differentiation, thus making it easier to deï¬ne and work with gradient- based optimization algorithms. Like Caffe, TensorFlow has a core written in C++, simplifying the deployment | 1603.04467#55 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 56 | Figure 12: EEG visualization of multi-threaded CPU operations (x-axis is time in µs).
CPU Utiization 214,09% orp: as: i i TS nn is [| Job.workerleplica-tnask Olgpu:0 erecep498 I 3,730,000 3,736,000 13,740,000 3,745,000 3,750,000 13,755,000 13,760,000 3,765,000
Figure 13: EEG visualization of Inception training showing CPU and GPU activity.
of trained models in a wide variety of production set- tings, including memory- and computation-constrained environments such as mobile devices.
The TensorFlow system shares some design charac- teristics with its predecessor system, DistBelief [14], and with later systems with similar designs like Project Adam [10] and the Parameter Server project [33]. Like DistBelief and Project Adam, TensorFlow allows com- putations to be spread out across many computational de- vices across many machines, and allows users to specify | 1603.04467#56 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 57 | machine learning models using relatively high-level de- scriptions. Unlike DistBelief and Project Adam, though, the general-purpose dataï¬ow graph model in TensorFlow is more ï¬exible and more amenable to expressing a wider variety of machine learning models and optimization al- gorithms. It also permits a signiï¬cant simpliï¬cation by allowing the expression of stateful parameter nodes as variables, and variable update operations that are just additional nodes in the graph; in contrast, DistBelief, Project Adam and the Parameter Server systems all have
15 | 1603.04467#57 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 58 | âjou:workerrepica onask eps Jjobsworkerkepicadrasleeps0 gpu-omemeny seo IES gpu/steam:12 1 i souttsean19 1 sou0sveans4 aounsream's | aounsveam's | gouoreveam:t7 (IRIN gpu/sveam:18 [| gpu/steam:19 I [ gpudisteam26 veracoteaui2 kracoicou's I 4} I = âeracacput \ ai) leracoieputs sol eracoioputs aU veracetout? racoicours y U keraceiepu'9 Q mM A kiracoicnu i Ly iracaienu2t tot | wind an veracoieu22 eracoiepu23 | | t La lL | eracelepudt reseco â7.684,000, res6.co 7,688,000 7,700,000 ee â at â___- ti 7,702,000 CPU Uniasion 159,20% \ ri moa id on een oowie ' 13% ie = if mon to tay 2 WOU a | i a | iat wi 1H =i, alli be a fox oan = we otis - i} 13% : mo Ln ou me nn al ey 0 coun em | 1603.04467#58 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
1603.04467 | 60 | Figure 14: Timeline of multi-stream GPU execution.
whole separate parameter server subsystems devoted to communicating and updating parameter values.
The Halide system [40] for expressing image pro- cessing pipelines uses a similar intermediate represen- tation to the TensorFlow dataï¬ow graph. Unlike Ten- sorFlow, though, the Halide system actually has higher- level knowledge of the semantics of its operations and uses this knowledge to generate highly optimized pieces of code that combine multiple operations, taking into ac- count parallelism and locality. Halide runs the resulting computations only on a single machine, and not in a dis- tributed setting. In future work we are hoping to extend TensorFlow with a similar cross-operation dynamic com- pilation framework. | 1603.04467#60 | TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems | TensorFlow is an interface for expressing machine learning algorithms, and an
implementation for executing such algorithms. A computation expressed using
TensorFlow can be executed with little or no change on a wide variety of
heterogeneous 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 flexible 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 learning systems into production across more
than a dozen areas of computer science and other fields, including speech
recognition, computer vision, robotics, information retrieval, natural language
processing, geographic information extraction, and computational drug
discovery. This paper describes the TensorFlow 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.tensorflow.org. | http://arxiv.org/pdf/1603.04467 | 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 Mane, 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 Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, Xiaoqiang Zheng | cs.DC, cs.LG | Version 2 updates only the metadata, to correct the formatting of
Mart\'in Abadi's name | null | cs.DC | 20160314 | 20160316 | [
{
"id": "1502.02072"
},
{
"id": "1507.04296"
}
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.