arXiv Vanity renders academic papers from arXiv as responsive web pages so you don’t have to squint at a PDF. Read this paper on arXiv.org.

# SWALP : Stochastic Weight Averaging in Low-Precision Training

###### Abstract

Low precision operations can provide scalability, memory savings, portability, and energy efficiency. This paper proposes SWALP, an approach to low precision training that averages low-precision SGD iterates with a modified learning rate schedule. SWALP is easy to implement and can match the performance of full-precision SGD even with all numbers quantized down to 8 bits, including the gradient accumulators. Additionally, we show that SWALP converges arbitrarily close to the optimal solution for quadratic objectives, and to a noise ball asymptotically smaller than low precision SGD in strongly convex settings.

{icmlauthorlist}\icmlauthor

Guandao Yangcornell \icmlauthorTianyi Zhangcornell \icmlauthorPolina Kirichenkocornell \icmlauthorJunwen Baicornell
\icmlauthorAndrew Gordon Wilsoncornell \icmlauthorChristopher De Sacornell

\icmlaffiliation

cornellCornell University

\icmlcorrespondingauthor

Guandao [email protected] \icmlcorrespondingauthorTianyi [email protected] \icmlcorrespondingauthorPolina [email protected] \icmlcorrespondingauthorJunwen [email protected] \icmlcorrespondingauthorAndrew Gordon [email protected] \icmlcorrespondingauthorChristopher De [email protected]

\icmlkeywords

Machine Learning, Low precision training, ICML

\printAffiliationsAndNotice

## 1 Introduction

Training deep neural networks (DNNs) usually requires a large amount of computational time and power. As model sizes grow larger, training DNNs more efficiently and with less memory becomes increasingly important. This is especially the case when training on a special-purpose hardware accelerator; such ML accelerators are in development and used in industry jouppi2017datacenter; projectbrainwave. Many ML accelerators have limited on-chip memory, and many ML applications are memory bounded jouppi2017datacenter. It is desirable to fit numbers that are frequently used during the training process into the on-chip memory. One of the useful techniques for doing this is low-precision computation, since using fewer bits to represent numbers reduces both memory consumption and computational cost.

Training a DNN in low-precision usually results in worse performance compared to training in full precision. Many techniques have been proposed to reduce this performance gap dorefa-net; WAGE; scalable8bittraining; 8bitfloat. One useful method is to compute forward and backward propagation with low-precision weights and accumulate gradient information in higher precision gradient accumulators binaryconnect; WAGE; 8bitfloat. Recently, 8bitfloat showed that one could eliminate the performance gap between low-precision and high-precision training by quantizing all numbers except the gradient accumulator to 8 bits without changing the network structure, establishing the state-of-the-art result in low-precision training. Since gradient accumulators are frequently updated during training, it would be desirable to also represent and store them in low-precision (e.g. 8 bits). In this paper, we will focus on the setting where all numbers including the gradient accumulators are represented in low precision during training.

Independently from low-precision computation, stochastic weight averaging (SWA) (SWA) has been recently proposed for improved generalization in deep learning. SWA takes an average of SGD iterates with a modified learning rate schedule and has been shown to lead to wider optima (SWA). large-batch also connect the width of the optimum and generalization performance. A wider optimum is especially relevant in the context of low-precision training as it is more likely to contain high-accuracy low-precision solutions. SWA also observed that SWA works well with a relatively high learning rate and can tolerate additional noise during training. Low-precision training, on the other hand, produces extra quantization noise during training and tends to underperform when the learning rate is low. Moreover, by averaging, one can combine weights that have been rounded up with those that been rounded down during quantization. For these reasons, we hypothesize that SWA can boost the performance of low-precision training and that performance improvement is more significant than in the case of SWA applied to full-precision training. Figure 1: SWALP intuition. The trajectory of low-precision SGD over the training objective (with given contours), and the SWALP solution obtained by averaging.

In this paper, we propose a principled approach using stochastic weight averaging while quantizing all numbers including the gradient accumulator and the velocity vectors during training. We prove that for quadratic objectives SWALP can converge to the optimal solution as well as to a smaller asymptotic noise ball than low-precision SGD for strongly convex objectives. Figure 1 illustrates the intuition behind SWALP. A quantized grid is only able to represent certain suboptimal solutions. By averaging we find centred solutions with better performance. Empirically, we demonstrate that training with 8-bit SWALP can match the full precision SGD baseline in deep learning tasks such as training Preactivation ResNet-164 preact-resnet on CIFAR-10 and CIFAR-100 datasets CIFAR10.

In summary, our paper makes the following contributions:

