Pith. sign in

REVIEW 2 major objections 5 minor 1 cited by

TruncQuant: Truncation-Ready Quantization for DNNs with Flexible Weight Bit Precision

T0 review · 2 major / 5 minor · reviewed 2026-08-07 · deepseek-v4-flash

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

Pith's one-line read A floor-based training quantizer, $q_t(W;n)=\lfloor (M_n+1)W\rfloor$, makes quantized-then-truncated DNN weights equal to directly quantized weights, so one model can serve many bit precisions by bit-shifting.

desk verdict A simple, correct quantizer design that rescues truncation accuracy on its own framework, but the integration results show the benefit is framework-dependent and the paper overclaims. read the letter →

arxiv 2506.11431 v1 pith:6X4MOZDG submitted 2025-06-13 cs.LG

Jinhee Kim , Seoyeon Yoon , Taeho Lee , Joo Chan Lee , Kang Eun Jeon , Jong Hwan Ko This is my paper
classification cs.LG
keywords quantization-awaretrainingweighttruncationbit-shiftinginferenceQTgapflexiblebitprecisionlow-bitDNNonce-for-allnetworksstraight-throughestimator
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

The paper claims that the accuracy collapse seen when quantization-aware-trained DNN weights are truncated to lower bit widths comes from a specific, removable mismatch: uniform rounding and bit-shifting divide the weight range into bins that do not line up, so some values map to different integers under the two operations. TruncQuant removes this mismatch by training with the quantizer $q_t(W;n)=\lfloor (M_n+1)W\rfloor$, whose bin boundaries coincide with truncation boundaries for any starting and target precision. With this change, truncating a trained model to a lower bit precision at runtime gives the same weight values as training at that precision directly, and the reported accuracy drop disappears (for example, ImageNet ResNet-50 at 2 bits goes from 3.9% when naively truncating a standard QAT model to 71.4% with TruncQuant). If the claim holds, a single stored 8-bit model can serve any lower bit precision by a simple bit-shift, avoiding the extra floating-point model and memory traffic that flexible-precision deployment usually requires.

What carries the argument

The central mechanism is the truncation-ready binwidth: intervals $[k/(M_n+1), (k+1)/(M_n+1))$ for $k=0,\dots,M_n$, produced by the floor quantizer $q_t(W;n)=\lfloor (M_n+1)W\rfloor$. Because truncation from a higher bit precision can be written as dividing the high-precision integer by a power of two and flooring, these evenly spaced bins are invariant under bit-shifting: the most significant bits of a low-precision weight agree with those of its higher-precision parent regardless of the starting precision. The paper also modifies the straight-through estimator to scale gradients by $M_n/(M_n+1)$, matching the slightly narrower binwidth.

What would settle it

Train a model with TruncQuant on a quantization-aware framework whose step sizes are learned, then truncate it to every bit width and compare against directly training at each width. If any width shows an accuracy gap even though the quantized-then-truncated integer values are identical to the directly quantized ones, the claim that bin alignment is sufficient for the recovery is falsified. The paper's own integration results at 5-8 bits already show small such gaps, so the decisive version of this test would use a framework where the QT Error is exactly zero and measure whether accuracy still drifts.

Watch

Extended reading notes

Core claim

TruncQuant is built on the observation that uniform quantization and truncation are not the same map even when both start from the same floating-point weight. For weights normalized to [0,1], the n-bit rounding quantizer uses bins of width $1/(2^n-1)$ centered at integer multiples, while truncation from b bits uses bins of width $2^{b-n}/(2^b-1)$; the two sets of boundaries differ, producing the QT Gap, the set of values that land in different bins under the two operations. The paper defines the QT Error as the distance between truncated and directly quantized weights and shows it is the product of the number of weights in the gap and the level size. TruncQuant's quantizer, $q_t(W;n)=\lfloor (M_n+1)W\rfloor$, makes both quantized and truncated binwidths equal to $1/(M_n+1)$, so the QT Gap vanishes and quantize-then-truncate equals direct quantization. The accompanying straight-through-estimator scaling by $M_n/(M_n+1)$ keeps the backward pass consistent with the new binwidth.

