Column-wise Quantization of Weights and Partial Sums for Accurate and Efficient Compute-In-Memory Accelerators

Jiyoon Kim; Jong Hwan Ko; Kang Eun Jeon; Yulhwa Kim

REVIEW 3 major objections 4 minor 12 references

Column-wise Quantization of Weights and Partial Sums for Accurate and Efficient Compute-In-Memory Accelerators

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

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

Pith's one-line read Quantizing weights and partial sums per crossbar column, each with its own learned scale factor, improves compute-in-memory DNN accuracy at no extra dequantization cost.

desk verdict Solid, modest CIM quantization contribution; the accuracy and training claims mostly hold, but the memory-variation robustness result is not testing what the paper says it tests. read the letter →

arxiv 2502.07842 v2 pith:A3KDYYDB submitted 2025-02-11 cs.AR cs.AIcs.LG

Jiyoon Kim , Kang Eun Jeon , Yulhwa Kim , Jong Hwan Ko This is my paper · ORCID

classification cs.ARcs.AIcs.LG

keywords compute-in-memorycolumn-wisequantizationpartial-sumweightquantization-awaretrainingADCresolutioncrossbararrayDNNaccelerator

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Compute-in-memory (CIM) accelerators cut data movement but pay a heavy cost in analog-to-digital converters (ADCs), and the cheap fix — low-precision ADCs — corrupts partial sums. Prior work quantized those partial sums at ever finer granularity (array-wise, then column-wise) but left weights coarsely quantized layer-wise, which caps the accuracy of the quantized partial sums. This paper's claim is that weights and partial sums should be quantized at the same granularity: one learned scale factor per crossbar column for each. That alignment raises ResNet accuracy by 0.99 points on CIFAR-10, 2.69 points on CIFAR-100, and 1.01 points on ImageNet over the best prior scheme, at the same per-column dequantization cost, and it lets the model train in one stage instead of two. If true, it says a purely software-side decision about where to place quantization scale factors can buy accuracy and variation robustness on CIM hardware for free.

What carries the argument

The load-bearing object is the matched pair of column-wise scale factors $(s_{w_i}, s_{p_i})$ attached to one column of a bit-scalable crossbar, together with the composed dequantization identity in Eq. (3), which multiplies each quantized partial sum by $s_{w_i}s_{p_i}$ once per column. The identity is what makes column-wise weight quantization free: the per-column multiplication count is the same as for column-wise partial-sum quantization alone, while the weight scales spread out the partial-sum distribution column by column as Fig. 6 shows. A software convolution framework realizes that granularity in training: weights are duplicated per bit-split, tiled with a stride that keeps stretched kernels intact inside each array (replacing the im2col bottleneck), and convolved as groups so that each group matches one array, making the per-column partial sums directly accessible for quantization.

What would settle it

Retrain ResNet-20 on CIFAR-10 with the proposed column-wise scheme and run the same weights on a real or faithfully emulated bit-scalable crossbar whose columns carry measured conductance variation and ADC offset; if top-1 accuracy drops more than roughly a point below the simulated 90.21% as variation grows, the alignment premise fails. A cheaper check is to verify whether the learned per-column partial-sum scales $s_{p_i}$ track the measured per-column partial-sum dynamic ranges, since that correlation is the mechanism's core prediction.

Watch

Extended reading notes

Core claim

On the paper's own terms, the central discovery is that weight and partial-sum quantization should share one granularity: the column of a compute-in-memory array. When each column's weights get their own learned scale factor $s_{w_i}$ and each column's partial sums get their own $s_{p_i}$, dequantization still costs exactly one multiplication per column, the product $s_{w_i}s_{p_i}$, matching the overhead of column-wise partial-sum-only schemes, yet the column-wise weight scales give the partial sums a wider, column-adaptive dynamic range. Because the two granularities are aligned, training runs as a single quantization-aware stage from scratch instead of the two-stage procedure needed when weights are layer-wise and partial sums column-wise. On ResNet-20/CIFAR-10, ResNet-20/CIFAR-100, and ResNet-18/ImageNet, the scheme reaches top-1 accuracies of 90.21%, 72.09%, and 68.51%, gains of 0.99, 2.69, and 1.01 points over the best prior scheme, and the per-column scale factors also keep accuracy higher than the baselines when log-normal cell variation is injected.

