Pith. sign in

REVIEW 4 major objections 5 minor 29 references

FineQ: Software-Hardware Co-Design for Low-Bit Fine-Grained Mixed-Precision Quantization of LLMs

T0 review · 4 major / 5 minor · reviewed 2026-08-16 · deepseek-v4-flash

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

Pith's one-line read FineQ claims that partitioning each LLM weight channel into clusters of three, with 2-bit normal values and 3-bit protected outliers, keeps perplexity competitive at an average of 2.33 bits per weight, and that the matching…

desk verdict FineQ has a genuinely new fine-grained mixed-precision scheme with strong empirical results, but Algorithm 1's signed min/max outlier test is wrong as written and must be fixed before the results are reproducible. read the letter →

arxiv 2504.19746 v1 pith:YRWYWULD submitted 2025-04-28 cs.LG cs.AR

Xilong Xie , Liang Wang , Limin Xiao , Meng Han , Lin Sun , Shuai Zheng , Xiangrong Xu This is my paper · ORCID
classification cs.LGcs.AR
keywords largelanguagemodelslow-bitquantizationmixed-precisionoutlierprotectiontemporalcodingsystolicarrayhardwareacceleratorsoftware-hardwareco-design
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

FineQ is a software-hardware co-design for pushing LLM weight quantization below 3 bits. The paper's claim is that the reason existing mixed-precision quantizers lose accuracy is coarse granularity: protecting outliers group-wide wastes bits or misses outliers. Its fix is to cut each weight channel into clusters of three, give every member 2 bits normally, and when a cluster contains an outlier give the two largest values 3 bits and zero the third. This reaches an average bit-width of 2.33 bits and, in the paper's measurements on LLaMA-2-3B/7B/13B, achieves lower perplexity on WikiText-2 and C4 than OWQ and PB-LLM. The companion accelerator encodes weights as temporal bitstreams so multiplications become additions, reducing systolic-array area by 61.2% and improving energy efficiency by up to 1.79x.

What carries the argument

The load-bearing object is the size-3 weight cluster with its 2-bit format code: one code says all three values are 2-bit, and the three other codes say this position is zeroed while the other two positions are 3-bit. Scale factors are per channel using the symmetric uniform-quantization formula $s = \mathrm{abs}(x_{\max})/(2^{b-1}-1)$, where $b$ is the cluster's bit-width. The hardware lever is temporal coding: each low-bit weight is converted into a fixed-length bitstream whose number of ones equals its value, so multiplication by the weight becomes a sequence of conditional additions of the activation, replacing the multiplier with an encoder, selectors, and an adder tree.

What would settle it

Run Algorithm 1 as printed on the actual LLaMA-2-7B weights and count the clusters that satisfy $\max > 4\min$. If the fraction is close to one (as signed arithmetic on mixed-sign weights predicts) rather than the roughly 0.3% outlier rate claimed, then the outlier-protection mechanism as written is not what produces the reported perplexity, and the algorithm is using an unstated absolute-value comparison.

Watch

Extended reading notes

Core claim

The central discovery is that fine-grained, per-cluster bit allocation makes 2-bit-scale quantization viable without retraining. Within each channel, FineQ computes a per-channel scale factor, forms clusters of three adjacent weights, and makes a binary decision: if the cluster's maximum exceeds four times its minimum, the two largest values are stored in 3 bits and the smallest is zeroed; otherwise all three are stored in 2 bits. A 2-bit format code per cluster, shared with a neighbor to keep memory aligned, tells the decoder which layout to expect. The paper reports this 2.33-bit average scheme beats OWQ at 2.25 bits and PB-LLM at 2.7 bits in perplexity across the LLaMA-2 family, and that the temporal-coding systolic array, which broadcasts unary bitstreams of the weights into a PE array and accumulates selected activations, reduces systolic-array area by 61.2% and power by 62.9% at 45 nm.

Load-bearing premise