Load-bearing premise

The load-bearing premise is that swapping the rounding-based quantizer for the floor-based one, and scaling the straight-through estimator accordingly, does not change how well the network learns; if that premise fails for some training framework, eliminating the bin mismatch would not by itself recover the lost accuracy.

Editorial extensions

If this is right

  • One model trained at 8 bits can be switched to 1-7 bits at runtime by bit-shifting, with per-precision accuracy close to direct quantization at that precision.
  • Precision switching requires no floating-point parent model and no re-quantization pass, so runtime energy and DRAM traffic for changing precision drop.
  • The fix is a one-line change to an existing quantization-aware training loop: replace round-to-nearest with $\lfloor (M_n+1)W\rfloor$ for weights; activations and the loss are untouched.
  • The quantization-truncation error analysis gives a measurable quantity (QT Error) that tracks the accuracy drop, so it can be used to audit other flexible-precision training schemes.

Reading between the lines

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

  • Inference: the same bin-alignment principle should apply to truncating activations or to any power-of-two-aligned non-uniform quantizer, but the paper only evaluates weights, so an activation-truncation test would be a natural extension.
  • Inference: the residual 5-8 bit accuracy gaps reported when TruncQuant is embedded in two other training frameworks suggest that bin alignment is necessary but not always sufficient; the remaining differences likely live in how each framework's step sizes and gradient estimates interact with the floor function.
  • Inference: the storage argument implies only the highest-precision tensor needs to persist, which opens the door to combining TruncQuant with lossless compression of the MSBs or with error-correction codes for the discarded LSBs; neither is explored in the paper.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

2 major / 5 minor

Summary. The paper proposes TruncQuant, a truncation-ready weight quantization scheme for quantization-aware training. The key idea is to replace the usual round-based quantizer with qt(W; n) = floor((M_n + 1)W), where M_n = 2^n - 1. Because M_n + 1 is a power of two, quantizing to a high bit-width and then truncating by bit-shifting is exactly equivalent to directly applying the same floor quantizer at the lower bit-width, so the quantization-truncation gap is eliminated by construction. The authors validate the method on CIFAR-10, SVHN, and ImageNet within an Any-Precision-style QAT framework, report integrations with RobustQuant and EQ-Net, and provide Timeloop-based energy estimates showing storage and energy benefits of bit-shifting from a single stored integer model.

Significance. The central mathematical observation in Eqs. (6)-(10) is clean, self-contained, and appears machine-checkable: replacing round-based quantization with floor((M_n+1)W) makes quantized-then-truncated weights exactly equal to directly quantized weights at the lower precision. The low-bit empirical results are also strong, especially the ImageNet ResNet-50 2-bit recovery from 3.9% to 71.4%. The release of code is a practical strength, and the CIFAR-10/SVHN tables include error bars. However, the significance is tempered by Table III, where the same floor quantizer degrades accuracy at 5-8 bits in RobustQuant and EQ-Net relative to simply truncating the baseline QAT weights. Since truncation is the identity at 8 bits, this degradation is not attributable to quantization-truncation misalignment and indicates that the benefit is framework-dependent rather than universal.

major comments (2)
  1. [Section V-C, Table III] The integrated experiments contradict the general claims in Contribution (3) and in Section V-C that TruncQuant achieves accuracy on par with the baseline and integrates well with existing QAT frameworks. At precisions where truncation is identity or nearly harmless, TruncQuant is consistently below the baseline QAT result: RobustQuant at 8 bits gives 88.5% versus 90.7% for the Quant row, and EQ-Net at 8 bits gives 86.3% versus 88.4%. At 4 bits, the EQ-Net TruncQuant result (86.5%) is also below the Trunc baseline (88.9%). Because no truncation occurs at 8 bits, these gaps cannot be caused by quantization-truncation misalignment; they show that replacing the round-based quantizer with floor((M_n+1)W) changes training dynamics and can degrade accuracy in these frameworks. The paper gives no analysis of this degradation. Please either provide such an analysis and a remedy, or explicitly scope the claims to the Any-Precision setting and to low bit-widths.
  2. [Section IV, Eq. (11)] The proposed STE correction is not derived from the forward mapping. For qt(W; n) = floor((M_n+1)W), if the integer output is dequantized by 1/M_n as in the DoReFa-style dequantization used elsewhere, the effective slope of the forward map under the STE is (M_n+1)/M_n, not M_n/(M_n+1); if the output is dequantized by 1/(M_n+1), the slope is 1 and no scaling is needed. The factor M_n/(M_n+1) is the inverse of the dequantized slope. The manuscript also states that the original STE performs well, leaving ambiguous which variant produced the reported results. Please correct or remove Eq. (11), and state explicitly which STE variant was used for Tables I-III.