• We propose a principled approach to using stochastic weight averaging in low-precision training (SWALP) where all numbers including the gradient accumulators are quantized. Our method is simple to implement and has little computational overhead.

• We prove that SWALP can reach the optimal solution for quadratic objectives with no loss of accuracy from the quantization. For strongly convex objectives, we prove that SWALP converges to a noise ball that is asymptotically smaller than that of low-precision SGD.

• We show that our method can significantly reduce the performance gap between low-precision and full-precision training. Our experiment results show that 8-bit SWALP can match the full-precision SGD baseline on CIFAR-10 and CIFAR-100 with both VGG-16 and PreResNet-164 VGG; preact-resnet.

## 2 Related Works

Low Precision Computation. Many works in low precision computation focus on expediting inference and reducing model size. Some compress trained models into low precision deepCompression; others train models to produce low-precision weights for inference binary-net; ternary-quant; incremental-quant. In contrast to works that focus on inference (test) time low-precision computation, our work focuses on low-precision training. Prior work on low precision training mostly explores two directions. Some investigate different numerical representations and quantization methods gupta2015deep; flexpoint; log-quant; dyanmic-fixed-point; 8bitfloat; others explore building specialized layers using low-precision arithmetic WAGE; xor-net; dorefa-net; binaryconnect; scalable8bittraining. Our work is orthogonal to both directions since we improve on the learning algorithm itself.

Stochastic Weight Averaging.

Inspired by the geometry of the loss function traversed by SGD with a modified learning rate schedule, SWA proposed Stochastic Weight Averaging (SWA), which performs an equally weighted average of SGD iterates with cyclical or high constant learning rates. SWA develop SWA for deep learning, showing improved generalization. While our work is inspired by SWA, we focus on developing SWA for low-precision training.

Convergence Analysis. It is known that low-precision SGD cannot produce arbitrarily optimal solutions due to quantization noise training-quantized-network-deeper-understanding. A recently developed variant of low-precision SGD, HALP HALP, can achieve arbitrarily optimal solutions, but it does so by dynamically scaling its low-precision numbers and using variance reduction, which can be computationally costly. We will show that SWALP can also achieve arbitrarily optimal solutions for quadratic objectives, while being computationally simpler. training-quantized-network-deeper-understanding analyze low-precision SGD, and even provide a convergence bound for low precision SWA. However, they use SWA only as a theoretical condition, not as a suggested algorithm. In contrast, we study SWA explicitly as a potential method that can improve low-precision training, and we use the averaging to improve the bound on the noise ball size. QSGD QSGD studies the convergence properties of using low-precision numbers for communicating among parallel workers, and ZipML ZipML investigates the convergence properties of end-to-end quantization of the whole model. Our paper focuses on convergence properties of low-precision SWA, which we hope can be combined with these exciting prior works.

## 3 Methods

SWA show that SWA leads to a wider solution, works well with a high learning rate, and is robust toward training noise. These properties make SWA a good fit for low precision training, since a wider optimum is more likely to capture a representable solution in low precision, and low-precision training suffers from low learning rate and quantization noise. In this section, we will first introduce quantization methods needed to make training low-precision (Sec 3.1). The algorithm applying SWA in low-precision training is then presented in Sec 3.2 and Sec 3.3.

### 3.1 Quantization

In order to use low-precision numbers during training, we define a quantization function , which rounds a real number to be stored in fewer bits. In this paper, we use fixed-point quantization with stochastic rounding to demonstrate the algorithm and analyze its convergence properties. Recently, many sophisticated quantization methods have been proposed and studied log-quant; flexpoint; dyanmic-fixed-point; low-precision-multiply. We will use block floating point error-analysis in our deep learning experiments (Sec LABEL:sec:expr).

Fixed Point Quantization. In stochastic rounding, numbers are rounded up or down at random such that for all that will not cause overflow. Explicitly, suppose we allocate bits to represent the quantized number and allocate of the bits to represent the fractional part of the number. The quantization gap represents the distance between successive representable fixed-point numbers. The upper limit of the representable numbers is and the lower limit is . We write the quantization function as such that

 Qδ(w)=⎧⎪⎨⎪⎩clip(δ⌊wδ⌋,l,u)w.p. ⌈wδ⌉−wδclip(δ⌈wδ⌉,l,u)w% .p. 1−(⌈wδ⌉−wδ) (1)

where . This quantization method has been shown to be useful for theory training-quantized-network-deeper-understanding and has been observed to perform empirically better than quantization methods without stochastic rounding gupta2015deep.

