LogART: Pushing the Limit of Efficient Logarithmic Post-Training Quantization
Authors: Jiawei Xu
Yi Zheng
Chenghe Sun
Taiyu Zhou
Zuqi Zhang
Jie Li
Lirong Zheng
Zhuo Zou
Venue: ICLR 2026 Poster (2026)
Keywords: Post-training quantization
Logarithmic quantization
Adaptive rounding
Hyperparameter search
Low-power computing
Primary area: optimization
TL;DR: LogART introduces a novel logarithmic quantizer and learnable logarithmic rounding to to improve accuracy in hardware-efficient post-training quantization.

Abstract: Efficient deployment of deep neural networks increasingly relies on Post-Training Quantization (PTQ). Logarithmic PTQ, in particular, promises multiplier-free hardware efficiency, but its performance is often limited by the nonlinear and symmetric quantization grid and standard rounding-to-nearest (RTN) approach. While learnable rounding has significantly advanced linear PTQ, its application to the non-linear and often discrete nature of logarithmic domain remains unexplored. This paper introduces learnable Logarithmic Adaptive Rounding Techniques (LogART) that pioneer task-aware learnable rounding specifically for the logarithmic domain. LogART further extends the learnable rounding strategy to flexibly support outlier-aware, asymmetric, and hardware-friendly dynamic logarithmic bases, determined in a distribution-aware manner using an efficient search strategy. Extensive experiments demonstrate that LogART achieves state-of-the-art accuracy while maintaining efficiency in quantizing models across various architectures and ultra-low bitwidths, outperforming existing logarithmic PTQ methods and paving the way for more effective hardware deployment. The code is available at https://github.com/logart-lab/logart.

Published as a conference paper at ICLR 2026
LOGART: PUSHING THE LIMIT OF EFFICIENT LOGA- RITHMIC POST- TRAINING QUANTIZATION
Jiawei Xu', Yi Zheng", Chenghe Sun', Taiyu Zhou', Zuqi , Jie Li", Lirong Zheng", Zhuo Zou" "University of Macau, FFudan University. South China University of Technology i awwi xuê um, edu. mo, zhuoê fudan. edu. cn
ABSTRACT
Efficient deployment of deep neural networks increasingly relies on Post-Training Quantization (PTQ). Logarithmic PTQ, in particular, promises multiplier-free hardware efficiency, but its performance is often limited by the nonlinear and symmetric quantization grid and standard rounding-to te-ressst (RTN) approach. While learnable rounding has significantly advanced linear PTQ, its application to the non-linear and often discrete nature of logarithmic domain remains unexplored. This paper introduces learnable Logarithmic Adaptive Rounding Techniques (Log- ART) that pioneer task-aware learnable rounding specifically for the logarithmic domain. LogART further extends the learnable rounding strategy to flexibly sup- port outlier-aware, asymmetric, and hardware-frie frienndlf dynamic logarithmic bases, determined in distribution- manner using efficient search strategy. Ex- tensive experiments demonstrate that LogART achieves state-of-the-art accuracy while maintaining efficiency in quantizing models across various architectures and ultra-low bitwidths, outperforming existing logarithmic PTQ methods and paving the way for more effective hardware deployment. The code is available attps: htt///gttuus com logart -ataaatttaab//aee logart
INTRODUCTION
Artificial intelligence (Al) has entered the era of large-scale models, with large language models (LLMs) Touvron et al. (2023: Biderman al. (2023) reaching billions to trillions of parameters and straining existing infrastructure. Their deployment requires significant computational and memory resources, posing challenges for scalability and practical adoption. This necessitates effective model compression and efficient inference techniques, particularly for deploying these models edge devices with tight constraints on computation, memory, and power consumption.
Quantization is widely adopted technique for compressing deep neural networks and accelerating inference, facilitating deployment on resource-consee constrained edge devices. Two main quantization approaches are commonly used: Quantization-Aware Training (QAT)Lin (2024) and Post- Bost-Training Quantization (PTQ) Nagel et al.) (2020); Li et al. (2021). QAT introduces quantization during training or re-training, allowing the model adapt quantization noises and typically yielding higher accuracy. However, QAT requires access to the original training data and involves training phases, which is often impractical for large-scale models due data privacy concerns. proprietary constraints, and the substantial computational resources required. In contrast, PTQ applies quantization a pre-trained model using only small calibration set Nagel al. (202))
al. (023); Chen et al.
L al.
(2021) Kim et al. (2024a); Wu et al. (2024), in some cases no data at all Lee et al. Xu et al. (2020), offering advantages compact model production speed and efficiency.
201
PTQ techniques are broadly categorized into linear Fang et al. (2000): Kwon et al. (2024): ) Gong
ct al. 2025) and non-linear Lee et al. (0117); : Xu et al. 20200; Lin et al. 2022): Li et al. (2023) ) Wu al.
2024) methods. Linear PTQ simplifies hardware implementation but struggles with bell-shaped distributions often observed. Logarithmic PTQ. a representative non non-linear method, offers two key advantages: 1) its non-uniform levels align better with bell-shaped and long-taile distributions, often outperforming linear PTQ at low bitwidths Lin et al. (2022); 2) base-2 logarithmic PTQ can boost
hardware efficiency by replacing bulky multipliers with shifters adders Xu et al. (2018 2023). To

---

Published as a conference paper at ICLR 2026
further improve performance, various optimization strategies have been proposed, including base L2 et al. (2023) and distribution-aware flexible bases Wu et al. (2024). However, logarithmic PTQ still faces key challenges, including performance bottlenecks at ultra-low bitwidths due to inherent symmetry and lack of outlier awareness, well as limited adaptability to emerging models. Critically, most logarithmic PTQ methods use rounding-to-nearee to-nearest (RTN), which is known to be suboptimal compared task-aware learnable rounding Li et al. (2021): Kim al. (2024a). Integrating it with logarithmic PTQ remains a challenge due to the non- non-linearity of logarithmic mapping, the non-differentiabiliy of rounding in the logarithmic domain, and the discrete nature of mixed bases.
In this paper, we propose Logarithmic Adaptive Rounding Techniques (LogART) for PTQ. The key idea to enable fast learnable logarithmic rounding with outier-resilient, asymmetric, dynamic and hardware- hardware-friendly bases, optimizing both accuracy and efficiency. Main contributions are:
We propose LogART, a novel PTQ method that learns the optimal rounding for logarithmic quantization using a small set of unlabeled calibration data. LogART addresses both the non-learnability of logarithmic rounding and the non- non-diffcrentiabiliy in dynamic bases.
We extend LogART with novel quantizer that enables outlier-aware, asymmetric, multi- base, and frieedy logarithmic quantization, using an efficient search strategy to rapidly identify optimal hyperparameters.
From extensive experiments on LLMs, covolutional neural networks (CNNs), and vision transformers, we demonstrate that LogART outperforms state-of-the-art approaches in balancing accuracy, quantization runtime and hardware efficiency.
2 RELATED WORK
2.1 PTQ FOR NNs
The key goal of PTQ is convert the weights and/or activations of pre-trained NN model from floating-por point to low-bitwidth fixed-point representations. Weights are static parameters determined after training, whereas activations are dynamic, input-dependent values generated during inference. While weight distributions remain fixed, activation distributions can vary significantly across layers and inputs. Prior studies have shown that activation PTQ can benefit from techniques such as LSQ Esser et al. (2020). whereas weight PTQ can leverage learnable rounding schemes Nagel et al, (2020); Li et al. (2021); Kim et al. (2024a). Focusing on learnable logarithmic adaptive rounding techniques for PTQ. this work specifically targets weight quantization.
PTQ techniques have been successfully applied across a variety of NN architectures. For CNNs, meth- ods like BRECQ Li al. (2021) leverage block-wisg reconstruction to achieve high accuracy even at ultra-low bitwidths by minimizing guantization error locally through learnable weight rounding. As
Transformer-based models Vaswani al. (017); Touvron al. (2023): Dosovitskiy et al. (2021) have become increasingly prominent in vision and natural language processing, specialized PTQ
methods have been developed to address the unique challenges posed by self-attention mechanisms
Lin et al. (2022); x Li et al. (2023); WW et al. (2024) 2025). More recently, with the rise of LLMs, PTQ has become indispensable. Techniques such GPTQTrantar et al. (2023), aespa Kim al. (2024a),
and Lin et al. (2024) address the challenges of quantizing massive models while mantaanning performance and enabling cost-effective quantization.
Learnable weight rounding schemes offer an effective way to significantly improve PTQ accuracy compared to standard RTN, especially at low bitwidths. First introduced by AdaRound Nagel et al. (2020), learnable weight rounding has pushed the limit of linear quantization into 4-bit PTQ regime. Techniques such as FlexRound Lee et al. (2023), aespa Kim al. (2024a) and APHO (P et al. (2025) have further adapted and extended learnable optimization principles for linear PTQ. However, while highly effective for linear PTQ. learnable weight rounding schemes are not directly applicable to the inherently non-linear nature of logarithmic PTQ. Existing logarithmic PTQ methods have instead focused on optimizing other quantization parameters, such as adaptive bases or scaling factors, often relying on complex hyperparameter search strategies Xu et al. (2033: Wu et al. (2024).
2

---

Published as a conference paper at ICLR 2026
Distribution Count
10a-
2
10a
2 10a-
2
Quant Levels
Logy2
2
2
2
10a
2-6
2
2
2
2
2
Log2
2- 2-7 2-3
2 2-1
2-9 2- 2
2
2-1
2-9 2- 2 2
2
(a) 4-bit Log2 Quantizer
(b) 4-bit Logv2 Quantizer
(c) 4-bit DLog Quantizer
Figure 1: Illustration of (a) Log2. (b) Logv2, and (c) DLog quantization applied to sample weight
distribution (in orange) from OPT- 125M model.
2.2 LOGARITHMIC PTQ
Logarithmic PTQ employs quantization levels that are exponentially spaced, corresponding uniform steps in the logarithmic domain. Key variants within this family primarily differ by their chosen base, including Log2 Lee et 2 Lin al. (002)), Logv2 2 Xu et al. (2018) ; et al. (023)) dynamic
log (DLog) Xu et al. (2020: 2023).
Log2 Quantization utilizes powers-of-two as the discrete quantization levels Lee et al. (0177)
Quant: : Qw clamp (1-105> log2 [W]) )
0, 2 11) 21oog (mmax (W))
Dequont: W
sgn W) @ 2 Qw,
where |-1 generates the element-wiss absolute value, log.(-) is the base-a logarithm function, 1-1 denotes the RTN function, sgn(.) the sign function, @ denotes the Hadamard product, and clamp(R, R, b) limits the value R to closed interval (a, b). Here, the floating shating-point point weight matrix W is quantized into an N-bit (sign bit included) integer-form Qw. from which the dequantized approximation W is derived. A key advantage of Log2 quantization is its hardware efficiency through the use of shifters instead of multipliers. However, the power-of-two scale results in coarse quantization steps especially at important large values, limiting the achievable accuracy.
Logv2 2 Quantization addresses this limitation by employing powers of / 2 to provide finer granularity and improve the achievable accuracy ceiling Xu et al. 2018): Li et al. (2023):
Quant: Qw clamp (1-105/2
W s
0, 2
2N
-1)-
2 log o (max WD)]
Dequant: W s sgn( W) 2 Qw
A notable drawback of Logv2 is its reduced frrendiess as multiplication by v2 cannot be implemented using simple shifters. Hardware acceleration strategies have been explored to compensate, such as the combined look-up table (LUT) and shifter approach Wu et al. (2024). Furthermore, it suffers from severe truncation errors that degrade accuracy, especially at low bitwidths.
DLog Quantization preserves fine-grat tne-ggrined representation for large values while reducing the quan- tization gap near zero by combining base 2 and /2 (Figure [). Optimizing the adaptive base allocation, which is critical for achieving high accuracy at low bitwidths, often relies on complex and time-consuming hyperparameter search strategies. Current logarithmic PTQ techniques face three key limitations: 1) Inherent symmetric quantization grid struggles with the asymmetric data distributions common in L.Mss. 2) High sensitivity to outliers, which often leads to severe performance degradation. 3) Reliance on the simple [-] function, which underperforms compared to task-aware learnable rounding methods proven effective in linear Nagel et al. 2000h: Li et al. (202T): Kim et al. (2024a). Effectively integrating learnable rounding into logarithmic PTQ remains significant challenge. Key difficulties include the non-linen con-linca of the logarithmic mapping, the non- non-differentiability of rounding in the logarithmic domain, and the discrete nature dynamic bases, all of which hinder gradient-baser optimization.
3