Load-bearing premise

Everything rests on the assumption that the software simulation's column structure — one tiled group per array, one learned scale per column — reproduces the physical behavior of a real bit-scalable crossbar, including its per-column ADC readouts and a cell-variation profile close to the log-normal model of Eq. (5), since the accuracy and robustness numbers come entirely from simulation.

Editorial extensions

If this is right

ResNet-20 on CIFAR-100 gains 2.69 points (to 72.09%) and ResNet-18 on ImageNet gains 1.01 points (to 68.51%) over the best prior scheme, while ResNet-20 on CIFAR-10 improves 0.99 points to 90.21%.
Per-column dequantization stays at one scale-factor multiplication per column — the same count as the layer-weight, column-partial-sum scheme — so the accuracy gain carries no added dequantization overhead (Fig. 8).
Aligning the two granularities removes the need for two-stage quantization-aware training; the one-stage run reaches higher accuracy with up to 34.27% less training time than the two-stage counterpart (Fig. 9).
Independent per-column scale factors keep accuracy above all compared schemes as injected log-normal cell variation grows, including at the largest tested standard deviation (Fig. 10).

Reading between the lines

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

The same column-aligned quantization could be tested on transformer or attention-based models, where per-channel dynamic-range mismatch is also common; the paper only evaluates residual CNNs.
If the dynamic-range mechanism in Fig. 6 is the real driver, the gain over layer-wise weight quantization should grow as partial-sum precision shrinks (binary or 2-bit) and shrink as ADC precision rises — a curve the paper does not plot.
A hardware-in-the-loop check of whether the learned per-column scales track measured per-column ADC readout ranges would turn the simulation claims into a design rule for real arrays and would test whether the tiling truly matches physical column boundaries.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Desk Editor's Note

read the letter

The real contribution is modest but genuine: prior work quantized partial sums column-wise with layer-wise weights; this paper aligns both at column-wise granularity, shows the dequantization multiplier count stays the same, and demonstrates a one-stage QAT that removes the two-stage training overhead. The open-source convolution framework with the tiling method and group convolution is useful for people who actually want to implement this. The three accuracy comparisons (ResNet-20 on CIFAR-10/100, ResNet-18 on ImageNet) support the central claim, and the overhead argument in Section III.B is sound. Code release is a real plus.

The soft spots are mostly in the variation-robustness claim, which the stress-test note correctly flags. Equation (5) applies log-normal noise to the full-precision weight before quantization. In hardware, variation perturbs the programmed conductance after the integer is placed in the cell; it does not change which integer was programmed. The simulation therefore changes the stored integer pattern and couples the noise with the quantization step. Also, a per-column scale factor multiplies signal and noise together, so by itself it cannot suppress independent per-cell variation. The Fig. 10 result may show that column-wise schemes degrade more gracefully under some noise model, but the stated mechanism—robustness via independent column-wise scale factors—is not established by this experiment. That section needs to be reworked or the claim tempered.

Two smaller points. All results are simulation only, with no error bars; for gains of 0.99% to 2.69%, multiple seeds are necessary before I would trust the exact deltas. The related-work baseline protocol should also be described clearly enough to reproduce. These are fixable, not fundamental.

The central accuracy and efficiency story holds up, and the paper is worth a serious referee. I would send it to review, but I would require the variation experiment to be redone with noise applied after quantization (or explicitly discussed as a different failure mode), and would ask for seed variability. The paper is aimed at researchers working on CIM accelerators and quantization-aware training; for that audience it is a useful, if incremental, contribution.

Referee Report

3 major / 4 minor