Block Floating Point (BFP) Quantization. Floating-point numbers have individual exponents, and fixed-point numbers all share the same fixed exponent. For block floating-point numbers, all numbers within a block share the same exponent, which is allowed to vary like a floating-point exponent. Suppose we allocate bits to represent each number in the block and bits to represent the shared exponent. The shared exponent for a block of numbers is usually set to be the largest exponent in a block to avoid overflow error-analysis; Mixed-precision-training. In our experiments, we simulated block floating point numbers by using the following formula to compute the shared exponent:

 E(w)=clip(⌊log2(maxi|wi|)⌋,−2F−1,2F−1−1)

We then apply equation (1) with replaced by to quantize all numbers in .

For deep learning experiments, BFP is preferred over fixed-point because BFP usually has less quantization error caused by overflow and underflow when quantizing DNN models error-analysis. We will discuss how to design appropriate blocks in Sec LABEL:sec:expr, and show that choosing appropriate block design can result in better performance.

### 3.2 Algorithm

In the warm-up phase, we first run regular low-precision SGD to produce a pre-trained model . SWALP then continues to run low-precision SGD, while periodically averaging the current model weight into an accumulator , which SWALP eventually returns. A detailed description is presented in Algorithm 1. SWALP is substantially similar to the algorithm in SWA, except that we use a constant learning rate and low-precision SGD. The convergence analysis in Sec LABEL:sec:convergence will be all based on Algorithm 1.

State-of-the-art low-precision training approaches usually separate weights from gradient accumulators binaryconnect; dorefa-net; WAGE; 8bitfloat. Expensive computations in forward and backward propagation are done with the low-precision weights (e.g., 8 bits), while the gradient information is accumulated onto a higher precision copy of the weights (e.g. 16 bits). Formally, the updating step with higher precision gradient accumulator can be written as , where is the gradient accumulator and is the weight. However, such an approach needs to store the high precision accumulators in low-latency memory (e.g. on-chip when running on an accelerator), which limits the memory efficiency. SWALP quantizes the gradient accumulator so that we only need to store the low-precision model in low-latency memory during training. Meanwhile, the averaged model is accessed infrequently so that it can be stored in higher-latency memory (e.g. off-chip when running on an accelerator).

Note that in Algorithm 1, we only quantize the gradient accumulator while leaving the quantization of the gradient, the layer activations, and back-propagation signals in full precision. In practice, however, it is desirable to quantize all above mentioned numbers. We make this simplification for the convenience of the theoretical analysis in Sec LABEL:sec:convergence, and following previous theoretical works in this space training-quantized-network-deeper-understanding; HALP. We will discuss how to quantize other numbers during training in the next section.

### 3.3 Quantizing Other Numbers

In order to train DNNs with low-precision storage, we need to also quantize other numbers during training. We follow prior convention to quantize the weights, activations, back-propagation errors, and gradients signals WAGE; 8bitfloat. Since we quantized the gradient accumulators into low-precision, there is no need to differentiate them from model weights. To use momentum during training, we need to store the velocity tensors in low precision, so we modified the SGD update as follows:
{"ft_lang_label":"__label__en","ft_lang_prob":0.91222006,"math_prob":0.87707084,"size":14158,"snap":"2019-13-2019-22","text_gpt3_token_len":2868,"char_repetition_ratio":0.15748198,"word_repetition_ratio":0.017180394,"special_character_ratio":0.1754485,"punctuation_ratio":0.10267289,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9685868,"pos_list":[0,1,2],"im_url_duplicate_count":[null,1,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2019-05-21T22:50:58Z\",\"WARC-Record-ID\":\"<urn:uuid:8ca32aa1-ee9c-4d9e-9cbc-1c39ec12a5e2>\",\"Content-Length\":\"203958\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:26f097b5-c9f4-44d3-b61e-1d4ac327e44f>\",\"WARC-Concurrent-To\":\"<urn:uuid:8f68f9fb-8344-4616-9916-fbdb3f4309c8>\",\"WARC-IP-Address\":\"104.27.185.171\",\"WARC-Target-URI\":\"https://www.arxiv-vanity.com/papers/1904.11943/\",\"WARC-Payload-Digest\":\"sha1:CNCBU4QCLIM2REEMA47UFT6R7IZGB3SY\",\"WARC-Block-Digest\":\"sha1:UQXMRTVV67VZUBSSPUO4BUM4HNA4NJ6R\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2019/CC-MAIN-2019-22/CC-MAIN-2019-22_segments_1558232256586.62_warc_CC-MAIN-20190521222812-20190522004812-00002.warc.gz\"}"}