Pith. sign in

REVIEW 3 major objections 5 minor 46 references

Differentiable Soft Quantization: Bridging Full-Precision and Low-Bit Neural Networks

T0 review · 3 major / 5 minor · reviewed 2026-08-14 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read This paper claims that a differentiable soft quantizer, which anneals into hard binary or uniform quantization during training, can train low-bit neural networks to accuracy close to full precision and run them faster on mobile processors.

desk verdict DSQ is a real new soft-quantization training trick with solid ablations; treat the headline ImageNet gains as plausible but unverified because baselines are external and the forward pass is actually hard. read the letter →

arxiv 1908.05033 v1 pith:OJTRM6XV submitted 2019-08-14 cs.CV cs.LGeess.IV

Ruihao Gong , Xianglong Liu , Shenghu Jiang , Tianxiang Li , Peng Hu , Jiazhen Lin , Fengwei Yu , Junjie Yan This is my paper · ORCID
classification cs.CVcs.LGeess.IV
keywords neuralnetworkquantizationdifferentiablesoftbinarynetworksuniformlearnedclippingevolutiontraininglow-bitinferenceimageclassification
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper proposes Differentiable Soft Quantization (DSQ), a way to train neural networks whose weights and activations are reduced to very few bits (1 to 4) without the usual accuracy collapse. DSQ replaces the hard, non-differentiable quantization step with a smooth curve built from piecewise hyperbolic tangents. During training the curve gradually sharpens into the true staircase quantizer, while the clipping range is learned at the same time. The result is that gradients stay informative and clipping and rounding errors are balanced, allowing low-bit models to keep much of the full-precision accuracy and to run faster on mobile CPUs.

What carries the argument

The central object is the DSQ function, a piecewise hyperbolic-tangent approximation of the binary or uniform quantizer. Inside each interval $P_i$ it is $Q_S(x) = l + \Delta(i + (\phi(x)+1)/2)$ with $\phi(x) = s\tanh(k(x-m_i))$, where the scaling $s$ makes adjacent pieces meet smoothly. Its work is to give a usable, nonzero gradient almost everywhere while still being able to degenerate to the exact sign or rounding operation at deployment. Two accompanying learned parameters carry the argument: the characteristic variable $\alpha = 1 - \tanh(0.5k\Delta)$, which measures how far the soft curve is from the hard staircase and is evolved during training, and the clipping bounds $l,u$, which are optimized to balance clipping error against rounding error. The training algorithm clips, applies $\phi$, applies sign, dequantizes, and then updates weights, $\alpha$, and clipping values with ordinary backpropagation.

What would settle it

Run DSQ on a held-out architecture, such as ResNet-50 with 2-bit weights and activations on ImageNet, and compare against the same baselines used in the paper: if accuracy does not reach those numbers, or if the final accuracy depends strongly on random seed and on the initial value of $\alpha$, the claim of consistent improvement is undercut. A more direct mechanism check is to compare DSQ's gradients with the true discretized gradients on the same model; if they are not closer than straight-through estimation, the stated cause of the improvement fails.

Watch

Extended reading notes

Core claim

The paper's central claim is that the gap between full-precision and low-bit neural networks can be bridged by training with a soft, differentiable version of the quantizer and letting it anneal into the hard quantizer. DSQ defines a piecewise function $Q_S(x)$ using scaled $\tanh$ curves inside each quantization interval; a single scalar $\alpha$ controls how close the soft curve is to the staircase, with $\alpha \to 0$ recovering standard uniform quantization. The paper shows $\alpha$ and the clipping bounds $l,u$ can be optimized by backpropagation, so the quantizer evolves during training rather than being fixed in advance. On CIFAR-10 and ImageNet the trained 1- to 4-bit models consistently outperform the compared binary and uniform baselines, and a 2-bit ARM implementation runs ResNet-18 faster than an 8-bit mobile framework.

Load-bearing premise

The load-bearing premise is that letting the softness parameter $\alpha$ and the clipping bounds be tuned by ordinary gradient descent, with $\alpha$ kept in $(0,0.5)$ and $k \le 1000$, steers training into a good solution of the true discrete quantization problem; the paper supports this only with experiments on a few datasets and architectures.

Editorial extensions

