Pith. sign in

REVIEW 4 major objections 8 minor 29 references

PoTPTQ: A Two-step Power-of-Two Post-training for LLMs

T0 review · 4 major / 8 minor · reviewed 2026-08-06 · deepseek-v4-flash

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

Pith's one-line read This paper claims that power-of-two quantization, with per-group scale initialization and calibration, beats uniform-quantization baselines at 2-3 bits for LLaMA models and dequantizes up to 3.67x faster on GPUs.

desk verdict Plausible two-step PoT PTQ with a faster dequant kernel, but the write-up has internal inconsistencies and the SOTA claim needs tempering. read the letter →

arxiv 2507.11959 v1 pith:2EIMENSK submitted 2025-07-16 cs.CL cs.AIcs.LG

Xinyu Wang , Vahid Partovi Nia , Peng Lu , Jerry Huang , Xiao-Wen Chang , Boxing Chen , Yufei Cui This is my paper · ORCID
classification cs.CLcs.AIcs.LG
keywords power-of-twoquantizationpost-trainingweight-onlylargelanguagemodelslow-bitprecisionGPUdequantizationscalecalibrationperplexity
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

Large language models are usually compressed by rounding weights to evenly spaced integer levels, an allocation that matches neither the bell-shaped distribution of real weights nor the floating-point cost of dequantizing them for inference. This paper argues that quantizing weights to signed powers of two can fix both problems, provided each group of weights gets a carefully chosen scale. It proposes a two-step post-training recipe: a data-free grid search that selects each group's scale to minimize local weight-reconstruction error, followed by a light fine-tuning of the scales on 128 calibration sequences so that each quantized layer's outputs match the original layer's outputs. On LLaMA-1 and LLaMA-2 models at 2.25 and 3.25 average bits, the method reports lower WikiText-2 perplexity than GPTQ, AWQ, and OmniQuant, and its GPU kernel rebuilds PoT weights with bit shifts and integer addition instead of floating-point arithmetic, running up to 3.67x faster than uniform integer dequantization. If those results survive contact with other data, power-of-two quantization becomes a practical way to run large models on smaller hardware.

What carries the argument

The load-bearing mechanism is the two-step scale-selection pipeline: a data-agnostic grid search over multipliers $b \in \{0.01, 0.02, \dots, 2\}$ that sets each group's initial scale by minimizing the group-wise PoT reconstruction error, followed by a per-group multiplicative residual $\Gamma$ on the scale, trained through the straight-through estimator against the layer-wise output-alignment loss of equation (14). This two-step design is what navigates the non-smooth, staircase-shaped error surface that makes gradient-based scale selection in pure PoT quantization unreliable. The companion mechanism is the dequantization kernel, which stores each quantized weight as a sign bit and an exponent field and reconstructs the FP16 value by bitwise assembly followed by fixed-point integer addition into a precomputed FP16 scale, so a multiplication by $2^E$ becomes an integer add into the exponent bits.

What would settle it

Quantize a model after calibrating on a different domain, such as 128 sequences from C4 or code, then measure WikiText-2 perplexity and downstream-task scores at 2.25 bits; if the reported advantage over OmniQuant shrinks to noise or reverses, the generalization claim is not established. Separately, benchmark a full transformer layer end-to-end with the PoT dequantization kernel inside the GEMM pipeline, since the published 3.67x and 1.63x figures are kernel-level warp-cycle counts for the dequantization step alone.

Watch

Extended reading notes

Core claim

The paper's central claim is that previous power-of-two (PoT) quantization failed on LLMs not because of the representation, but because its scaling factors were set badly, and that a dedicated two-step post-training algorithm fixes the problem. Step 1 treats the scale of each group of weights as a free parameter and picks it by a parallel grid search over multipliers, minimizing the squared error between the original weights and their PoT reconstruction; Step 2 multiplies each group's scale by a small learnable residual $\Gamma$ and tunes that residual with the straight-through estimator against the layer-wise output reconstruction loss $\mathcal{Q}_2(\Gamma)$ of equation (14), using 128 sequences from WikiText-2. The paper further claims that because a quantized weight is just a sign bit times $2^E$ times a shared scale, dequantization can be done with AND/OR masks and fixed-point integer addition that injects the exponent directly into the exponent field of a precomputed FP16 scale, eliminating floating-point arithmetic. Across LLaMA-1 and LLaMA-2 at 2.25 and 3.25 average bits, the method reports the best perplexity among the compared post-training quantizers, matches or beats OmniQuant on six downstream harness tasks, and measures 3.67x and 1.63x faster dequantization than uniform integer dequantization on a V100 and an RTX 4090.

