EfficientQuant: An Efficient Post-Training Quantization for CNN-Transformer Hybrid Models on Edge Devices

Lanyu Xu; Shaibal Saha

REVIEW 4 major objections 4 minor 31 references

EfficientQuant: An Efficient Post-Training Quantization for CNN-Transformer Hybrid Models on Edge Devices

T0 review · 4 major / 4 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 This paper proposes EfficientQuant, a structure-aware post-training quantization method that applies uniform quantization to convolutional weights and log2 quantization to transformer post-softmax activations, reporting 2.5×–8.7× latency…

desk verdict The accuracy story is plausible, but the quantization as described cannot produce the claimed speedups because weights and activations are dequantized back to FP32, and the edge latency table is internally inconsistent. read the letter →

arxiv 2506.11093 v1 pith:E2PHZ6JO submitted 2025-06-05 cs.CV

Shaibal Saha , Lanyu Xu This is my paper

classification cs.CV

keywords EfficientQuantpost-trainingquantizationCNN-transformerhybridmodelsMobileViTlog2edgeinferenceTensorRTImageNet-1K

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

EfficientQuant sets out to make CNN-transformer hybrid models such as MobileViT and MobileViTv2 deployable on edge hardware by quantizing them after training, with no retraining. The paper observes that convolutional weights in these models are roughly uniformly distributed while transformer post-softmax activations follow a power-law pattern, and it assigns a matching quantizer to each: uniform 8-bit quantization for convolutional weights, and $\log_2$ quantization for transformer activations. On ImageNet-1K it reports 2.5×–8.7× lower latency than the Q-HyViT baseline on an RTX 3080, with top-1 accuracy within about 0.4–6 percentage points of the FP32 models, and it demonstrates deployments on Jetson Nano and AGX Xavier. If those numbers hold, hybrid models could run on resource-constrained devices with near-full accuracy and a large speed gain.

What carries the argument

The load-bearing mechanism is a structure-aware block-identification pass followed by type-specific quantization. A depth-first traversal with a queue classifies each module as convolutional or transformer based on layer names such as 'Conv2d', 'Linear', 'attn', and 'Attention', returning two lists. Convolutional weights are quantized with min-max uniform quantization using $\Delta_W = (W_{\max} - W_{\min})/(2^b - 1)$ and $Z_W = \mathrm{round}(-W_{\min}/\Delta_W)$, then dequantized back to floating point before inference (Equation 3). Transformer post-softmax activations are quantized on a $\log_2$ scale via $A_{\mathrm{quantized}} = \mathrm{clamp}(\lfloor (-\log_2(a+\epsilon))/\Delta_{\log} + Z_a \rceil, 0, 2^b-1)$, with $\epsilon = 10^{-5}$ to avoid $\log(0)$, and dequantized as $2^{(A_{\mathrm{quantized}} - Z_a)\Delta_{\log}}$. The intended role of this pairing is to match the quantizer to the observed distribution so that accuracy is preserved while the model becomes hardware-friendly.

What would settle it

Run the same MobileViT and MobileViTv2 models in TensorRT with identical engine settings and batch size, once with EfficientQuant applied and once with the original FP32 model, and profile whether any convolutional layer actually executes in 8-bit integer arithmetic. If the unquantized engine is equally fast, or if the quantized engine shows no INT8 convolution, then the 2.5×–8.7× speedup cannot be attributed to the quantization scheme.

Watch

Extended reading notes

Core claim

On its own terms, the paper's central claim is that a single structural rule—uniform quantization for convolutional weights, $\log_2$ quantization for transformer post-softmax activations—is enough to compress hybrid vision models after training. Across MobileViT and MobileViTv2 variants, EfficientQuant reports top-1 ImageNet-1K accuracy within roughly 0.4–6 percentage points of the unquantized models, with the largest drops on the smallest variants and under one point on the largest. Against existing hybrid PTQ methods, it reports 2.5×–8.7× lower latency than Q-HyViT and up to 3.85× lower than HyQ on an RTX 3080, while scaling to MobileViTv2 variants that HyQ does not support. The paper presents this as evidence that structure-aware type-specific quantization is sufficient for practical edge deployment of hybrid models.

Load-bearing premise