The whole accuracy story rests on the outlier test firing only on rare clusters; if the printed comparison is read literally on signed weights, nearly every cluster fires, so the reported gains depend on an interpretation the paper does not state.

Editorial extensions

If this is right

  • FineQ reaches an average bit-width of 2.33 bits and reports lower perplexity than OWQ at 2.25 bits and PB-LLM at 2.7 bits on LLaMA-2-3B, 7B, and 13B on WikiText-2 and C4, so coarse-grained grouping is not needed to protect outliers.
  • The 2-bit cluster format code, forced to be shared with a neighboring cluster, packs four allocation codes into one byte and eliminates a separate sparse index for outliers.
  • The quantization algorithm runs offline without retraining, so an existing FP16 model can be re-encoded and then served without gradient updates.
  • At 45 nm, replacing MAC multipliers with temporal-coding PEs lowers the 64x64 systolic array area from 0.954 mm^2 to 0.370 mm^2 and its power from 88.793 mW to 32.891 mW.
  • Energy efficiency improves by up to 1.79x across sequence lengths under input-stationary dataflow, with the accumulation unit, not the PEs, becoming the dominant power consumer.

Reading between the lines

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

  • A reader who implements Algorithm 1 verbatim on signed weights should first count how many clusters satisfy $\max > 4\min$; if that fraction is near one, the published accuracy numbers are best explained by an unstated absolute-value variant of the test.
  • The choice of cluster size 3 is tied to the 2-bit format code packing into one byte; varying the cluster size while keeping the same packing would be a direct ablation of the paper's claim that finer granularity is what protects outliers.
  • Temporal coding of weights is agnostic to the specific 2/3-bit policy; any scheme that turns weights into small integers can reuse the multiplier-free PE array, so the hardware result applies beyond FineQ's exact bit allocation.
  • The 61.2% area saving is for the systolic array only; including the decoder, buffers, and control logic would give a fuller end-to-end comparison, although the decoder itself is reported at only 0.008 mm^2.
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

4 major / 5 minor

Summary. FineQ proposes a software-hardware co-design method for low-bit, fine-grained mixed-precision quantization of LLM weights. On the algorithm side, weights are partitioned into per-channel clusters of three values; each cluster is either quantized uniformly to 2 bits or, if an outlier is detected, the two largest values are quantized to 3 bits while the smallest is set to zero. A 2-bit format code and a memory-alignment scheme are used to encode cluster types, and an accelerator based on temporal coding is proposed to replace conventional multipliers in a systolic array. The paper reports perplexity results on WikiText-2 and C4 for LLaMA-2 3B/7B/13B at an average bit-width of 2.33 bits, claiming better accuracy than OWQ and PB-LLM, and reports a 61.2% systolic-array area reduction and up to 1.79x energy efficiency from RTL synthesis and cycle-level simulation.

Significance. If the results are reproducible, FineQ is a useful contribution: it offers a no-retraining, 2.33-bit weight-only quantization scheme with a plausible hardware mapping, and the temporal-coding PE array is a concrete attempt to exploit low-bit computation beyond conventional MAC replacement. The paper is honest about its engineering choices, does not claim a parameter-free derivation, and provides synthesis-based hardware numbers, which is a strength. However, the central algorithmic claims currently depend on ambiguous pseudocode and bit-accounting details, so the significance is conditional on a corrected and released implementation. The gap between FineQ and the baselines in Table I is large enough that the approach is worth pursuing, but the reported numbers cannot be verified from the manuscript as written.