Summary. The paper proposes column-wise quantization of both weights and partial sums for bit-scalable compute-in-memory (CIM) accelerators. The method assigns a separate learned scale factor to each crossbar column for both weight and partial-sum quantization, in contrast to prior layer-wise or array-wise schemes. The authors argue that this granularity alignment improves accuracy without increasing the number of dequantization multiplications, removes the need for two-stage quantization-aware training, and improves robustness to memory-cell variations. They also contribute an open-source convolution framework based on a tiling scheme and group convolution to emulate column-wise behavior. Experiments on ResNet-20 (CIFAR-10, CIFAR-100) and ResNet-18 (ImageNet) report accuracy improvements of 0.99%, 2.69%, and 1.01% over the best related works, plus a variation-robustness study.

Significance. The main algorithmic observation—that column-wise weight granularity can be aligned with column-wise partial-sum granularity without changing the dequantization multiplication count—is clearly derived in Eqs. (1)-(4) and is a worthwhile contribution to CIM quantization design. The open-source framework is a concrete and reproducible asset, and the comparisons to multiple prior schemes are useful. However, the variation-robustness claim, which appears in the abstract and Section IV.E, is not established by the reported experiment because Eq. (5) applies variation before quantization instead of perturbing the programmed cell conductances. In addition, the sub-1% gains on CIFAR-10 and ImageNet are reported without seed-to-seed variance, so their statistical strength is unclear. These issues do not invalidate the accuracy and dequantization-overhead arguments, but they need to be addressed before the headline claims are fully supported.

major comments (3)

[Section IV.E, Eq. (5)] The variation-robustness experiment does not test the claimed mechanism. Eq. (5) defines w_var = w * exp(theta) and then quantizes w_var. In a bit-scalable CIM array, the programmed quantity is the quantized integer q_i = round(w_i / s_i); device variation perturbs the conductance representing q_i, i.e., G_i = q_i * s_i * exp(theta_i), without changing q_i. Applying noise before quantization changes the stored integer pattern and couples the noise with the quantization step, so Fig. 10 measures a different failure mode from the hardware one. Furthermore, a per-column scale factor s_i is a common multiplier for the signal and the per-cell noise in each column, so it cannot suppress independent cell-to-cell variation. The authors should either rerun the experiment with post-quantization log-normal conductance noise (or an equivalent circuit-level model) or substantially qualify the robustness claim in the abstract and Section III.A.
[Section IV.B, Table III, Fig. 7] The accuracy improvements over the best prior scheme are 0.99 percentage points on CIFAR-10 and 1.01 percentage points on ImageNet, yet no multiple-seed results or confidence intervals are reported. Training ResNet-20 and ResNet-18 with QAT involves stochastic initialization, data ordering, and scale-factor initialization; a sub-1% difference can easily lie within run-to-run variation. The authors should report the mean and standard deviation over at least three seeds for the key comparisons (at least Ours vs. [9]) or otherwise demonstrate that the gains are statistically robust.
[Section IV.A, Table III] The ImageNet comparison lists accuracy values for Kim [5], Bai [6,7], Saxena [8], and Saxena [9], but it is not stated whether these numbers were obtained by re-running the prior methods under the same code, epochs, augmentation, and quantization-aware training schedule, or whether they are quoted from the original papers. If they are quoted, the 1.01% advantage over [9] may be confounded with training-recipe differences rather than granularity. Please clarify the baseline provenance and, if possible, include same-pipeline reimplementations.

minor comments (4)

[Abstract and Section I] Typos such as 'Granualrity' in Fig. 1 and 'introduces errors' in the first paragraph of Section I should be corrected.
[Fig. 9] Fig. 9 is hard to interpret: the plus/circle/star marks and the meaning of 'training cost' (wall-clock time, epochs, or FLOPs) should be defined precisely in the caption or text.
[Section IV.E, Eq. (5)] The distribution parameter sigma is not defined in the text; Fig. 10 refers to 'variation standard deviation' but the relationship to theta should be stated explicitly.
[Section III.B] The dequantization-overhead comparison counts multiplications only; the additional storage and control cost of per-column weight scale factors should be acknowledged so that the 'no overhead' claim is not overstated.