Load-bearing premise

The load-bearing premise is that minimizing each layer's output error on 128 WikiText-2 sequences — the same corpus on which perplexity is then reported — is a faithful proxy for preserving the full model's quality on the data users actually generate and evaluate.

Editorial extensions

If this is right

  • At 2.25 and 3.25 average bits, LLaMA-1 and LLaMA-2 models quantized this way reach lower WikiText-2 perplexity than RTN, GPTQ, AWQ, and OmniQuant, making extreme low-bit weight-only deployment practical without retraining.
  • The improvement carries over to downstream tasks: on the six Open LLM Leaderboard harness benchmarks the method matches or beats OmniQuant on most tasks and posts a higher average score in nearly every setting.
  • The whole pipeline runs on one V100 in about 43 minutes for LLaMA-7B using only 128 calibration sequences, so the recipe fits deployment workflows that cannot afford retraining or multi-GPU calibration.
  • Because dequantization is reduced to bit masks and fixed-point integer addition into a precomputed FP16 scale, no floating-point multiply is needed to reconstruct weights, which is what produces the 3.67x and 1.63x kernel speedups on the V100 and RTX 4090.
  • Porting uniform PTQ methods straight onto PoT levels degrades accuracy sharply — GPTQ-PoT, for instance, collapses to perplexities above $10^4$ at 2.125 bits — which the paper takes as evidence that scale handling, not the format itself, was the missing ingredient.

Reading between the lines

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

  • Because the calibration set and the perplexity evaluation both come from WikiText-2, the reported accuracy lead is partly a same-distribution result; a natural test would calibrate on a different domain, such as C4 or code, and evaluate out-of-domain to see how much of the gap survives.
  • The dequantization speedups are reported as kernel-level warp-cycle counts for the dequantization step alone, so whether they become end-to-end speedups depends on the share of latency the dequantization occupies inside real GEMM layers, which the paper does not measure.
  • The scale-tuning recipe treats the quantization levels generically through a sign-and-exponent encoding, so the same grid-search-plus-residual calibration could plausibly be applied to other low-bit formats, including formats with a zero level or subnormal-like spacing.
  • Because Step 2 learns only one scalar per weight group, the same output-alignment objective could be run during fine-tuning itself, which would turn the post-training recipe into a drop-in quantization-aware training schedule.
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

4 major / 8 minor

Summary. The paper proposes PoTPTQ, a weight-only post-training quantization method for LLMs that constrains weights to signed powers of two. The method has two steps: a data-agnostic grid search over per-group scales (Section 3.2), and a data-dependent refinement of those scales by matching transformer-block outputs on 128 WikiText-2 sequences (Section 3.3). The paper also describes a GPU dequantization kernel using bit manipulation and integer addition (Section 4). Experiments are reported on LLaMA1/Llama2 at 2- and 3-bit precisions: WikiText-2 perplexity (Table 1), a six-task harness comparison with OmniQuant (Table 3), ablations (Table 4), and kernel cycle counts (Table 6). The abstract claims state-of-the-art accuracy at low precision and 3.67x/1.63x dequantization speedups.

Significance. If the accuracy results survive held-out evaluation, the contribution would be useful: the two-step scale initialization and refinement is simple and computationally light, and the integer-based dequantization is a plausible direction for low-bit LLM serving. The paper is also transparent in providing ablations, epoch-wise evolution, and quantization wall-clock time. However, the reported evidence currently does not fully support the headline claims: the main perplexity results are measured on the same corpus used for calibration, two 2-bit entries lose to OmniQuant, and several quantitative statements are internally inconsistent. These issues are fixable and do not invalidate the core algorithmic idea.