If this is right

  • Low-bit (1- to 4-bit) networks can be trained end-to-end from a full-precision start with gradients that reflect the forward quantization, reducing the optimization instability associated with straight-through estimation.
  • Because the trained model is exactly the hard quantizer, deployment can use fast 2- to 4-bit integer arithmetic; the paper measures up to 1.7x speedup over an 8-bit mobile inference framework.
  • The automatically learned $\alpha$ values indicate that weights tolerate more quantization than activations and that different layers have different sensitivity to quantization, offering a data-driven view of where quantization hurts.
  • Uniform, hardware-friendly quantizers can match or beat non-uniform learned quantizers on ImageNet at 2 and 3 bits, so hardware-friendly inference need not sacrifice accuracy.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Editorial inference: the same annealing idea could apply to other discrete structures, such as embedding tables in language models or vector-quantized generative models, wherever a hard rounding step blocks gradient flow.
  • Editorial inference: the learned per-layer $\alpha$ values read like a sensitivity map, so using them to allocate mixed bit-widths across layers is a natural next step that the paper does not itself propose.
  • Editorial inference: a strong test of the method would be running DSQ on a wider set of architectures and tasks, such as detection or segmentation, because the paper's evidence is limited to image classification on a few networks.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 5 minor

Summary. The paper introduces Differentiable Soft Quantization (DSQ), a differentiable surrogate for binary and uniform low-bit quantizers, together with an evolution training scheme and an ARM deployment implementation. The quantizer is defined per quantization interval by a scaled tanh function (Eqs. 3–8), with a similarity variable α controlling how closely the surrogate approaches the staircase of the true quantizer, and clipping bounds l and u controlling the quantization range. The authors propose to optimize α, l, and u jointly with network weights, using a constrained loss (Eq. 9) and the update rules in Algorithm 1. Experiments on CIFAR-10 and ImageNet report state-of-the-art accuracy for 1-bit, 2-bit, and 3-bit networks, and an ARM NEON implementation of 2-bit GEMM is reported to be up to 1.7× faster than NCNN's 8-bit inference.

Significance. The main mathematical construction is sound and clearly presented: the reparameterization of the tanh steepness by α is correct, and the internal ablations (Tables 3–5) provide evidence that learning α and the clipping bounds helps. The algorithm is specified in enough detail to be reimplemented, and the ARM deployment section gives concrete measured numbers. If the accuracy claims survive controlled comparisons, the method would be a useful bridge between differentiable surrogates and hard quantizers, with a practical low-bit inference kernel. At present, however, the evidence for consistently outperforming state-of-the-art methods is not yet convincing because the most important comparisons are not controlled.

major comments (3)
  1. [Algorithm 1 / Section 3.5] In the forward pass of Algorithm 1, lines 1–4, the network computes a_sq = φ(a), then applies the hard sign, a_q = sgn(a_sq), and dequantizes. In the backward pass, line 6, the gradient chain is written as ∂L/∂a = ∂L/∂â · ∂â/∂a_q · ∂a_sq/∂a, with no factor for ∂a_q/∂a_sq; the sign function is therefore treated as the identity in the backward pass. As a result, the network that is actually trained is a hard quantizer trained with an STE-like gradient proxy, not the differentiable soft quantizer QS of Eq. (5). This does not invalidate the empirical results, but it weakens the paper's central mechanism story: the forward model is not the differentiable function whose properties are analyzed in Sections 3.2–3.4. I ask the authors to either train with the soft QS forward pass and anneal it toward the hard quantizer, or explicitly present DSQ as a modified STE gradient and show that the gradient proxy, not the forward redistribution, is what drives the gains.
  2. [Tables 6 and 7 / Section 4.4] The headline comparisons against DoReFa-Net, LQ-Net, PACT, and other methods use accuracy numbers taken from the original papers rather than from re-implementations under the same training protocol, and no results are reported with multiple seeds or error bars. The two ImageNet wins most relevant to the abstract's claim are small: 65.17% versus 64.90% for ResNet-18 2/2 and 72.54% versus 71.90% for ResNet-34 3/3. Since single-run ImageNet fine-tuning can easily vary by more than these margins across random seeds, initialization, and schedule choices, the data do not establish that DSQ consistently outperforms state-of-the-art methods. Please add controlled comparisons, preferably using the released code of the baselines, with the same augmentation, epochs, learning-rate schedule, and precision placement, and report the mean and standard deviation over at least three runs.
  3. [Section 4.5 / Tables 8–9] The deployment experiment compares a custom 2-bit ARM NEON GEMM implementation against one commit of NCNN running 8-bit, on one device and one network. This is a useful engineering data point, but it does not support the general claim that DSQ provides faster inference. The measured speedup conflates the quantization method with the kernel implementation, and the paper does not report threading, compiler flags, frequency behavior, or whether NCNN was also using NEON SIMD. At minimum, please add a second device, report the DSQ 3-bit and 4-bit kernels at the network level, and clarify exactly which operations, including convolution, batch norm, and element-wise layers, are included in the timings.