---

Published as a conference paper at ICLR 2026
Optimized Hyperparameter Search
(OHS)
Tensor-Wise Asymmetric
Optimal
2
2
2
2
2
2
Learnalle Log
Rounding (LLR)
DLog Quantizer
Bound Search (ABS)
Block-Wise Scaling
Frobenius Norm
Config.
Base- Base-v 2
Base Selector
Block
Hessian
Recon.
Error
Local Loss
Function
Hardware Approx
Function (HAF)
(SF5)
Reg. Term
Calib.
Block-Wise Dynamic Base Search (DBS)
Data
Back Propagation
................................
Block
Tensor
Norm
Conv
Norm
Norm
MatMull
MatMuu
Norm
MLP
Blocks
ResNet Block
Transformer Block
Figure 2: The overall LogART framework consists of two key components: OHS and LLR. OHS searches for optimal hyperparameter configurations in asymmetry- outlier-resillent and multi-base manner. LLR replaces RTN with learnable element-wise rounding that minimizes local reconstruction loss while absorbing hardware approximation noise during calibration.
METHODOLOGY
LogART (Figure starts by formulating an efficient learnable rounding algorithm for base-2 logarithmic PTQ to optimize the quantzzationinduued task loss. We then extend LogART to support outlier-aware, asymmetrie, multi-base, and hardware-friendly dynamic logarithmic bases, enhancing practical performance. The searching strategy for hyperparameters and the hardware implementation of V2-based computation are also analyzed.
3.1 LEARNABLE LOGARITHMIC ROUNDING (LLR)
Inspired by AdaRound Nagel et al. (2020), LogART is the first to enable learnable rounding in the base-2 logarithmic domain by replacing the RTN operation in Eq. (1) with a floor operation [.]. while learnable variable R determines whether each weight is rounded down or up to get the soft-quantized W:
Quant Qw clamp (1-10gs logg
W
+ a (R))
(5)
Dequant W s sgn W) o 2-22-10 Qw.
(6)
The variable R are optimized by minimizing task-aware reconstruction error with a regularization
term that encourages the sigmoid-like function (R) towards either 0 1:
arg min (A())) + Σ (Ro,) 1.j
R
here, L (.) denotes the task loss function, which can be flexibly configured based the reconstruction granularity, such as layer-wise reconstruction Frantar et al. (2023):
E [[C(AW)) = ||AwX] ]]] trAW xx AW AW = W W,
(8)
where 1| denotes the Frobenius norm, and tr(-) denotes the trace square matrix. Block-wise reconstruction is also supported, and the gradient of L.RR analyzed and compared with linear learnable rounding in Appendix A
3.2 EXTENDING LOGART FOR NOVEL LOGARITHMIC QUANTIZER
To overcome the limitations of the fixed Log2 quantization, LogART is extended to support novel multi-base, outiier-reilliet,, and asymmetric logarithmic quantizer.
4

---

Published as a conference paper at ICLR 2026
(b) Symmetric Linear PTQ
Clipping Bound
Original Distribution
(d) Symmetric Logarithmic PTQ
Challenge 1: Inherent Symmetry
Distribution Count
Challenge 2: Limit Point at Zero
Asymmetric Log Quantizer:
Not
#Step Compute number
Not
unused points du-
#Step Shift lower-bound by
0
An to achleve asymmetry.
0
2-2----200
20205
-205
-2
21
2-
2 2
Shift by
Gui
(c) Asymmetric Linear PTQ
(a) Original Weight
(W]
(e) Asymmetric
Logarithmic/PT
Lower ghin
Count
Distributon on Count
UpPS popecBound ghit
Lower Lower-Bound Bound Shift
Min 00665
Dequantic
Woue 1.45 d.=2
-1
0
-1 Log2 Grid
2-32-2-2223 2020.
-205
2222222----22211 2 205
Linear Grid
S Logv22 Grid
Inactive Grid
Log Domain
Linear Domain
Figure Illustration of the asymmetry challenge in logarithmic quantization and the proposed solution. (a) Original weight distribution. In linear PTQ, switching from symmetry (b) to asymmetry (c) easily achieved by using zero-point to shift the clamping bounds. (d) Conventional logarithmic PTQ is inherently symmetric. (e) The proposed asymmetric logarithmic quantizer.
Dynamic Base Quantizer uses base v for large values and base 2 to smaller values, with the ratio between them adapted in distribution aware resulting N-bit integer-form quantization codebook contains n. base- /2 codes and n2 base-2 codes:
aware manner. Given selected base configuration, the
+ 12 = N 1, 71, 72 E 2 [0, 20,2~~ N-1 1].
The threshold t is then calculated to separate the input values into regions where either base or base-v2 quantization is applied, from which the element-wise scaling factor S, upper bound U, and base selector B are constructed:
m
2
m
log 2 (max( W)))
(10)
V2,
W
2 v
1 <t>
1V2".
W 2
|i 1,
W
2
Bij
Si
U
W
2
W <t
122
1,
W
<t
(11)
Dynamic quantization applies an ilement-wise conversion to the logarithmic domain:
Quant: Qw clamp (L
logg
(R), (R).o.U).
(12)
S
Dequant: W = S sgn W) ① B B-Qw.
(13)
Asymmetric Quantizer addresses the inherent symmetry of existing logarithmic quantization with simple yet effective adaptive bound l,. As shown in Figure most logarithmic quantization methods begin by taking the absolute value of the weight tensor and then applying logarithmic quantization symmetrically, which fails to capture the naturally asymmetric weight distributions, particularly prominent in LLMs. Furthermore, in contrast to linear quantization, logarithmic quantization cannot rely on a simple zero-pont pero-pointt to shift bounds for asymmetry due to its non-uniform spacing near zero. To overcome these challenges, LogART introduces the first asymmetric logarithmic quantizer that allocates different numbers of codes to positive and negative weights, based on the maximum Wmax and minimum Wiin weight values:
wh max W mmxx
Wmin): wi min W mmxx Wmin),
La = [da/2],
(14)
log /2 (w)) log (wi)
wi 2
111 1,
Wij 2
da
Ui =
(15)
ni + - [log2 (w;)
Wi <
122
1 las
Wij <t²
Quant Qw clamp (1
(l1188 logB
W
+
(R) 10,UU
(16)
5

---

Published as a conference paper at ICLR 2026
Integer (Signed) Multiplier
Qv
chk even
INT MUL
LUT
Shift
0x
Signed
Or
Decoder
Shift
Signed Signed Operator
sgn w7
LUT
Oy
n1
Qw
0r
Signed
Approx (Add)
Shift
Or
Signed
MUL
0x
Signed
Approx
(Add)
0x
sgn( W)
(c)
sgni (V)
(d)
sgn( WV
(e)
Figure 4: Flow charts of AE designs for: (a) linear quantization, (b) base-2 logarithmic quantization,
(c) base- 2 quantization, (d) AdaLog quantization, and (e) LogART quantization.
Outlier-Resilient Quantizer addresses the strong outlier sensitivity of logarithmic PTQ by introduc- ing a searchable hyperparameter Instead of determining the quantization range from the absolute maximum value, which is easily skewed by outliers, Sof enables adaptive clipping of extreme values:
Quant: Qw = clamp (1 logg
W
)
+ (R),aa U)
(17)
Sot S
3.3 OPTIMIZED HYPERPARAMETEN SEARCH (OHS)
While element-wise LLR helps reduce local quantization error, the overall performance of PTQ critically depends the choice of quantizer hyperparameters. This motivates the exploration of an efficient search strategy to identify optimal hyperparameters. Our proposed OHS solution is a multi-level search strategy composed three components:
Tensor-Wise Asymmetric Bound Search (ABS): A calibration-free step that determines the per-channel based solely on the minimum and maximum weight values, as previously defined in Eq. (14-16), making it both simple and efficient.
Block- Wise Scaling Factor Search (SFS): Searches for the optimal per-channel scaling factor Soe by minimizing the reconstruction error at the block level (e.g., residual bottleneck in ResNet or an attention module in Transformer).
Block- Wise Dynamic Base Search (DBS): Adaptively assigns different M2 logarithmic base configurations across weight channels, guided by block-level reconstruction error.
ABS requires no calibration, while SFS and DBS are jointly optimized using a small calibration set by minimizing the Frobenius norm of the block-witd reconstruction enror:
arg min
[[ICAAW
(18)
Suf fi 222
The granularity of OHS can vary from tensor- to block-wise, wise, to align with different reconstruction levels. We analyze the impact of these search granularities, both with and without LLR, in Appendix Our findings reveal a strong synergy between the multi-level OHS and LLR, leading to higher quantized model accuracy and significantly faster convergence.
B
3.4 HARDWARE APPROXIMATION FUNCTION (HAF)
Beyond model accuracy, hardware efficiency is critical consideration for the practical deployment of quantized models. LogART, particularly when employing dynamic logarithmic bases, necessitates careful analysis of the associated hardware implementation complexity and efficiency.
To ensure a hardware-friene
design for the Arithmetic Element (AE) that handles computations involving /2 in LogART, we introduce HAF module. HAF is incorporated into the quantized forward pass during the OHS and LLR process, allowing the induced error to be absorbed as noise during the learning process. The core principle of HAF is to replace multiplications involving v with simple shift-add operations through the hardware approximation:
V2 ~ SDE(V2, K)
where an E 4-1,+1) de EN, di < d2 ..... (19)
2de

---

Published as a conference paper at ICLR 2026
Table 1: Ablation results of LogART key components LLMs with 3-bit per-channel weight quantization, evaluated in terms of calibration data (from WikiText-2) dependency, PPL on WikiText- 2 dataset, time cost, and GPU memory cost.
OPT-125M
LLaMA2-7B
DBS
LLR Calib, Data
PPL
Time
Memory
PPL
Time
Memory
X
170.64
0.7 s
0.40 GB
60.16
1
9.8 GB
X
X
X
32
66.63
3.8
0.75 GB
18.49
83.2
20.9 GB
X
32
36.10
16,8
0.75 GB
6,56
17.9 min
20.9 GB
V
V
X
32
34.29
17.0
0.75 GB
6.45
17.9 min
20.9 GB
32
31.15
75.1
0.75 GB
6.14
74.2
20.9
Table 2: Ablation results of LogART key components CNN and vision transformer models with 4-bit per-channel weight quantization, evaluated terms of top-1 accuracy and GPU runtime.
ResNet18
MobileNetV2
ViT-Base
DeiT-Tiny
DBS
SFS
ABS
LLR
Acc(%)
Time
Acc(%)
Time
Acc(%)
Time
Acc(%)
Time
x
x
31.53
0.9
1.22
1.9
79.55
0,0 min
57.25
0.0 min
68.45
1.0
66.91
2.3
84.24
0.1 min
69.17
0.0 min
69.69
10.8
69.47
22.0
84.61
2.8 min
70.29
1.4 min
69.89
1
69.86
24.4
84.67
min
70.40
1.4 min
70.79
72.3
71.62
156.6
85.02
10.9 min
71.62
5.6 min
Here, SDE(V2, K) denotes the K-term Signed Dyadic Expansion of the real number v2. For example, 2-term (K 2) approximation is /2 x 2 2-1
In Appendix C we provide detailed analysis of the hardware complexity of the AE designs in Figure 4 for different PTQ methods. Our evaluation demonstrates that the multiplier free LogART AE consistently achieves a favorable balance between accuracy and hardware efficiency.
4 EXPERIMENT
To evaluate the effectiveness of LogART, we conduct experiments across various models. An ablation study is performed analyze the contribution key components. LogART benchmarked against state-of-the-aar (SOTA) PTQ methods in terms of accuracy, GPU memory, runtime, data dependency, and AE hardware efficiency. Additional experiments and results are provided in the Appendix.
4.1 EXPERIMENTAL SETUP
Datasets and Models. We quantize publicly available pre-trained full-precision models, including LLMs: OPT Zhang et al. (2022) and LLaMA Touvron el al. (2023) series on the WikiText-2 2
al.
2017) and C4 Raftel et (2020) dataset; CNNs: ResNet al. (2016) and MobileNetV2
Sandler et al. (2018) on the ImageNet Russakovsky et al. (2015) dataset; and vision transformers:
ViT Dosovitskiy al. (202T) and DeiT Touvron al. 2021 on ImageNet.
Quantization Details. Our evaluation focuses on 3-bit and 4-bit weight-only quantization, a common setting that significantly accelerates large models by reducing memory movement overhead Kim et al. (024bb). While our experiments focus on weights, LogART RT is fully compatible with various existing activation quantization methods, such as SmoothQuani Xiao et al. (202)), AdaLog Wu et al. (2024), QuaRot Ashkboos et al. (2024), ERQ Zhong et al. (022)) and APHQ Wu et al. (2025). ) For the calibration dataset, we randomly sample 32 segments 2048 tokens each from the Wikilext-2 or C4 dataset for language tasks, and 2048 unlabeled images from ImageNet for vision tasks. The primary evaluation metrics are perplexity (PPL) for language modeling and top-1 accuracy for image classification. All experiments conducted single NVIDIA RTX 5090D GPU (32 GB).