Circularity Check

0 steps flagged · score 2.0 of 10

No significant circularity: accuracy and overhead claims rest on experiments and direct algebra; the variation-robustness caveat is a validity limitation, not a circular reduction.

full rationale

The paper's central claims are empirically evaluated rather than derived from fitted parameters. Section III.A's equations (1)-(4) only describe the arithmetic of column-wise quantization and dequantization; the claim of unchanged dequantization overhead follows from counting per-column multiplications, not from a parameter fitted to the reported accuracy. The scale factors are learned end-to-end with LSQ during quantization-aware training on the training set and evaluated on held-out test data against external baselines, so no accuracy 'prediction' is forced by construction. The one prior-work citation that may be self-authored, reference [5] (Y. Kim et al.), is used only as a related-work baseline and is not load-bearing for the proposed method. A genuine caveat exists in Section IV.E: Eq. (5) applies log-normal noise before quantization, whereas programmed-cell variation in a bit-scalable CIM array would perturb the stored conductance after the quantized integer is written; as reported, the experiment tests a different failure mode and does not demonstrate the claimed per-column-scale-factor robustness mechanism. That is an experimental-validity concern, however, not a circular derivation. Under the circularity rubric, the paper is self-contained and its central comparisons are not reduced to their own inputs.

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

No new physical entities are introduced. The central claims rest on four modeling assumptions about CIM hardware and noise; they are standard for architecture simulation papers, but the hardware fidelity premise is unverified.

free parameters (2)

Column-wise weight scale factors sw_i = Learned per column, values not reported
Trained with LSQ during quantization-aware training; central to the method but learned from training data, not hand-picked.
Column-wise partial-sum scale factors sp_i = Learned per column, values not reported
Trained with LSQ during quantization-aware training; define ADC reference levels in simulation and are not externally constrained.

assumptions (4)

domain assumption The bit-scalable CIM architecture is faithfully represented by integer rounding of weights and partial sums at column granularity.
Used in Section III.A and Section III.C; no hardware measurements are provided.
domain assumption Column-wise scale factors are sufficient to capture the dynamic range of each physical crossbar column.
Section III.A and Fig. 3 assume one scale factor per column is enough for accurate dequantization and robustness.
domain assumption Memory cell variations follow a multiplicative log-normal noise model with zero mean.
Section IV.E and Eq. (5) rely on this model from [11].
domain assumption LSQ converges properly when extended to column-wise scale factors.
Section III.A applies LSQ [10] without modification or stability analysis; all reported results depend on this.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Column-wise Quantization of Weights and Partial Sums for Accurate and Efficient Compute-In-Memory Accelerators." pith.science (2026). https://pith.science/paper/A3KDYYDB

@misc{pith2026250207842,
  author       = {Pith},
  title        = {Pith review of: Column-wise Quantization of Weights and Partial Sums for Accurate and Efficient Compute-In-Memory Accelerators},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/A3KDYYDB}},
  note         = {Machine review of arXiv:2502.07842}
}

read the original abstract

Compute-in-memory (CIM) is an efficient method for implementing deep neural networks (DNNs) but suffers from substantial overhead from analog-to-digital converters (ADCs), especially as ADC precision increases. Low-precision ADCs can reduce this overhead but introduce partial-sum quantization errors degrading accuracy. Additionally, low-bit weight constraints, imposed by cell limitations and the need for multiple cells for higher-bit weights, present further challenges. While fine-grained partial-sum quantization has been studied to lower ADC resolution effectively, weight granularity, which limits overall partial-sum quantized accuracy, remains underexplored. This work addresses these challenges by aligning weight and partial-sum quantization granularities at the column-wise level. Our method improves accuracy while maintaining dequantization overhead, simplifies training by removing two-stage processes, and ensures robustness to memory cell variations via independent column-wise scale factors. We also propose an open-source CIM-oriented convolution framework to handle fine-grained weights and partial-sums efficiently, incorporating a novel tiling method and group convolution. Experimental results on ResNet-20 (CIFAR-10, CIFAR-100) and ResNet-18 (ImageNet) show accuracy improvements of 0.99%, 2.69%, and 1.01%, respectively, compared to the best-performing related works. Additionally, variation analysis reveals the robustness of our method against memory cell variations. These findings highlight the effectiveness of our quantization scheme in enhancing accuracy and robustness while maintaining hardware efficiency in CIM-based DNN implementations. Our code is available at https://github.com/jiyoonkm/ColumnQuant.