minor comments (5)
  1. [Section 3.3, Eqs. (6)–(8)] The derivation of k from α is correct, but the sentence in Section 4.2.3 that when α becomes large DSQ behaves more like an identity operation is not transparent from Eq. (5); α approaching 0.5 gives a softer, more linear surrogate, not an identity map, and α approaching 0 gives the hard quantizer. Please rephrase or justify this statement.
  2. [Section 4.4] The text contains typographical errors: 'enble' in Section 3.3, 'origin papers' in Section 4.1, 'consisteny' in Section 4.4, and 'protential' in Section 4.4. Please proofread the manuscript.
  3. [Table 5] The caption of Table 5 does not state the dataset or network architecture; from context it appears to be 2-bit ResNet-20 on CIFAR-10, but this information should be explicit.
  4. [Section 3.3, Eq. (9)] The regularization constraint ||α||_2 < λ is not specified: it is unclear whether α is a scalar per tensor, whether λ is tuned, and how the norm is computed. Please provide the exact objective and the update rule for α, including the learning rate.
  5. [Table 6] For VGG-Small, the claim that 1-bit DSQ can even obtain better performance than the full-precision model rests on a 0.07-point difference (91.72 versus 91.65) from a single run; this should be reported with variance or softened.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: DSQ is a self-contained quantization surrogate evaluated on external benchmarks, with no prediction that reduces to a fitted input.

full rationale

The paper's central claim is an empirical one: training low-bit networks with DSQ improves accuracy and speed over prior quantization methods. DSQ's soft quantizer (Eqs. 3-8) is defined as a tanh-based approximation to the standard uniform quantizer, with alpha, l, and u learned during training; none of these learned quantities is a prediction derived from the method, and the reported accuracies come from network training on CIFAR-10 and ImageNet rather than from the defining equations alone. The relation between alpha and k (Eqs. 6-8) is an algebraic reformulation of the same tanh parameterization, not a circular derivation of performance. The ablation study (Tables 3-5) and comparisons (Tables 6-7) are benchmark experiments against external methods; even though baseline numbers are imported from prior papers, this is a comparison-protocol concern, not a circularity concern. The observation that learned alpha differs across layers (Table 2) is an interpretation of trained parameters, not a validation that presupposes the conclusion. Algorithm 1's forward pass uses a sign operation after phi while backward propagation differentiates through phi, which is an internal consistency issue between the stated soft mechanism and the deployed hard quantizer, but it does not make any result equivalent to its inputs by construction. There are no load-bearing self-citations and no uniqueness theorems or renamed known results invoked to force the authors' choice. Accordingly, no circular step meeting the evidence standard is present.

Assumptions & free parameters 2 free parameters · 4 assumptions · 0 invented entities

The method introduces no physical entities; the only new objects are the DSQ function and its trainable parameters, listed above. The paper's claims rest on standard empirical deep learning assumptions: pre-trained initialization, STE-like gradients, and the transferability of soft training to hard inference.

free parameters (2)
  • alpha (similarity factor) = learned per layer, initialized 0.2, constrained to (0, 0.5)
    Controls the steepness of the tanh approximation; optimized via gradient descent with L2 regularization (Eq. 9).
  • clipping bounds l and u = learned per layer (or moving average)
    Chosen to balance clipping and rounding error; optimized via Eqs. (11)-(12).