---

Published as a conference paper at ICLR 2026
Table 3: Performance (PPL), GPU runtime, and memory usage of 3-bit weight quantization of
LogART and existing PTQ methods on LLM models. (Calibration data from C4)
Model
Method
FP16
GPTQ
BRECQ
AffineQuant
aespa
LogART
Domain
Linear
Linear
Linear
Linear
Log
OPT-125M
PPL (WikiText-2)
27.65
52.95
34.07
36.15
34.53
31.52
PPL (C4) Runtime
26.56
42.88
31.44
32.78
31.41
29.98
19.8
1.06
16.7 min
2.81 min
1.25 min
Memory (GB)
1.05
3.07
3.14
1.52
0.75
OPT-1.3B
PPL (WikiText-2)
14.63
20.36
16.09
17.26
16.07
15.53
PPL (C4)
16.07
20,53
17.46
18.27
17.40
17.29
Runtime
2.44 min
4,57 hr
1.10 hr
31.8 min
11.0 min
Memory (GB)
4.08
15.4
9.23
5.07
4.18
OPT-6.7B
PPL (WikiText-2)
10.86
13,01
0OM
12.30
11.35
11.11
PPL (C4)
12.71
14.61
OOM*
13.80
13.42
13.37
Runtime
12.2 min 12.3
OOM*
4.54 hr
4.42 hr
1.45 hr
Memory (GB)
OOM*
23.4
14.3
17.1
LLaMA2-7B
PPL (WikiText-2)
5,47
8.66
OOM*
6.80
6.45
6.31
PPL (C4)
7.26
11.24
OOM*
9.06
8.51
8.38
Runtime
10.4 min
OOM*
5,01 hr
3,39 hr
1,24 hr
Memory (GB)
8.28
OOM
23.7
21.2
20.8
LLaMA3-8B
PPL (WikiText-2)
6,14
11.14
OOM
8,95
8.19
PPL (C4)
9.45
13.86
0OM
12.59
12.44
Runtime
12.5 min
0OM
3.68 hr
1,46 hr
Memory (GB)
10.6
O0M*
20.0
21.6
OOM indicates that an out-of-memory (0OM) error occurred during quantization.
4.2 COMPARISON WITH SOTA APPROACHES
Ablation Study. Our ablation study, detailed in Table Table and Appendix validates
distinct and complementary contributions of each LogART component: DBS, SFS, ABS and LLR. The results identify SFS and LLR as the most impactful modules. SFS delivers a significant reduction in perplexity with moderate time overhead. Specifically, it lowers PPL LLaMA2-7B from 9.74 to 6.24 when added to the LLR baseline at the cost of extra 4.5 minutes. The benefits of L.RR are demonstrated by the significant accuracy boost it provides over the RTN counterpart. The advantage of DBS is clearly evident when applied alone. Compared to a fixed Log2 base, DBS reduces PPL by more than half, owing its enhanced flexibility in capturing diverse weight characteristics. ABS is highly efficient, providing consistent accuracy gains without calibration data and with negligible overhead. Its impact depends on model weight distributions, with larger improvements observed on LLaMA2-7B than on OPT-125M Ultimately, the study reveals powerful synergistic effect, as the full LogART with all components enabled consistently achieves the best performance. This confirms that each module is a vital and complementary contributor to the final result.
Comparison on LLMs. We benchmark the proposed LogART against several SOTA PTQ methods on LLMs, with per-channel weight quantization results presented in Table For our method, we enable the full OHS and LLR, performing optimization for 500 iterations using the Adam optimizer. We employ CosineAnnealingei and a rounding loss weight 1. We compare against strong basclines: the backpropagation GPTQ Frantar et al. (2023), the classic ootimization-basee BRECQ Li al. (202T). and its efficient successors AffineQuant Ma et al. (2024) and aespa Kim et al.) (2024a). For BRECQ, we employ the hyperparameter settings provided Li al. (021). For AffineQuant and aespa, we use their official implementations and reported settings. For a fair comparison, we use the calibration dataset from C4, and additional results using the WikiText-2 dataset are available in Appendix
scheduler with learning rate decaying from 0.05 0.015
LogART is the first logarithmic PTQ method to scale effectively to LLMs at 3-bit, and it consistently achieves SOTA accuracy across all tested LLMs. While GPTQ is the fastest method due its RTN-
8

---

Published as a conference paper at ICLR 2026
Table 4: Comparison of top-1 accuracy on ImageNet and GPU runtime (in minutes) for different
per-channel 4-bit weight PTQ methods on CNN models.
Method
FP16
AdaRound
BRECQ
FlexRound
LogNet
SLogll
LogART
Model
Domain
Linear
Linear
Linear
Log
Log
Log
ResNet18
Acc (%)
71.00
70.18
70.47
70.28
31.53
67.52
70.79
Runtime
8.0
9.3
_*
0.0
0.4
1.2
ResNet50
Acc (%)
76.63
75,86
76.43
75.95
42.76
74.14
76.57
Runtime
19.4
22.7
.*
0.0
2.1
3.1
MobileNetV2
Acc (%)
72.62
69.46
71.52
70.82 *
1.22
31.20
71.62
Runtime
17.6
19.5
0.0
1.3
2.6
The GPU runtime not reported and cannot he measured, as its code is not publicly available.
Table 5: Comparison of top-1 accuracy on ImageNet and GPU runtime (in minutes) for different
per-channel 4-bit weight PTQ methods on vision transformer models.
Method
FP16
BRECQ
APHQ
Adal
LogNet
SLogl
LogART
Model
Domain
Linear
Linear
Linear
Log
Log
Log
VIT-Small
Ace (%)
81.39
80.52
80.72
80.65
70.14
78.54
81.06
Runtime
35.6
32.1
32.2
0.0
3.1
6.7
ViT-Base
Acc (%)
85.10
84.83
84.79
84.77
79.55
83.54
85.02
Runtime
91.8
88.9
91.6
0.0
6.2
10.9
DeiT-Tiny
Acc (%)
72.16
71.34
71.46
71.14
$7.25
68.36
71.62
Runtime
21.9
22.2
22.1
0.0
1.6
5.6
DeiT-Base
Acc (%)
81.98
81.77
81.71
81.85
79.53
81.01
81.92
Runtime
92.5
89.0
91.7
0.0
6.2
10.9
based, learning-free design, LogART surpasses it with significant accuracy advantage. Compared to optimization-banl linear PTQ methods like BRECQ, AffineQuant, and aespa, LogART not only achieves lower perplexity but also substantially faster, reducing runtime by over 24.9x, 3.1 x and 2.2x, respectively, with similar or lower GPU memory usage. The outstanding performance of LogART is attributed the inherent advantages of logarithmic quantization, which better captures the data distribution in LLMs, and the synergistic effect of the proposed OHS and LLR techniques.
Comparison on CNNs and Vision Transformers. We compare LogART with SOTA PTQ methods on CNNs and vision transformers, with per-channel weight quantization results reported in Table Table Appendix F Baselines include linear-domain weight-rounding methods (AdaRound, BRECQ, FlexRound, APHQ, AdaLog) and logarithmic schemes (LogNet, SLoglI). Although AdaLog applies logarithmic quantization to activations and linear quantization to weights, we categorize under the linear domain in this comparison, our primary focus is weight quantization. For BRECQ Li al. 2021) and SLogll Xu et al. (2023), we use the official implementations with their reported settings. AdaRound Nagel et al. (2020) re-implemented following BRECQ, and LogNet [Lee et al.) (2017) is re-implemented following SLogII. Results for FlexRound Lee et al. (2023) are directly quoted from the original publication. For vision transformer experiments, we implement APHQ and AdaLog with official code?] Since the original BRECQ does not support vision transformers, we re-implement it within the APHQ framework. For LogART, we use the same settings as LLMs but increase LLR iterations to 2000 to ensure convergence on these architectures.
4
LogART consistently achieves SOTA accuracy across all evaluated CNN and vision transformer models. It significantly outperforms the logarithmic PTQ baselines, with particularly notable im- provements on MobileNetV2, where it achieves >40% higher top-1 accuracy. These gains stem from the proposed OHS and L.R techniques, whereas prior logarithmic PTQ methods are limited by symmetric quantizers, tensor-wise hyperparameter search, and naive RTN policies. Compared to advanced linear PTQ methods with learnalle rounding, LogART remains competitive in accuracy

---