major comments (4)
  1. [Section 5.2, Table 1] The claim of consistent superiority at low precision is not supported by the table's own numbers: at 2.25 bits, PoTPTQ has higher perplexity than OmniQuant on LLaMA1-7B (9.79 vs 9.77) and on LLaMA1-13B (7.96 vs 7.93). Since these are two of the central 2-bit cases, the abstract's statement that the method 'surpasses the current state-of-the-art in integer quantization, particularly at low precisions such as 2- and 3-bit formats' overstates the results. The authors should either revise the claim or provide repeated-run statistics showing that these differences are not meaningful.
  2. [Section 5.1, Section 5.2, Eq. (14)] The calibration set for Step 2 consists of 128 random 2048-token sequences from WikiText-2, and Table 1 evaluates perplexity on WikiText-2. Minimizing the layer-wise output-reconstruction loss of Eq. (14) on the same corpus used for the main evaluation can inflate the reported gains, because the learned scales may align with WikiText-2 statistics rather than generalize. A held-out perplexity evaluation (for example on C4 or PTB), or calibration on a different corpus, is needed to establish the accuracy advantage over baselines. Table 3's six-task harness helps, but it covers only a limited set of tasks and only compares against OmniQuant.
  3. [Section 5.4, Table 4, Section 5.5, Table 5] There is a numerical inconsistency in the 2-bit results. Table 4 reports that LLaMA1-13B with both steps achieves perplexity 7.96, while Table 5 reports that 'LLaMA-13B' achieves 2-bit perplexity 12.90 after 10 epochs. If Table 5 uses a different model family (for example Llama2-13B), a different bit assignment, or a different evaluation setup, this must be stated explicitly; as written, the two tables contradict each other and weaken confidence in the reported numbers. The same ambiguity affects the 3-bit row, where Table 5 reports 5.48 and Table 1 reports 5.42 for LLaMA1-13B.
  4. [Section 5.6, Table 6, Abstract] The speedup numbers are internally inconsistent. The text in Section 5.6 reports 3.66x on V100 and 1.48x on RTX 4090, whereas Table 6 reports 3.67x and 1.63x, and the abstract reports 3.67x and 1.63x. The authors should correct this discrepancy. In addition, the benchmark description gives no measurement protocol: it is unclear whether the cycle counts are for the dequantization kernel alone, what tensor shapes and group sizes are used, and whether the comparison against uniform integer dequantization uses the same data layout and memory-access pattern. Since the speedup is one of the two headline contributions, this lack of detail makes the claim difficult to reproduce.
minor comments (8)
  1. [Figure 3] The left-panel caption is garbled ('Loss in Step1 O/W Step 1'); it should say something like 'Loss with and without Step 1'. The right panel is also not described in the caption.
  2. [Section 3.1] The notation W(l) ∈ R^{d×d} assumes square weight matrices, but transformer projection matrices are generally rectangular; use d_out and d_in or equivalent notation.
  3. [Section 3.2, Algorithm 1] The experimental setup says the grid search is over the interval [0, 2] with step size 0.01, but Algorithm 1 uses B = {0.01, 0.02, ..., 2.00}; the interval should be written as (0, 2] or [0.01, 2.00].
  4. [Section 2.1, References] The abbreviation 'RTN' in Section 5.2 cites reference [6], but reference [6] is GPT3.int8(); the paper should cite a standard round-to-nearest baseline or define RTN explicitly.
  5. [Tables 1 and 2] Table 1 uses 'Avg Bits' 3.25 and 2.25, while Table 2 uses 3.125 and 2.125; the relationship between these bit counts should be explained, since the difference affects how the results should be compared.
  6. [Section 3.3 and Section 5.1] Equation (14) introduces a regularization coefficient λ, but Section 5.1 only mentions a weight decay of 1e-1; the paper should clarify whether λ is the same as the weight decay or a separate hyperparameter, and report its value.
  7. [General] The paper uses 'PoT', 'POT', and 'POTPTQ' inconsistently across the title, abstract, and body; one spelling should be chosen and used consistently.
  8. [Table 5] The model in Table 5 is listed as 'LLaMA-13B' without specifying whether it is LLaMA1 or Llama2; this should be stated, along with the group size and bit-count setting used for the epoch-wise numbers.

Circularity Check

0 steps flagged · score 1.0 of 10

No load-bearing circularity: the two-step calibration method is an empirical fit-and-evaluate pipeline, and the reported PPL and speed numbers do not reduce to the paper's own equations or citations by construction.

full rationale