minor comments (5)
  1. [Table I] The row labels in Table I and the surrounding text are corrupted by unicode replacement tokens, so it is not possible to tell which block corresponds to which architecture and dataset (e.g., AlexNet, SVHN, ResNet-8, CNN-8, ResNet-20, MobileNetV2). Please fix the typesetting.
  2. [Table II] The ImageNet results in Table II have no error bars or number of runs; given that the 1-bit entries differ by about one point, these single-run results should be labeled as preliminary or supplemented with multiple runs.
  3. [Eqs. (6)-(7)] The binwidth formulas write the first bin as starting at -0.5/M_n and the last bin as ending at M_n + 0.5 over M_n; the edge bins should be clipped to the normalized range [0,1].
  4. [Eq. (5)] Equation (5) is stated as an equality, but it is only exact under the assumption that every weight in the QT Gap is assigned to an adjacent bin and therefore contributes exactly one level size; this assumption should be stated explicitly.
  5. [Fig. 6] The claim that QT Error is inversely proportional to the accuracy drop is supported by only two model curves; please provide a quantitative correlation or additional data points to substantiate this trend.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: TruncQuant's floor quantizer is a design construction whose truncation-identity is mathematical, and the accuracy claims are validated against external benchmarks rather than derived from fitted inputs.

full rationale

The core claim of the paper is that defining the training quantizer as qt(W;n)=floor((M_n+1)W) makes quantized-then-truncated weights equal to directly quantized weights, because (M_b+1)/2^{b-n}=M_n+1. This is a mathematical identity established by construction, not a fitted parameter renamed as a prediction. The QT Error decomposition in Eq. (5) is a definitional restatement of the distance between quantized and truncated weights, and the paper uses it only to explain observed accuracy-drop trends, not to generate predictions from fitted coefficients. The empirical claims, including ImageNet ResNet-50 2-bit truncation accuracy of 71.4%, are direct measurements on held-out benchmark data. No load-bearing step reduces to an input of the paper itself, and no uniqueness theorem or self-citation is invoked to force the choice of quantizer. The Table III deviations on EQ-Net and RobustQuant at 5-8 bits are a correctness/robustness concern about scope of the method, not a circularity concern, because those accuracy numbers are external empirical results rather than outputs of the paper's own derivation.

Assumptions & free parameters 0 free parameters · 3 assumptions · 0 invented entities

The paper's central derivation introduces no fitted parameters and no new physical or conceptual entities. It depends on the standard QAT framework, the [0,1] normalization convention, and the straight-through estimator approximation.

assumptions (3)
  • domain assumption Weights are normalized to [0,1] before quantization
    The binwidth derivations (Eqs. 6-10) and the quantizer in Eq. 9 assume a [0,1] normalized input; the paper follows DoReFa's tanh clip and normalization but does not discuss how other normalization schemes would affect the result.
  • domain assumption The straight-through estimator approximates the gradient of the floor quantizer well enough for training
    Section IV modifies the STE (Eq. 11) but also states the original STE works; the training success relies on the STE approximation holding for the floor function.
  • domain assumption A hardware right-shift by (b-n) exactly equals floor division by 2^(b-n) on stored integer representations
    Eq. 8 equates bit-shifting with floor division; this holds for non-negative integer representations, but signed or negative-weight handling is not discussed in the paper.

how reviews work