The speedups reported in the paper are caused by EfficientQuant's quantization choices rather than by the TensorRT engine's own optimizations, even though the paper's equations restore convolutional weights to full precision before inference and no ablation separates the quantization from the engine effects.

Editorial extensions

If this is right

MobileViT and MobileViTv2 can be quantized after training to within about 0.4–6 percentage points of FP32 top-1 accuracy on ImageNet-1K, with larger variants losing under one point.
Latency on an RTX 3080 falls 2.5×–8.7× relative to Q-HyViT and up to 3.85× relative to HyQ, making latency-sensitive hybrid inference feasible.
The method covers the full MobileViTv2 family (050–200), including variants that the HyQ baseline cannot run, so it removes a scalability gap in hybrid PTQ.
Only a small calibration set (batch size 32) and no retraining are needed, which fits deployment pipelines where quantization-aware training is too costly.
On edge hardware the paper reports average memory use of roughly 2.3–2.6 GiB and acceptable engine load times, supporting static edge deployment.

Reading between the lines

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

Because the paper's own equations dequantize convolutional weights to FP32 before inference, the reported speedups are probably dominated by TensorRT engine optimizations rather than by the quantization itself; an editor-level reading is that the missing ablation is the real experiment needed.
The block-identification pass keys on layer names such as 'attn' and 'Attention', so models that rename or wrap these modules could silently fall back to no quantization, making the method's portability depend on naming conventions.
The $\log_2$ activation quantizer is not tied to hybrid architectures and could transfer to pure transformer models whose post-softmax attention maps have the same power-law shape; the paper does not test this.
Without an unquantized FP32 baseline on Jetson Nano and AGX Xavier, the absolute latency and memory figures reported on edge devices do not establish an advantage over plain TensorRT deployment; that comparison is the missing baseline.

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.

Desk Editor's Note

read the letter

Colleague, here's my take on EfficientQuant. It's a workshop paper with a modest, understandable idea: use uniform quantization for conv weights and log2 quantization for transformer post-softmax activations, and detect which blocks are which by walking the module tree. The structure detector is trivial but fine. The accuracy table is plausible and shows the method holds up reasonably across MobileViT variants; the authors honestly report that small variants lose more accuracy. That part is fine.

The problem is the central latency claim. Their own Section 2.2 says weights are restored to FP32 during inference (Equation 3), and the activations are dequantized too (Equation 6). So the model still computes in FP32. There is no way the quantization itself reduces arithmetic or memory traffic by 2.5x–8.7x. The speedups they report are almost certainly from TensorRT engine optimizations, not from their method. They provide no ablation that isolates the quantization from TensorRT, and no edge-device baselines at all. The RTX 3080 comparisons re-evaluate baselines, but it's not clear that the baselines ran under the same engine precision and TensorRT version.

There's also a straightforward internal inconsistency in Section 3.3: they say Jetson Nano is 3x–5x slower than AGX Xavier, but the reported averages are 17.8 ms for Jetson Nano and 40.7 ms for AGX Xavier. That inverts the claimed ordering. The underlying latency table isn't shown. This is the kind of number that should make an editor pause.

So the load-bearing claim is not supported. The accuracy numbers alone don't rescue it, and there is no code to check. The paper is not a total waste—the distribution observation and the per-block quantization recipe might be useful to someone—but as written, the main result doesn't hold together. I would not send this to peer review; it needs a major rewrite and real experiments that separate the quantization from the engine optimizations. If the authors can show a speedup with a matching FP32 TensorRT baseline and fix the latency table, there might be a decent workshop paper underneath.

Referee Report

4 major / 4 minor

Summary. The paper proposes EfficientQuant, a post-training quantization method aimed at CNN-transformer hybrid models such as MobileViT and MobileViTv2. The method applies uniform quantization to convolutional weights and log2-based quantization to post-softmax transformer activations, guided by an automated structure-aware block identification algorithm. The authors report top-1 accuracy results on ImageNet-1K, latency comparisons against several PTQ baselines on an RTX 3080, and latency/memory measurements on AGX Xavier and Jetson Nano edge devices. The paper's central claim is that EfficientQuant achieves a 2.5x to 8.7x latency reduction with minimal accuracy loss, making hybrid models practical for edge deployment.