The derivation chain is self-contained in the sense required here. Step 1 (Section 3.2, Eqs. 6-10) minimizes per-group weight reconstruction MSE via a grid search; Step 2 (Section 3.3, Eq. 14) minimizes a layer-wise output reconstruction loss over a low-dimensional residual scale parameter; neither objective is algebraically identical to the final WikiText-2 perplexity or to the dequantization latency. Table 6 reports measured warp cycles (110 vs 30 on V100, 98 vs 60 on RTX 4090), so the 3.67x and 1.63x speedups are benchmark numbers rather than definitional consequences. The one circularity-adjacent issue is that Section 5.1 calibrates on 128 WikiText-2 sequences and Table 1 evaluates perplexity on WikiText-2, so low-bit PPL gains may be partly inflated by fitting to the evaluation distribution; this is a data-overlap validity risk, not a reduction by construction, and Table 3 provides partially independent harness evidence, albeit only against OmniQuant. The fact that two 2-bit entries in Table 1 lag OmniQuant is a correctness and claim-calibration concern, not a circularity one. The self-citations to prior power-of-two quantization work ([12], [13]) are background citations and are not load-bearing for the claimed two-step algorithm or GPU kernel, so they do not raise the circularity score.

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

The paper does not introduce new physical or mathematical entities. Its free parameters are the per-group scales and residuals that are fitted in the two steps; the listed axioms are standard assumptions in PTQ but are load-bearing for the claimed accuracy gains.

free parameters (2)
  • per-group scale multiplier b* = chosen from 200 values in {0.01..2.00}
    Step 1 grid search minimizes weight reconstruction MSE per group; final dequantized weights and all downstream results depend on it (Eq. 9, Algorithm 1).
  • per-group residual scale Gamma = optimized, values not reported
    Step 2 fits one residual per group by minimizing layer-wise output loss on calibration data (Eq. 14-17).
assumptions (4)
  • domain assumption LLM weight distributions are approximately bell-shaped or exponential, so power-of-two levels allocate resolution better than uniform levels.
    Section 2.2 and Figure 1; motivates the whole quantization scheme but is presented as observation, not proof.
  • domain assumption The layer-wise output reconstruction loss in Eq. 14 is a valid proxy for preserving full-model quality.
    Step 2 optimizes this objective; the paper does not prove it transfers to end-to-end perplexity or downstream harness tasks beyond its own experiments.
  • domain assumption Straight-through estimator provides a usable gradient for the round operation in Eq. 16.
    Eq. 18 approximates the non-differentiable rounding; standard practice but an approximation.
  • domain assumption A small 128-sequence calibration set from WikiText-2 represents the evaluation distribution.
    Section 5.1 draws calibration from WikiText-2 and Table 1 evaluates on WikiText-2, making the overlap a load-bearing assumption.

how reviews work

0 comments
Cite this review

Pith. "Pith review of PoTPTQ: A Two-step Power-of-Two Post-training for LLMs." pith.science (2026). https://pith.science/paper/2EIMENSK

@misc{pith2026250711959,
  author       = {Pith},
  title        = {Pith review of: PoTPTQ: A Two-step Power-of-Two Post-training for LLMs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/2EIMENSK}},
  note         = {Machine review of arXiv:2507.11959}
}
abstract

Large Language Models (LLMs) have demonstrated remarkable performance across various natural language processing (NLP) tasks. However, their deployment is challenging due to the substantial computational resources required. Power-of-two (PoT) quantization is a general tool to counteract this difficulty. Albeit previous works on PoT quantization can be efficiently dequantized on CPUs using fixed-point addition, it showed less effectiveness on GPUs. The reason is entanglement of the sign bit and sequential bit manipulations needed for dequantization. We propose a novel POT quantization framework for LLM weights that (i) outperforms state-of-the-art accuracy in extremely low-precision number formats, and (ii) enables faster inference through more efficient dequantization. To maintain the accuracy of the quantized model, we introduce a two-step post-training algorithm: (i) initialize the quantization scales with a robust starting point, and (ii) refine these scales using a minimal calibration set. The performance of our PoT post-training algorithm surpasses the current state-of-the-art in integer quantization, particularly at low precisions such as 2- and 3-bit formats. Our PoT quantization accelerates the dequantization step required for the floating point inference and leads to $3.67\times$ speed up on a NVIDIA V100, and $1.63\times$ on a NVIDIA RTX 4090, compared to uniform integer dequantization.

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

