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

Title: RedSync : Reducing Synchronization Traffic for Distributed Deep Learning

Paper content:
Data parallelism has become a dominant method to scale Deep Neural Network (DNN) training across multiple nodes.
Since the synchronization of the local models or gradients can be a bottleneck for large-scale distributed training, compressing communication traffic has gained widespread attention recently.
Among several recent proposed compression algorithms, 
Residual Gradient Compression (RGC) is one of the most successful approaches---it can significantly compress the transmitting message size (0.1% of the gradient size) of each node and still preserve accuracy.
However, the literature on compressing deep networks focuses almost exclusively on achieving good compression rate, while the efficiency of RGC in real implementation has been less investigated.
In this paper, we develop an RGC method that achieves significant training time improvement in real-world multi-GPU systems.
Our proposed RGC system design called RedSync, introduces a set of optimizations to reduce communication bandwidth while introducing limited overhead.
We examine the performance of RedSync on two different multiple GPU platforms, including a supercomputer and a multi-card server.
Our test cases include image classification on Cifar10 and ImageNet, and language modeling tasks on Penn Treebank and Wiki2 datasets.
For DNNs featured with high communication to computation ratio, which has long been considered with poor scalability, RedSync shows significant performance improvement.
For training large-scale deep neural networks (DNNs) on multiple computing nodes, data parallelism has emerged as the most popular choice due to its simplicity and effectiveness BID5 ; BID13 ).
However, the communication bandwidth of network fabric has become the bottleneck limiting data parallel performance.
On one hand, models of DNNs, which already contain tens to hundreds of layers and totaling 10-20 million parameters today, continue to grow bigger.
Therefore, the requirement of communicating model parameter updates among all computing nodes poses a higher challenge to network bandwidth.
On the other hand, the development of DNN training accelerators has shifted the bottleneck of training towards communication across models.
As the evolution of the inter-connected network bandwidth is not as fast as computing hardware, synchronization overhead has become the bottleneck of data parallelism on distributed systems using new computing hardware.Many recent studies focused on reducing the communication cost between nodes by reducing the size of the gradients to be transmitted.
One line of work BID15 ; BID2 ; Wen et al. (2017) ) propose to quantize the gradients to low-precision values.
Considering compression ratio (ratio of compressed gradients size to their original size) achieved by quantization is limited, another line of research orthogonal to quantization is to sparsify communication gradients and restrict weight-updates to a small subset of parameters.
Residual Gradient Compression (RGC) method (Strom (2015) ; BID0 ; BID4 ; BID9 ; BID14 ) is currently the most promising pruning method to achieve good compression ratio while ensuring no loss of training accuracy.
It transmits only a small subset of gradients and maintains the remaining gradients locally as residuals to be added to gradients of the next iteration.
The first RGC implementation is proposed by Strom (2015) and uses a threshold-based method to only send gradients larger than a predefined constant threshold for fully-connected layers.
Considering a predefined threshold is hard to be chosen appropriately, BID0 improve the robustness of RGC by selecting top 1% gradients to communicate according to their magnitude.
Because these two implementations are tuned for some specific network structures, applying them to other DNNs will lead to accuracy loss as indicated in BID4 .
Based on their work, the latest RGC variants, such as BID14 ; BID4 ; BID9 ), are able to achieve a 0.1% compression ratio on local gradients while ensuring almost no loss of model accuracy on a variety of DNN structures after introducing some key modifications.Despite of good model accuracy achieved with simulation experiments, no recent studies have discussed the potential performance gain after integrating the latest RCG methods to real distributed training system, especially to the multi-GPU systems equipped with high-quality network infrastructures.
The challenges of applying RGC to distributed GPU systems come from two aspects.
First, there is no efficient compression algorithm proposed for RGC method.
According to our experimental results, selecting top-0.1% elements with the state-of-the-art GPU-based top-k algorithm are so expensive that the overhead of compression is much higher than the benefits of network bandwidth reduction.
Second, synchronization of sparse data structures is nontrivial to be supported with existing efficient communication libraries, such as Message Passing Interface (MPI), which are designed for dense data structures.Targeting multi-GPU systems, a highly-efficient RGC implementation called RedSync is proposed.
Our contributions are listed as follows:• We combined pruning and quantization techniques together to compress transmitting gradients.
A set of parallel-friendly top-0.1% selection methods are designed to support pruning operations inside GPU device memory, which are orders of magnitude faster than the stateof-the-art GPU-based top-k selection method.•
Considering the distribution characteristics of communication data, we apply allgather operation using MPI for a sparse synchronization scheme. A
cost model is derived to analyze both communication cost and calculation overhead. Based
on it, we pointed out potential performance gain and the bottleneck of our implementation.• RedSync
is able to ensure almost no accuracy loss to train a set of DNNs after integrating with the latest algorithm improvements. This is the
first work, as far as we known, to evaluate the performance of RGC method on the scale of 128 GPUs. RedSync provides
significant performance improvements for communication-intensive networks, like VGG, AlexNet and some LSTMs.
This paper proposes a distributed implementation called RedSync to accelerate data parallel DNN training by utilizing a type of gradient sparsification method named as Residual Gradient Compression (RGC).
We solved two major obstacles to implement RGC on multi-GPU systems : high overhead of compression using GPU and lack of support for collective communication implementation for sparse data structures.
We tested the performance of RedSync on two GPU platforms, including a supercomputer system and a multi-GPU server.
For AlexNet, VGG16, and LSTM, we observed significant speedup for large-scale DNN training.
The left part of FIG3 illustrates how sparse allgather works by recursive doubling method.
We assume the compression rate on all of the node is the same as D. If we use threshold binary search for communication-set selection, D here should be the average compression ratio of all nodes for a good approximation.
In the first step, nodes that are a distance 1 apart exchange their compressed residuals, the size of which is M × D. In the second step, nodes that are a distance 2 apart exchange their own data as well as the data they received in the previous step, which is 2M × D in total.
In the third step, nodes that are a distance 4 apart exchange their own data as well the data they received in the previous two steps.
In this way, for a power-of-two number of processes, all processes get all the data in lgp steps.
The amount of data exchanged by each node is M × D in the first step, 2M × D in the second step, and so forth, up to 2 lg(p)−1 M × D in the last step.
Therefore, The time for message transfer taken by this algorithm is T transf er = lg(p)α + (p − 1)M × Dβ.
After including decompressing overhead γ for collected p different compressed residuals and communication selection overhead T select , the time for all-gather based synchronization should be T transf er DISPLAYFORM0 As shown in the right part of FIG3 , the Rabenseifners algorithm is adopted for allreduce operation on messages.
It does a reduce-scatter followed by an allgather.
Reduce-scatter is a variant of reduce in which the result, instead of being stored at the root, is scattered among all p nodes.
We use a recursive halving algorithm, which is analogous to the recursive doubling algorithm used for allgather but in reverse way.
In the first step, each node exchanges data with a node that is a distance p/2 away: Each process sends the data needed by all processes in the other half, which is of size M/2.
They also receives the data needed by all processes in its own half, and performs the reduction operation on the received data.
In the second step, each process exchanges data with a process that is a distance p/4 away.
This procedure continues recursively, halving the data communicated at each step, for a total of lgp steps.
After reduce-scatter, allgather phase will have the the same bandwidth and latency requirements.
The time taken by Rabenseifners algorithm is the sum of the times taken by reduce-scatter (recursive halving), allgather and reduction operations.
The total time should be DISPLAYFORM1

assistant: text: We proposed an implementation to accelerate DNN data parallel training by reducing communication bandwidth requirement.