assumptions (4)
  • ad hoc to paper The tanh-based asymptotic function phi(x)=s*tanh(k(x-m_i)) is a valid differentiable surrogate for the uniform quantizer.
    Introduced in Eq. (3) to provide gradients; not derived from first principles.
  • domain assumption Hardening the soft output with the sign function at inference preserves the accuracy of the soft model.
    Algorithm 1 step 3 applies sgn to the soft output; the paper assumes no train-test mismatch penalty.
  • ad hoc to paper The constraint alpha in (0, 0.5) and k <= 1000 is sufficient for stable training.
    Stated in Section 4.2.3 as a stability measure; not justified by theory.
  • domain assumption Gradient descent through the soft surrogate provides a valid descent direction for the quantized loss.
    The backward pass uses the derivatives of the soft function, not the true derivative of the hard quantizer.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Differentiable Soft Quantization: Bridging Full-Precision and Low-Bit Neural Networks." pith.science (2026). https://pith.science/paper/OJTRM6XV

@misc{pith2026190805033,
  author       = {Pith},
  title        = {Pith review of: Differentiable Soft Quantization: Bridging Full-Precision and Low-Bit Neural Networks},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/OJTRM6XV}},
  note         = {Machine review of arXiv:1908.05033}
}
abstract

Hardware-friendly network quantization (e.g., binary/uniform quantization) can efficiently accelerate the inference and meanwhile reduce memory consumption of the deep neural networks, which is crucial for model deployment on resource-limited devices like mobile phones. However, due to the discreteness of low-bit quantization, existing quantization methods often face the unstable training process and severe performance degradation. To address this problem, in this paper we propose Differentiable Soft Quantization (DSQ) to bridge the gap between the full-precision and low-bit networks. DSQ can automatically evolve during training to gradually approximate the standard quantization. Owing to its differentiable property, DSQ can help pursue the accurate gradients in backward propagation, and reduce the quantization loss in forward process with an appropriate clipping range. Extensive experiments over several popular network structures show that training low-bit neural networks with DSQ can consistently outperform state-of-the-art quantization methods. Besides, our first efficient implementation for deploying 2 to 4-bit DSQ on devices with ARM architecture achieves up to 1.7$\times$ speed up, compared with the open-source 8-bit high-performance inference framework NCNN. [31]

Figures

Figures reproduced from arXiv: 1908.05033 by the authors.