major comments (4)
  1. [Section III.A, Algorithm 1 (lines 6-8), Eq. (1)] The outlier test as printed uses signed values: 'if max val > 4 × min val'. For signed, roughly centered LLM weights, most clusters contain a negative value, so 4×min is very negative and the inequality is almost always true. The outlier branch would then zero the smallest (usually most negative) element instead of protecting it, which contradicts the paper's claim that 2-bit encoding is the common case and makes the perplexity results in Table I not derivable from the printed algorithm. Please state explicitly whether the intended test uses absolute values, e.g., max(|C|) > 4 × min(|C|), define 'top two values' as top two magnitudes in the 3-bit branch, and reconcile Eq. (1), where s = abs(xmax)/(2^{b-1}-1), with signed per-cluster bit-widths. Figure 4 only shows positive weights and does not resolve this ambiguity.
  2. [Section III.B, Algorithm 1 (lines 15-24), Table I] The reported average bit-width of 2.33 bits is inconsistent with the text as written. A per-cluster 2-bit format code plus 6 data bits gives 8 bits per 3 weights, i.e., 2.67 bits/weight; to obtain 2.33 bits/weight, the format code must be shared between a pair of adjacent clusters (6 data bits + 1 index bit per 3 weights). This matches the sentence 'four index values are encoded within a single byte ... subsequent eight clusters', but it contradicts Figure 4 step 5, which draws one 2-bit code per cluster ('00 10 00 11'). Algorithm 1's neighbor loop (lines 15-24) copies the first cluster's encoding to every later cluster, which would force one encoding for the whole channel and does not implement pairwise optimization; the prose is also self-contradictory, saying adjacent clusters are required to use the same encoding and then discussing cases where they use different encodings. Please restate the index-sharing scheme and pair-optimization loop, define the arg-min loss in line 22, and give an explicit bit-accounting formula.
  3. [Table III, Fig. 9] The headline hardware numbers need a precise comparison boundary. Table III labels the baseline 'Systolic Array 64×64 PEs' and the proposed design 'FineQ PE Array 64×64 PEs', while Fig. 8 reports that the ACC unit consumes 71.8% of the FineQ PE-array power. Please state explicitly whether the baseline row includes accumulator units and whether the FineQ PE-array row includes ACC and temporal encoders, so the 61.2% area reduction and the up-to-1.79x energy efficiency are computed on identical component boundaries. In addition, because temporal coding is bit-serial, the energy-efficiency comparison in Fig. 9 should state how bitstream length and extra clock cycles are amortized.
  4. [Section V] The empirical accuracy claim rests on a single configuration with no sensitivity analysis. The cluster size of 3, the 4× threshold in Algorithm 1, and the 2-bit/3-bit bit-width allocation are free engineering parameters, yet no ablation shows how Table I changes with these parameters, and no error bars or repeated-run statistics are reported. Please add this sensitivity analysis and describe the exact evaluation protocol, including tokenizer, perplexity computation, and whether embedding and final layers are quantized; releasing the quantization code and RTL would resolve the ambiguity in Algorithm 1 and allow Table I to be checked.
minor comments (5)
  1. [Abstract, Section I, Fig. 1] There are typos ('differnet', 'fined-grained') and the x-axis of Fig. 1 shows integer bit-widths 16, 8, 4, 3, 2, so FineQ's 2.33-bit point is not visually placed; consider adding an explicit marker or axis annotation.
  2. [Table II] The entry 'FineQ(Ours)2.3364.47' is missing a separator between the average bit-width and the first perplexity value; this makes the table difficult to read.
  3. [Table I] The table reports no variance or repeated evaluations, and the baselines are described only by average bit-width; adding the exact configuration (e.g., group size for OWQ, retention ratio for PB-LLM) in a column would help readers interpret the comparison.
  4. [Related Work, Section V] The abstract and conclusion call FineQ 'SOTA' relative to mixed-precision quantization, but the comparison omits several recent low-bit PTQ methods, e.g., SqueezeLLM, APTQ, QuIP#, and AQLM; please qualify the claim or add such comparisons.
  5. [Fig. 6] In the decoder block diagram, the zero-padding paths for 2-bit data are shown as '000' wires but are not labeled in the figure; a short caption note would make the padding behavior self-contained.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: FineQ's accuracy and hardware claims are empirical evaluations against external baselines, not derived from fitted inputs or self-cited theorems.