Significance. The proposed idea of tailoring quantization schemes to block type in hybrid models is reasonable and the accuracy table, if correctly measured, suggests the method is competitive in preserving accuracy. The automated structure-aware block identification is a useful engineering contribution, and the paper attempts to evaluate on real edge hardware, which is commendable. However, the primary significance claim, the large latency speedup, is not supported by the evidence. The paper's own description indicates that convolutional weights are dequantized back to FP32 before use, and activations are also dequantized, so the inference computation remains FP32. No ablation separates the effect of EfficientQuant from TensorRT engine-level optimizations, and no code is provided. The internal inconsistency in the edge-device latency numbers further undermines the empirical claims. Therefore, while the accuracy results may be of interest, the headline latency contribution is not established.

major comments (4)

[Section 2.2, Equation (3)] Equation (3) explicitly dequantizes convolutional weights back to FP32, and the text states that weights are restored to floating-point precision during inference. This means convolutional arithmetic remains FP32 and the 8-bit uniform weight quantization cannot reduce multiply-accumulate cost or memory traffic during actual inference under the described scheme. Some speedup could in principle arise if dequantized weights were reused across many inputs, but the paper does not describe such reuse or measure it separately. Therefore the reported 2.5x-8.7x latency reduction cannot be attributed to the proposed quantization without additional evidence.
[Section 3.2 and Section 3.3] The latency comparisons are not controlled for implementation backend. All methods are said to be accelerated with TensorRT, but the paper does not state whether the baselines (Q-HyViT and HyQ) were converted into TensorRT engines with the same precision settings, TensorRT version, and engine calibration as EfficientQuant. Section 3.3 explicitly says no baseline comparisons are available on edge devices. Without an ablation that isolates TensorRT engine-level optimizations from EfficientQuant's quantization scheme, the reported speedups are confounded and could be an artifact of engine configuration or implementation differences.
[Section 3.3, latency paragraph] The reported average inference times are internally inconsistent. The text states that Jetson Nano is 3x to 5x slower than AGX Xavier, yet the reported averages are 40.7 ms on AGX Xavier and 17.8 ms on Jetson Nano, meaning Jetson Nano is about 2.3x faster than AGX Xavier according to these numbers. This contradiction undermines the credibility of the edge-device latency measurements and prevents any reliable conclusion about relative device performance.
[Section 3.1, epsilon and calibration] The stability constant epsilon for log2 quantization is set to 1e-5 based on trial and error on the target models and the ImageNet-1K dataset, and the quantization ranges are calibrated on a batch from the same ImageNet-1K distribution used for evaluation. This is a mild circularity concern for the accuracy numbers and should be addressed, for example by reporting sensitivity to epsilon and by calibrating on a disjoint distribution or clearly separating calibration from test performance.

minor comments (4)

[Abstract and Section 1] The text contains duplicated and rephrased sentences in the introduction, such as the repeated statement about choosing weight quantization for convolutional blocks and activation quantization for transformer blocks; this should be cleaned up.
[Section 2.2, Equations (1)-(3)] The quantization formula in Equation (2) does not explicitly show the rounding operation before clamping, even though Equation (1) uses a round operation for the zero point. Please clarify whether Wquantized is rounded to integers or kept as a real-valued rescaling.
[Section 3.3, memory paragraph] The text says that memory differences are approximately 2%, but the reported averages (2568 MiB, 2344 MiB, 2265 MiB) differ by roughly 9% between RTX 3080 and AGX Xavier and by about 3.4% between AGX Xavier and Jetson Nano; please correct this characterization.
[General] The paper would benefit from a statement on code and configuration availability; no code link or detailed TensorRT configuration is provided, which hampers reproducibility of the latency claims.

Circularity Check

0 steps flagged · score 0.0 of 10

No circular derivation: EfficientQuant is an empirical PTQ recipe with standard calibration; reported speedups and accuracy are measurements, not consequences of a self-referential chain.

full rationale

