To harness the power of deep convolutional networks in embedded and large-scale application domains requires energy-efficient implementation, leading to great interest in low-precision networks suitable for deployment with low-precision hardware accelerators. Consequently there have been a flurry of methods for quantizing both the weights and activations of these networks [Jacob et al.2017, Courbariaux, Bengio, and David2015, Polino, Pascanu, and Alistarh2018, Xu et al.2018, Baskin et al.2018, Mishra et al.2017, Choi et al.2018].
A common perception is that 8-bit networks offer the promise of decreased computational complexity with little loss in accuracy, without any need to retrain. However, the published accuracies are typically lower for the quantized networks than for the corresponding full-precision net [Migacz2017]. Even training 8-bit networks from scratch fails to close this gap [Jacob et al.2017] (See Table 1). The situation is even worse for 4-bit precision. To our knowledge, for the ImageNet classification benchmark, no method has been able to match the accuracy of the corresponding full-precision network when quantizing both the weights and activations at the 4-bit level. Closing this performance gap has been an important open problem until now.
|Network||Method||Precision (w,a)||Accuracy (% top-1)||Accuracy (% top-5)|
|ResNet-18||FAQ (This paper)||8,8||70.02||89.32|
|ResNet-18||FAQ (This paper)||4,4||69.82||89.10|
|ResNet-34||FAQ (This paper)||8,8||73.71||91.63|
|ResNet-34||FAQ (This paper)||4,4||73.31||91.32|
|ResNet-50||FAQ (This paper)||8,8||76.52||93.09|
|ResNet-50||FAQ (This paper)||4,4||76.27||92.89|
|ResNet-152||FAQ (This paper)||8,8||78.54||94.07|
|Inception-v3||FAQ (This paper)||8,8||77.60||93.59|
|Densenet-161||FAQ (This paper)||8,8||77.84||93.91|
|VGG-16bn||FAQ (This paper)||8,8||73.66||91.56|
from the PyTorch model zoo. Other results reported in the literature are shown for comparison, with methods exceeding or matching the top-1 baseline in bold. Precision is in bits, where w= weight , and a=activation function. Accuracy is reported for the ImageNet classification benchmark. Compared methods: Apprentice[Mishra and Marr2017], Distillation [Polino, Pascanu, and Alistarh2018], UNIQ [Baskin et al.2018], IOA [Jacob et al.2017], Joint Training [Jung et al.2018]. Since we found that only one epoch was necessary to train any of the models we tried with 8-bit quantization, we were able to quickly test new models to include in this table. However, training 4-bit networks, especially the larger models, takes much longer, and we therefore were not able to test as wide a variety of 4-bit networks, which we leave for future work.
Guided by theoretical convergence bounds for stochastic gradient descent (SGD), we propose fine-tuning, training pretrained high-precision networks for low-precision inference, by combating noise during the training process as a method for discovering both 4-bit and 8-bit integer networks. We evaluate the proposed solution on the ImageNet benchmark on a representative set of state-of-the-art networks at 8-bit and 4-bit quantization levels (Table 1). Contributions include the following.
We demonstrate 8-bit scores on ResNet-18, 34, 50, and 152, Inception-v3, Densenet-161, and VGG-16 exceeding the full-precision scores after just one epoch of fine-tuning.
We present the first evidence of 4 bit, fully integer networks which match the accuracy of the original full-precision networks on the ImageNet benchmark.
We present empirical evidence for gradient noise that is introduced by weight quantization. This gradient noise increases with decreasing precision and may account for the difficulty in fine-tuning low-precision networks.
We demonstrate that reducing noise in the training process through the use of larger batches provides further accuracy improvements.
We find direct empirical support that, as with 8-bit quantization, near optimal 4-bit quantized solutions exist close to high-precision solutions, making training from scratch unnecessary.
Our goal is to quantize existing networks to 8 and 4 bits for both weights and activations, without increasing the computational complexity of the network to compensate, e.g. with modifications such as feature expansion, while achieving accuracies that match or exceed the corresponding full-precision networks. For precision below 8 bits, the typical method is to train the model using SGD while enforcing the constraints [Courbariaux, Bengio, and David2015]. There are at least two problems faced when training low-precision networks: learning in the face of low-precision weights and activations, and capacity limits in the face of these constraints. Assuming that capacity is sufficient and a low-precision solution exists, we wish to solve the first problem, that is, find a way to train low-precision networks to obtain the best possible score subject to capacity limits.
We use low-precision training to optimize quantized networks. We hypothesize that noise introduced by quantizing weights and activations during training is the crux of the problem and is similar to gradient noise inherent to stochastic gradient descent. In support of this idea, Polino et al. (2018) showed that unbiased quantization of weights is equivalent to adding Gaussian noise to the activations, in expectation. The problem is then to find ways to overcome this noise.
SGD requires 111 This assumes a convex loss function, a simpler case.
This assumes a convex loss function, a simpler case.
iterations to find a -approximate optimal value, where is the gradient noise level, is related to the curvature of the convex function, and are the initial and optimal network parameters, respectively, and is the error tolerance [Meka2017].
This suggests two ways to minimize the final error. First, start closer to the solution, i.e. minimize . In fact Goodfellow et al [Goodfellow, Vinyals, and Saxe2014] suggest that much of the training time of SGD is due to the length of the trajectory needed to arrive at a solution. We therefore start with pretrained models for quantization, rather than training from scratch as is done customarily (although see [Zhou et al.2017, Baskin et al.2018]). Second, minimize . To do this, we combine well-known techniques to combat noise: 1) larger batches which reduce the gradient noise proportional to the square root of the batch size [Goodfellow et al.2016], and 2) proper learning rate annealing with longer training time. We refer to this technique as Fine-tuning after quantization, or FAQ.
We argue that the method of fine-tuning for quantization is the right approach in the sense that it directly optimizes the proper objective function, the final score, rather than proxies which measure distance from the full-precision network parameters [Migacz2017].
In the quest for training state-of-the-art low-precision networks, there has been a vast diversity in how the precision constraints are imposed as well as in approaches used in their training. Typical variations in applying low-precision constraints include allowing non-uniform quantization of weights and activations [Miyashita, Lee, and Murmann2016, Zhou et al.2017, Cai et al.2017] where the discrete dictionary may depend on the data, stochastic quantization [Polino, Pascanu, and Alistarh2018, Courbariaux, Bengio, and David2015]. Approaches to training these networks include distillation [Polino, Pascanu, and Alistarh2018], layer-wise quantization and retraining [Xu et al.2018], introducing noise during training [Baskin et al.2018], increasing features [Mishra et al.2017]
, learning quantization-specific parameters using backpropagation[Choi et al.2018], using Stochastic Variance-Reduced Gradient instead of SGD [Sa et al.2018], and relaxation methods resembling annealing [Yin et al.2018].
With notable exception of a few papers dealing with binary or trinary networks [Courbariaux, Bengio, and David2015, Rastegari et al.2016, Courbariaux and Bengio2016]222Even these networks may have occasional floating point scaling steps between layers.
, most of the literature on low-precision networks constrain the number of discrete values that the weights and activations assume but otherwise allow them to be floating-point numbers. In addition, low-precision constraints are not necessarily imposed on batch-normalization constants, average-pooling results etc. in these networks. This is in contrast to how 8-bit integer networks are supported by TensorRT as well as TensorFlow framework, where all the parameters and activations are quantized to 8-bit fixed-point integers (see for example[Jacob et al.2017]). Recent attempts [Wu et al.2018] at training low-precision networks with integer constraints have hinted at the possibility of porting such networks to commercially available hardware for inference333NVIDIA’s recently announced Turing architecture supports 4-bit integer operations, for example..
We focus on training networks with both weights and activations constrained to be either 4 bit, or 8-bit fixed-point integers, and restrict all other scalar multiplicative constants (for example, batch-normalization) in the network to be 8-bit integers and additive constants (for example, bias values) to be 32-bit integers.
Low-precision Fine-tuning Methods
We start with pretrained, high-precision networks from the PyTorch model zoo, quantize, and then fine-tune for a variable number of epochs depending on the precision. We hypothesize that noise is the limiting factor in finding low-precision solutions, and use well-known methods to over come noise in training. Otherwise, we use the techniques of [Courbariaux, Bengio, and David2015, Esser et al.2016] to train low-precision networks. Details of this procedure are described next.
Fixed point quantizer
The quantizer we use throughout this paper is parametrized by the precision (in number of bits) , and the location of the least significant-bit relative to the radix , and denoted by . A calibration phase during initialization is used to determine a unique
for each layer of activations, which remains fixed subsequently throughout the fine-tuning. Similarly, each layer’s weight tensor as well as other parameter tensors are assigned a uniqueand this quantity is determined during each training iteration. The procedures for determining for activations and other parameters are described in the following subsections. A given scalar is quantized to a fixed-point integer for unsigned values, and for signed values.
Given a desired network precision of either 8 or 4 bits, we quantize all weights and activations to this level. In the 4-bit case, we leave the first and last layer weights at 8 bits and allow full-precision (32-bit fixed point) linear activations in the last, fully-connected layer [Courbariaux, Bengio, and David2015, Esser et al.2016]. In addition, the input to that last, fully-connected layer is also allowed to be an 8-bit integer as is the common practice in the literature. In such networks containing -bit internal layers and -bit final layer, the transition from -bit to
-bit is facilitated by the last ReLU activation layer in the network. Every other ReLU layer’s output tensor is quantized to a-bit integer tensor.
Quantizing network parameters
Given a weight tensor , SGD is used to update as usual but a fixed-point version is used for inference and gradient calculation [Courbariaux, Bengio, and David2015, Esser et al.2016]. The fixed-point version is obtained by applying element-wise. The quantization parameter for a given weight tensor is updated during every iteration and computed as follows: We first determine a desired quantization step-size by first clipping the weight tensor at a constant multiple444The constant, in general, depends on the precision. We used a constant of 4.12 for all our 4-bit experiments.
of its numerically estimated standard-deviation, and then dividing this range into equally-sized bins. Finally, the required constantis calculated as . All other parameters, including those used in batch-normalization, use .
Network parameters are first initialized from an available pretrained model file (https://pytorch.org/docs/stable/torchvision/models.html). Next, the quantization parameter for each layer of activation is calibrated using the following procedure: Following [Jacob et al.2017], we use a technique of running several (5) training data batches through the unquantized network to determine the maximum range for uniform quantization. Specifically, for each layer, is the maximum across all batches of the 99.99th percentile of the batch of activation tensor of that layer, rounded up to the next even power of two. This percentile level was found to give the best initial validation score for 8-bit layers, while 99.9 was best for layers with 4-bit ReLUs. The estimated , in turn, determines the quantization parameter for that tensor. For ReLU layers, the clipped tensor in the range is then quantized using . Once these activation function parameters are determined for each of the tensors, they are kept fixed during subsequent fine-tuning.
For control experiments which start from random initialization rather than pretrained weights, we did not perform this ReLU calibration step, since initial activation ranges are unlikely to be correct. In these experiments, we set the maximum range of all ReLU activation functions to , where is the number of bits of precision.
To train such a quantized network we use the typical procedure of keeping a floating point copy of the weights which are updated with the gradients as in normal SGD, and quantize weights and activations in the forward pass [Courbariaux, Bengio, and David2015, Esser et al.2016], clipping values that fall above the maximum range as described above. We also use the straight through estimator [Bengio, Léonard, and Courville2013] to pass the gradient through the quantization operator.
For fine-tuning pretrained 8-bit networks, since the initial quantization is already within a few percent of the full-precision network in many cases, we find that we need only a single additional epoch of training, with a learning rate of after the initial quantization step, and no other changes are made to the original training parameters during fine-tuning.
However, for 4-bit networks, the initial quantization alone gives poor performance, and matching the performance of the full-precision net requires training for 110 additional epochs using exponential decay of the learning rate such that the learning rate drops from the initial rate of 0.0015 (slightly higher than the final learning rate used to train the pretrained net) to a final value of . Accordingly we multiply the learning rate by 0.936 after each epoch for a 110 epoch fine-tuning training run. In addition, for the smallest ResNet 4-bit network, ResNet-18, the weight decay parameter is reduced from used to train ResNet models to assuming that less regularization is needed with smaller, lower precision networks. The batch size used was 256 split over 2 GPUs. SGD with momentum was used for optimization. Software was implemented using PyTorch.
Fine-tuning matches or exceeds the accuracy of the initial high-precision network and outperforms other methods
FAQ trained 8-bit networks outperform all comparable quantization methods in all but one instance and exceeded pretrained fp32 network accuracy with only one epoch of training following quantization for all networks explored (Table 1). Immediately following quantization, network accuracy was nearly at the level of the pretrained networks (data not shown) with one exception, Inception-v3, which started at 72.34% top-1. Since the networks started close to a good solution, they did not require extensive fine-tuning to return to and surpass pretrained networks.
FAQ trained 4-bit network accuracy outperforms all comparable quantization methods, exceeding the next closest approach by over % for ResNet-18 [Jung et al.2018], and matched or exceeded pretrained fp32 network accuracy. FAQ 4-bit networks required significantly longer fine-tuning – 110 epochs – for networks trained, ResNet-18, ResNet-34, and ResNet-50. In constrast to the 8-bit cases, immediately following quantization, network accuracy dropped precipitously, requiring significant fine-tuning to match and surpass the pretrained networks.
FAQ trained 4-bit network accuracy is sensitive to several hyperparameters (Table2). In summary, longer training duration, initialization from a pretrained model, larger batch size, lower weight decay, and activation calibration all contribute to improved accuracy when training the 4-bit ResNet-18 network, while the exact learning rate decay schedule contributed the least. We elaborate on some of these results subsequently.
|Epochs||Pretrained||Batch size||Learning rate||Weight||Activation||Accuracy||Change|
Longer training time was necessary for 4-bit networks
For the 4-bit network, longer fine-tuning improved accuracy (Table 2), potentially by averaging out gradient noise introduced by discretization [Polino, Pascanu, and Alistarh2018]. We explored sensitivity to shortening fine-tuning by repeating the experiment for 30, 60 and 110 epochs, with the same initial and final learning rates in all cases, resulting in top-1 accuracies of 69.30, 69.40, and 69.68 respectively. The hyperparameters were identical, except the batch size was increased from 256 to 400. These results indicate that training longer was necessary.
Quantizing a pretrained network improves accuracy
Initializing networks with a discretized pretrained network followed by fine-tuning improved accuracy compared with training a quantized network from random initialization for the same duration (Table 2), suggesting proximity to a full-precision network enhances low-precision fine-tuning. For a 4-bit network, we explored the contribution of the pretrained network by training two Resnet-18 networks with standard initialization for 110 epochs, one with the previous learning rate decay schedule555We used a higher initial learning rate of , equal to that used to train the full-precision net from scratch, with a decay factor of , such that final learning rate was . and the other with a learning rate from [Choi et al.2018], dropping by a factor of at epochs , , , and , plus an additional drop to at epoch to match the fine-tuning experiments. These two approaches reached top-1 accuracies of % and %, respectively – both less than FAQ’s accuracy after 30 epochs and more than 0.5% short of FAQ’s accuracy after 110 epochs. The one FAQ change that degraded accuracy the most was neglecting to calibrate activation ranges for each layer using the pretrained model, which dropped accuracy by %. This is another possible reason why training 8-bit networks from scratch has not achieved higher scores in the past [Jacob et al.2017].
Reducing noise with larger batch size improves accuracy
Fine-tuning with increasing batch size improved accuracy (Table 2), suggesting gradient noise limits low-precision accuracy. For a 4-bit network, we explored the contribution of increasing FAQ batch size with a Resnet-18 network, which increased top-1 validation accuracy to %. We scheduled batch sizes, starting at and doubled at epochs , , , reaching as maximum batch size666To simulate batch sizes larger than within memory constraints, we used virtual batches, updating the weights once every actual batches with the gradient average for effective batch size ., each doubling effecting a factor drop in gradient noise, which is proportional to square root of batch size. We used epochs to approximately conserve the number of weight updates as the -epochs -batch-size case as our focus here is not training faster but reducing gradient noise to improve final accuracy.
The exact form of exponential learning rate decay was not critical
Replacing the exponential learning rate decay with a typical step decay which reduced the learning rate from to in 3 steps of 0.1 at epochs 30, 60, and 90, improved results slightly (+0.08). This suggests that FAQ is insensitive to the exact form of exponential decrease in learning rate.
Reducing weight decay improves accuracy for ResNet-18 but not for ResNet-34 or 50 for 4-bit networks
For the 4-bit ResNet-18 network, increasing weight decay from to , used in the original pretrained network, reduced the validation accuracy by % (Table 2). This results suggest that the smaller ResNet-18 may lack sufficient capacity to compensate for low-precision weights and activations. In contrast, for the 4-bit ResNet-34 and 50 networks, the best results used weight decay of .
Quantizing weights introduces gradient noise
Weight discretization increases gradient noise for 8-, 4-, and 2-bit networks7772-bit network is used only to demonstrate how discretization-induced gradient noise varies with bit precision.. We define the increase in gradient noise due to weight discretization as the angular difference between the step taken by the learning algorithm, , on the float-point copy at iteration , , and the actual step taken due to quantizing the weights, i.e. . We measure this angle using cosine similarity (normalized dot-product) between the instantaneous and an exponential moving average of the actual step directions with smoothing factor (Figure 1). Cosine similarity of corresponds to an fp32 network and the absence of discretization-induced gradient noise. As bit precisions decrease, similarity decreases, signaling higher gradient noise.
These results directly show discretization-induced gradient noise appreciably influences the fine-tuning and training trajectories of quantized networks. The increased noise (decreased similarity) of the 4-bit case compared to the 8-bit case possibly accounts for the difference in fine-tuning times required. Even the 8-bit case is significantly below unity, possibly explaining why training from scratch has not lead to the highest performance [Jacob et al.2017].
The 4-bit solution was similar to the high-precision solution
The weights of the FAQ trained 4-bit network were similar to those in the full-precision pretrained network used for its initialization (Figure 2). We define the network similarity as the cosine similarity between the networks’ weights. The average of the cosine similarity between the weights of every corresponding neuron in the two networks is very close to
, indicating that the weight vectors have not moved very far during 110 epochs of fine-tuning and that the 4-bit network exists close to its high-precision counterpart, demonstrating that pretrained initialization strongly influenced the final network. Contrast this with the same measure when training from scratch, where the similarity between the initial weights and final weights is close to(). The fact that the 4-bit solution was close to the high-precision solution suggests that training from scratch is unnecessary.
We show here that low-precision quantization followed by fine-tuning, when properly compensating for noise, is sufficient to achieve state of the art performance for networks employing 4- and 8-bit weights and activations. Compared to previous work, our approach offers a major advantage in the 8-bit space, by requiring only a single epoch of post quantization training to consistently exceed high-precision network scores, and a major advantage in the 4-bit space by, for the first time, matching high-precision baseline scores. We find support for the idea that overcoming noise is the main challenge in successful fine-tuning, given sufficient capacity in a network model: longer training times, exponential learning rate decay, very low final learning rate, and larger batch sizes all seem to contribute to improving the results of fine-tuning.
We believe that this approach marks a major change in how low-precision networks can be trained, particularly given the wide availability of pretrained high-precision models. We conjecture that within every region containing a local minimum for a high-precision network, there exists a subregion(s) which also contains solutions to the lower precision 4-bit problem, provided that the network has sufficient capacity. The experiments reported herein provide experimental support for this conjecture. In addition, it could be argued, given that the weights of a low-precision net can be trivially represented in higher precision, that it is likely that the lower precision regions would be found well inside the boundary defining the 32-bit region, requiring additional training to move into the center (for example, see Figure 1 of [Izmailov et al.2018]). This provides a possible reason why additional training, and not merely quantization that tried to match as closely as possible the high-precision weights, would yield the best accuracy for a given level of quantization. If true, 1) this direct method of fine-tuning will become a standard quantization methodology, supplanting these other methods; and 2) additional techniques which better optimize high-precision networks will lead to better quantization performance as well, perhaps without any further training. We predict, for instance, that a recently proposed weight averaging method designed to move closer to the minimum [Izmailov et al.2018] will also lead to higher accuracy of the initial quantization.
We expect that other approaches will further improve quantization results. For example, layer-specific learning rates and the Adam learning algorithms achieved the best results in an early low-precision study using binary weights [Courbariaux, Bengio, and David2015]. Optimal learning rates, and better effective learning rate adjustments over the course of training may allow the network to learn more effectively in the presence of noise, thereby improving the results of fine-tuning. Perhaps new training algorithms designed specifically to fight the ill-effects of noise [Baskin et al.2018]
introduced by weight quantizaiton will lead to further improvements, for example, by incorporating Kalman filtering techniques for optimal noise level estimation.
It will be interesting in the future to apply fine-tuning to networks quantized to 2 bits. Training in the 2-bit case will be more challenging given the additional noise due to quantization (Figure 2), and there may be a fundamental capacity limit with 2-bit quantization, at least for the smaller networks like ResNet-18. It seems more likely that larger 2-bit models will be able to match the accuracy of the full-precision models [Mishra et al.2017].
Fine-tuning for quantization has been previously studied. In [Zhou et al.2017], increasingly larger subsets of neurons from a pretrained network are replaced with low-precision neurons and fine-tuned, in stages. This process repeats until all neurons have been replaced. The accuracy exceeds the baseline for a range of networks quantized with 5-bit weights and 32-bit activations. Our results here with both fixed-precision weights and activations at either 8 or 4 bits suggest that the key was fine-tuning, and incremental training may have been unnecessary. In [Baskin et al.2018], fine-tuning is employed along with a non-linear quantization scheme during training to show successful quantization on a variety of networks. We have listed their results for 4-bit weights and either 8- or 32-bit activations in Table 1 for comparison. We have shown that low-precision quantization followed by fine-tuning, when properly compensating for noise, is sufficient to achieve even greater accuracy when quantizing both weights and activations at 4 bits.
Fine-tuning is a principled approach to quantization. Ultimately, the goal of quantization is to match or exceed the validation score of a corresponding full-precision network. We would argue that the most direct way to achieve this is to fine-tune the network using the original objective function used for model selection and training: training error. There is no reason to switch objective functions during quantization to one which tries to closely approximate the high-precision network parameters. Our work here demonstrates 8-bit and 4-bit quantized networks performing at the level of their high-precision counterparts can be created with a modest investment of training time, a critical step towards harnessing the energy-efficiency of low-precision hardware.
- [Baskin et al.2018] Baskin, C.; Schwartz, E.; Zheltonozhskii, E.; Liss, N.; Giryes, R.; Bronstein, A. M.; and Mendelson, A. 2018. UNIQ: uniform noise injection for the quantization of neural networks. CoRR abs/1804.10969.
- [Bengio, Léonard, and Courville2013] Bengio, Y.; Léonard, N.; and Courville, A. 2013. Estimating or propagating gradients through stochastic neurons for conditional computation. arXiv preprint arXiv:1308.3432.
- [Cai et al.2017] Cai, Z.; He, X.; Sun, J.; and Vasconcelos, N. 2017. Deep learning with low precision by half-wave gaussian quantization. CoRR abs/1702.00953.
- [Choi et al.2018] Choi, J.; Wang, Z.; Venkataramani, S.; Chuang, P. I.; Srinivasan, V.; and Gopalakrishnan, K. 2018. PACT: parameterized clipping activation for quantized neural networks. CoRR abs/1805.06085.
- [Courbariaux and Bengio2016] Courbariaux, M., and Bengio, Y. 2016. Binarynet: Training deep neural networks with weights and activations constrained to +1 or -1. CoRR abs/1602.02830.
[Courbariaux, Bengio, and
Courbariaux, M.; Bengio, Y.; and David, J.-P.
Binaryconnect: Training deep neural networks with binary weights during propagations.In Advances in neural information processing systems, 3123–3131.
- [Esser et al.2016] Esser, S.; Merolla, P.; Arthur, J.; Cassidy, A.; Appuswamy, R.; Andreopoulos, A.; Berg, D.; McKinstry, J.; Melano, T.; Barch, D.; et al. 2016. Convolutional networks for fast, energy-efficient neuromorphic computing. 2016. Preprint on ArXiv. http://arxiv. org/abs/1603.08270. Accessed 27.
- [Goodfellow et al.2016] Goodfellow, I.; Bengio, Y.; Courville, A.; and Bengio, Y. 2016. Deep learning, volume 1. MIT press Cambridge.
- [Goodfellow, Vinyals, and Saxe2014] Goodfellow, I. J.; Vinyals, O.; and Saxe, A. M. 2014. Qualitatively characterizing neural network optimization problems. arXiv preprint arXiv:1412.6544.
- [He et al.2016] He, K.; Zhang, X.; Ren, S.; and Sun, J. 2016. Deep residual learning for image recognition. In , 770–778.
- [Huang et al.2017] Huang, G.; Liu, Z.; Van Der Maaten, L.; and Weinberger, K. Q. 2017. Densely connected convolutional networks. In CVPR, volume 1, 3.
- [Izmailov et al.2018] Izmailov, P.; Podoprikhin, D.; Garipov, T.; Vetrov, D.; and Wilson, A. G. 2018. Averaging weights leads to wider optima and better generalization. arXiv preprint arXiv:1803.05407.
- [Jacob et al.2017] Jacob, B.; Kligys, S.; Chen, B.; Zhu, M.; Tang, M.; Howard, A.; Adam, H.; and Kalenichenko, D. 2017. Quantization and training of neural networks for efficient integer-arithmetic-only inference. arXiv preprint arXiv:1712.05877.
- [Jung et al.2018] Jung, S.; Son, C.; Lee, S.; Son, J.; Kwak, Y.; Han, J.-J.; and Choi, C. 2018. Joint training of low-precision neural network with quantization interval parameters. arXiv preprint arXiv:1808.05779.
- [Meka2017] Meka, R. 2017. Cs289ml: Notes on convergence of gradient descent. https://raghumeka.github.io/CS289ML/gdnotes.pdf.
- [Migacz2017] Migacz, S. 2017. Nvidia 8-bit inference with tensorrt. GPU Technology Conference.
- [Mishra and Marr2017] Mishra, A., and Marr, D. 2017. Apprentice: Using knowledge distillation techniques to improve low-precision network accuracy. arXiv preprint arXiv:1711.05852.
- [Mishra et al.2017] Mishra, A. K.; Nurvitadhi, E.; Cook, J. J.; and Marr, D. 2017. WRPN: wide reduced-precision networks. CoRR abs/1709.01134.
- [Miyashita, Lee, and Murmann2016] Miyashita, D.; Lee, E. H.; and Murmann, B. 2016. Convolutional neural networks using logarithmic data representation. CoRR abs/1603.01025.
- [Polino, Pascanu, and Alistarh2018] Polino, A.; Pascanu, R.; and Alistarh, D. 2018. Model compression via distillation and quantization. CoRR abs/1802.05668.
- [Rastegari et al.2016] Rastegari, M.; Ordonez, V.; Redmon, J.; and Farhadi, A. 2016. Xnor-net: Imagenet classification using binary convolutional neural networks. In European Conference on Computer Vision, 525–542. Springer.
- [Sa et al.2018] Sa, C. D.; Leszczynski, M.; Zhang, J.; Marzoev, A.; Aberger, C. R.; Olukotun, K.; and Ré, C. 2018. High-accuracy low-precision training. CoRR abs/1803.03383.
- [Simonyan and Zisserman2014] Simonyan, K., and Zisserman, A. 2014. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556.
- [Szegedy et al.2016] Szegedy, C.; Vanhoucke, V.; Ioffe, S.; Shlens, J.; and Wojna, Z. 2016. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE conference on computer vision and pattern recognition, 2818–2826.
- [Wu et al.2018] Wu, S.; Li, G.; Chen, F.; and Shi, L. 2018. Training and inference with integers in deep neural networks. In International Conference on Learning Representations.
- [Xu et al.2018] Xu, Y.; Wang, Y.; Zhou, A.; Lin, W.; and Xiong, H. 2018. Deep neural network compression with single and multiple level quantization. CoRR abs/1803.03289.
- [Yin et al.2018] Yin, P.; Zhang, S.; Lyu, J.; Osher, S.; Qi, Y.; and Xin, J. 2018. Binaryrelax: A relaxation approach for training deep neural networks with quantized weights. CoRR abs/1801.06313.
- [Zhou et al.2017] Zhou, A.; Yao, A.; Guo, Y.; Xu, L.; and Chen, Y. 2017. Incremental network quantization: Towards lossless cnns with low-precision weights. CoRR abs/1702.03044.