0 comments
Cite this review

Pith. "Pith review of TruncQuant: Truncation-Ready Quantization for DNNs with Flexible Weight Bit Precision." pith.science (2026). https://pith.science/paper/6X4MOZDG

@misc{pith2026250611431,
  author       = {Pith},
  title        = {Pith review of: TruncQuant: Truncation-Ready Quantization for DNNs with Flexible Weight Bit Precision},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/6X4MOZDG}},
  note         = {Machine review of arXiv:2506.11431}
}
read the original abstract

The deployment of deep neural networks on edge devices is a challenging task due to the increasing complexity of state-of-the-art models, requiring efforts to reduce model size and inference latency. Recent studies explore models operating at diverse quantization settings to find the optimal point that balances computational efficiency and accuracy. Truncation, an effective approach for achieving lower bit precision mapping, enables a single model to adapt to various hardware platforms with little to no cost. However, formulating a training scheme for deep neural networks to withstand the associated errors introduced by truncation remains a challenge, as the current quantization-aware training schemes are not designed for the truncation process. We propose TruncQuant, a novel truncation-ready training scheme allowing flexible bit precision through bit-shifting in runtime. We achieve this by aligning TruncQuant with the output of the truncation process, demonstrating strong robustness across bit-width settings, and offering an easily implementable training scheme within existing quantization-aware frameworks. Our code is released at https://github.com/a2jinhee/TruncQuant.

Figures

Figures reproduced from arXiv: 2506.11431 by the authors.