The paper does not contain a derivation chain in which a predicted quantity is defined in terms of itself or in which a fitted parameter is renamed as a prediction. EfficientQuant's quantization choices (uniform for conv weights, log2 for post-Softmax activations) are justified empirically by observed weight and activation distributions, and the quantization parameters are obtained from min/max calibration statistics and a tuned epsilon. These are standard PTQ practices, not circular inputs. Accuracy and latency are measured on ImageNet-1K and TensorRT engines, respectively, rather than derived from the method's assumptions. The dequantization of weights back to FP32 (Eq. 3) and the lack of a TensorRT-matched ablation are serious threats to the causal attribution of the speedup, but these are correctness/experimental-design issues, not circularity. The only self-citation ([26], a survey by the same authors) is not load-bearing. No uniqueness theorem is imported from prior work, no ansatz is smuggled in via citation, and no known result is merely renamed. Calibrating on ImageNet-1K and evaluating on ImageNet-1K validation can inflate accuracy figures, but that is an evaluation-overlap concern rather than a circular derivation. Consequently, no circular step can be identified from the paper's own equations or citations.

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

The central claim rests on several unvalidated empirical premises (weight/activation distribution shapes, dequantized fake quantization still speeding up inference) and one tuned constant (epsilon). There are no invented physical or architectural entities.

free parameters (2)

epsilon (log2 quantization stability constant) = 1e-5
Added in Equation 5 to avoid log(0); the paper states in Section 2.3 that 1e-5 was selected 'based on trial and error' and that smaller values increase errors while larger values distort small values.
quantization bit-width b = 8
The paper fixes b=8 for both quantizers (Section 2.2 and 2.3). This is a hand-chosen parameter, though common in PTQ; it affects the reported accuracy and latency.

assumptions (4)

domain assumption Convolutional weights in hybrid models are approximately uniformly distributed
Figure 2 shows a histogram for one block of MobileViT-s; the paper generalizes to all convolutional blocks without statistical testing.
domain assumption Post-softmax activations follow a power-law distribution
Figure 3 shows a single histogram of post-softmax activations; the log2 quantizer design depends on this shape.
ad hoc to paper Dequantizing weights back to FP32 still permits large inference speedups via TensorRT
Section 2.2 dequantizes weights before computation; no mechanism or experiment explains how this yields latency reduction.
standard math Standard quantization and logarithmic identities are valid
Equations 1-6 rely on standard min-max quantization and log2 arithmetic.

how reviews work

0 comments

Cite this review

Pith. "Pith review of EfficientQuant: An Efficient Post-Training Quantization for CNN-Transformer Hybrid Models on Edge Devices." pith.science (2026). https://pith.science/paper/E2PHZ6JO

@misc{pith2026250611093,
  author       = {Pith},
  title        = {Pith review of: EfficientQuant: An Efficient Post-Training Quantization for CNN-Transformer Hybrid Models on Edge Devices},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/E2PHZ6JO}},
  note         = {Machine review of arXiv:2506.11093}
}

abstract

Hybrid models that combine convolutional and transformer blocks offer strong performance in computer vision (CV) tasks but are resource-intensive for edge deployment. Although post-training quantization (PTQ) can help reduce resource demand, its application to hybrid models remains limited. We propose EfficientQuant, a novel structure-aware PTQ approach that applies uniform quantization to convolutional blocks and $log_2$ quantization to transformer blocks. EfficientQuant achieves $2.5 \times - 8.7 \times$ latency reduction with minimal accuracy loss on the ImageNet-1K dataset. It further demonstrates low latency and memory efficiency on edge devices, making it practical for real-world deployment.

Figures

Figures reproduced from arXiv: 2506.11093 by the authors.

