user: text: Write a concise one-sentence TLDR summary of the scientific paper content below.

Title: Pipelined Training with Stale Weights of Deep Convolutional Neural Networks

Paper content:
The growth in the complexity of Convolutional Neural Networks (CNNs) is increasing interest in partitioning a network across multiple accelerators during training and pipelining the backpropagation computations over the accelerators.
Existing approaches avoid or limit the use of stale weights through techniques such as micro-batching or weight stashing.
These techniques either underutilize of accelerators or increase memory footprint.
We explore the impact of stale weights on the statistical efficiency and performance in a pipelined backpropagation scheme that maximizes accelerator utilization and keeps memory overhead modest.
We use 4 CNNs (LeNet-5, AlexNet, VGG and ResNet) and show that when pipelining is limited to early layers in a network, training with stale weights converges and results in models with comparable inference accuracies to those resulting from non-pipelined training on MNIST and CIFAR-10 datasets; a drop in accuracy of 0.4%, 4%, 0.83% and 1.45% for the 4 networks, respectively.
However, when pipelining is deeper in the network, inference accuracies drop significantly.
We propose combining pipelined and non-pipelined training in a hybrid scheme to address this drop.
We demonstrate the implementation and performance of our pipelined backpropagation in PyTorch on 2 GPUs using ResNet, achieving speedups of up to 1.8X over a 1-GPU baseline, with a small drop in inference accuracy.
Modern Convolutional Neural Networks (CNNs) have grown in size and complexity to demand considerable memory and computational resources, particularly for training.
This growth makes it sometimes difficult to train an entire network with a single accelerator (Huang et al., 2018; Harlap et al., 2018; .
Instead, the network is partitioned among multiple accelerators, typically by partitioning its layers among the available accelerators, as shown in Figure 1 for an example 8-layer network.
The 8 layers are divided into 4 computationally-balanced partitions, P 0 ...P 3 and each partition is mapped to one of the 4 accelerators, A 0 ...A 3 .
Each accelerator is responsible for the computations associated with the layers mapped to it.
However, the nature of the backpropagation algorithm used to train CNNs (Rumelhart et al., 1986) is that the computations of a layer are performed only after the computations of the preceding layer in the forward pass of the algorithm and only after the computations of the succeeding layer in the backward pass.
Further, the computations for one batch of input data are only performed after the computations of the preceding batch have updated the parameters (i.e., weights) of the network.
These dependences underutilize the accelerators, as shown by the space-time diagram in Figure 2 ; only one accelerator can be active at any given point in time.
The underutilization of accelerators can be alleviated by pipelining the computations of the backpropagation algorithm over the accelerators (Huang et al., 2018; Harlap et al., 2018; .
That is, by overlapping the computations of different input data batches using the multiple accelerators.
However, pipelining causes an accelerator to potentially use weights that are yet to be updated by an accelerator further down in the pipeline.
The use of such stale weights can negatively affect the statistical efficiency of the network, preventing the convergence of training or producing a model with lower inference accuracy.
Common wisdom is that the use of stale weights must either be avoided, e.g., with the use of microbatches (Huang et al., 2018) , be constrained to ensure the consistency of the weights within an accelerator using stashing (Harlap et al., 2018) , or by limiting the use of pipelining to very small networks (Mostafa et al., 2017) .
However, these approaches either underutilize accelerators (Huang et al., 2018) or inflate memory usage to stash multiple copies of weights (Harlap et al., 2018) .
In this paper we question this common wisdom and explore pipelining that allows for the full utilization of accelerators while using stale weights.
This results in a pipelining scheme that, compared to existing schemes, is simpler to implement, fully utilizes the accelerators and has lower memory overhead.
We evaluate this pipelining scheme using 4 CNNs: LeNet-5 (trained on MNIST), AlexNet, VGG and ResNet (all trained on CIFAR-10).
We analyze the impact of weight staleness and show that if pipelining is limited to early layers in the network, training does converge and the quality of the resulting models is comparable to that of models obtained with non-pipelined training.
For the 4 networks, the drop in accuracy is 0.4%, 4%, 0.83% and 1.45%, respectively.
However, inference accuracies drop significantly when the pipelining is deeper in the network.
While this is not a limitation since the bulk of computations that can benefit from pipelining are in the early convolutional layers, we address this through a hybrid scheme that combines pipelined and non-pipelined training to maintain inference accuracy while still delivering performance improvement.
Evaluation shows that our pipelined training delivers a speedup of up to 1.8X on a 2-GPU system.
The remainder of this paper is organized as follows.
Section 2 briefly describes the backpropagation for training of CNNs.
Section 3 details our pipelining scheme.
Section 4 describes how non-pipelined and pipelined backpropagation are combined.
Section 5 highlights some of the implementation details.
Experimental evaluation is presented in Section
6. Related work is reviewed in Section
7. Finally, Section 8 gives concluding remarks and directions for future work.

assistant: text: Accelerating CNN training on a Pipeline of Accelerators with Stale Weights