full rationale

FineQ makes no first-principles derivation that could collapse into its inputs. The quantization scheme (cluster size 3, 2/3-bit allocation, 4x outlier threshold, index encoding) is a presented design with engineering choices; accuracy is evaluated by measuring perplexity on WikiText-2/C4 against external baselines (RTN, Uniform, GPTQ, PB-LLM, OWQ). The average bit-width of 2.33 bits is a stated configuration, not a predicted outcome fitted to the perplexity numbers. Hardware results come from RTL synthesis in a 45nm process and cycle-level simulation against a systolic-array baseline with the same buffer size, so the 61.2% area reduction and 1.79x energy efficiency are independent measurements rather than consequences of the claimed conclusions. The temporal-coding mechanism is attributed to prior external work (uBrain, ref [3]) and is used as a building block, not as evidence for FineQ's own performance. The only notable concern in the manuscript is an apparent ambiguity in Algorithm 1 lines 6-8, where max(C) > 4*min(C) on signed weights would fire for most clusters; that is a reproducibility/correctness issue, not circularity, because the reported perplexities do not reduce to this pseudocode by construction. No self-citation is load-bearing, and no fitted parameter is renamed as a prediction. Therefore the appropriate circularity score is 0.

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

The central accuracy claim rests mainly on empirical choices: the 4x threshold, cluster size 3, and 2/3-bit split. These are not derived from first principles and are not ablated. The hardware claims rest on an unspecified baseline. No new physical entities are introduced.

free parameters (3)
  • outlier threshold ratio = 4
    Algorithm 1 line 8 uses max(C) > 4*min(C). No ablation or sensitivity analysis is given; the value appears chosen by hand.
  • cluster size = 3
    Section III-A partitions every three weights into a cluster. This determines the encoding overhead and granularity; no comparison with other sizes is provided.
  • bit-widths for normal and outlier values = 2 bits and 3 bits
    Observation II claims 3-bit outliers suffice and 2-bit normal values degrade accuracy, but no derivation or ablation of these specific bit-widths is given; they set the 2.33-bit average.
assumptions (3)
  • domain assumption Outliers are sparse and concentrated in specific channels
    Section II-C Observation II. The method's effectiveness depends on this statistical property of LLM weights; if outliers are diffuse, zeroing the smallest cluster element will hurt accuracy.
  • standard math Temporal coding is lossless for the quantized integers
    Section IV-C. A bitstream with a number of ones equal to the magnitude plus a sign bit exactly represents the integer; this is true by construction if the stream is long enough.
  • domain assumption The baseline systolic array uses MAC units with comparable operand precision
    Section V-C. The claimed 61.2% area reduction and 1.79x energy improvement are only meaningful relative to a specified baseline; the paper does not state the baseline multiplier width.

how reviews work

0 comments
Cite this review

Pith. "Pith review of FineQ: Software-Hardware Co-Design for Low-Bit Fine-Grained Mixed-Precision Quantization of LLMs." pith.science (2026). https://pith.science/paper/YRWYWULD

@misc{pith2026250419746,
  author       = {Pith},
  title        = {Pith review of: FineQ: Software-Hardware Co-Design for Low-Bit Fine-Grained Mixed-Precision Quantization of LLMs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/YRWYWULD}},
  note         = {Machine review of arXiv:2504.19746}
}
read the original abstract