29 extracted references · 17 canonical work pages

  1. [1]

    Ainslie, J

    J. Ainslie, J. Lee-Thorp, M. de Jong, Y . Zemlyanskiy, F. Lebrón, and S. Sanghai. GQA: training generalized multi-query transformer models from multi-head checkpoints. In EMNLP, pages 4895–4901. Association for Computational Linguistics, 2023

    work page 2023

  2. [2]

    Bengio, N

    Y . Bengio, N. Léonard, and A. C. Courville. Estimating or propagating gradients through stochastic neurons for conditional computation. CoRR, abs/1308.3432, 2013

    arXiv 2013

  3. [3]

    Brown, B

    T. Brown, B. Mann, N. Ryder, M. Subbiah, J. D. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell, et al. Language mod- els are few-shot learners. Advances in neural information processing systems, 33:1877–1901, 2020

    1901

  4. [4]

    J. Chee, Y . Cai, V . Kuleshov, and C. D. Sa. QuIP: 2-bit quantization of large language models with guarantees. In Thirty-seventh Conference on Neural Information Processing Systems, 2023. URL https://openreview. net/forum?id=xrk9g5vcXR

    work page 2023

  5. [5]

    Dettmers, M

    T. Dettmers, M. Lewis, Y . Belkada, and L. Zettlemoyer. Gpt3. int8 (): 8-bit matrix multiplication for transformers at scale. Advances in Neural Information Processing Systems, 35:30318–30332, 2022

    work page 2022

  6. [6]

    Dettmers, M

    T. Dettmers, M. Lewis, Y . Belkada, and L. Zettlemoyer. Gpt3.int8(): 8-bit matrix multiplication for transformers at scale. In S. Koyejo, S. Mohamed, A. Agarwal, D. Belgrave, K. Cho, and A. Oh, editors, Advances in Neural Information Processing Systems , volume 35, pages 30318–30332. Curran Associates, Inc., 2022. URL https://proceedings.neurips.cc/paper_...

    work page 2022

  7. [7]

    Dettmers, R

    T. Dettmers, R. Svirschevski, V . Egiazarian, D. Kuznedelev, E. Frantar, S. Ashkboos, A. Borzunov, T. Hoefler, and D. Alistarh. Spqr: A sparse- quantized representation for near-lossless llm weight compression. arXiv preprint arXiv:2306.03078, 2023

    arXiv 2023

  8. [8]

    Elhoushi, Z

    M. Elhoushi, Z. Chen, F. Shafiq, Y . H. Tian, and J. Y . Li. Deepshift: Towards multiplication-less neural networks. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 2359–2368, 2021

    work page 2021