Published as a conference paper at ICLR 2026
Table 6: HAF evaluation and AE comparison in terms of top-1 accuracy and hardware efficiency.
Hardware Evaluation
Accuracy (%) Evaluation
Method
W/A Domain
Arca(ym²)
Power(wW)
ViT-S
ViT-B
DeiT-T
DeiT-B
BRECQ
Linear/Lineat
95.8
6.28
80.47
84.69
71.05
81.36
AdaLog
Lincar/Log
76.2
5,56
77.37
83.15
67.18
80.14
LogART w/o HAF
80.12
84.36
70.14
81.51
Log/Linear
53.2
3.45
LogART HAF
81.02
84.99
71.59
81.88
while offering substantially higher efficiency, achieving speedups of over 6.3x, 3.9x,, 4.0x, and x.9x against AdaRound, BRECQ, APHQ, and AdaLog, respectively. The accelcration is primarily driven by the faster convergence enabled through the synergy of OHS and LLR.
HAF and AE Hardware Efficiency Evaluation. The proposed HAF is highly effective, incurring minimal accuracy degradation (<0.2% on vision models and <0.2 PPL on LLMs) compared to ideal LogART, while significantly outperforming a naive hardware approximation (e.g., +8.81 % accuracy on MobileNetV2). See Appendix(CI] for experimental results. For AE hardware efficiency, we sinulate LogART AE in Figure 4 under a 4-bit weight and 8-bit activation setting, with results presented in Table 6 and Appendix G Here, activation quantization is performed in the linear domain. Power and area consumption are synthesized in 28-nm UMC process using Synopsys Design Compiler, operating at 250 MHz and 0.9 V. BRECQ applies asymmetric linear quantization to weights and activations, requiring 8/8-bit multipliers and consuming 80.08% more and 82.03% more power than LogART. Since AdaLog uses linear quantization for weights and logarithmic quantization for activations, we adopt 8-bit weights and 4-bit activations for fair comparison. Compared to the LUT//ultiplier/hhiffe---bb AdaLog AE, LogART AE achieves a 43.23% area and 61.16% power advantage, confirming its superiority in both accuracy and hardware efficiency.
Computational Overhead in Practical Deployment. LogART achieves a dual advantage in com- putational overhead: low one-off offline model production cost and reduced recurring inference hardware cost. The one-off cost is incurred only during the model production phase, not during practical inference after deployment. The reported GPU runtime corresponds exactly this produc- tion time and explicitly includes the learning iterations. For practical usage, the learned rounding parameters are frozen into the model weights. Therefore, the recurring inference cost is determined by the AE. As discussed above, the LogART AE achieves significant hardware savings. From long-term perspective, the extra learning time a one-off setup cost amortized over millions of inference runs, resulting in a negligible marginal cost. Overall, LogART achieves competitive balance, offering both fast offline quantized model production and superior online inference hardware efficiency.
5 CONCLUSION
We propose LogART, the first PTQ scheme that integrates learnable rounding into the logarithmic domain. By combining this with the novel multi-base, outlier-resllient, and asymmetric quantizer through efficient search strategy, LogART pushes the limit of logarithmic weight PTQ to ultra-low bitwidths on LLMs, CNNs, and vision transformers. Furthermore, LogART achieves a superior trade- off between accuracy and hardware efficiency by incorporating practical hardware approximation directly into optimization. Extensive experiments validate that LogART not only consistently reaches SOTA accuracy but also achieves 40% reduction in AE area and power consumption. By providing a robust and hardware-awarr solution, LogART paves the way for the efficient deployment of large models on resource-constraaied hardware. Future work will extend LogART joint weight- activation quantization and explore its integration with other compression techniques.
ACKNOWLEDGMENTS
This work was supported in part by the Science and Technology Development Fund, Macau SAR (FDCT) under Grant 0001/2025/NRP; in part by the National Natural Science Foundation of China under Grant 62476062; in part by the University of Macau under Grant MYRG-GRG2025-00228 IME; in part by the Shanghai Platform for Neuromorphic and AI Chip (NeuHelium).
10

---

Published as a conference paper at ICLR 2026
REPRODUCIBILITY STATEMENT
To ensure reproducibility, we provide the full source code for LogART along with all experiment scripts in the anonymous repository linked in the abstract. All datasets used (ImageNet, C4, WikiText- 2) are publicly available, and our data processing and calibration procedures are described in Section 4 and Appendix [E] The experimental setup and hyperparameter configure configurations for all methods are detailed in Section 4. Comprehensive results, including full ablation tables and hardware analysis, and G to support our claims.
provided in Appendix B
ETHICS STATEMENT
This work does not involve human subjects, personally identifiable information, sensitive user data. All datasets used in our experiments (ImageNet, C4, and WikiText-2) are publicly available benchmark datasets, and we followed the standard licensing and usage guidelines associated with each. Our methods focus on post-training quantization and hardware-efficient deployment of large models such as LLMs and vision transformers. While model compression and efficiency improvements may enable broader deployment of these models, we acknowledge potential concerns about misuse, including the generation of harmful content or biased outputs inherited from pretrained models. We emphasize that our contributions exacerbate underlying dataset or model biases. We have taken care to report results transparently, and comply with research integrity and ethical guidelines as outlined in the ICLR Code of Ethics. The authors declare no competing interests.
methodological and hardware- focused,, and do not alter or
REFERENCES
Salch Ashkboos, Amirkeivan Mohtashami, Maximilian L. Croci, Bo Li, Pashmina Cameron, Martin Jaggi, Dan Alistarh, Torsten Hoefler, and James Hensman. QuaRot: Outlier-Free 4- 4-Bit Inference in Rotated LLMs. In Advances in Neural Information Processing Systems, volume 37, pp. 100213- 100240, 2024. URL httpp::/ppooceeeiiiiiice neuripsseeeppppp cwppaper Borrr_fiii__ ffles//aperr -aapraaaeeeeaaaeaeaaaaaor-oooooo Paper-
Stella Biderman, Hailey Schoelkopf, Quentin Gregory Anthony, Herbie Bradley, Kyle O'Brien, Eric Hallahan, Mohammad Aflah Khan, Shivanshu Purohit, Usvsn Sai Prashanth, Edward Raff, Aviya Skowron, Lintang Sutawika, and Oskar Van Der Wal. Pythia: A Suite for Analyzing Large Language Models Across Training and Scaling. In Proceedings of the 40th International Conference on Machine Leurning, volume 202, pp. 2397-2430, 23-29 Jul 2023. URL https //proceedings.. ml www.prressellp. www.0////idermmmm2mmm 23mmmmllll
Mengzhao Chen, Wenqi Shao, Peng Xu, Jiahao Wang, Peng Gao, Kaipeng Zhang, and Ping Luo. EfficientQAT: Efficient Quantization-Awart Training for Large Language Models. arXiv preprint arXiv:2407.1106,, 2024.
Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn. Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, Jakob Uszkoreit, and Neil Houlsby. An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale. In International Conference on Learning Representations, 2021. URL
abs/ 0tss/2110.1100
Steven K. Esser, Jeffrey L. McKinstry, Deepika Bablani, Rathinakumar Appuswamy, and Dhar- mendra S. Modha. Learned Step Size Quantization. In International Conference on Learning Representations, 2020. URL htttst:/t//aaiiiii 9ttp://aaraa...orraa////922220. 08153
Jun Fang, Ali Shafiee, Hamzah Abdel-Aziz, David Thorsley, Georgios Georgiadis, and Joseph H. Hassoun. Fost-Training Piecewise Linear Quantization for Deep Neural Networks. In The European Conference on Computer Vision (ECCV), pp. 69-86, 2020. ISBN 978-3-030-585335- doi: 10.1007/ 0188---000-5536-5555 URL |ttp:///AAAAaa////a...../..//0/.
Elias Frantar, Saleh Ashkboos, Torsten Hoefler, and Dan Alistarh. GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers. In International Conference on Learning Representations, 2023. / 17323

---

Published as a conference paper at ICLR 2026
Ruihao Gong, Xianglong Liu, Yuhang Li, Yunqiang Fan, Xiuying Wei, and Jinyang Guo. Pushing the Limit of Post- -rainnngn Quantization. IEEE Transactions on Pattern Analysis and Machine Intelligence, pp. 1-15, 2025, doi: 10.1 101109/TAAML20033555553.3
Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep Residual Learning for Image Recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2016.
Junhan Kim, Chungman Lee,, Eulrang Cho, Kyungphil Park, Ho young Kim, Joonyoung Kim, and Yongkweon Jeon. Towards Next-Level Post-Training Quantization of Hyper-Scale Transformers. In The eighth Annual Conference on Neural Information Processing Systems, 2024a. URL
https: /aaxivv..ivv.....a org/ abs 2 2402 08958
Schoon Kim, Coleman Richard Charles Hooper, Amir Gholami, Zhen Dong. Xiuyu Li, Sheng Shen, Michael W. Mahoney, and Kurt Keutzer. Squee7el.LM: Dense-and-Sparse Quantization. In Proceedings of the 41 International Conference on Machine Learning, volume 235, pp. 23901-23923, 21-27 Jul 2024b. URL.htttss:/arxxiv...
Eunji Kwon, Minxuan Zhou, Weihong Xu, Tajana Rosing, and Seokhyeong Kang. RL-PTQ: RL- based Mixed Precision Quantization for Hybrid Vision Transformers. In Proceedings of the 61st ACM/EEE Design Automation Conference, DAC '24, 2024. ISBN 9798400706011, doi: 10.1
URL
145/ 364
Edward H. Lee, Daisuke Miyashita, Elaina Chai, Boris Murmann, and S. Simon Wong. LogNet: Energy-Efficien Neural Networks Using Logarithmic Computation. In 2017 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 5900-5904, 2017. doi:
10.1009ICASPP:227777553
Jung Hyun Lee, Jeonghoon Kim, Se Jung Kwon, and Dongsoo Lee. FlexRound: Learnable Rounding based on Element-wise Division for Post- Trainirainng Quantization. In Proceedings of the 40th International Conference on Machine Learning, volume 202, pp. 18913-18939, 2023. URL
prresprrsss.... 2202//ee2222e2e lee23h html
Yuhang Li, Ruihao Gong, Xu Tan, Yang Yang. Peng Hu, Qi Zhang, Fengwei Yu, Wei Wang, and Shi Gu. BRECQ: Pushing the Limit of Post- Best-Training Quantization by Block Reconstruction. In International Conference on Learning Representations, 2021. URL https:://axii..tr
abs/ /ass/2202..m 01426
Zhikai Li, Junrui Xiao, Lianwei Yang. and Qingyi Gu. RepQ-ViT: Scale Reparameterization for Post-Training Quantization of Vision Transformers. In Proceedings of the IEEE/CVF International Conference Computer Vision (ICCV), pp. 17227-17236, October 2023.
Lin, Jiaming Tang, Haotian Tang, Shang Yang. Wei-Ming Chen, Wei-Chen Wang, Guangxuan Xiao, Xingyu Dang, Chuang Gan, and Song Han. AWQ: Activation- aware Weight Quantization for On-Device LLM Compression and Acceleration. In Proceedings of Machine Learning and Systems, volume 6, pp. 87-100, 2024. URL
pdd
Yang Lin, Tianyu Zhang. Peiqin Sun, Zheng Li, and Shuchang Zhou. FQ-Vit TQ- Post- Bost-Training Quantization for Fully Quantized Vision Transformer. In Proceedings of the Thirty-Firss In- lernational Joint Conference on Artificial Intelligence, IJCAI-22, pp. 1173-1179, 179, 7 2022. doi: 2022/164
10.24963/jcca.22022/61
htl.stts:: wttpooooo///...////eeeee.
Zechun Liu, Barlas Oguz, Changsheng Zhao, Ernie Chang, Pierre Stock, Yashar Mehdad, Yangyang Shi, Raghuraman Krishnamoorthi, and Vikas Chandra. LLM-QAT: Data-Free Quantization Aware Training for Large Language Models. arXiv preprint arXiv:2305. 2058.288..888.. 2023.
Yuexiao Ma. Huixia Li. Xiawu Zheng, Feng Ling, Xuefeng Xiao, Rui Wang, Shilei Wen, Fei Chao, and Rongrong Ji. AffineQuant: Affine Transformation Quantization for Large Language Models. In International Conference on Learning Representations, 2024. URL https: /ttp:://axivoooooo pdf /2403. 12544
12

---