Figure 1
Figure 1. A conceptual diagram depicting three approaches for [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 3
Figure 3. Three quantization-truncation scenarios illustrating the QT Gap (shaded in grey), where the weight is quantized to [PITH_FULL_IMAGE:figures/full_fig_p003_3.png] view at source ↗
Figure 4
Figure 4. The QT Error trend can be explained as the combined [PITH_FULL_IMAGE:figures/full_fig_p004_4.png] view at source ↗
Figures from the paper (2 more)
Figure 6
Figure 6. Figure 6: Comparison of accuracy drop and the QT Error of [PITH_FULL_IMAGE:figures/full_fig_p005_6.png]
Figure 7
Figure 7. Figure 7: Runtime energy breakdown for initial loading and bit [PITH_FULL_IMAGE:figures/full_fig_p006_7.png]

Discussion (0). Sign in to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. MoBiQuant: Mixture-of-Bits Quantization for Token-Adaptive Any-Precision LLM

    cs.LG 2026-02 conditional novelty 6.0 of 10

    MoBiQuant assigns each token its own quantization bit-width via learned routing over recursive residual bit slices, enabling elastic 2–6-bit LLM inference that matches static PTQ accuracy.

Reference graph

Works this paper leans on

39 extracted references · 20 canonical work pages · cited by 1 Pith paper

  1. [1]

    Dory: Automatic end-to-end deployment of real-world dnns on low-cost iot mcus,

    A. Burrello, A. Garofalo, N. Bruschi, G. Tagliavini, D. Rossi, and F. Conti, “Dory: Automatic end-to-end deployment of real-world dnns on low-cost iot mcus,” IEEE Transactions on Computers, vol. 70, no. 8, pp. 1253–1268, 2021

    work page 2021

  2. [2]

    Quantization networks,

    J. Yang, X. Shen, J. Xing, X. Tian, H. Li, B. Deng, J. Huang, and X.-s. Hua, “Quantization networks,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition , 2019, pp. 7308–7316

    2019

  3. [3]

    Post training 4-bit quantization of convolutional networks for rapid-deployment,

    R. Banner, Y . Nahshan, and D. Soudry, “Post training 4-bit quantization of convolutional networks for rapid-deployment,” Advances in Neural Information Processing Systems , vol. 32, 2019

    work page 2019

  4. [4]

    Up or down? adaptive rounding for post-training quantization,

    M. Nagel, R. A. Amjad, M. Van Baalen, C. Louizos, and T. Blankevoort, “Up or down? adaptive rounding for post-training quantization,” in International Conference on Machine Learning . PMLR, 2020, pp. 7197–7206

    work page 2020

  5. [5]

    Brecq: Pushing the limit of post-training quantization by block reconstruction,

    Y . Li, R. Gong, X. Tan, Y . Yang, P. Hu, Q. Zhang, F. Yu, W. Wang, and S. Gu, “Brecq: Pushing the limit of post-training quantization by block reconstruction,” arXiv preprint arXiv:2102.05426 , 2021

    arXiv 2021

  6. [6]

    Slimmable neural networks,

    J. Yu, L. Yang, N. Xu, J. Yang, and T. Huang, “Slimmable neural networks,” arXiv preprint arXiv:1812.08928 , 2018

    arXiv 2018

  7. [7]

    Universally slimmable networks and improved training techniques,

    J. Yu and T. S. Huang, “Universally slimmable networks and improved training techniques,” in Proceedings of the IEEE/CVF international conference on computer vision , 2019, pp. 1803–1811

    2019

  8. [8]

    Efficientnet: Rethinking model scaling for con- volutional neural networks,

    M. Tan and Q. Le, “Efficientnet: Rethinking model scaling for con- volutional neural networks,” in International conference on machine learning. PMLR, 2019, pp. 6105–6114

    2019

Show all 39 references
  1. [9]

    BranchyNet: Fast inference via early exiting from deep neural networks,

    S. Teerapittayanon, B. McDanel, and H. T. Kung, “BranchyNet: Fast inference via early exiting from deep neural networks,” in Proceedings of the 23rd International Conference on Pattern Recognition . IEEE, 2016, pp. 2464–2469

    2016

  2. [10]

    Adaptive inference through early-exit networks: Design, challenges and directions,

    S. Laskaridis, A. Kouris, and N. D. Lane, “Adaptive inference through early-exit networks: Design, challenges and directions,” in Proceedings of the 5th International Workshop on Embedded and Mobile Deep Learning, 2021, pp. 1–6

    2021

  3. [11]

    Review and analysis of variable bit-precision mac microarchi- tectures for energy-efficient ai computation,

    S. Ryu, “Review and analysis of variable bit-precision mac microarchi- tectures for energy-efficient ai computation,” JOURNAL OF SEMICON- DUCTOR TECHNOLOGY AND SCIENCE, vol. 22, no. 5, pp. 353–360, 2022

    2022

  4. [12]

    Review and bench- marking of precision-scalable multiply-accumulate unit architectures for embedded neural-network processing,

    V . Camus, L. Mei, C. Enz, and M. Verhelst, “Review and bench- marking of precision-scalable multiply-accumulate unit architectures for embedded neural-network processing,” IEEE Journal on Emerging and Selected Topics in Circuits and Systems , vol. 9, no. 4, pp. 697–711, 2019

    2019

  5. [13]

    Bit fusion: Bit-level dynamically composable architecture for accelerating deep neural network,

    H. Sharma, J. Park, N. Suda, L. Lai, B. Chau, J. K. Kim, V . Chandra, and H. Esmaeilzadeh, “Bit fusion: Bit-level dynamically composable architecture for accelerating deep neural network,” in 2018 ACM/IEEE 45th Annual International Symposium on Computer Architecture (ISCA). IE...

    2018

  6. [14]

    14.5 en- vision: A 0.26-to-10tops/w subword-parallel dynamic-voltage-accuracy- frequency-scalable convolutional neural network processor in 28nm fdsoi,

    B. Moons, R. Uytterhoeven, W. Dehaene, and M. Verhelst, “14.5 en- vision: A 0.26-to-10tops/w subword-parallel dynamic-voltage-accuracy- frequency-scalable convolutional neural network processor in 28nm fdsoi,” in 2017 IEEE International Solid-State Circuits Conference (ISSCC),...

    2017

  7. [15]

    Bitblade: Area and energy- efficient precision-scalable neural network accelerator with bitwise summation,

    S. Ryu, H. Kim, W. Yi, and J.-J. Kim, “Bitblade: Area and energy- efficient precision-scalable neural network accelerator with bitwise summation,” in Proceedings of the 56th Annual Design Automation Conference 2019, 2019, pp. 1–6

    2019

  8. [16]

    Flexibit: Fully flexible precision bit-parallel accelerator architecture for arbitrary mixed precision ai,

    F. Tahmasebi, Y . Wang, B. Y . Huang, and H. Kwon, “Flexibit: Fully flexible precision bit-parallel accelerator architecture for arbitrary mixed precision ai,” arXiv preprint arXiv:2411.18065 , 2024

    2024 arXiv

  9. [17]

    Eq-net: Elastic quanti- zation neural networks,

    K. Xu, L. Han, Y . Tian, S. Yang, and X. Zhang, “Eq-net: Elastic quanti- zation neural networks,” in Proceedings of the IEEE/CVF International Conference on Computer Vision , 2023, pp. 1505–1514

    2023

  10. [18]

    Robust quantization: One model to rule them all,

    B. Chmiel, R. Banner, G. Shomron, Y . Nahshan, A. Bronstein, U. Weiser et al., “Robust quantization: One model to rule them all,” Advances in neural information processing systems , vol. 33, pp. 5308–5317, 2020

    2020

  11. [19]

    Multiquant: Training once for multi-bit quantization of neural networks

    K. Xu, Q. Feng, X. Zhang, and D. Wang, “Multiquant: Training once for multi-bit quantization of neural networks.” in IJCAI, 2022, pp. 3629– 3635

    2022

  12. [20]

    Mbquant: A novel multi-branch topology method for arbitrary bit-width network quantization,

    Y . Zhong, Y . Zhou, F. Chao, and R. Ji, “Mbquant: A novel multi-branch topology method for arbitrary bit-width network quantization,” arXiv preprint arXiv:2305.08117, 2023

    2023 arXiv

  13. [21]

    FlashAttention: Fast and memory-efficient exact attention with IO-awareness,

    T. Dao, D. Y . Fu, S. Ermon, A. Rudra, and C. R ´e, “FlashAttention: Fast and memory-efficient exact attention with IO-awareness,” in Advances in Neural Information Processing Systems , 2022

    2022

  14. [22]

    Any- precision deep neural networks,

    H. Yu, H. Li, Haoxiang opand Shi, T. S. Huang, and G. Hua, “Any- precision deep neural networks,” in Proceedings of the AAAI Conference on Artificial Intelligence , vol. 35, no. 12, 2021, pp. 10 763–10 771

    2021

  15. [23]

    A survey of quantization methods for efficient neural network infer- ence,

    A. Gholami, S. Kim, Z. Dong, Z. Yao, M. W. Mahoney, and K. Keutzer, “A survey of quantization methods for efficient neural network infer- ence,” in Low-Power Computer Vision. Chapman and Hall/CRC, 2022, pp. 291–326

    2022

  16. [24]

    Binary neural networks: A survey,

    H. Qin, R. Gong, X. Liu, X. Bai, J. Song, and N. Sebe, “Binary neural networks: A survey,” Pattern Recognition, vol. 105, p. 107281, 2020

    2020

  17. [25]

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

    B. Jacob, S. Kligys, B. Chen, M. Zhu, M. Tang, A. Howard, H. Adam, and D. Kalenichenko, “Quantization and training of neural networks for efficient integer-arithmetic-only inference,” in Proceedings of the IEEE conference on computer vision and pattern recognition, 2018, pp. 2...

    2018

  18. [26]

    Learned step size quantization,

    S. K. Esser, J. L. McKinstry, D. Bablani, R. Appuswamy, and D. S. Modha, “Learned step size quantization,” arXiv preprint arXiv:1902.08153, 2019

    1902 arXiv

  19. [27]

    Once quantization-aware training: High performance extremely low-bit architecture search,

    M. Shen, F. Liang, R. Gong, Y . Li, C. Li, C. Lin, F. Yu, J. Yan, and W. Ouyang, “Once quantization-aware training: High performance extremely low-bit architecture search,” in Proceedings of the IEEE/CVF International Conference on Computer Vision , 2021, pp. 5340–5349

    2021

  20. [28]

    Estimating or propagating gradients through stochastic neurons for conditional computation,

    Y . Bengio, N. L ´eonard, and A. Courville, “Estimating or propagating gradients through stochastic neurons for conditional computation,” arXiv preprint arXiv:1308.3432, 2013

    2013 arXiv

  21. [29]

    Dorefa-net: Training low bitwidth convolutional neural networks with low bitwidth gradients,

    S. Zhou, Y . Wu, Z. Ni, X. Zhou, H. Wen, and Y . Zou, “Dorefa-net: Training low bitwidth convolutional neural networks with low bitwidth gradients,” arXiv preprint arXiv:1606.06160 , 2016

    2016 arXiv

  22. [30]

    Nonuniform- to-uniform quantization: Towards accurate quantization via generalized straight-through estimation,

    Z. Liu, K.-T. Cheng, D. Huang, E. P. Xing, and Z. Shen, “Nonuniform- to-uniform quantization: Towards accurate quantization via generalized straight-through estimation,” in Proceedings of the IEEE/CVF Confer- ence on Computer Vision and Pattern Recognition, 2022, pp. 4942–4952

    2022

  23. [31]

    Understanding straight-through estimator in training activation quantized neural nets,

    P. Yin, J. Lyu, S. Zhang, S. Osher, Y . Qi, and J. Xin, “Understanding straight-through estimator in training activation quantized neural nets,” arXiv preprint arXiv:1903.05662 , 2019

    1903 arXiv

  24. [32]

    Deep residual learning for image recognition,

    K. He, X. Zhang, S. Ren, and J. Sun, “Deep residual learning for image recognition,” in Proceedings of the IEEE conference on computer vision and pattern recognition , 2016, pp. 770–778

    2016

  25. [33]

    Mobilenetv2: Inverted residuals and linear bottlenecks,

    M. Sandler, A. Howard, M. Zhu, A. Zhmoginov, and L.-C. Chen, “Mobilenetv2: Inverted residuals and linear bottlenecks,” in Proceedings of the IEEE conference on computer vision and pattern recognition , 2018, pp. 4510–4520

    2018

  26. [34]

    Imagenet classification with deep convolutional neural networks,

    A. Krizhevsky, I. Sutskever, and G. E. Hinton, “Imagenet classification with deep convolutional neural networks,” Advances in neural informa- tion processing systems , vol. 25, 2012

    2012

  27. [35]

    Learning multiple layers of features from tiny images,

    A. Krizhevsky, G. Hinton et al. , “Learning multiple layers of features from tiny images,” 2009

    2009

  28. [36]

    Imagenet: A large-scale hierarchical image database,

    J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei, “Imagenet: A large-scale hierarchical image database,” in 2009 IEEE conference on computer vision and pattern recognition . Ieee, 2009, pp. 248–255

    2009

  29. [37]

    Reading digits in natural images with unsupervised feature learning,

    Y . Netzer, T. Wang, A. Coates, A. Bissacco, B. Wu, A. Y . Ng et al. , “Reading digits in natural images with unsupervised feature learning,” in NIPS workshop on deep learning and unsupervised feature learning , vol. 2011, no. 5. Granada, Spain, 2011, p. 7

    2011

  30. [38]

    Timeloop: A systematic approach to dnn accelerator evaluation,

    A. Parashar, P. Raina, Y . S. Shao, Y .-H. Chen, V . A. Ying, A. Mukkara, R. Venkatesan, B. Khailany, S. W. Keckler, and J. Emer, “Timeloop: A systematic approach to dnn accelerator evaluation,” in 2019 IEEE inter- national symposium on performance analysis of systems and soft...

    2019

  31. [39]

    Eyeriss: An energy- efficient reconfigurable accelerator for deep convolutional neural net- works,

    Y .-H. Chen, T. Krishna, J. S. Emer, and V . Sze, “Eyeriss: An energy- efficient reconfigurable accelerator for deep convolutional neural net- works,” IEEE journal of solid-state circuits, vol. 52, no. 1, pp. 127–138, 2016

    2016

Pith tools

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