Figures

Figures reproduced from arXiv: 2502.07842 by the authors.

**Figure 2.** Implementation of the convolution layer on bit-scalable CIM architec [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗

**Figure 3.** Matrix multiplication of a DNN layer with the proposed column-wise [PITH_FULL_IMAGE:figures/full_fig_p003_3.png] view at source ↗

Figures from the paper (5 more)

**Figure 4.** Figure 4: Dequantization process after matrix multiplication in CIM. From (a) [PITH_FULL_IMAGE:figures/full_fig_p003_4.png]

**Figure 5.** Figure 5: Convolution framework overview for bit-scalable CIM. The figure [PITH_FULL_IMAGE:figures/full_fig_p004_5.png]

**Figure 6.** Figure 6: Column-wise partial-sum distribution of 4th convolution layer of [PITH_FULL_IMAGE:figures/full_fig_p005_6.png]

**Figure 8.** Figure 8: Top-1 inference accuracy and dequantize operation overhead of [PITH_FULL_IMAGE:figures/full_fig_p006_8.png]

**Figure 9.** Figure 9: Comparison of QAT schemes in terms of accuracy and train time. ‘A/B’ [PITH_FULL_IMAGE:figures/full_fig_p006_9.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

12 extracted references · 11 canonical work pages

[9]

Partial-sum quantization for near ADC-less compute-in-memory accelerators,

U. Saxena and K. Roy, “Partial-sum quantization for near ADC-less compute-in-memory accelerators,” 2023 IEEE/ACM International Sym- posium on Low Power Electronics and Design (ISLPED), Aug. 2023

work page 2023
[5]

Extreme partial-sum quantization for analog computing-in-memory neural network accelerators,

Y . Kim, H. Kim, and J.-J. Kim, “Extreme partial-sum quantization for analog computing-in-memory neural network accelerators,” ACM Journal on Emerging Technologies in Computing Systems, vol. 18, no. 4, pp. 1–19, Oct. 2022

work page 2022
[8]

Towards ADC-less compute-in- memory accelerators for energy efficient deep learning,

U. Saxena, I. Chakraborty, and K. Roy, “Towards ADC-less compute-in- memory accelerators for energy efficient deep learning,” 2022 Design, Automation & Test in Europe Conference & Exhibition (DATE), Mar. 2022

work page 2022
[1]

ISAAC: A convolutional neural network accelerator with in-situ analog arithmetic in crossbars,

A. Shafiee, et al. , “ISAAC: A convolutional neural network accelerator with in-situ analog arithmetic in crossbars,” in ISCA, 2016

work page 2016
[2]

A configurable multi-precision CNN computing framework based on single bit RRAM,

Z. Zhu et al., “A configurable multi-precision CNN computing framework based on single bit RRAM,” in DAC, 2019

work page 2019
[3]

Deep residual learning for image recognition,

K. He, X. Zhang, S. Ren and J. Sun, “Deep residual learning for image recognition,” in Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp 770-778, 2016

work page 2016
[4]

Imagenet classification with deep convolutional neural networks,

A. Krizhevsky, I. Sutskever, and G. Hinton, “Imagenet classification with deep convolutional neural networks,” in Proceedings of the Advances in Neural Information Processing Systems , 2012

work page 2012
[6]

Partial sum quantiza- tion for computing-in-memory-based neural network accelerator,

J. Bai, W. Xue, Y . Fan, S. Sun, and K. Wang, “Partial sum quantiza- tion for computing-in-memory-based neural network accelerator,” IEEE Transactions on Circuits and Systems II-express Briefs, vol. 70, no. 8, pp. 3049–3053, Aug. 2023

work page 2023

Show all 12 references

[7]

CIMQ: A hardware-efficient quantization framework for computing-in-memory based neural network accelerators,

J. Bai, S. Sun, W. Zhao, and W. Kang, “CIMQ: A hardware-efficient quantization framework for computing-in-memory based neural network accelerators,” IEEE Transactions on Computer-Aided Design of Inte- grated Circuits and Systems, vol. 43, no. 1, pp. 189–202, Jan. 2024

2024
[10]

Learned step size quantization,

S. K. Esser, J. L. McKinstry, D. Bablani, R. Appuswamy, and D. S. Modha, “Learned step size quantization,” International Conference on Learning Representations, Apr. 2020

2020
[11]

Accurate inference with inaccurate RRAM devices: a joint algorithm- design solution,

G. Charan, A. Mohanty, X. Du, G. Krishnan, R. V . Joshi, and Y . Cao, “Accurate inference with inaccurate RRAM devices: a joint algorithm- design solution,” IEEE Journal on Exploratory Solid-State Computational Devices and Circuits, vol. 6, no. 1, pp. 27–35, June 2020

2020
[12]

A survey of quantization methods for efficient neural network inference,

A. Gholami, S. Kim, Z. Dong, Z. Yao, M. W. Mahoney, and K. Keutzer, “A survey of quantization methods for efficient neural network inference,” 2021, arXiv:2103.13630

2021 arXiv

Pith tools

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

[1] [9]

Partial-sum quantization for near ADC-less compute-in-memory accelerators,

U. Saxena and K. Roy, “Partial-sum quantization for near ADC-less compute-in-memory accelerators,” 2023 IEEE/ACM International Sym- posium on Low Power Electronics and Design (ISLPED), Aug. 2023

work page 2023

[2] [5]

Extreme partial-sum quantization for analog computing-in-memory neural network accelerators,

Y . Kim, H. Kim, and J.-J. Kim, “Extreme partial-sum quantization for analog computing-in-memory neural network accelerators,” ACM Journal on Emerging Technologies in Computing Systems, vol. 18, no. 4, pp. 1–19, Oct. 2022

work page 2022

[3] [8]

Towards ADC-less compute-in- memory accelerators for energy efficient deep learning,

U. Saxena, I. Chakraborty, and K. Roy, “Towards ADC-less compute-in- memory accelerators for energy efficient deep learning,” 2022 Design, Automation & Test in Europe Conference & Exhibition (DATE), Mar. 2022

work page 2022

[4] [1]

ISAAC: A convolutional neural network accelerator with in-situ analog arithmetic in crossbars,

A. Shafiee, et al. , “ISAAC: A convolutional neural network accelerator with in-situ analog arithmetic in crossbars,” in ISCA, 2016

work page 2016

[5] [2]

A configurable multi-precision CNN computing framework based on single bit RRAM,

Z. Zhu et al., “A configurable multi-precision CNN computing framework based on single bit RRAM,” in DAC, 2019

work page 2019

[6] [3]

Deep residual learning for image recognition,

K. He, X. Zhang, S. Ren and J. Sun, “Deep residual learning for image recognition,” in Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp 770-778, 2016

work page 2016

[7] [4]

Imagenet classification with deep convolutional neural networks,

A. Krizhevsky, I. Sutskever, and G. Hinton, “Imagenet classification with deep convolutional neural networks,” in Proceedings of the Advances in Neural Information Processing Systems , 2012

work page 2012

[8] [6]

Partial sum quantiza- tion for computing-in-memory-based neural network accelerator,

J. Bai, W. Xue, Y . Fan, S. Sun, and K. Wang, “Partial sum quantiza- tion for computing-in-memory-based neural network accelerator,” IEEE Transactions on Circuits and Systems II-express Briefs, vol. 70, no. 8, pp. 3049–3053, Aug. 2023

work page 2023