Figure 1
Figure 1. An overview of Differentiable Soft Quantization (DSQ), taking 2-bit uniform quantization as an example. During training, we [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Curves of differentiable soft quantization function for (a) [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. The characteristic variable α in DSQ. Furthermore, we can reformulate the DSQ function only with respect to the parameter α and ∆. Specifically, based on the above equation, we have s = 1 1 − α . (7) With the facts ∆ = u−l 2 b−1 and ϕ(0.5∆) = 1, we also have k = 1 ∆ log( 2 α − 1). (8) [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (3 more)
Figure 4
Figure 4. Figure 4: Data flow in our fast GEMM implementation. [PITH_FULL_IMAGE:figures/full_fig_p005_4.png]
Figure 6
Figure 6. Figure 6: Training quantized model with/without DSQ function. [PITH_FULL_IMAGE:figures/full_fig_p006_6.png]
Figure 7
Figure 7. Figure 7: Automatic evolution of α during training. For both activations and weights, we can see that at the beginning of training, α will increase sharply. Considering when α becomes large, DSQ behaves more like an iden￾tity operation, this phenomenon implies that we should not…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

46 extracted references · 24 canonical work pages

  1. [1]

    Mur- ray, Benoit Steiner, Paul Tucker, Vijay Vasudevan, Pete War- den, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng

    Martin Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghe- mawat, Geoffrey Irving, Michael Isard, Manjunath Kudlur, Josh Levenberg, Rajat Monga, Sherry Moore, Derek G. Mur- ray, Benoit Steiner, Paul Tucker, Vijay Vasudevan, Pete War- den, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. Ten- sorflow: A system fo...

    2016

  2. [2]

    Post-training 4-bit quantization of convolution networks for rapid-deployment

    Ron Banner, Yury Nahshan, Elad Hoffer, and Daniel Soudry. Post-training 4-bit quantization of convolution networks for rapid-deployment. arXiv preprint arXiv:1810.05723, 2018

    arXiv 2018

  3. [3]

    UNIQ: Uniform Noise Injection for Non-Uniform Quantization of Neural Networks

    Chaim Baskin, Eli Schwartz, Evgenii Zheltonozhskii, Natan Liss, Raja Giryes, Alex M. Bronstein, and Avi Mendelson. Uniq: Uniform noise injection for non-uniform quantization of neural networks. arXiv preprint arXiv:1804.10969, 2018

    work page Pith review arXiv 2018

  4. [4]

    Estimating or propagating gradients through stochastic neurons for conditional computation

    Yoshua Bengio, Nicholas Lonard, and Aaron Courville. Estimating or propagating gradients through stochastic neurons for conditional computation. arXiv preprint arXiv:1308.3432, 2013

    arXiv 2013

  5. [5]

    Deep learning with low precision by half-wave gaussian quantization

    Zhaowei Cai, Xiaodong He, Jian Sun, and Nuno Vasconce- los. Deep learning with low precision by half-wave gaussian quantization. 2017 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), Jul 2017

    work page 2017

  6. [6]

    Bridging the accuracy gap for 2- bit quantized neural networks (qnn)

    Jungwook Choi, Pierce I-Jen Chuang, Zhuo Wang, Swa- gath Venkataramani, Vijayalakshmi Srinivasan, and Kailash Gopalakrishnan. Bridging the accuracy gap for 2- bit quantized neural networks (qnn). arXiv preprint arXiv:1807.06964, 2018

    arXiv 2018

  7. [7]

    Pact: Parameterized clipping activa- tion for quantized neural networks

    Jungwook Choi, Zhuo Wang, Swagath Venkataramani, Pierce I-Jen Chuang, Vijayalakshmi Srinivasan, and Kailash Gopalakrishnan. Pact: Parameterized clipping activa- tion for quantized neural networks. arXiv preprint arXiv:1805.06085, 2018

    arXiv 2018

  8. [8]

    Binaryconnect: Training deep neural networks with binary weights during propagations

    Matthieu Courbariaux, Yoshua Bengio, and Jean-Pierre David. Binaryconnect: Training deep neural networks with binary weights during propagations. arXiv preprint arXiv:1511.00363, 2015

    arXiv 2015

Show all 46 references
  1. [9]

    Binarized neural networks: Training deep neural networks with weights and activations constrained to +1 or -1

    Matthieu Courbariaux, Itay Hubara, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks: Training deep neural networks with weights and activations constrained to +1 or -1. arXiv preprint arXiv:1602.02830 , 2016

    2016 arXiv

  2. [10]

    J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei- Fei. ImageNet: A Large-Scale Hierarchical Image Database. 2009 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), Jul 2009

    2009

  3. [11]

    Highly efficient 8-bit low precision in- ference of convolutional neural networks with intelcaffe

    Jiong Gong, Haihao Shen, Guoming Zhang, Xiaoli Liu, Shane Li, Ge Jin, Niharika Maheshwari, Evarist Fomenko, and Eden Segal. Highly efficient 8-bit low precision in- ference of convolutional neural networks with intelcaffe. Proceedings of the 1st on Reproducible Quality-Efficient...

    2018

  4. [12]

    Horowitz, and William J

    Song Han, Xingyu Liu, Huizi Mao, Jing Pu, Ardavan Pe- dram, Mark A. Horowitz, and William J. Dally. Eie. ACM SIGARCH Computer Architecture News, 44(3):243254, Jun 2016

    2016

  5. [13]

    Song Han, Huizi Mao, and William J. Dally. Deep com- pression: Compressing deep neural networks with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149, 2015

    2015 arXiv

  6. [14]

    Deep residual learning for image recognition

    Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), Jun 2016

    2016

  7. [15]

    Identity mappings in deep residual networks

    Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. Lecture Notes in Computer Science, page 630645, 2016

    2016

  8. [16]

    Binarized neural networks

    Itay Hubara, Matthieu Courbariaux, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks. In Advances in Neural Information Processing Systems 29 , pages 4107–4115. Curran Associates, Inc., 2016

    2016

  9. [17]

    gemmlowp: a small self-contained low- precision gemm library.(2017), 2017

    Benoit Jacob et al. gemmlowp: a small self-contained low- precision gemm library.(2017), 2017

    2017

  10. [18]

    Quantization and training of neural networks for efficient integer-arithmetic-only inference

    Benoit Jacob, Skirmantas Kligys, Bo Chen, Menglong Zhu, Matthew Tang, Andrew Howard, Hartwig Adam, and Dmitry Kalenichenko. Quantization and training of neural networks for efficient integer-arithmetic-only inference. 2018 IEEE Conference on Computer Vision and Pattern Recognit...

    2018

  11. [19]

    Caffe: Convolutional architecture for fast feature embedding

    Yangqing Jia, Evan Shelhamer, Jeff Donahue, Sergey Karayev, Jonathan Long, Ross Girshick, Sergio Guadarrama, and Trevor Darrell. Caffe: Convolutional architecture for fast feature embedding. arXiv preprint arXiv:1408.5093, 2014

    2014 arXiv

  12. [20]

    Learning to quantize deep networks by op- timizing quantization intervals with task loss

    Sangil Jung, Changyong Son, Seohyung Lee, Jinwoo Son, Youngjun Kwak, Jae-Joon Han, Sung Ju Hwang, and Changkyu Choi. Learning to quantize deep networks by op- timizing quantization intervals with task loss. arXiv preprint arXiv:1808.05779, 2018

    2018 arXiv

  13. [21]

    Quantizing deep convolu- tional networks for efficient inference: A whitepaper

    Raghuraman Krishnamoorthi. Quantizing deep convolu- tional networks for efficient inference: A whitepaper. arXiv preprint arXiv:1806.08342, 2018

    2018 arXiv

  14. [22]

    The cifar-10 dataset

    Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. The cifar-10 dataset. online: http://www. cs. toronto. edu/kriz/cifar. html, page 4, 2014

    2014

  15. [23]

    Ternary weight networks

    Fengfu Li, Bo Zhang, and Bin Liu. Ternary weight networks. arXiv preprint arXiv:1605.04711, 2016

    2016 arXiv

  16. [24]

    Training quantized nets: A deeper understanding

    Hao Li, Soham De, Zheng Xu, Christoph Studer, Hanan Samet, and Tom Goldstein. Training quantized nets: A deeper understanding. arXiv preprint arXiv:1706.02379 , 2017

    2017 arXiv

  17. [25]

    Towards accu- rate binary convolutional neural network

    Xiaofan Lin, Cong Zhao, and Wei Pan. Towards accu- rate binary convolutional neural network. In I. Guyon, U. V . Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vish- wanathan, and R. Garnett, editors,Advances in Neural Infor- mation Processing Systems 30 , pages 345–353. Curran...

    2017

  18. [26]

    McKinstry, Steven K

    Jeffrey L. McKinstry, Steven K. Esser, Rathinakumar Ap- puswamy, Deepika Bablani, John V . Arthur, Izzet B. Yildiz, and Dharmendra S. Modha. Discovering low-precision net- works close to full-precision networks for efficient embed- ded inference. arXiv preprint arXiv:1809.04191, 2018

    2018 arXiv

  19. [27]

    8-bit inference with tensorrt

    Szymon Migacz. 8-bit inference with tensorrt. In GPU Tech- nology Conference, 2017

    2017

  20. [28]

    Apprentice: Using knowledge distillation techniques to improve low-precision network ac- curacy

    Asit Mishra and Debbie Marr. Apprentice: Using knowledge distillation techniques to improve low-precision network ac- curacy. arXiv preprint arXiv:1711.05852, 2017

    2017 arXiv

  21. [29]

    Wrpn: Wide reduced-precision networks

    Asit Mishra, Eriko Nurvitadhi, Jeffrey J Cook, and Deb- bie Marr. Wrpn: Wide reduced-precision networks. arXiv preprint arXiv:1709.01134, 2017

    2017 arXiv

  22. [30]

    Lee, and Boris Murmann

    Daisuke Miyashita, Edward H. Lee, and Boris Murmann. Convolutional neural networks using logarithmic data rep- resentation. arXiv preprint arXiv:1603.01025, 2016

    2016 arXiv

  23. [31]

    nihui et al. Ncnn. https://github.com/Tencent/ ncnn, 2017

    2017

  24. [32]

    Automatic dif- ferentiation in PyTorch

    Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic dif- ferentiation in PyTorch. In NIPS Autodiff Workshop, 2017

    2017

  25. [33]

    Xnor-net: Imagenet classification using bi- nary convolutional neural networks

    Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-net: Imagenet classification using bi- nary convolutional neural networks. Lecture Notes in Com- puter Science, page 525542, 2016

    2016

  26. [34]

    Mobilenetv2: Inverted residuals and linear bottlenecks

    Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zh- moginov, and Liang-Chieh Chen. Mobilenetv2: Inverted residuals and linear bottlenecks. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR) , June 2018

    2018

  27. [35]

    Clip-q: Deep network com- pression learning by in-parallel pruning-quantization

    Frederick Tung and Greg Mori. Clip-q: Deep network com- pression learning by in-parallel pruning-quantization. 2018 IEEE Conference on Computer Vision and Pattern Recogni- tion (CVPR), June 2018

    2018

  28. [36]

    Haq: Hardware-aware automated quantization

    Kuan Wang, Zhijian Liu, Yujun Lin, Ji Lin, and Song Han. Haq: Hardware-aware automated quantization. arXiv preprint arXiv:1811.08886, 2018

    2018 arXiv

  29. [37]

    Two-step quantization for low-bit neural networks

    Peisong Wang, Qinghao Hu, Yifan Zhang, Chunjie Zhang, Yang Liu, and Jian Cheng. Two-step quantization for low-bit neural networks. 2018 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018

    2018

  30. [38]

    Deep neural network compression with sin- gle and multiple level quantization

    Yuhui Xu, Yongzhuang Wang, Aojun Zhou, Weiyao Lin, and Hongkai Xiong. Deep neural network compression with sin- gle and multiple level quantization. In AAAI, 2018

    2018

  31. [39]

    Elthakeb, Prannoy Pil- ligundla, FatemehSadat Mireshghallah, and Hadi Es- maeilzadeh

    Amir Yazdanbakhsh, Ahmed T. Elthakeb, Prannoy Pil- ligundla, FatemehSadat Mireshghallah, and Hadi Es- maeilzadeh. Releq: An automatic reinforcement learning approach for deep quantization of neural networks. arXiv preprint arXiv:1811.01704, 2018

    2018 arXiv

  32. [40]

    Blended coarse gradient descent for full quantization of deep neural networks.Research in the Mathematical Sciences, 6(1):14, 2019

    Penghang Yin, Shuai Zhang, Jiancheng Lyu, Stanley Osher, Yingyong Qi, and Jack Xin. Blended coarse gradient descent for full quantization of deep neural networks.Research in the Mathematical Sciences, 6(1):14, 2019

    2019

  33. [41]

    Lq-nets: Learned quantization for highly accurate and compact deep neural networks

    Dongqing Zhang, Jiaolong Yang, Dongqiangzi Ye, and Gang Hua. Lq-nets: Learned quantization for highly accurate and compact deep neural networks. In The European Conference on Computer Vision (ECCV), September 2018

    2018

  34. [42]

    Incremental network quantization: Towards lossless cnns with low-precision weights

    Aojun Zhou, Anbang Yao, Yiwen Guo, Lin Xu, and Yurong Chen. Incremental network quantization: Towards lossless cnns with low-precision weights. arXiv preprint arXiv:1702.03044, 2017

    2017 arXiv

  35. [43]

    Dorefa-net: Training low bitwidth convo- lutional neural networks with low bitwidth gradients

    Shuchang Zhou, Yuxin Wu, Zekun Ni, Xinyu Zhou, He Wen, and Yuheng Zou. Dorefa-net: Training low bitwidth convo- lutional neural networks with low bitwidth gradients. arXiv preprint arXiv:1606.06160, 2016

    2016 arXiv

  36. [44]

    Balanced quantization: An effective and ef- ficient approach to quantized neural networks

    Shu-Chang Zhou, Yu-Zhi Wang, He Wen, Qin-Yao He, and Yu-Heng Zou. Balanced quantization: An effective and ef- ficient approach to quantized neural networks. Journal of Computer Science and Technology, 32(4):667682, Jul 2017

    2017

  37. [45]

    Chenzhuo Zhu, Song Han, Huizi Mao, and William J. Dally. Trained ternary quantization. arXiv preprint arXiv:1612.01064, 2016

    2016 arXiv

  38. [46]

    Adap- tive layerwise quantization for deep neural network compres- sion

    Xiaotian Zhu, Wengang Zhou, and Houqiang Li. Adap- tive layerwise quantization for deep neural network compres- sion. 2018 IEEE International Conference on Multimedia and Expo (ICME), pages 1–6, 2018

    2018

Pith tools

Reviewed August 14, 2026 · model on record in the stance chip above.