Show all 29 references
  1. [9]

    Frantar, S

    E. Frantar, S. Ashkboos, T. Hoefler, and D. Alistarh. OPTQ: accurate quantization for generative pre-trained transformers. In ICLR. OpenRe- view.net, 2023

    2023

  2. [10]

    S. Kim, C. Hooper, A. Gholami, Z. Dong, X. Li, S. Shen, M. Mahoney, and K. Keutzer. Squeezellm: Dense-and-sparse quantization. arXiv, 2023

    2023

  3. [11]

    C. Lee, J. Jin, T. Kim, H. Kim, and E. Park. Owq: Outlier-aware weight quantization for efficient fine-tuning and inference of large language models. In AAAI Conference on Artificial Intelligence , 2023. URL https://api.semanticscholar.org/CorpusID:267095435

    2023

  4. [12]

    X. Li, B. Liu, Y . Yu, W. Liu, C. Xu, and V . Partovi Nia. S3: Sign-sparse- shift reparametrization for effective training of low-bit shift networks. Advances in Neural Information Processing Systems, 34:14555–14566, 2021

    2021

  5. [13]

    X. Li, B. Liu, R. H. Yang, V . Courville, C. Xing, and V . P. Nia. Denseshift: Towards accurate and efficient low-bit power-of-two quantization. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 17010–17020, 2023

    2023

  6. [14]

    Y . Li, X. Dong, and W. Wang. Additive powers-of-two quantization: An efficient non-uniform discretization for neural networks. In ICLR. OpenReview.net, 2020

    2020

  7. [15]

    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. In International Conference on Learning Represen- tations, 2021. URL https://openreview.net/forum?id=POWv6hDd9XH

    2021

  8. [16]

    J. Lin, J. Tang, H. Tang, S. Yang, W.-M. Chen, W.-C. Wang, G. Xiao, X. Dang, C. Gan, and S. Han. Awq: Activation-aware weight quantization for llm compression and acceleration. In MLSys, 2024

    2024

  9. [17]

    Y . Lin, H. Tang, S. Yang, Z. Zhang, G. Xiao, C. Gan, and S. Han. Qserve: W4a8kv4 quantization and system co-design for efficient llm serving, 2024

    2024

  10. [18]

    Merity, C

    S. Merity, C. Xiong, J. Bradbury, and R. Socher. Pointer sentinel mixture models, 2016

    2016

  11. [19]

    Przewlocka-Rus, S

    D. Przewlocka-Rus, S. S. Sarwar, H. E. Sumbul, Y . Li, and B. De Salvo. Power-of-two quantization for low bitwidth and hardware compliant neural networks. arXiv preprint arXiv:2203.05025, 2022

    2022 arXiv

  12. [20]

    W. Shao, M. Chen, Z. Zhang, P. Xu, L. Zhao, Z. Li, K. Zhang, P. Gao, Y . Qiao, and P. Luo. Omniquant: Omnidirectionally cali- brated quantization for large language models. In The Twelfth In- ternational Conference on Learning Representations , 2024. URL https://openreview.net...

    2024

  13. [21]

    G. Team, R. Anil, S. Borgeaud, Y . Wu, J.-B. Alayrac, J. Yu, R. Soricut, J. Schalkwyk, A. M. Dai, A. Hauth, et al. Gemini: a family of highly capable multimodal models. arXiv preprint arXiv:2312.11805, 2023

    2023 arXiv

  14. [22]

    Touvron, T

    H. Touvron, T. Lavril, G. Izacard, X. Martinet, M.-A. Lachaux, T. Lacroix, B. Rozière, N. Goyal, E. Hambro, F. Azhar, et al. Llama: Open and efficient foundation language models. arXiv preprint arXiv:2302.13971, 2023

    2023 arXiv

  15. [23]

    Touvron, L

    H. Touvron, L. Martin, K. Stone, P. Albert, A. Almahairi, Y . Babaei, N. Bashlykov, S. Batra, P. Bhargava, S. Bhosale, et al. Llama 2: Open foundation and fine-tuned chat models.arXiv preprint arXiv:2307.09288, 2023

    2023 arXiv

  16. [24]

    X. Wei, Y . Zhang, Y . Li, X. Zhang, R. Gong, J. Guo, and X. Liu. Outlier suppression+: Accurate quantization of large language models by equiv- alent and optimal shifting and scaling. ArXiv, abs/2304.09145, 2023. URL https://api.semanticscholar.org/CorpusID:258187503

    2023 arXiv

  17. [25]

    G. Xiao, J. Lin, M. Seznec, H. Wu, J. Demouth, and S. Han. SmoothQuant: Accurate and efficient post-training quantization for large language models. In Proceedings of the 40th International Conference on Machine Learning, 2023

    2023

  18. [26]

    A. Yang, B. Yang, B. Zhang, B. Hui, B. Zheng, B. Yu, C. Li, D. Liu, F. Huang, H. Wei, H. Lin, J. Yang, J. Tu, J. Zhang, J. Yang, J. Yang, J. Zhou, J. Lin, K. Dang, K. Lu, K. Bao, K. Yang, L. Yu, M. Li, M. Xue, P. Zhang, Q. Zhu, R. Men, R. Lin, T. Li, T. Xia, X. Ren, X. Ren, Y ...

    2024 arXiv

  19. [27]

    H. Yao, P. Li, J. Cao, X. Liu, C. Xie, and B. Wang. Rapq: Rescuing accuracy for power-of-two low-bit post-training quantization. In Pro- ceedings of the Thirty-First International Joint Conference on Artificial Intelligence (IJCAI-22), 2022

    2022

  20. [28]

    H. You, X. Chen, Y . Zhang, C. Li, S. Li, Z. Liu, Z. Wang, and Y . Lin. Shiftaddnet: A hardware-inspired deep network. Advances in Neural Information Processing Systems, 33:2771–2783, 2020

    2020

  21. [29]

    Zhang, S

    S. Zhang, S. Roller, N. Goyal, M. Artetxe, M. Chen, S. Chen, C. Dewan, M. Diab, X. Li, X. V . Lin, et al. Opt: Open pre-trained transformer language models. arXiv preprint arXiv:2205.01068, 2022

    2022 arXiv

Pith tools

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