Published as a conference paper at ICLR 2026
Stephen Merity, Caiming Xiong, James Bradbury. and Richard Socher. Pointer Sentinel Mixture Models. In International Conference on Learning Representations, 2017. URL https://
arxiv.org/ absgg//bs// www.ab//...... wtt.v.orrr//bs//100.078888
Markus Nagel, Rana Ali Amjad, Mart Van Baalen, Christos Louizos, and Tijmen Blankevoort.
Up or Down? Adaptive Rounding for Post-Training Quantization. Proceedings of the 37th International Conference Machine Learning, volume 119, pp. 7197-7206, 13-18 Jul 2020.
URL htttps://proceeddnngg wttp:gg..mr......s...m wtt......e/..////aaeer..eeeeeee. 120a .ttml
Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer. Journal of Machine Learning Research, 21(140):1 2020. URL
http://jmlr: wwtp:/pppppppppataet.taee.eeeaee
papers wwwpaarrrr.aaaaaaaaaaaeeaee (ttpperrs/2//2-044hhhh... html
Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. ImageNet Large Scale Visual Recognition Challenge. International journal of computer vision, 1 11:2211-22,, 2015.
Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh
Chieh Chen. Mo- bileNetV2: Inverted Residuals and Linear Bottlenecks. In Proceedings of the IEEE Conference Computer Vision and Pattern Recognition (CVPR), June 2018.
Hugo Touvron, Matthieu Cord, Matthijs Douze, Francisco Massa, Alexandre Sablayrolles, and Herve Jegou. Training Data-Efficient Image Transformers & Distillation Through Attention. In Proceedings of the 38th International Conference on Machine Learming, volume 139, pp. 10347- 10357, 18 24 Jul 2021. URL ptttps://proceeddnngg mlr.mmm.... wtt..ppress/ull///twoooo..
html
Hugo Touvron, Thibaut Lavril, Gautier Izacard, Xavier Martinet, Mane Lachaux, Timothée Lacroix, Baptiste Rozière, Naman Goyal, Eric Hambro, Faisal Azhar, et al. LLaMA: Open and Efficient Foundation Language Models. arXiv preprint arXiv:2302.1397 2023.
Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, F. ukasz Kaiser, and Illia Polosukhin. Attention is All you Need. In Advances in Neural Information Pro- cessing Systems, volume 30, 2017. /tRLLttttpp:/rrrrceeiing...
ccppper pdf
Zhuguanyu Wu, Jiaxin Chen, Hanwen Zhong, Di Huang, and Yunhong Wang. AdaLog: Post- Training
Quantization for Vision Transformers with Adaptive Logarithm Quantizer. In The European Con-
ference on Computer Vision (ECCV), pp. 411 411-427, 2024. ISBN 978-3-031-73388-6 doi: 10.10
00100001-7330 73383-73333 978-3-031-73383-3224 URL/tttps: //tp:::////ooo/o org 1007 -311--333-----------------33----
24
Zhuguanyu Wu, Jiayi Zhang, Jiaxin Chen, Jinyang Guo, Di Huang, and Yunhong Wang. APHQ-ViT Post-Training Quantization with Average Perturbation Hessian Based Reconstruction for Vision Transformers. In Proceedings the IEEE/CVF Conference Computer Vision and Pattern Recognition (CVPR), June 2025. URL.
abaaaaas22000 2504 02508
Guangxuan Xiao, Ji Lin, Mickael Seznec, Hao Wu, Julien Demouth, and Song Han. SmoothQuant: Accurate and Efficient Post-Training Quantization for Large Language Models. In Proceedings of the 40th International Conference on Machine Learning, volume 202, pp. 38087-38099, 23-29 Jul 2023. URL htt.tp:://pprccedi.not/ mlr presss /22/2222222222 http/22//xxxx2200 http:/xaxac3cc.c html
Jiawei Xu, Yuxiang Huan, Li-Rong Zheng, and Zhuo Zou. A Low-Power Arithmetic Element for Multi-Base Logarithmic Computation on Deep Neural Networks. In 20/8 3 IEEE International System-on- on-hhp Conference (SOCC), pp. 48. 2018. doi: 10. 000////00C.111888188866600
Jiawei Xu, Yuxiang Huan, Yi Jin, Haoming Chu, Li-Rong Zheng, and Zhuo Zou. Base-Reconfigurable Segmented Logarithmic Quantization and Hardware Design for Deep Neural Networks. Journal of Signal Processing Systems, 92(11): 1263-1276. 2020. doi: 10. 1265-20000155--8.
Jiawei Xu, Jiangshan Fan, Baolin Nan, Chen Ding, Li-Rong Zheng, Zhuo Zou, and Yuxiang Huan.
ASLog: An Area-Efficiemt CNN Accelerator for Per-Channel Logarithmic Post- Training Quantiza- tion. IEEE Transactions on Circuits and Systems Regular Papers, 70 70(12):5380-338 2023. doi: 10. 00.100/TCCS1.223.33311
2023.
13

---

Published as a conference paper at ICLR 2026
Susan Zhang, Stephen Roller, Naman Goyal, Mikel Artetxe, Moya Chen, Shuohui Chen, Christopher Dewan, Mona Diab, Xian Li. Xi Victoria Lin, Todor Mihaylov, Myle Ott, Sam Shleifer, Kurt Shuster, Daniel Simig, Punit Singh Koura, Anjali Sridhar, Tianlu Wang. and Luke Zettlemoyer. OPT: Open Pre-trained Transformer I Language Models. arXiv preprint ax00v2205.01066,, 2022. URL httphhtts///aiiii wtt.v//..rrgbbb//....... 01068
Yunshan Zhong, Jiawei Hu, You Huang, Yuxin Zhang, and Rongrong Ji. ERQ: Error Reduction for Post- Training Quantization of Vision Transformers. In Proceedings of the 41st International Conference on Machine Learning, 2024. URL https: /ttp:://ppeeeveeeeee ew. net/ / forum?? d= KKOW1 1 grabb
14

---

Published as a conference paper at ICLR 2026
A GRADIENT OF TASK-AWARD LLR LOSS
The total loss function for LLR combines a task-aware reconstruction error with a regularization term. For example, under layer-wise reconstruction granularity, the loss defined according Eq. (8) as:
| | p+], Lreg = X (reg(R),
C Lrecon + Cregs
Crecon = E
(20)
Sreg (R)
1 22 (Rij) 11))
(21)
1,j
For block-wise reconstruction granularity, the reconstruction loss for attention module is defined as:
Lrecon = K| (ali))--A(Q,,,
SA(Q, K, V)
(22)
Here SA K, V) generates the output of the attention module, and AWQ. q. AWK, AW denote the quantization error of query, key, and value projections respectively. To reduce computational overhead, Crcoo is further optimized in a divide-and saide-and-conquer manner Kim et al. (2024a):
Precon = [|SAA SA(Q, K, v
RS |KAWaXX
(23)
-
[ K|
E
AWQ XX | AWa
CK recon
= E
|SA[Q K. V) K, VJ 1 [QA
(24)
[ Q] AWK E X J -WK
|||[SACQ. K, V) SA(Q,K, v 1)[1]] =E [AA
CYacom
TE.
(25)
=trAAw E [XA AWv.).
The aim of the LLR process is to minimize the loss function L by optimizing the learnable variable R using stochastic gradient descent. The gradient L with respect to R is derived through the following steps. The gradient of the layer-wise reconstruction error term is computed by propagating derivatives through the quantization chain. First, the derivative of the loss L with respect W is:
OC 2. (WX - WX) X
(26)
OW
which captures the sensitivity of the Frobenius norm to deviations between the original and quantized weights. The quantized weights W depend on the integer form Qw during logarithmic quantization as shown in Eq. (6), leading to:
ow 2n sgn(w) (W) O 2 Qw,
(27)
dQw
The Qw clamped within [0, N 1] to enforce bit-width constraints, introducing binary mask M
M. I(Qw N01 -1),
(28)
that truncates gradients outside the valid range. Combined with the derivative of the sigmoid function a (R), the reconstruction gradient becomes:
oLrcco
OR
2s M, ④ 2 Qw sgn (W)
(WX-WxX) W
-
ØR
(29)
For the regularization term freg. its gradient expressed directly in differential form without expanding the chain rule:
Ö X Öfeeg(R) (R)
(30)
ØR
0R
15

---

Published as a conference paper at ICLR 2026
The total gradient of the loss with respect to R combines both components:
dc
rCrccon
3Creg
(31)
òR
OR
ŌR
That is the gradient for LLR, and we will next compare it to the gradient used in the learnable rounding process for symmetric linear quantization counterpart. While the loss function remains the same, the soft-quantizer weights in the linear quantization setting are defined as:
Quant: : Qw' = clamp (10N-1
W 8
a (R'),0,2*11-1) ='x W)),
(32)
Dequant: W
sgn W) C Qw'.
(33)
2N-1
The gradient of l' with respect to R' is derived as:
ec
2x'
M @ sgn( (W) ④ (WX W'XX
do (R()))
(34)
OR
2N -1
0R!
oL'reg
= A OSreg( (R')
(35)
0R'
δR'
OL
a. òR'
05
(36)
0R'
0R'
The key difference between the gradients of logarithmic and linear Iearnable rounding lies in the term Orecoon /ŌR, which originates from their distinct quantization strategies. In logarithmic quantization, the reconstruction gradient derived in Eq. (29) includes an exponential term 2 Qw and a logarithmic scaling factor In 2. In contrast, linear quantization uses a constant scaling factor of -|ー in Eq.
(34). The presence of the exponential term 2 Qw in LLR results in smaller gradients for weights with small magnitudes, while the constant scaling in linear quantization provides more uniform gradient flow across all weight magnitudes. Assuming s' RJ 8, the ratio between the gradient scaling factors in logarithmic and linear quantization becomes In 2 2 Qw to 2v - This ratio is particularly useful when considering the appropriate choice of the regularization coefficient X, which governs the trade-off between reconstruction fidelity and rounding determinism. larger À encourages harder rounding behavior, while smaller À allows softer updates during optimization.
16

---

Published as a conference paper at ICLR 2026
B SYNERGISTIC EFFECTS OF MULTI-LEVEL OHS AND LLR
We conduct a detailed analysis the synergistic relationship between the proposed OHS and LLR techniques, drawing insights from the comprehensive ablation results in Table [1 Our findings reveal that their integration is a key driver of LogART effectiveness: beyond being merely additive in quantization performance, the synergy between OHS and LLR also accelerates convergence and substantially enhances overall optimization.
B.1 OHS AS AN ENABLER FOR EFFECTIVE LEARNABLE ROUNDING
The effectiveness of LLR ultimately bounded by the quality of the underlying quantization grid. While LLR can optimize how values are mapped to existing quantization points, it cannot compensate for a poorly chosen grid. The final accuracy will remain limited regardless of rounding quality. This is where synergy with OHS becomes critical. The multi-level OHS (comprising tensor-wise ABS, block-wise SFS, and Block-wise DBS) first establishes an optimal quantization grid, which then enables LLR to fully exploit its rounding optimization.
ABS corrects for asymmetry based on the original weight distribution and therefore requires only tensor-wise search. SFS improves robustness outliers, while DBS selects the most appropriate base Both SFS and DBS operate an activation-awar manner through block-wise search. This multi-level search strategy also avoids the vast search space that would otherwise prolong OHS runtime. By constructing better-structured grid, OHS enables LLR to converge to a superior final solution with lower overall quantization performance gains in Table [T] where each OHS component added on top of the LLR baseline further improves results, resulting the best performance when all components are active.
This is validated by the consistent and cumulative
B.2 LLR AS HINER-GRAINGE OPTIMIZATION BUILT ON EFFECTIVE SEARCH
Compared to the yoarse-grained OHS, which focuses on optimizing quantization hyperparameters for an entire weight tensor, L.RR operates at the element level. Specifically, L.R learns the optimal rounding decision for each weight element to minimize the task-aware loss. The additive benefit of LLR clearly demonstrated Table where, under every configuration of DBS, SFS, and ABS, the inclusion of LLR consistently leads to higher accuracy than the corresponding setting without it.
This is because a naive RTN policy produces a highly suboptimal and rugged loss landscape. LLR fundamentally changes this dynamic by introducing task-aware, learnable rounding mechanism. A drawback of LLR is that requires backpropagation at the layer or block level, making the gradient descent process isstucce-nteesive and time-consuming, particularly for large models such as LLMs. Therefore, improving the convergence speed of L.R has become critical topic.
B.3 THEORETICAL ANALYSIS OF COMPONENT SYNERGY
We mathematically justify the synergy between OHS and LLR by decomposing the quantization етror in the task-aware metric space. The LogART optimization objective minimizes the task-aware reconstruction loss. Let W denote the soft-quantized weight matrix and AW w - -W be the quantization error. The loss function can be expressed as a Frobenius norm by incorporating the matrix square root of the Hessian H E|XX] _ directly into the norm:
f (A (AWHAWT)
AWH
(37)
The triangle inequality establishes an upper limit on the quantization enror norm, separating it into two distinct geometric terms:
AWH F s (l(w-utto -o (W))
(u (w) W)
+
(38)
(OHS)
Ea (LLR)
Here, C(0) denotes the quantization codebook characterized by OHS hyperparameters 0 {Sot, l. and C(o) (W) represents the ideal projection of W onto C(0) under the Hessian- weighted metric. Since minimizing non-negative norm 8 is equivalent to minimizing its square
17

---

Published as a conference paper at ICLR 2026
E formulate the following optimization objectives in the squared domain for mathematical convenience and consistency with the loss definition. The term & defines the intrinsic discretization enror determined purely by the geometry of the codebook. OHS explicitly minimizes this term to identify the optimal (
0- = arg min
Σ min ((W c)² - cEC(8)
(39)
where 8r denotes the optimal set of hyperparameters found by OHS, c denotes a codebook value, and H refers to the diagonal elements of the Hessian. Specifically, SFS aligns the global scale through 8of, DBS optimizes local density using ni, and ABS adjusts support bounds by la The term E2 represents the optimization gap between the ideal projection C(0) and the result W determined by LLR. LLR learns the optimal rounding variable R*:
R = arg min R
( c(0
(W)
s.t. W WEC())
(40)
This mathematical decomposition proves the synergistic relationship. OHS searches for the optimal quantization grid that minimizes the intrinsic discretization error, while LLR learns the optimal rounding decision to minimize the residual error that established grid. Consequently, the full integration of all proposed components yields the theoretically optimal configuration.
B.4 ACCELERATED CONVERGENCE
The synergy between OHS and LLR also accelerates convergence during the learnable rounding phase. When LLR operates on a poorly configured grid, its optimization must compensate for the inherent flaws of that grid. By using OHS establish more suitable quantization grid, the rounding problem becomes simpler and better-posed, allowing the optimizer to reach a high-quality solution in fewer iterations.
Table Performance (PPL) and runtime comparison of LLR convergence with and without OHS.
Runtime (min)
PPL
ABS
SFS
DBS
LLR iters
OHS
LLR
Total
WikiText-2
C4
x
X
2000
0.05
3.95
4.00
36.27
34.60
500
0.28
0.97
1.25
31.15
30.44
50.0
47.5
w/o OHS, WikiText-2 (Mean)
Performance (PPL)
LLR w/o OHS, PPL on WikiText-2 (Min/Max)
42.5
LLR w/ OHS, PPL on WikiText-2 (Mean)
LLR OHS, PPL WikiText-2 (Min/Max)
40.0
w/o OHS,
C4 (Mean)
LLR w/o OHS, PPL on C4 (Min/Max)
LLR w/ OHS, PPL on C4 (Mean)
35.0
LLR OHS, PPL on C4 (Min/Max)
32.5
30.0
500
1250 1500
Number Iterations
Figure 5: LLR combined with multi-level OHS converges faster and achieves higher accuracy.
To validate the accelerated convergence, we conducted a comparative experiment on the OPT-125M model using the WikiText-2 calibration dataset. We compare two configurations, both including LLR. The experimental group employs our full multi-level OHS with the same settings as our main LLM experiments. The control group uses simplified strategy where ABS, SFS, and DBS are all disabled,
18

---

Published as a conference paper at ICLR 2026
with the total number of iterations, learning rate and weight of the rounding loss to 2000, 0.015, and I, respectively. The results, shown in Table 7 and Figure indicate that while multi-level OHS itself incurs longer runtime due to the required local forward computations, it enables LLR to converge more efficiently to a better local minimum, resulting in superior overall accuracy and total runtime.
19

---

Published as a conference paper at ICLR 2026
C HAF MODULE AND HARDWARE-LEVER ANALYSIS
We analyze the hardware complexity of the AE designs for the core WX computation resulting from different PTQ methods applied to weights:
Linear: Linear quantization schemes include symmetric and asymmetric approaches. Sym- metric linear PTQ allows the AE to be implemented using low-bitwidth fixed-point signed integer multipliers (INT SMUL). Asymmetric linear PTQ, due to the introduction of zero- point offsets in quantized weights, typically requires INT SMUL in Figure a) with higher bitwidth or additional hardware to handle these offsets.
Log2: Base-2 logarithmic PTQ offers significant hardware advantages by enabling the replacement of multipliers with shifters, as shown in Figure 4b). To accommodate the sign of the weights, the AE incorporates signed operational logic to compute correctly.
Logv2: Base-v2 quantization does not directly translate to multiplier-frre operations. However, hardware efficiency can be achieved by v2 R 20 + 2-1 Xu et al. (2018) 2023). This approximation allows multipliers be replaced with shift-add operations, as shown in Figure 4 c).
AdaLog: It important to note that AdaLog Wu et al. 2024) does not support logarithmic quantization for weights. Instead, it applies logarithmic quantization to activations while keeping weights linear. To enable flexible logarithmic bases, AdaLog adopts an AE design that combines LUTs, multiplier, and a shifter, as illustrated in Figure ( provides flexibility but at the cost of higher resource utilization.
(d). This design
LogART: LogART adopts a multiplier- freee AE design (Figure 4(e) that facilitates DLog-
quantized WX computation through shift-add approach enabled by HAF. Configured with dynamic logarithmic bases, the AE takes in the quantized weight and input activation codes, along with control signals such as n and chk_even. The decoder, implementable with simple combinational logic, generates the enable signal for the Approx module and the shifting bits for the Shift module.
To effectively incorporate the hardware approximation into the LogART LLR process, allowing the induced error be absorbed as noise during the learning process, introduce add-on HAF into the quantized forward pass. As described in Eq. (9)-(17,, the floating-point weight matrix W first quantized into its integer-form representation Qw, and subsequently dequantized back into hard-quantized W. To model the hardware approximation, an element mask M generated, which is used to modify the dequantized weights W, resulting in an approximated version W
M = (Q mod 2) 3 B v2]
W W o (7-
(41)
where mod denotes the modulo operation that returns the remainder after division, [B = v2 is an dlement-wise indicator function identifying which elements of B are equal to v2, and y represents the hardware approximation factor:
SDE( ()
(42)
V2
Here, SDE(V2, K) denotes the Signed Dyadic Expansion function, which takes the real number / and integer K, and returns a signed dyadic expansion approximation with K terms:
1 2d
SDE(V2,K)
where as E (-1,+1) de E, d1 < de d3
(43)
This expansion useful for replacing the multipliers required in -2-involved computation with shifters and adders, thereby enabling efficient hardware AE design. The construction of the SDE function follows a greedy iterative approach. Starting with the initial residual rı 22, at each iteration k we search for the integer d, that meet the requirement:
1
1 |rxl <
(44)
2d
2d
20

---

Published as a conference paper at ICLR 2026
We then assign the sign ag to match the sign of the residual:
ag = sgn(rx) (-1,+1}
(45)
Next, the selected dyadic term is subtracted from the residual:
Tk+11 Tk ap 2d
(46)
This process is repeated to generate a sequence of signed dyadic terms that bring the residual closer to zero. After K steps, the partial sum Σk=1 4kk 2% provides an approximation of /2 with K terms. By determining the number of terms K, obtain the SDE approximation of v2. The absolute error introduced the approximation of /2 by HAF is defined as:
can generate the corresponding AE design and
CK = V2 V2 SDE K)
|rx+1| = Pк ak
(47)
2d
From Eq. (44) and (45), we derive the theoretical upper bound of ex
<K |rx]
(48)
2d
1
1
(49)
2dx
2dx
2dx'
Utilizing this approximation to compute 7 and W', the error induced by HAF on the quantized
weights W is given by:
o ( 1)M,
(50)
where the hardware approximation factor 7 relates to the final residual TK+1 as:
SDE(V2, K)
/2 TK+1
TK+1
(51)
22
2
v2
Applying the 22 error bound in Eq. (49) yields the theoretical upper bound of the weight error:
rK+1
AW
W
O M
(52)
V2
C M.
(53)
V2 2dx
This local weight error propagates through the quantized forward pass, affecting the task-aware reconstruction loss L:
c (W(WW))
= E |wwx| = ((WHAW"), H= ]
(54)
r tr (WOM H ( M)))
(55)
2
21+24x tr (WoM) M)
H
W ( WOM)).
(56)
This derivation provides the theoretical upper bound for the HAF-induced error in the reconstruction loss, which diminishes exponentially with respect to dx. While a larger K reduces reconstruction loss and potentially improves accuracy, incurs increasing hardware overhead. Specifically, as K increases, the area and power consumption of the AE design grow sublinearly.
To resolve this trade-off, we integrate the HAF-induced error directly into the LLR learning pro- cess, allowing the model to compensate via element-wii optimized rounding decisions. During backpropagation, HAF introduces additional gradient path from W to W:
W
=1+ 1)M.
(57)
ow
By incorporating this error into the gradient descent of LLR, the optimization theoretically learns to absorb this deviation. This ensures dual benefit. The final accuracy using HAF (K 2) is
21

---

Published as a conference paper at ICLR 2026
Table 8: Evaluation of how K affects top-1 accuracy (%) and GPU runtime for 4-bit PTQ CNNs.
Method
HAF
ResNet18
ResNet50
MobileNerV2
LogART
Acc
70.79
76.57
71.62
Runtime (min)
1.2
3.1
2.6
K 2
X
Acc
68.75
74.41
62.64
K = 3
X
Acc
70.68
76,36
70.94
K
Acc
70.59
76.48
71.49
V
Runtime (min)
1.3
3,4
2.8
K
Acc
70.71
76,48
71.45
70.74
76.59
71.63
=
Acc
70.79
76.53
71.64
Table 9: Evaluation of how K affects top-1 accuracy (%) and GPU runtime for 3/4-bit PTQ on vision tranformers.
Method
W
HAF
VIT-S
ViT-B
DeiT-T
DeiT-B
LogART
4-bit
Acc
81.06
85.02
71.62
81.92
4-bit
x
Runtime (min)
6.7
10.9
5.6
10.9
K 2
4-bit
X
Acc
80.12
84,36
70.14
81.51
K 3
4-bit
X
Ace
80.81
84.89
71.35
81.79
K
4-bit
Ace
80.97
84,96
71.50
81.84
4-bit
Runtime (min)
6,8
11.4
5.7
11.2
K K 3
4-bit
Ace
81.02
84,99
71.59
81.88
4-bit
Acc
80.98
85.01
71.70
81.94
K ==d 4
4-bit
Acc
80.98
84.98
71.63
81.92
LogART
3-bit
Acc
79.56
84.54
70.21
81.51
3-bit
Runtime (min)
5.9
9,9
5.0
10.1
K 2
3-bit
X
Acc
78.89
84.18
69.50
81,28
K 3
3-bit
X
Acc
79.35
84.36
69.80
81.39
K 4
3-bit
X
Acc
79.41
84.42
70.10
81.44
3-bit
Runtime (min)
6.0
10.3
5.2
10.3
K 2
3-bit
Acc
79.67
84.58
70.14
81,45
K 3
3-bit
Ace
79.50
84.56
70.25
81.50
K 4
3-bit
V
Acc
79.46
84.51
70.26
81.52
negligibly different from ideal v2 implementation, while the LogART AE maintains its most efficient configuration. To assess the trade-off and the effect K on final accuracy, we conduct 3-bit and 4-bit per-channel weight quantization experiments LLM, CNN and vision transformer models.
The experimental setup for LogART follows the configuration in Section 4.2, enabling full OHS in combination with L.IR. "ideal" LogART variant, which assumes a perfect representation of /2. used the benchmark. To evaluate the impact of hardware approximation, compare the top-1 accuracy when applying the approximation function with:
K =
v2x 1+
(58)
K = 3:
-2 1
+
(59)
2
24
K 44 V2 1
(60)
24
26
Experimental results in Tables 10 and confirm the effectiveness of the proposed HAF, naive hardware approximation presents difficult trade-off: increasing the number of approximation terms (K) improves accuracy by providing better estimate of v2. but also significantly increases the area and power consumption of the LogART AE. The proposed HAF resolves this dilemma. Experimental results show that the accuracies with HAF are consistently higher than those under
22

---

Published as a conference paper at ICLR 2026
Table 10: Evaluation of how K affects 3-bit PTQ OPT-125M. (Calibration data from WikiTeex-2)
Method
HAF
WikiText-2
C4
LogART
PPL
31.15
30.44
Runtime
75.1
K 2
PPI.
31.94
30.66
K = 3
x
PPI.
31.62
30.58
K 1
PPI.
31,48
30.54
Runtime (s)
79.5
K 2
PPI.
31.30
30.40
K 3
PPL.
31.34
30.42
K 4
PPL
31.30
30.44
naive hardware approximation. By incorporating the hardware approximation error into the OHS and LLR optimization process, the chosen hyperparameters and element- wise rounding decisions become robust to the hardware approximation error and the choice of K. The performance degradation is negligible, and in some cases, the HAF-enabled model can even surpass the "ideal" LogART (e.g.. with K = 2 for 3-bit quantization on the ViT-Small model). As HAF mitigates the accuracy impact of a lower K, we select K for our final LogART AE design, achieving superior hardware efficiency while maintaining performance.
23

---

Published as a conference paper at ICLR 2026
D FULL ABLATION STUDY
We provide comprehensive component-yy-compone results of the full ablation study, which are excluded from the main text due to page limitations. The evaluation encompasses LLMs (OPT-125M, LLaMA2-7B), CNNs (ResNet18, MobileNetV2), and vision transformers (DeiT-Tiny, ViT-Base). These experiments validate the individual and synergistic contributions of the four key components of LogART: DBS, SFS, ABS, and LLR.
To clarify the ablation study conditions in Table and Table 2 the following settings are used when components disabled: without LLR,, standard RTN policy is applied; without ABS, symmetric quantizer is used; without SFS, the scaling factor is fixed to and without DBS, a fixed Log2 base used. The absolute baseline (first row), with all components disabled, represents symmetric, single-base Log2 quantizer that uses a simple RTN policy and fixed scaling factor of 1.
Table 11: Full ablation results of LogART key components LLMs with 3-bit channel-we weight quantization, evaluated in terms of calibration data (from WikiTexx-2) dependency, PPI. on WikiText-2 dataset, time cost, and GPU memory cost.
OPT-125M
LLaMA2-7B
DBS
SFS
ABS
LLR
Calib. Data
Time
Memory
PPL
Time
Memory
X
170.64
0.7
0.40 GB
60.16
13.0
9.8 GB
32
38.55
61.3
0.75 GB
9.74
58.6 min
20.9
X
X
X
79.70
0.7
0.40 GB
8.28
13.2
9.8 GB
V
32
36.39
61.3
0.75 GB
6.44
58.2 min
20.9 GB
V
32
38.41
12.1
0.75 GB
6.66
6.6 min
20.9 GB
32
33.21
64.6
0.75
6.24
63.1 min
20.9
X
X
32
35.15
12.2 s
0.75 GB
6,55
6.6 min
20.9 GB
32
32.55
64.6
0.75
6,23
63.5 min
20.9 GB
32
66.63
3.8
0.75 GB
18.49
83.2
20.9 GB
X
32
35.46
62.7 s
0.75 GB
9.26
59.0 min
20.9 GB
X
32
47.92
3.8
0.75
7,82
82.2
20.9
32
33.68
62.9 s
GB75
6,38
59.1 min
20.9 GB
32
36.10
16.8
0.75
6.56
17.9 min
20.9 GB
32
32.37
75.0
OB75
6.19
73.7 min
20.9 GB
X
32
34.29
17.0
OB75
6.45
17.9
20,9 GB
32
31.15
75.1 8
0.75
6.14
74.2 min
20.9 GB
Table 12: Full ablation results of LogART key components on CNN and vision transformer models with 4-bit channel-wise weight quantization, evaluated in terms of top-1 accuracy on the ImageNet dataset, and GPU runtime.
ResNet18
MobileNetV2
ViT-B
D
DBS
SFS
ABS
LLR
Acc(%)
Time
Acc(%)
Time
Acc(%)
Time
Acc(%)
Time
31.53
0.9 s
1.22
1.9
79.55
0.0 min
57.25
0.0 min
X
69.75
60.8
68.58
133.0
84.43
min
69.58
4.2 min
X
X
X
32.04
1.0s
1.25
1.9
79.63
0.0 min
57.37
0.0 min
X
V
69.78
61.0s
68.62
1
84.50
8.1 min
69.65
4.2 min
V
67.13
2.8
58.43
5.6
83.25
0.6 min
64.32
0.3 min
69,82
62.7s
68.96
138.8
84.59
8.9 min
69.81
4.5 min
X
67.29
2.8
58.48
5.6%
83.31
min
64,38
0.3 min
69.89
62.8
69.02
138.9
84.67
8.9 min
69.85
4.5 min
68.45
1.0
66.91
2.3
84.24
0.1 min
69.17
0.0 min
70.50
61.7
71.24
134.4
84.91
8.3 min
71.44
4.2 min
X
69.04
1.0S
2.3
84.28
0.1 min
69.32
0.0 min
X
70.59
61.5
71.25
134.6s
84,94
8.3 min
71.48
4.3 min
69.69
10.8
69.47
22.0
84.61
2.8 min
70.29
1.4 min
70.69
71.15
71.55
1
84.99
10.9 min
71.56
5.6 min
69.89
11.68
69.86
24.4
84.67
2.8 min
70.40
1.4 min
70.79
72.3
71.62
156.6
85.02
10.9 min
71.62
5.6 min
24

---

Published as a conference paper at ICLR 2026
The full ablation results clearly illustrate the synergistic and cumulative effects of the LogART components. While each module provides a benefit in isolation, they are most effective when combined. A clear observation from Table [T and Table i2 is that regardless of the starting component or any combination of components, adding an additional module always leads to further improvement in accuracy (evidenced by lower PPI. on LLMs higher top-1 accuracy ImageNet). This phenomenon highlights the complementary nature of our proposed modules, with each one targeted address a distinct challenge in logarithmic PTQ.
We further analyze the trade-off between the performance contribution and computational efficiency of each component. DBS serves the critical foundation for logarithmic PTQ. offering the best socciency-t--perfommaa
ratio. SFS demonstrates strong standalone robustness, particularly for L.Mss, restoring LLaMA2-7B from 60. PPL to 6.66. ABS functions best as complementary refinement, yielding consistent accuracy improvements with negligible GPU runtime and memory overhead. Finally, L.R,, operating at the finest element-wis granularity, stands out as high-precision powerhouse but comes at the cost of computational time.
The effectiveness of each component varies across model architectures. Compact models like MobileNetV2 are vulnerable quantization noise (1.22% baseline), making DBS critical for restoring usable accuracy (66.91%). In contrast, large-scale architectures like vision transformers and LLMs exhibit greater resilience to initial quantization errors. Notably, SFS has a more significant impact on LLMS compared to CNNs and vision transformers, likely due to the widely observed outliers in language models. ABS yields the most substantial gains LLaMAA27B, effectively addressing its asymmetric weight distribution. For all models to restore near full-precision performance, LLR is necessary for fine-ge ane-ggained refinement.
In summary, the ablation study validates the design of LogART as unified framework. The lightweight components (DBS, SFS, ABS) ensure robust functionality and efficient basis construction. while LLR provides the necessary precision refinement. Combined, they yield the best accuracy performance.
25

---

Published as a conference paper at ICLR 2026
E
IMPACT OF THE CALIBRATION DATASET ON PERFORMANCE
E.1 IMPACT OF CALIBRATION DATASET SOURCE
The main experiments LLMs, detailed in Table utilize the C4 dataset for calibration to ensure a fair comparison with prior SOTA methods. This section evaluates the robustness of LogART by measuring sensitivity to the calibration data source. We conduct parallel set of experiments where models are calibrated using the WikiText-2 dataset instead of C4. All other experimental conditions, including the models and experimental settings, remain identical to those in the main text to isolate the effect of the calibration data. The results of this comparison are summarized in Table
13
Table 13: Comparison of performance (PPL) for per-channel 3-bit LogART on LLM weights using 32 random 2048-token segments for calibration from C4 and WikiText-2 datasets.
Calib. Dataset
OPT-125M
OPT-1.3B
OPT-6.7B
LLaMA2-7B
LLaMA3-8B
PPL (WikiText-2)
31.52
15.53
11.11
6,31
8.19
C4
PPL. (C4)
29.98
17.29
13.37
8.38
12.44
PPL (WikiText-2)
31.15
15.61
11.37
6,14
7.83
WikiText-2
(C4)
30.44
17.60
13.54
8.55
13.27
Table reveals distinct in-domain alignment pattern. Models generally achieve lower PPL when the calibration source matches the test domain. This indicates that the calibration set helps quantization parameters adapt to specific linguistic distribution of the target domain. The performance difference stems from domain alignment and outlier coverage. C4 provides high linguistic diversity, covering a wider range of activation outliers, which ensures better generalization. In contrast, Wiki'Text-2 offers highly consistent, formal distribution, leading slightly lower PPL. due to in-domain overfitting when used for both calibration and test.
Crucially, despite these variations, LogART exhibits strong robustness. The performance variance across different calibration sources is marginal, and the model maintains high accuracy regardless of the source. For perpooe-purpose deployment and fair SOTA comparison, recommend using a large-scale, diverse dataset like C4. However, for tasks targeting a specific domain, utilizing in-domain calibration data yields the best fine-grained performance.
E.2 IMPACT OF CALIBRATION DATASET SIZE
In addition to the choice of calibration data source, the size of the calibration dataset is also critical factor for the practicality and efficiency of a PTQ method. A method that requires large number of samples can be costly and time-consuming In this section, performance to the number of calibration samples. The study is conducted on the OPT-1251 and LLaMA2-7B models with 3-bit per-channel weight quantization, using the calibration data from the WikiText-2 dataset. We vary the number of calibration segments, testing sizes of 32 and 128 samples (each containing 2048 tokens), and measure the resulting PPL. The results for OHS alone and for the full LogART (OHS+LLR) are presented in Table 14
evaluate the sensitivity of LogART
Table 14: Comparison of performance (PPL) for different calibration dataset sizes under 3-bit
per-channel weight quantization using LogART.
OPT- 125M
LLaMA2-7B
Config.
Segments
PPL (WT-2)*
PPL (C4)
Runtime
PPL (WT-2)*
PPL (C4)
Runtime
32
34.29
32.17
1
6.45
8.72
17.9 min
OHS
128
34.26
32.14
22.6s
6.42
8.67
20.6 min
32
31.15
30.44
75.1
6.14
8.55
1.24
OHS+LLR
128
31.17
30.38
79.9
6.09
8.52
1.30 hr
WT-2 refers the WikiText-2 dataset.
26

---

Published as a conference paper at ICLR 2026
F 3-BIT PTQ PERFORMANCE OF LOGART ON VISION TRANSFORMERS
In the main body of the paper (Table we present the 4-bit weight quantization performance of LogART on various vision transformer models. To further evaluate the robustness and effectiveness of our method under more aggressive compression settings, this section provides the corresponding results for 3-bit per-channel weight quantization. The experimental setup follows that of 4-bit experiments in the main text, with only the target bitwidth changed. The comparison results are presented in Table
Table 15: Comparison top-1 accuracy and GPU runtime (in minutes) for 3-bit and 4-bit per- per-channel weight quantization with LogART on vision transformers.
ViT-Small
ViT-Base
DeiT-Tiny
DeiT-Base
W
Acc(%)
Runtime
Acco(%)
Runtime
Accc(%)
Runtime
Acco(%)
Runtime
FP16
81.39
85.10
72.16
81.98
4-bit
81.06
6.7
85.02
10.9
71.62
5.6
81.92
10.9
3-bit
79.56
84.54
70.21
81.51
27

---

Published as a conference paper at ICLR 2026
G DETAILS OF LOGART AE
G.1 LOGART AE DESIGN
While our proposed multi-base logarithmic quantizer enhances accuracy compared with fixed Log2 quantizer, it indeed introduces implementation challenges for the AE. Our LogART AE, shown in Figure 4 is customized overcome these issues. It handles the computation involving v2 through the integrated HAF, and also performs efficient on-chip decoding of the dynamic multi-base values through novel encoding and decoding scheme. The functionality is realized through a design consisting of four primary modules: decoder, signed arithmetic logic, approximate computing logic, and shifter.
The decoder and its associated encoding scheme efficiently manage the complexity introduced by the multi-base logarithmic quantizer. In 4-bit example, each weight is encoded with 1-bit sign and a 3-bit value code code that maps to one of the n1 b2se-v2 larger-valued codes and ne smaller-valued base-2 codes. This is accompanied by 4-bit per-channel metadata that stores n2 and parity flag (chk_even). The chk_ is decided by the parity of the maximum base-v2 exponent. During computation. the decoder uses simple combinational logic to process this information and output control signals for the multiplier-free AE: 1-bit sign, 3 shift bits (Shift bils), and 1-bit approximation flag (Approx flag). Table 16 provides concrete examples this process.
Table 16: Encoding and decoding scheme examples.
Weight
Base
After Scaling
w_code
Shift.bits
Approx-flog
Example n2=4, chk,even=l, Scaling Factor=2-
2
2
2
000
2
2
2²
001
0
2
2
010
2
23
Encoding >>
011
Decoding-> >
3
0
2 --5
V2
23.5
100
2 2
V2
24
101
4
0
2 3.5
V2
24.
110
2
V2
2
111
5
0
Example nı=55, chk even=0, Scaling Factor=2
2 2-8
20
000
2 2-7
001
0
2
2²
010
2 5.5
V2
22.5
Encoding >>
011
Decoding-> >>
2 5
V2
23
100
2
V2
23.3
101
3
2
V2
24
110
2 3.5
V2
24.3
111
The signed arithmetic logic operates based on the sign bit of the weight. For positive weight, the activation is used directly. For a negative weight, the module computes the two's complement the activation to perform the negation. This module is crucial part of the arithmetic logic that ensures calculations involving negative weights are performed correctly and efficiently in hardware. The output of the signed arithmetic logic is then passed to the approximate computing logic.
The approximate computing logic and the shifter operate together to execute the final stage of the multiplier-fret free computation, supporting the multi-base feature of the LogART quantizer. The approximate computing logic is specifically designed handle computations involving the v2 base. With K = 2 selected for our HAF due to its strong balance between hardware efficiency and accuracy, the multiplication by /2 x 1.5 is implemented as + X/2. The approximate computing logic takes enabling signal, Approz-flas -fagg from the decoder. If disabled, the activation passes through unchanged; otherwise, adds the activation to half of its value. The shifter then performs the final multiplication-lik step. It takes the output from the approximate computing logie and applies left
28

---

Published as a conference paper at ICLR 2026
bit-shift, with the number of shift positions determined by Shift_bit from the decoder. This single shift operation equivalent to a multiplication by a power of 2, completing the computation and producing the final output value.
G.2 LOGART AE BREAKDOWN
With all four modules working in concert, the LogART AE correctly computes the product for any weight in its multi-base system, thereby realizing fully multiplier design. The overall area and power consumption for this complete AE are presented in Table 6 To provide a more granular analysis, T7 further breaks down the hardware cost into the key functional modules, as illustrated in the block diagram in Figure4ee)
Table 17: Area and power breakdown of the LogART AE.
LogART AE
Signed
Decoder
Approx(Add)
Shift
Area (pm²)
53.2 (100%)
19.6%
17.5%
25.6%
37.3%
Power (c:W)
3.45 (100%)
20.7%
21.1%
20.0%
38.2%
The hardware breakdown reveals that the shifter is the dominant contributor hardware cost, accounting for 37.3% of the total area and 38.2% of the power. This result is expected, as the variable shifter serves the core computational unit in a LogART AE. The next largest contributors are the modules that enable our multi-base scheme: the approximate computing logic, which implements the hardware-friendly operation for the /2 base, is the second-largest by area (25.6%), while the decoder is the second-largest consumer of power (21.1%). Together, these two modules represent the necessary hardware investment to support the flexibility and high accuracy of our multi-base design. This breakdown validates our design choices, showing that even with this essential overhead, the LogART AE remains compact and power-efficient overall.
29

---

Published as a conference paper at ICLR 2026
H THE USE OF LLMS
During the preparation of this manuscript, the authors utilized an Al language model to assist with improving the grammar, clarity, and overall readability of the text. The role of LLMs was strictly limited to that of writing assistant for language polishing.
30


Reviews:
[{"review_id": "gfqkgMi2Rz", "reviewer": "Reviewer_KiDj", "summary": "The paper presents several methods that combined together improve the current SoTA on logarithm PTQ:\n- Learnable Logarithmc Rounding (LLR): train the best rounding on calibration data set;\n- Dynamic Base Quantizer (DBS): combine sqrt(2) and 2 bases;\n- Asymmetric Quantizer (ABS): induce an asymmetry by clamping close to 0 values;\n- Scaling Factor (SFS): train a scaling factor for clamping on a calibration data set, to better handle outliers.", "questions": "If you could explain how and why ABS work.\nAlso, you only made full ablation study on Transformers. I would be very interested to see a similar full ablation study on CNN.", "limitations": "", "rating": 4, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 2, "strengths": "- The paper advances the SotA on logarithmic quantization, mostly by combining/transfering known methods;\n- Adequate systematic ablation study is made (available in the supplementary material, albeit only for Transformers);\n- The paper evaluates its methods on both CNN and Transformers models;\n- Although secondary in the main paper, a study of hardware implementation of the dual sqrt(2) and 2 base log is performed.", "weaknesses": "- I did not understood the asymmetric quantizer scheme: it seems to me that your are only clamping small values after quantization, therefore actually reducing the effective number of bits! I don't understand how this can improve things and indeed, from your ablation studies, it seems to degrade the PPL when not used in combination with LLR.\n- The paper is very incremental and essentially combines/transfers known methods from the SoTA.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "s1rHl4sAim", "reviewer": "Reviewer_HfTW", "summary": "This paper proposes a novel adaptive weight rounding technique called LogART for improving logarithmic post-training quantization (logarithmic PTQ) performance on large language models (LLMs). The method introduces key components including dynamic base selection, scaling factor selection, adaptive base selection, and learnable weight rounding, significantly enhancing the performance of 3-bit channel-wise weight quantization models while maintaining hardware efficiency.", "questions": "(1) The paper mentions that LogART's components can be used in combination, but does not detail how these components work together, nor whether there exists an optimal combination.\n(2) The paper uses WikiText-2 and C4 as calibration datasets in experiments, but does not deeply explore the impact mechanism of different calibration datasets on performance, nor how to choose the best calibration dataset.", "limitations": "", "rating": 6, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "(1) First proposes a learnable weight rounding technique specifically for logarithmic PTQ, solving the problem that existing methods cannot apply learnable weight rounding in non-linear quantization.\n(2) Designs multiple combinable components (DBS, SFS, ABS, LLR), with experiments showing that these components produce synergistic effects when used together, significantly reducing perplexity (PPL).\n(3) Extensively validates LogART's effectiveness on LLMs such as OPT-125M and LLaMA2-7B, demonstrating significant performance improvements under 3-bit quantization.\n(4) Analyzes the impact of calibration datasets on performance, proving LogART's robustness to calibration data sources.", "weaknesses": "(1) The paper lacks theoretical analysis of the proposed method, particularly in-depth explanation of interactions between components.\n(2) Experiments are primarily focused on LLMs, with insufficient validation on other model types such as CNNs or ViTs, limiting the method's generalizability.\n(3) The paper does not discuss the additional computational overhead of LogART in practical deployment, especially the extra training steps required for learning rounding parameters, which may contradict the core goal of quantization techniques to simplify models and improve hardware efficiency.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "5r2ADL6w1G", "reviewer": "Reviewer_zR6Q", "summary": "The paper introduces LogART, a novel post-training quantization (PTQ) method designed for logarithmic quantization of neural network weights. Unlike linear quantization, logarithmic quantization aligns better with weight distributions often found in large models, and enables hardware efficiencies through base-2 arithmetic. LogART innovates by combining learnable rounding in the logarithmic domain with an adaptive quantizer that supports outlier resilience, asymmetry, and multi-base logarithmic representations. The authors also propose a multi-level hyperparameter search and a hardware approximation function (HAF) to make their scheme efficient and hardware-friendly. They evaluate LogART on a variety of architectures, LLMs, CNNs, and ViTs, showing higher accuracy than prior log-based PTQ, and meaningful hardware-area and power benefits.", "questions": "- Error Bound Analysis: do you have theoretical bounds on the error introduced by the HAF approximation of $\\sqrt{2}$? \n\n- Lower Bitwidth: have you experimented with 2-bit weight quantization? If so, how does LogART perform?", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 2, "strengths": "- LogART supports multi-base quantization, e.g., mixing base-2 and base-$\\sqrt{2}$.\n\n\n- The HAF (Hardware Approximation Function) approximates $\\sqrt{2}$ with shift-add operations, trading off minimal accuracy loss for hardware efficiency. They simulate area and power in a 28 nm process, showing substantial savings compared to conventional designs.\n\n- Experiments across LLMs, CNNs, and ViTs strengthen the claim of generality.\n\n- The ablation studies clearly show the impact of each component (LLR, OHS, dynamic base, etc.).", "weaknesses": "- The evaluations focus primarily on 3-bit quantization. It would be useful to show how LogART performs at even lower (2-bit) weights and to compare it with other PTQ methods like QuIP[1].\n\n- The paper mentions compatibility with activation quantization but does not deeply explore joint weight-activation quantization. Joint methods are often more relevant for real deployments.\n\n[1] QuIP: 2-Bit Quantization of Large Language Models With Guarantees", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)