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

Title: Provably Communication-efficient Data-parallel SGD via Nonuniform Quantization

Paper content:
As the size and complexity of models and datasets grow, so does the need for communication-efficient variants of stochastic gradient descent that can be deployed on clusters to perform model fitting in parallel.
Alistarh et al. (2017) describe two variants of data-parallel SGD that quantize and encode gradients to lessen communication costs.
For the first variant, QSGD, they provide strong theoretical guarantees.
For the second variant, which we call QSGDinf, they demonstrate impressive empirical gains for distributed training of large neural networks.
Building on their work, we propose an alternative scheme for quantizing gradients and show that it yields stronger theoretical guarantees than exist for QSGD while matching the empirical performance of QSGDinf.
Deep learning is booming thanks to enormous datasets and very large models, leading to the fact that the largest datasets and models can no longer be trained on a single machine.
One common solution to this problem is to use distributed systems for training.
The most common algorithms underlying deep learning are stochastic gradient descent (SGD) and its variants, which led to a significant amount of research on building and understanding distributed versions of SGD.
Implementations of SGD on distributed systems and data-parallel versions of SGD are scalable and take advantage of multi-GPU systems.
Data-parallel SGD, in particular, has received significant attention due to its excellent scalability properties (Zinkevich et al., 2010; Bekkerman et al., 2011; Recht et al., 2011; Dean et al., 2012; Coates et al., 2013; Chilimbi et al., 2014; Duchi et al., 2015; Xing et al., 2015; .
In data-parallel SGD, a large dataset is partitioned among K processors.
These processors work together to minimize an objective function.
Each processor has access to the current parameter vector of the model.
At each SGD iteration, each processor computes an updated stochastic gradient using its own local data.
It then shares the gradient update with its peers.
The processors collect and aggregate stochastic gradients to compute the updated parameter vector.
Increasing the number of processing machines reduces the computational costs significantly.
However, the communication costs to share and synchronize huge gradient vectors and parameters increases dramatically as the size of the distributed systems grows.
Communication costs may thwart the anticipated benefits of reducing computational costs.
Indeed, in practical scenarios, the communication time required to share stochastic gradients and parameters is the main performance bottleneck (Recht et al., 2011; Seide et al., 2014; Strom, 2015; .
Reducing communication costs in data-parallel SGD is an important problem.
One promising solution to the problem of reducing communication costs of data-parallel SGD is gradient compression, e.g., through gradient quantization (Dean et al., 2012; Seide et al., 2014; Sa et al., 2015; Gupta et al., 2015; Abadi et al., 2016; Zhou et al., 2016; Bernstein et al., 2018) .
(This should not be confused with weight quantization/sparsification, as studied by ; Hubara et al. (2016) ; Park et al. (2017) ; , which we do not discuss here.
) Unlike full-precision data-parallel SGD, where each processor is required to broadcast its local gradient in full-precision, i.e., transmit and receive huge full-precision vectors at each iteration, quantization requires each processor to transmit only a few communication bits per iteration for each component of the stochastic gradient.
One popular such proposal for communication-compression is quantized SGD (QSGD), due to .
In QSGD, stochastic gradient vectors are normalized to have unit L 2 norm, and then compressed by quantizing each element to a uniform grid of quantization levels using a randomized method.
While most lossy compression schemes do not provide convergence guarantees, QSGD's quantization scheme, is designed to be unbiased, which implies that the quantized stochastic gradient is itself a stochastic gradient, only with higher variance determined by the dimension and number of quantization levels.
As a result, are able to establish a number of theoretical guarantees for QSGD, including that it converges under standard assumptions.
By changing the number of quantization levels, QSGD allows the user to trade-off communication bandwidth and convergence time.
Despite their theoretical guarantees based on quantizing after L 2 normalization, Alistarh et al. opt to present empirical results using L ∞ normalization.
We call this variation QSGDinf.
While the empirical performance of QSGDinf is strong, their theoretical guarantees on the number of bits transmitted no longer apply.
Indeed, in our own empirical evaluation of QSGD, we find the variance induced by quantization is substantial, and the performance is far from that of SGD and QSGDinf.
Given the popularity of this scheme, it is natural to ask one can obtain guarantees as strong as those of QSGD while matching the practical performance of the QSGDinf heuristic.
In this work, we answer this question in the affirmative by providing a new quantization scheme which fits into QSGD in a way that allows us to establish stronger theoretical guarantees on the variance, bandwidth, and cost to achieve a prescribed gap.
Instead of QSGD's uniform quantization scheme, we use an unbiased nonuniform logarithmic scheme, similar to those introduced in telephony systems for audio compression (Cattermole, 1969) .
We call the resulting algorithm nonuniformly quantized stochastic gradient descent (NUQSGD).
Like QSGD, NUQSGD is a quantized data-parallel SGD algorithm with strong theoretical guarantees that allows the user to trade off communication costs with convergence speed.
Unlike QSGD, NUQSGD has strong empirical performance on deep models and large datasets, matching that of QSGDinf.
In particular, we provide a new efficient implementation for these schemes using a modern computational framework (Pytorch), and benchmark it on classic large-scale image classification tasks.
The intuition behind the nonuniform quantization scheme underlying NUQSGD is that, after L 2 normalization, many elements of the normalized stochastic gradient will be near-zero.
By concentrating quantization levels near zero, we are able to establish stronger bounds on the excess variance.
In the overparametrized regime of interest, these bounds decrease rapidly as the number of quantization levels increases.
Combined with a bound on the expected code-length, we obtain a bound on the total communication costs of achieving an expected suboptimality gap.
The resulting bound is slightly stronger than the one provided by QSGD.
To study how quantization affects convergence on state-of-the-art deep models, we compare NUQSGD, QSGD, and QSGDinf, focusing on training loss, variance, and test accuracy on standard deep models and large datasets.
Using the same number of bits per iteration, experimental results show that NUQSGD has smaller variance than QSGD, as expected by our theoretical results.
This smaller variance also translates to improved optimization performance, in terms of both training loss and test accuracy.
We also observe that NUQSGD matches the performance of QSGDinf in terms of variance and loss/accuracy.
Further, our distributed implementation shows that the resulting algorithm considerably reduces communication cost of distributed training, without adversely impacting accuracy.
Our empirical results show that NUQSGD can provide faster end-to-end parallel training relative to data-parallel SGD, QSGD, and Error-Feedback SignSGD (Karimireddy et al., 2019) on the ImageNet dataset.
We study data-parallel and communication-efficient version of stochastic gradient descent.
Building on QSGD , we study a nonuniform quantization scheme.
We establish upper bounds on the variance of nonuniform quantization and the expected code-length.
In the overparametrized regime of interest, the former decreases as the number of quantization levels increases, while the latter increases with the number of quantization levels.
Thus, this scheme provides a trade-off between the communication efficiency and the convergence speed.
We compare NUQSGD and QSGD in terms of their variance bounds and the expected number of communication bits required to meet a certain convergence error, and show that NUQSGD provides stronger guarantees.
Experimental results are consistent with our theoretical results and confirm that NUQSGD matches the performance of QSGDinf when applied to practical deep models and datasets including ImageNet.
Thus, NUQSGD closes the gap between the theoretical guarantees of QSGD and empirical performance of QSGDinf.
One limitation of our study which we aim to address in future work is that we focus on all-to-all reduction patterns, which interact easily with communication compression.
In particular, we aim to examine the interaction between more complex reduction patterns, such as ring-based reductions (Hannun et al., 2014) , which may yield superior performance in bandwidthbottlenecked settings, but which interact with communication-compression in non-trivial ways, since they may lead a gradient to be quantized at each reduction step.
Read that bit plus N following bits; The encoding, ENCODE(v), of a stochastic gradient is as follows: We first encode the norm v using b bits where, in practice, we use standard 32-bit floating point encoding.
We then proceed in rounds, r = 0, 1, · · · .
On round r, having transmitted all nonzero coordinates up to and including t r , we transmit ERC(i r ) where t r+1 = t r + i r is either
(i) the index of the first nonzero coordinate of h after t r (with t 0 = 0) or
(ii) the index of the last nonzero coordinate.
In the former case, we then transmit one bit encoding the sign ρ t r+1 , transmit ERC(log(2 s+1 h t r+1 )), and proceed to the next round.
In the latter case, the encoding is complete after transmitting ρ t r+1 and ERC(log(2 s+1 h t r+1 )).
The DECODE function (for Algorithm 1) simply reads b bits to reconstruct v .
Using ERC −1 , it decodes the index of the first nonzero coordinate, reads the bit indicating the sign, and then uses ERC −1 again to determines the quantization level of this first nonzero coordinate.
The process proceeds in rounds, mimicking the encoding process, finishing when all coordinates have been decoded.
Like , we use Elias recursive coding (Elias, 1975, ERC) to encode positive integers.
ERC is simple and has several desirable properties, including the property that the coding scheme assigns shorter codes to smaller values, which makes sense in our scheme as they are more likely to occur.
Elias coding is a universal lossless integer coding scheme with a recursive encoding and decoding structure.
The Elias recursive coding scheme is summarized in Algorithm 2.
For any positive integer N, the following results are known for ERC

assistant: text: NUQSGD closes the gap between the theoretical guarantees of QSGD and the empirical performance of QSGDinf.