**Figure 2.** Weight distribution of a convolutional block on MobileViT s model. Frequency 100 10000 Activations 0 0.02 0.04 0.06 0.07 0.09 [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗

**Figure 4.** The overview of the EfficientQuant to perform uniform [PITH_FULL_IMAGE:figures/full_fig_p002_4.png] view at source ↗

Figures from the paper (2 more)

**Figure 6.** Figure 6: Load time of MobileViT models on edge devices with [PITH_FULL_IMAGE:figures/full_fig_p004_6.png]

**Figure 7.** Figure 7: Inference time of MobileViT models on edge devices [PITH_FULL_IMAGE:figures/full_fig_p004_7.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

31 extracted references · 21 canonical work pages

[1]

Quantization-aware policy distillation (qpd)

Thomas Av´e, Kevin Mets, Tom De Schepper, and Steven Latr´e. Quantization-aware policy distillation (qpd). InDeep Reinforcement Learning Workshop, NeurIPS 2022, 9 Decem- ber, 2022, pages 1–15, 2022. 1

work page 2022
[2]

Once-for-all: Train one network and specialize it for efficient deployment.arXiv preprint arXiv:1908.09791,

Han Cai, Chuang Gan, Tianzhe Wang, Zhekai Zhang, and Song Han. Once-for-all: Train one network and specialize it for efficient deployment.arXiv preprint arXiv:1908.09791,

arXiv 1908
[3]

Pact: Parameterized clipping activation for quantized neural networks.arXiv preprint arXiv:1805.06085,

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

arXiv
[4]

Low-bit quantization of neural networks for efficient infer- ence

Yoni Choukroun, Eli Kravchik, Fan Yang, and Pavel Kisilev. Low-bit quantization of neural networks for efficient infer- ence. In2019 IEEE/CVF International Conference on Com- puter Vision Workshop (ICCVW), pages 3009–3018. IEEE,

work page
[5]

Imagenet: A large-scale hierarchical image database

Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In2009 IEEE Conference on Computer Vision and Pattern Recognition, pages 248–255, 2009. 3, 4

work page 2009
[6]

An image is worth 16x16 words: Trans- formers for image recognition at scale.arXiv preprint arXiv:2010.11929, 2020

Alexey Dosovitskiy. An image is worth 16x16 words: Trans- formers for image recognition at scale.arXiv preprint arXiv:2010.11929, 2020. 1

arXiv 2010
[7]

A survey of quan- tization methods for efficient neural network inference

Amir Gholami, Sehoon Kim, Zhen Dong, Zhewei Yao, Michael W Mahoney, and Kurt Keutzer. A survey of quan- tization methods for efficient neural network inference. In Low-Power Computer Vision, pages 291–326. Chapman and Hall/CRC, 2022. 1

2022
[8]

HPTQ: Hardware-Friendly Post Training Quantization

Hai Victor Habi, Reuven Peretz, Elad Cohen, Lior Dikstein, Oranit Dror, Idit Diamant, Roy H Jennings, and Arnon Netzer. Hptq: Hardware-friendly post training quantization.arXiv preprint arXiv:2109.09113, 2021. 1

work page Pith review arXiv 2021

Show all 31 references

[9]

Unetr: Transformers for 3d medical image segmentation

Ali Hatamizadeh, Yucheng Tang, Vishwesh Nath, Dong Yang, Andriy Myronenko, Bennett Landman, Holger R Roth, and Daguang Xu. Unetr: Transformers for 3d medical image segmentation. InProceedings of the IEEE/CVF winter con- ference on applications of computer vision, pages 574–584,
[10]

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. InProceed- ings of the IEEE conference on computer vision a...

2018
[11]

Learning to quantize deep networks by optimizing quantization intervals with task loss

Sangil Jung, Changyong Son, Seohyung Lee, Jinwoo Son, Jae- Joon Han, Youngjun Kwak, Sung Ju Hwang, and Changkyu Choi. Learning to quantize deep networks by optimizing quantization intervals with task loss. InProceedings of the IEEE/CVF conference on computer vision and pattern...

2019
[12]

Hyq: Hardware- friendly post-training quantization for cnn-transformer hybrid networks

Nam Joon Kim, Jongho Lee, and Hyun Kim. Hyq: Hardware- friendly post-training quantization for cnn-transformer hybrid networks. InProceedings of the Thirty-Third International Joint Conference on Artificial Intelligence, IJCAI-24, pages 4291–4299. International Joint Conferenc...

2024
[13]

Im- agenet classification with deep convolutional neural networks

Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Im- agenet classification with deep convolutional neural networks. Communications of the ACM, 60(6):84–90, 2017. 1

2017
[14]

Q-hyvit: Post-training quantization of hybrid vision transformers with bridge block reconstruction for iot systems.IEEE Internet of Things Journal, 2024

Jemin Lee, Yongin Kwon, Sihyeong Park, Misun Yu, Jeman Park, and Hwanjun Song. Q-hyvit: Post-training quantization of hybrid vision transformers with bridge block reconstruction for iot systems.IEEE Internet of Things Journal, 2024. 1, 3, 4

2024
[15]

Quantization for rapid deployment of deep neural networks.arXiv preprint arXiv:1810.05488, 2018

Jun Haeng Lee, Sangwon Ha, Saerom Choi, Won-Jo Lee, and Seungwon Lee. Quantization for rapid deployment of deep neural networks.arXiv preprint arXiv:1810.05488, 2018. 1

2018 arXiv
[16]

Efficient- former: Vision transformers at mobilenet speed.Advances in Neural Information Processing Systems, 35:12934–12949,

Yanyu Li, Geng Yuan, Yang Wen, Ju Hu, Georgios Evange- lidis, Sergey Tulyakov, Yanzhi Wang, and Jian Ren. Efficient- former: Vision transformers at mobilenet speed.Advances in Neural Information Processing Systems, 35:12934–12949,
[17]

Re- thinking vision transformers for mobilenet size and speed

Yanyu Li, Ju Hu, Yang Wen, Georgios Evangelidis, Kamyar Salahi, Yanzhi Wang, Sergey Tulyakov, and Jian Ren. Re- thinking vision transformers for mobilenet size and speed. In Proceedings of the IEEE international conference on com- puter vision, 2023. 1

2023
[18]

Bevformer: Learn- ing bird’s-eye-view representation from multi-camera images via spatiotemporal transformers

Zhiqi Li, Wenhai Wang, Hongyang Li, Enze Xie, Chonghao Sima, Tong Lu, Yu Qiao, and Jifeng Dai. Bevformer: Learn- ing bird’s-eye-view representation from multi-camera images via spatiotemporal transformers. InEuropean conference on computer vision, pages 1–18. Springer, 2022. 1, 2

2022
[19]

Repq- vit: Scale reparameterization for post-training quantization of vision transformers

Zhikai Li, Junrui Xiao, Lianwei Yang, and Qingyi Gu. Repq- vit: Scale reparameterization for post-training quantization of vision transformers. InProceedings of the IEEE/CVF International Conference on Computer Vision, pages 17227– 17236, 2023. 3, 4

2023
[20]

Edgenext: efficiently amalga- mated cnn-transformer architecture for mobile vision appli- cations

Muhammad Maaz, Abdelrahman Shaker, Hisham Cholakkal, Salman Khan, Syed Waqas Zamir, Rao Muhammad Anwer, and Fahad Shahbaz Khan. Edgenext: efficiently amalga- mated cnn-transformer architecture for mobile vision appli- cations. InEuropean conference on computer vision, pages 3–...

2022
[21]

Mobilevit: light- weight, general-purpose, and mobile-friendly vision trans- former.arXiv preprint arXiv:2110.02178, 2021

Sachin Mehta and Mohammad Rastegari. Mobilevit: light- weight, general-purpose, and mobile-friendly vision trans- former.arXiv preprint arXiv:2110.02178, 2021. 1, 2

2021 arXiv
[22]

Separable self- attention for mobile vision transformers.arXiv preprint arXiv:2206.02680, 2022

Sachin Mehta and Mohammad Rastegari. Separable self- attention for mobile vision transformers.arXiv preprint arXiv:2206.02680, 2022. 1

2022 arXiv
[23]

Intriguing properties of vision transform- ers.Advances in Neural Information Processing Systems, 34: 23296–23308, 2021

Muhammad Muzammal Naseer, Kanchana Ranasinghe, Salman H Khan, Munawar Hayat, Fahad Shahbaz Khan, and Ming-Hsuan Yang. Intriguing properties of vision transform- ers.Advances in Neural Information Processing Systems, 34: 23296–23308, 2021. 1

2021
[24]

An approximate memory architecture for en- ergy saving in deep learning applications.IEEE Transactions on Circuits and Systems I: Regular Papers, 67(5):1588–1601,

Duy Thanh Nguyen, Nguyen Huy Hung, Hyun Kim, and Hyuk-Jae Lee. An approximate memory architecture for en- ergy saving in deep learning applications.IEEE Transactions on Circuits and Systems I: Regular Papers, 67(5):1588–1601,
[25]

TensorRT

NVIDIA. TensorRT. https://developer.nvidia. com/tensorrt/, 2021. Retrieved July 1, 2021. 3

2021
[26]

Vision transformers on the edge: A comprehensive survey of model compression and acceleration strategies.Neurocomputing, page 130417, 2025

Shaibal Saha and Lanyu Xu. Vision transformers on the edge: A comprehensive survey of model compression and acceleration strategies.Neurocomputing, page 130417, 2025. 1

2025
[27]

Pytorch image models

Ross Wightman. Pytorch image models. https : / / github . com / rwightman / pytorch - image - models, 2019. 3

2019
[28]

Easyquant: Post-training quantization via scale optimization.arXiv preprint arXiv:2006.16669, 2020

Di Wu, Qi Tang, Yongle Zhao, Ming Zhang, Ying Fu, and Debing Zhang. Easyquant: Post-training quantization via scale optimization.arXiv preprint arXiv:2006.16669, 2020. 3, 4

2006 arXiv
[29]

Adalog: Post-training quantization for vision transformers with adaptive logarithm quantizer.arXiv preprint arXiv:2407.12951, 2024

Zhuguanyu Wu, Jiaxin Chen, Hanwen Zhong, Di Huang, and Yunhong Wang. Adalog: Post-training quantization for vision transformers with adaptive logarithm quantizer.arXiv preprint arXiv:2407.12951, 2024. 1

2024 arXiv
[30]

Ptq4vit: Post-training quantization for vision transformers with twin uniform quantization

Zhihang Yuan, Chenhao Xue, Yiqi Chen, Qiang Wu, and Guangyu Sun. Ptq4vit: Post-training quantization for vision transformers with twin uniform quantization. InEuropean conference on computer vision, pages 191–207. Springer,
[31]

Improving neural network quantization without retraining using outlier channel splitting

Ritchie Zhao, Yuwei Hu, Jordan Dotzel, Chris De Sa, and Zhiru Zhang. Improving neural network quantization without retraining using outlier channel splitting. InInternational conference on machine learning, pages 7543–7552. PMLR,

Pith tools

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

[1] [1]

Quantization-aware policy distillation (qpd)

Thomas Av´e, Kevin Mets, Tom De Schepper, and Steven Latr´e. Quantization-aware policy distillation (qpd). InDeep Reinforcement Learning Workshop, NeurIPS 2022, 9 Decem- ber, 2022, pages 1–15, 2022. 1

work page 2022

[2] [2]

Once-for-all: Train one network and specialize it for efficient deployment.arXiv preprint arXiv:1908.09791,

Han Cai, Chuang Gan, Tianzhe Wang, Zhekai Zhang, and Song Han. Once-for-all: Train one network and specialize it for efficient deployment.arXiv preprint arXiv:1908.09791,

arXiv 1908

[3] [3]

Pact: Parameterized clipping activation for quantized neural networks.arXiv preprint arXiv:1805.06085,

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

arXiv

[4] [4]

Low-bit quantization of neural networks for efficient infer- ence

Yoni Choukroun, Eli Kravchik, Fan Yang, and Pavel Kisilev. Low-bit quantization of neural networks for efficient infer- ence. In2019 IEEE/CVF International Conference on Com- puter Vision Workshop (ICCVW), pages 3009–3018. IEEE,

work page

[5] [5]

Imagenet: A large-scale hierarchical image database

Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In2009 IEEE Conference on Computer Vision and Pattern Recognition, pages 248–255, 2009. 3, 4

work page 2009

[6] [6]

An image is worth 16x16 words: Trans- formers for image recognition at scale.arXiv preprint arXiv:2010.11929, 2020

Alexey Dosovitskiy. An image is worth 16x16 words: Trans- formers for image recognition at scale.arXiv preprint arXiv:2010.11929, 2020. 1

arXiv 2010

[7] [7]

A survey of quan- tization methods for efficient neural network inference

Amir Gholami, Sehoon Kim, Zhen Dong, Zhewei Yao, Michael W Mahoney, and Kurt Keutzer. A survey of quan- tization methods for efficient neural network inference. In Low-Power Computer Vision, pages 291–326. Chapman and Hall/CRC, 2022. 1

2022

[8] [8]

HPTQ: Hardware-Friendly Post Training Quantization

Hai Victor Habi, Reuven Peretz, Elad Cohen, Lior Dikstein, Oranit Dror, Idit Diamant, Roy H Jennings, and Arnon Netzer. Hptq: Hardware-friendly post training quantization.arXiv preprint arXiv:2109.09113, 2021. 1

work page Pith review arXiv 2021