Large language models (LLMs) have significantly advanced the natural language processing paradigm but impose substantial demands on memory and computational resources. Quantization is one of the most effective ways to reduce memory consumption of LLMs. However, advanced single-precision quantization methods experience significant accuracy degradation when quantizing to ultra-low bits. Existing mixed-precision quantization methods are quantized by groups with coarse granularity. Employing high precision for group data leads to substantial memory overhead, whereas low precision severely impacts model accuracy. To address this issue, we propose FineQ, software-hardware co-design for low-bit fine-grained mixed-precision quantization of LLMs. First, FineQ partitions the weights into finer-grained clusters and considers the distribution of outliers within these clusters, thus achieving a balance between model accuracy and memory overhead. Then, we propose an outlier protection mechanism within clusters that uses 3 bits to represent outliers and introduce an encoding scheme for index and data concatenation to enable aligned memory access. Finally, we introduce an accelerator utilizing temporal coding that effectively supports the quantization algorithm while simplifying the multipliers in the systolic array. FineQ achieves higher model accuracy compared to the SOTA mixed-precision quantization algorithm at a close average bit-width. Meanwhile, the accelerator achieves up to 1.79x energy efficiency and reduces the area of the systolic array by 61.2%.

Figures

Figures reproduced from arXiv: 2504.19746 by the authors.

Figure 1
Figure 1. Perplexity of LLaMA-2-7B on C4 under differnet bit-widths. Lower [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. (a) The transformer block architecture. (b) Memory layout for serving [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗
Figure 3
Figure 3. Three observations about hardware-software co-design of mixed [PITH_FULL_IMAGE:figures/full_fig_p002_3.png] view at source ↗
Figures from the paper (6 more)
Figure 4
Figure 4. Figure 4: An example of fine-grained intra-cluster quantization algorithm. [PITH_FULL_IMAGE:figures/full_fig_p003_4.png]
Figure 5
Figure 5. Figure 5: (a) Overview of FineQ architecture. (b) Temporal coding PE array [PITH_FULL_IMAGE:figures/full_fig_p004_5.png]
Figure 6
Figure 6. Figure 6: FineQ decoder design ① load the input temporal coding 25+0+0+9+1 = 35 21+0+0+5+3 = 29 17+0+0+8+1 = 26 23+0+0+8+6 = 37 8 7 4 9 9 1 5 3 2 6 3 6 8 1 8 6 8 7 12 10 12 1 5 3 2 6 3 6 8 1 8 6 1 1 1 1 1 1 2 2 0 0 1 1 1 1 1 1 4+9+5+3 = 21 8+7+9+1 = 25 2+6+8+1 = 17 3+6+8+6 = 23 …
Figure 7
Figure 7. Figure 7: An example of matrix multiplication with temporal coding PE array. [PITH_FULL_IMAGE:figures/full_fig_p005_7.png]
Figure 8
Figure 8. Figure 8: Breakdown of power in FineQ PE array. the accelerator exhibits higher energy efficiency, attributed to the simplified design of most PEs and the reduction in the complexity of multipliers. Overall, the accelerator achieves up to 1.79× average energy efficiency on vario…
Figure 9
Figure 9. Figure 9: Normalized energy efficiency over baseline accelerator. [PITH_FULL_IMAGE:figures/full_fig_p006_9.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

29 extracted references · 9 canonical work pages

  1. [1]

    Attention is all you need,

    A. Vaswani, “Attention is all you need,” Advances in Neural Information Processing Systems, 2017

    2017

  2. [2]

    Llama: Open and efficient foundation language models,

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

    arXiv 2023

  3. [3]

    ubrain: A unary brain computer interface,

    D. Wu, J. Li, Z. Pan, Y . Kim, and J. S. Miguel, “ubrain: A unary brain computer interface,” in Proceedings of the 49th Annual International Symposium on Computer Architecture , 2022, pp. 468–481

    work page 2022

  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]

    Gptq: Accurate post-training quantization for generative pre-trained transformers,

    E. Frantar, S. Ashkboos, T. Hoefler, and D. Alistarh, “Gptq: Accurate post-training quantization for generative pre-trained transformers,” arXiv preprint arXiv:2210.17323, 2022

    arXiv 2022

  6. [6]

    Zeroquant: Efficient and affordable post-training quantization for large- scale transformers,

    Z. Yao, R. Yazdani Aminabadi, M. Zhang, X. Wu, C. Li, and Y . He, “Zeroquant: Efficient and affordable post-training quantization for large- scale transformers,” Advances in Neural Information Processing Systems , vol. 35, pp. 27 168–27 183, 2022

    2022

  7. [7]

    Llm. int8 (): 8-bit matrix multiplication for transformers at scale. corr abs/2208.07339 (2022),

    T. Dettmers, M. Lewis, Y . Belkada, and L. Zettlemoyer, “Llm. int8 (): 8-bit matrix multiplication for transformers at scale. corr abs/2208.07339 (2022),” 2022

    arXiv 2022

  8. [8]

    Awq: Activation-aware weight quanti- zation for on-device llm compression and acceleration,

    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 quanti- zation for on-device llm compression and acceleration,” Proceedings of Machine Learning and Systems , vol. 6, pp. 87–100, 2024

    2024

Show all 29 references
  1. [9]

    Owq: Outlier-aware weight quantization for efficient fine-tuning and inference of large language models,

    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 Proceedings of the AAAI Conference on Artificial Intelligence, vol. 38, no. 12, 2024, pp. 13 355–13 364

    2024

  2. [10]

    Llm-mq: Mixed-precision quantization for efficient llm deployment,

    S. Li, X. Ning, K. Hong, T. Liu, L. Wang, X. Li, K. Zhong, G. Dai, H. Yang, and Y . Wang, “Llm-mq: Mixed-precision quantization for efficient llm deployment,” in The Efficient Natural Language and Speech Processing Workshop with NeurIPS , vol. 9, 2023

    2023

  3. [11]

    Pb-llm: Partially binarized large language models,

    Y . Shang, Z. Yuan, Q. Wu, and Z. Dong, “Pb-llm: Partially binarized large language models,” arXiv preprint arXiv:2310.00034 , 2023

    2023 arXiv

  4. [12]

    Olive: Accelerating large language models via hardware- friendly outlier-victim pair quantization,

    C. Guo, J. Tang, W. Hu, J. Leng, C. Zhang, F. Yang, Y . Liu, M. Guo, and Y . Zhu, “Olive: Accelerating large language models via hardware- friendly outlier-victim pair quantization,” in Proceedings of the 50th Annual International Symposium on Computer Architecture , 2023, pp. 1–15

    2023

  5. [13]

    Tender: Accelerating large language models via tensor decomposition and runtime requantization,

    J. Lee, W. Lee, and J. Sim, “Tender: Accelerating large language models via tensor decomposition and runtime requantization,” arXiv preprint arXiv:2406.12930, 2024

    2024 arXiv

  6. [14]

    Gpt3. int8 (): 8-bit matrix multiplication for transformers at scale,

    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 , vol. 35, pp. 30 318–30 332, 2022

    2022

  7. [15]

    Abstractive long text summarization using large language models,

    G. Keswani, W. Bisen, H. Padwad, Y . Wankhedkar, S. Pandey, and A. Soni, “Abstractive long text summarization using large language models,” Int. J. Intell. Syst. Appl. Eng , vol. 12, pp. 160–168, 2024

    2024

  8. [16]

    Transformer models used for text-based question answering systems,

    K. Nassiri and M. Akhloufi, “Transformer models used for text-based question answering systems,” Applied Intelligence , vol. 53, no. 9, pp. 10 602–10 635, 2023

    2023

  9. [17]

    Efficient memory management for large language model serving with pagedattention,

    W. Kwon, Z. Li, S. Zhuang, Y . Sheng, L. Zheng, C. H. Yu, J. Gonzalez, H. Zhang, and I. Stoica, “Efficient memory management for large language model serving with pagedattention,” in Proceedings of the 29th Symposium on Operating Systems Principles , 2023, pp. 611–626

    2023

  10. [18]

    Pointer sentinel mixture models,

    S. Merity, C. Xiong, J. Bradbury, and R. Socher, “Pointer sentinel mixture models,” arXiv preprint arXiv:1609.07843 , 2016

    2016 arXiv

  11. [19]

    Exploring the limits of transfer learning with a unified text-to-text transformer,

    C. Raffel, N. Shazeer, A. Roberts, K. Lee, S. Narang, M. Matena, Y . Zhou, W. Li, and P. J. Liu, “Exploring the limits of transfer learning with a unified text-to-text transformer,” Journal of machine learning research , vol. 21, no. 140, pp. 1–67, 2020

    2020

  12. [20]

    Kurup and T

    P. Kurup and T. Abbasi, Logic synthesis using Synopsys® . Springer Science & Business Media, 1997

    1997

  13. [21]

    Ascend-freepdk45: An open source standard cell library for asyn- chronous design,

    C. H. Oliveira, M. T. Moreira, R. A. Guazzelli, and N. L. Calazans, “Ascend-freepdk45: An open source standard cell library for asyn- chronous design,” in 2016 IEEE International Conference on Electronics, Circuits and Systems (ICECS) . IEEE, 2016, pp. 652–655

    2016

  14. [22]

    Efficient processing of deep neural networks: A tutorial and survey,

    V . Sze, Y .-H. Chen, T.-J. Yang, and J. S. Emer, “Efficient processing of deep neural networks: A tutorial and survey,” Proceedings of the IEEE , vol. 105, no. 12, pp. 2295–2329, 2017

    2017

  15. [23]

    A survey of large language models,

    W. X. Zhao, K. Zhou, J. Li, T. Tang, X. Wang, Y . Hou, Y . Min, B. Zhang, J. Zhang, Z. Dong et al. , “A survey of large language models,” arXiv preprint arXiv:2303.18223, 2023

    2023 arXiv

  16. [24]

    Squeezellm: Dense-and-sparse quantization,

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

    2023 arXiv

  17. [25]

    Aptq: Attention-aware post-training mixed-precision quantization for large lan- guage models,

    Z. Guan, H. Huang, Y . Su, H. Huang, N. Wong, and H. Yu, “Aptq: Attention-aware post-training mixed-precision quantization for large lan- guage models,” arXiv preprint arXiv:2402.14866 , 2024

    2024 arXiv

  18. [26]

    Understanding reuse, performance, and hardware cost of dnn dataflow: A data-centric approach,

    H. Kwon, P. Chatarasi, M. Pellauer, A. Parashar, V . Sarkar, and T. Kr- ishna, “Understanding reuse, performance, and hardware cost of dnn dataflow: A data-centric approach,” in Proceedings of the 52nd Annual IEEE/ACM International Symposium on Microarchitecture , 2019, pp. 754–768

    2019

  19. [27]

    Outlier suppression+: Accurate quantization of large language models by equiva- lent and optimal shifting and scaling,

    X. Wei, Y . Zhang, Y . Li, X. Zhang, R. Gong, J. Guo, and X. Liu, “Outlier suppression+: Accurate quantization of large language models by equiva- lent and optimal shifting and scaling,” arXiv preprint arXiv:2304.09145 , 2023

    2023 arXiv

  20. [28]

    Mobile and edge evaluation of large language models,

    S. Laskaridis, K. Katevas, L. Minto, and H. Haddadi, “Mobile and edge evaluation of large language models,” in Workshop on Efficient Systems for Foundation Models II@ ICML2024

  21. [29]

    Hardware-aware parallel prompt decoding for memory-efficient acceleration of llm inference,

    W. Luk, K. F. C. Yiu, R. Li, K. Mishchenko, S. I. Venieris, H. Fan et al. , “Hardware-aware parallel prompt decoding for memory-efficient acceleration of llm inference,” arXiv preprint arXiv:2405.18628 , 2024

    2024

Pith tools

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