Pith. sign in

REVIEW 4 major objections 4 minor 44 references

Efficient Column-Wise N:M Pruning on RISC-V CPU

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

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

Pith's one-line read The paper claims that column-wise N:M pruning at tile level, running in an extended XNNPACK/AITemplate stack, makes sparse ResNet inference up to 4.0x faster on RISC-V vector CPUs while keeping ImageNet top-1 accuracy within 2.1% of the…

desk verdict Useful column-wise N:M pruning for RISC-V, but the speedup claims mix layout and auto-tuning effects with pruning. read the letter →

arxiv 2507.17301 v1 pith:JS4BVQQ5 submitted 2025-07-23 cs.DC

Chi-Wei Chu , Ding-Yong Hong , Jan-Jan Wu This is my paper
classification cs.DC
keywords column-wiseN:MpruningRISC-VvectorextensionstructuredsparsityXNNPACKCNNinferenceaccelerationim2colfusiondatapackingauto-tuning
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

The paper sets out to show that N:M weight pruning can make CNN inference faster rather than slower on a RISC-V vector CPU, by changing the pruning format instead of the hardware. In N:M pruning, at most N of every M consecutive weights survive; the paper proposes column-wise N:M pruning, in which entire columns of the weight matrix are pruned or retained together, so the matrix-multiplication kernel can reuse one loaded input vector across many multiply-accumulates and keep partial sums in registers. The same software stack fuses the im2col (image-to-column) rearrangement and data-packing preprocessing into a single pass, and uses compiler auto-tuning to pick per-layer tile sizes and vector register group multipliers. The reported result is up to 4.0x higher ResNet throughput and less than 2.1% top-1 accuracy loss on ImageNet, with the strongest gains in deep, 3x3-convolution-heavy layers. A sympathetic reader would care because it suggests sparse CNN execution is feasible on commodity RISC-V hardware through software alone.

What carries the argument

The load-bearing mechanism is the column-wise N:M pruning pattern applied at tile level inside a tiled matrix-multiplication micro-kernel. In this pattern, all weights in a given column of the weight matrix are pruned or retained as a unit, and the retained columns are accessed through an index array; the micro-kernel then performs an outer-product accumulation into T vector registers, one per output row, so each vector load from the input data is reused across T weights and partial sums never leave registers. A second mechanism is the fused im2col-and-packing pass, which exploits the CNHW layout's contiguous W dimension to move data directly from the feature map into vector-length-aligned strips in a single step, with RISC-V's variable vector length handling leftover elements without masked-load overhead. A third mechanism is the auto-tuning wrapper, which profiles tile size from 1 to 32 and LMUL values of 1, 2, 4, and 8 to select the fastest kernel configuration for each convolution layer.

What would settle it

Benchmark ResNet-50 at batch size 1 with 50 percent sparsity against the paper's dense CNHW baseline instead of the NHWC baseline, with LMUL and tile sizes matched; if the pruned model's speedup over dense CNHW is around 1.9x or less rather than the reported 3-4x, the pruning-specific contribution is small, since the paper's own figures show dense CNHW is already up to 1.8x faster than NHWC.

Watch

Extended reading notes

Core claim

The central claim is that the conventional row-wise N:M pruning pattern is the wrong granularity for CPUs with vector registers, and that grouping weights column-wise at tile level makes sparse matrix multiplication outer-product-friendly. For a tile of T output rows, the micro-kernel loads each retained column of the data matrix once into a vector register and accumulates scalar-weight times vector into T vector accumulators, so no partial output touches memory until the tile is finished. Because M can be as large as the full input-channel dimension, the retained column count N is derived from the target sparsity ratio, making the pattern nearly as flexible as unstructured pruning while keeping execution regular. The paper claims this yields convolution-layer speedups up to 1.86x over a dense CNHW layout and end-to-end speedups up to 4.0x over the dense NHWC baseline, at 25 to 75 percent sparsity, with accuracy loss at most 2.1 percentage points.

Load-bearing premise

The headline speedup is measured against a dense baseline whose deeper layers run much slower than the paper's own alternative dense layout; if that baseline is not the fair performance reference, the gain attributable to pruning itself is far smaller than 4x.

Editorial extensions

If this is right

  • A software-only change to the pruning format and memory layout can make sparse ResNet inference up to 4.0x faster than a dense NHWC baseline on a commodity RISC-V vector CPU.
  • Group sizes M can be far larger than 4, up to the full input-channel dimension, so adaptive column-wise N:M pruning keeps ImageNet accuracy within about two percentage points of dense even at 75 percent sparsity.
  • Fusing im2col with data packing cuts L1-cache loads by up to 42 percent, and per-layer auto-tuning of LMUL and tile size is necessary because no static configuration wins across all layers.
  • The approach transfers across ResNet-18/34/50/101/152 and DenseNet-121, but gives smaller gains on MobileNet-V2, whose depthwise convolutions are more sensitive to the structured pattern.
  • The dense CNHW layout alone provides up to 1.8x speedup over the NHWC baseline, meaning the reported end-to-end gains combine layout engineering with pruning rather than pruning alone.

Reading between the lines

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

  • The column-wise format is not tied to RISC-V's specific vector length, so the same tile-level outer-product kernel should transfer to other SIMD ISAs with vector registers, such as ARM SVE or AVX-512, after re-profiling the tuning space.
  • Because M can span the full input-channel dimension, the effective constraint resembles channel-wise column selection; the accuracy behavior should therefore be compared against channel pruning and block pruning, not only against row-wise N:M, to map the accuracy-versus-speed frontier.
  • A natural testable extension is to let the auto-tuner also choose the sparsity ratio per layer instead of one global ratio; the accuracy tables suggest layers tolerate different sparsities, so per-layer sparsity search could widen the speedup at a fixed accuracy budget.
  • If the dense CNHW layout is the fair performance reference, then the pruning-specific contribution to the 4x headline is smaller than it appears; a reader should expect the gain from pruning to shrink once the layout gain is separated out.
  • One could test the fused im2col-packing idea on non-convolution operators, such as pointwise layers in transformers, where the same contiguous-dimension vectorization and variable-length handling may apply.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 4 minor

Summary. The paper proposes a column-wise N:M pruning scheme applied at the tile level for convolutional layers, together with a fused im2col-and-data-packing step and an auto-tuning mechanism built on XNNPACK and AITemplate for RISC-V vector CPUs. It reports that the approach accelerates ResNet inference by up to 4.0x over a dense baseline while keeping ImageNet top-1 accuracy within 2.1% of the dense model. It also reports L1-cache load reductions, layer-level timing comparisons, and accuracy results for several CNN architectures.

Significance. If the reported speedups are a fair measure of the pruning benefit, the work is a useful contribution to sparse inference on general-purpose RISC-V hardware: it delivers a concrete software stack, real measurements on a commercial RISC-V board, and a kernel design that improves data reuse. The paper also ships reproducible engineering details (LMUL/tile space, fusion algorithm), which supports the empirical claims. However, the central headline claim is currently entangled with layout changes and asymmetric auto-tuning, so the significance of the pruning-specific contribution is hard to assess as written.

major comments (4)
  1. [§4.4, Fig. 10] The speedup claim does not isolate the effect of pruning. In Section 4.4 the pruned kernels use the AITemplate auto-tuning mechanism to select LMUL and tile size per layer, while both dense baselines (NHWC and CNHW) fix LMUL=4. Figure 9 shows that for the sparse kernels the LMUL choice alone can change runtime by up to 4x. Consequently, the reported up-to-2.1x speedup over the dense CNHW baseline (Figure 10) may partly reflect a suboptimal, untuned dense baseline rather than pruning. Please add a dense CNHW baseline that is auto-tuned with the same per-layer search, and report the speedup relative to that baseline; alternatively, report the incremental speedup after controlling for layout and tuning in a separate column.
  2. [Abstract; §1; Table 2] The headline 'up to 4.0x' speedup is relative to the SiFive-optimized dense NHWC XNNPACK baseline, which the paper itself shows is up to 21x slower than the proposed method in some Stage-4 layers (Figure 10) and which the CNHW layout alone already outperforms by up to 1.8x (Figure 12). Thus the 4.0x number conflates the effects of pruning, the layout switch, and the auto-tuning. This is not an invalid comparison per se, but it should not be described as the effect of the proposed pruning method alone. The abstract and introduction should state the comparison baseline explicitly and, if the claim is about pruning, report the speedup over a competitive dense CNHW baseline.
  3. [§4.5, Table 2] The accuracy results appear to come from a single training run with no variance or seed information. For example, ResNet-18 at 25% sparsity is reported as 70.0% versus 69.7% for the dense model; this difference is within typical run-to-run noise. Since the paper claims accuracy is preserved within 2.1%, please either report the mean and standard deviation over multiple runs, or explicitly state that the results are from one run and draw conclusions accordingly.
  4. [§4.2, Fig. 5] The one controlled comparison that partially addresses the tuning concern is the single-threaded layer-wise study in Figure 5, which compares dense, conventional N:M, and column-wise N:M in the same CNHW layout with the fused im2col/data packing. However, the paper does not state whether auto-tuning was applied to all three configurations or only to the pruned ones, nor what LMUL values were used. Please clarify the experimental setup for Figure 5 so the reader can verify that this 1.5x average speedup is indeed a pruning-only, tuning-constant comparison.
minor comments (4)
  1. [Algorithm 2] The pseudocode for the fused im2col and data packing is hard to follow: the inner loop bound `V step min(V, W_out)` is confusing, `vl` can become negative when padding is large, and the variable `output_offset` is used without being defined. Please rewrite this pseudocode with clear bounds and explicit initialization.
  2. [§3.2, text after Fig. 4] There is a grammatical issue in the sentence 'registers are typically sized as powers of two.' Also, the preceding sentence appears to be cut off; please revise for clarity.
  3. [§2.1, Ref. [33]] The RISC-V V extension citation refers to a 'frozen specification for public review'; if the final ratified specification exists, it would be preferable to cite the ratified version.
  4. [§1, contributions] The contribution bullet 'Our method supports arbitrary N:M sparsity patterns and improves model accuracy' is slightly misleading: the accuracy gain over dense is within noise, and the main claim is efficiency. Rephrase to 'preserves accuracy'.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the paper is an empirical systems study whose speedup and accuracy claims rest on external baselines, independent frameworks, and transparent auto-tuning rather than on a derivation that reduces to its own inputs.

full rationale

This is an empirical systems paper with no theoretical derivation chain whose outputs could be equivalent to its inputs by construction. The central claims are (1) column-wise N:M pruning at tile level is more cache-friendly than row-based N:M pruning on RISC-V vector CPUs, (2) fusing im2col with data packing reduces memory overhead, and (3) using AITemplate's profiling to choose LMUL and tile size improves performance. Each is supported by direct measurements against external baselines: the SiFive-optimized XNNPACK dense NHWC implementation, a dense CNHW baseline, and conventional row-based N:M pruning. No load-bearing step is justified by a self-citation chain: XNNPACK and AITemplate are external open-source frameworks, and the prior work cited for N:M pruning, Sparse Tensor Cores, and sparse convolution is independent of the authors. The only near-concern is that the sparse pipeline receives per-layer auto-tuned LMUL and tile sizes (Section 3.3, Figure 9) while both dense baselines fix LMUL=4 (Section 4.4), so part of the reported speedup over the dense baselines may reflect tuning benefits rather than pruning alone. This is a legitimate benchmarking-fairness limitation, not circularity: the tuned parameters are selected by runtime profiling on the target hardware and are not fitted to the reported accuracy or end-to-end speedup numbers, and the paper explicitly discloses the tuning asymmetry. The accuracy results are also genuinely external: one-shot pruning plus ImageNet retraining against the Torchvision dense models. Thus there is no self-definitional step, no fitted parameter renamed as a prediction, and no uniqueness claim imported from the authors' prior work. The derivation, such as it is, is an engineering implementation and measurement chain, and the central claims retain independent empirical content.

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

The central performance claim rests primarily on two hardware tuning parameters (tile size T and LMUL) selected by profiling on the benchmark platform; no new theoretical entities are introduced. Accuracy claims rest on an assumed retraining protocol.

free parameters (2)
  • tile size T = per-layer, auto-tuned in [1,32]
    The micro-kernel performance and the reported speedups depend on the chosen number of accumulator registers; optimal T is selected by profiling on the evaluation platform.
  • LMUL = per-layer, profiled among 1,2,4,8
    The vector register grouping multiplier is tuned on the target hardware for each layer; the paper reports that varying LMUL can change runtime by up to 4x, so the speedup claim depends on this tuning.
assumptions (5)
  • standard math GEMM-based convolution via im2col matches dense convolution semantics
    The whole approach relies on im2col (Section 2.2) to express convolutions as matrix multiplications without loss.
  • domain assumption CNHW layout allows contiguous W-dimension access and is used throughout the network
    The fused im2col and packing kernel assumes the CNHW layout with W contiguous; the paper converts models from NHWC to CNHW at the start.
  • domain assumption Column-wise L1-norm pruning followed by 90-epoch ImageNet retraining recovers accuracy
    The accuracy claims rest on this retraining protocol, which is described but not justified, and it fails to recover accuracy for MobileNet-V2 at 75% sparsity.
  • domain assumption RISC-V Vector VLA and LMUL behavior as specified
    The kernels rely on scalable vector length and register grouping behavior of RVV 1.0.
  • domain assumption XNNPACK and AITemplate integration preserves operator semantics
    The performance claims assume the generated kernels compute correct convolution outputs.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Efficient Column-Wise N:M Pruning on RISC-V CPU." pith.science (2026). https://pith.science/paper/JS4BVQQ5

@misc{pith2026250717301,
  author       = {Pith},
  title        = {Pith review of: Efficient Column-Wise N:M Pruning on RISC-V CPU},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/JS4BVQQ5}},
  note         = {Machine review of arXiv:2507.17301}
}
read the original abstract

In deep learning frameworks, weight pruning is a widely used technique for improving computational efficiency by reducing the size of large models. This is especially critical for convolutional operators, which often act as performance bottlenecks in convolutional neural networks (CNNs). However, the effectiveness of pruning heavily depends on how it is implemented, as different methods can significantly impact both computational performance and memory footprint. In this work, we propose a column-wise N:M pruning strategy applied at the tile level and modify XNNPACK to enable efficient execution of pruned models on the RISC-V vector architecture. Additionally, we propose fusing the operations of im2col and data packing to minimize redundant memory accesses and memory overhead. To further optimize performance, we incorporate AITemplate's profiling technique to identify the optimal implementation for each convolutional operator. Our proposed approach effectively increases ResNet inference throughput by as much as 4.0x, and preserves ImageNet top-1 accuracy within 2.1\% of the dense baseline.

Figures

Figures reproduced from arXiv: 2507.17301 by the authors.

Figure 1
Figure 1. N:M pruning with N=4 and M=8. ceil (C / Vector Length) * V C ector Length R Vector Length Data Packing Vector Length Matrix [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 3
Figure 3. Traditional N:M pruning and our proposed column-wise N:M pruning. [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗
Figure 4
Figure 4. Illustration of fusing Im2col and data packing. Input feature map layout is CNHW, and [PITH_FULL_IMAGE:figures/full_fig_p008_4.png] view at source ↗
Figures from the paper (8 more)
Figure 5
Figure 5. Figure 5: Comparison of inference time for the convolution layers in ResNet-50. [PITH_FULL_IMAGE:figures/full_fig_p013_5.png]
Figure 6
Figure 6. Figure 6: Speedup of our fusion optimization compared to performing im2col and data packing [PITH_FULL_IMAGE:figures/full_fig_p014_6.png]
Figure 7
Figure 7. Figure 7: Reduction of L1-cache loads by fusing im2col and data packing over the non-fused approach, across various LMUL configurations for 3x3 convolution layers in ResNet-50. Stem-conv Stage1-conv2 Stage2-conv2 Stage3-conv2 Stage4-conv2 0 50 100 150 200 250 300 Runtime (ms) im…
Figure 8
Figure 8. Figure 8: Execution time breakdown. values compared to the baseline. The result suggests a strong correlation between greater speedup ( [PITH_FULL_IMAGE:figures/full_fig_p014_8.png]
Figure 9
Figure 9. Figure 9: Convolution inference time across LMUL values with our column-wise N:M pruning. [PITH_FULL_IMAGE:figures/full_fig_p016_9.png]
Figure 10
Figure 10. Figure 10: Inference time comparison with dense versions and our column-wise N:M pruning. [PITH_FULL_IMAGE:figures/full_fig_p016_10.png]
Figure 11
Figure 11. Figure 11: Comparison of ResNet-50 inference time across various batch sizes and sparsity levels. (4) Column-wise N:M pruning with adaptive N, M, and tile size. The value of M is adjusted based on the number of input channels for each convolution layer, and the tile size is dete…
Figure 12
Figure 12. Figure 12: Comparison of inference time with NHWC and CNHW layouts. [PITH_FULL_IMAGE:figures/full_fig_p019_12.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

44 extracted references · 32 canonical work pages

  1. [1]

    Low-memory gemm-based convolution algorithms for deep neural networks

    Andrew Anderson and Aravind Vasudevan. Low-memory gemm-based convolution algorithms for deep neural networks. arXiv preprint arXiv:1709.03395, 2017

    arXiv 2017

  2. [2]

    Structured sparsity in the nvidia ampere architecture and its applica- tions

    Hongxiao Bai and Yun Li. Structured sparsity in the nvidia ampere architecture and its applica- tions. https://developer.nvidia.com/blog/structured-sparsity-in-the-nvidia-ampere-architecture-and- applications-in-search-engines/, 2020

    work page 2020

  3. [3]

    Progressive gradient flow for robust n:m sparsity Efficient Column-Wise N:M Pruning on RISC-V CPU 21 training in transformers, 2024

    Abhimanyu Rajeshkumar Bambhaniya, Amir Yazdanbakhsh, Suvinay Subramanian, Sheng-Chun Kao, Shivani Agrawal, Utku Evci, and Tushar Krishna. Progressive gradient flow for robust n:m sparsity Efficient Column-Wise N:M Pruning on RISC-V CPU 21 training in transformers, 2024. URL https://arxiv.org/abs/2402.04744

    arXiv 2024

  4. [4]

    Banana Pi BPI-F3: RISC-V Single Board Computer

    Banana Pi Project. Banana Pi BPI-F3: RISC-V Single Board Computer. https://www.banana-pi.org/en/ banana-pi-sbcs/175.html, 2023. Available at: https://www.banana-pi.org/en/banana-pi-sbcs/175.html

    work page 2023

  5. [5]

    Gradient and magnitude-based pruning for sparse deep neural networks

    Kaleab Belay. Gradient and magnitude-based pruning for sparse deep neural networks. In Proceedings of the AAAI Conference on Artificial Intelligence , volume 36 of AAAI, pages 13126–13127, 2022. doi: 10.1609/aaai.v36i11.21699. URL https://doi.org/10.1609/aaai.v36i11.21699

    work page doi:10.1609/aaai.v36i11.21699 2022

  6. [6]

    Fraguela, and Torsten Hoefler

    Roberto López Castro, Andrei Ivanov, Diego Andrade, Tal Ben-Nun, Basilio B. Fraguela, and Torsten Hoefler. VENOM: A Vectorized N:M Format for Unleashing the Power of Sparse Tensor Cores. In Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis (SC), pages 1–17. IEEE, 2022

    work page 2022

  7. [7]

    Accelerating gnns on gpu sparse tensor cores through n:m sparsity-oriented graph reordering

    Jou-An Chen, Hsin-Hsuan Sung, Ruifeng Zhang, Ang Li, and Xipeng Shen. Accelerating gnns on gpu sparse tensor cores through n:m sparsity-oriented graph reordering. In Proceedings of the 30th ACM SIGPLAN Annual Symposium on Principles and Practice of Parallel Programming , page 16–28, 2025

    work page 2025

  8. [8]

    Minimum variance unbiased n :m sparsity for the neural gradients

    Brian Chmiel, Itay Hubara, Ron Banner, and Daniel Soudry. Minimum variance unbiased n :m sparsity for the neural gradients. In Proceedings of the 11th International Conference on Learning Representations, ICLR, 2023. URL https://openreview.net/forum?id=vuD2xEtxZcj. OpenReview ID vuD2xEtxZcj

    work page 2023

Show all 44 references
  1. [9]

    Xne: an ultra-low energy convolutional neural network accelerator for embedded systems

    Francesco Conti, Robert Schilling, Pasquale Davide Schiavone, Davide Rossi, Antonio Pullini, Michael Gautschi, Igor Loi, and Luca Benini. Xne: an ultra-low energy convolutional neural network accelerator for embedded systems. In Proceedings of the conference on Design, Automat...

    2018

  2. [10]

    Imagenet: A large-scale hierarchical image database

    Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 248–255, 2009. doi: 10.1109/CVPR.2009.5206848

    2009

  3. [11]

    Learning to prune deep neural networks via layer-wise optimal brain surgeon

    Xin Dong, Shangyu Chen, and Sinno Jialin Pan. Learning to prune deep neural networks via layer-wise optimal brain surgeon. In Advances in Neural Information Processing Systems , volume 30 of NeurIPS, pages 4857–4867, 2017. doi: 10.48550/arXiv.1705.07565. URL https://doi.org/10...

    2017 doi arXiv

  4. [12]

    The indirect convolution algorithm, 2019

    Marat Dukhan. The indirect convolution algorithm, 2019. URL https://arxiv.org/abs/1907.02129

    2019 arXiv

  5. [13]

    Fast sparse convnets

    Erich Elsen, Marat Dukhan, Trevor Gale, and Karen Simonyan. Fast sparse convnets. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR) , pages 14629–14638, 2020

    2020

  6. [14]

    Gap-8: A risc-v soc for ai at the edge of the iot

    Eric Flamand, Davide Rossi, Francesco Conti, Igor Loi, Antonio Pullini, Felipe Rotenberg, and Luca Benini. Gap-8: A risc-v soc for ai at the edge of the iot. 2018 IEEE 29th International Conference on Application-specific Systems, Architectures and Processors (ASAP) , pages 1–4, 2018

    2018

  7. [15]

    The state of sparsity in deep neural networks

    Trevor Gale, Erich Elsen, and Sara Hooker. The state of sparsity in deep neural networks. arXiv preprint arXiv:1902.09574, 2019

    1902 arXiv

  8. [16]

    Xnnpack: Efficient inference library for neural network operators, 2024

    Google. Xnnpack: Efficient inference library for neural network operators, 2024. URL https://github. com/google/XNNPACK. Accessed: 2024-03-23

    2024

  9. [17]

    Dynamic network surgery for efficient DNNs

    Yiwen Guo, Anbang Yao, and Yurong Chen. Dynamic network surgery for efficient DNNs. In Advances in Neural Information Processing Systems , volume 29 of NeurIPS, pages 1379–1387, 2016. URL https://proceedings.neurips.cc/paper/2016/file/2823f4797102ce1a1aec05359cc16dd9-Paper.pdf

    2016

  10. [18]

    Learning both weights and connections for efficient neural network

    Song Han, Jeff Pool, John Tran, and William J Dally. Learning both weights and connections for efficient neural network. In Advances in Neural Information Processing Systems (NeurIPS) , pages 1135–1143, 2015

    2015

  11. [19]

    Deep residual learning for image recognition

    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), pages 770–778, 2016

    2016

  12. [20]

    Soft filter pruning for accelerating deep convolutional neural networks

    Yang He, Guoliang Kang, Xuanyi Dong, Yanwei Fu, and Yi Yang. Soft filter pruning for accelerating deep convolutional neural networks. In International Joint Conference on Artificial Intelligence (IJCAI) , pages 2234–2240, 2018

    2018

  13. [21]

    Channel pruning for accelerating very deep neural networks

    Yihui He, Jian Zhang, and Jian Sun. Channel pruning for accelerating very deep neural networks. In Proceedings of the IEEE International Conference on Computer Vision , ICCV, pages 1389–1397, 2017. doi: 10.1109/ICCV.2017.154. URL https://openaccess.thecvf.com/content_ICCV_2017...

    2017 doi

  14. [22]

    Weinberger

    Gao Huang, Zhuang Liu, Laurens van der Maaten, and Kilian Q. Weinberger. Densely connected convolutional networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 2261–2269, 2017

    2017

  15. [23]

    Elsa: Exploiting layer-wise n :m sparsity for vision transformer acceleration

    Ning-Chi Huang, Chi-Chih Chang, Wei-Cheng Lin, Endri Taka, Diana Marculescu, and Kai-Chiang Wu. Elsa: Exploiting layer-wise n :m sparsity for vision transformer acceleration. arXiv preprint arXiv 2409.09708, 2024. URL https://arxiv.org/abs/2409.09708

    2024 arXiv

  16. [24]

    Accelerated sparse neural training: A provable and efficient method to find n:m transposable masks

    Itay Hubara, Brian Chmiel, Moshe Island, Ron Banner, Joseph Naor, and Daniel Soudry. Accelerated sparse neural training: A provable and efficient method to find n:m transposable masks. In Advances in Neural Information Processing Systems , volume 34 of NeurIPS, pages 21099–211...

    2021

  17. [25]

    Training recipe for n:m structured sparsity with decaying pruning mask, 2022

    Sheng-Chun Kao, Amir Yazdanbakhsh, Suvinay Subramanian, Shivani Agrawal, Utku Evci, and Tushar Krishna. Training recipe for n:m structured sparsity with decaying pruning mask, 2022. URL https://arxiv.org/abs/2209.07617

    2022 arXiv

  18. [26]

    Namhoon Lee, Thalaiyasingam Ajanthan, and Philip H. S. Torr. Snip: Single-shot network pruning based on connection sensitivity, 2019. URL https://arxiv.org/abs/1810.02340

    2019 arXiv

  19. [27]

    Group fisher pruning for practical network compression

    Liyang Liu, Shilong Zhang, Zhanghui Kuang, Aojun Zhou, Jing-Hao Xue, Xinjiang Wang, Yimin Chen, Wenming Yang, Qingmin Liao, and Wayne Zhang. Group fisher pruning for practical network compression. Proceedings of the 38th International Conference on Machine Learning (ICML) , 13...

    2021

  20. [28]

    Step: Learning n:m structured sparsity masks from scratch with precondition, 2023

    Yucheng Lu, Shivani Agrawal, Suvinay Subramanian, Oleg Rybakov, Christopher De Sa, and Amir Yazdanbakhsh. Step: Learning n:m structured sparsity masks from scratch with precondition, 2023. URL https://arxiv.org/abs/2302.01172

    2023 arXiv

  21. [29]

    Haichuan Mao, Song Han, Jeff Pool, Wenshuo Li, Xingyu Liu, Yu Wang, and William J. Dally. Exploring the regularity of sparse structure in convolutional neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops (CVPRW) , pages 1...

    2017

  22. [30]

    Meta Platforms

    Inc. Meta Platforms. Aitemplate: High-performance inference engine for ai models, 2024. URL https://github.com/facebookincubator/AITemplate. Accessed: 2024-03-23

    2024

  23. [31]

    Accelerating sparse deep neural networks

    Asit Mishra, Jorge Albericio Latorre, Jeff Pool, Darko Stosic, Dusan Stosic, Ganesh Venkatesh, Chong Yu, and Paulius Micikevicius. Accelerating sparse deep neural networks. arXiv preprint arXiv:2104.08378, 2021

    2021 arXiv

  24. [32]

    Pruning convolutional neural networks for resource efficient inference, 2017

    Pavlo Molchanov, Stephen Tyree, Tero Karras, Timo Aila, and Jan Kautz. Pruning convolutional neural networks for resource efficient inference, 2017. URL https://arxiv.org/abs/1611.06440

    2017 arXiv

  25. [33]

    The RISC–V “V” Vector Extension, Version 1.0

    RISC–V International. The RISC–V “V” Vector Extension, Version 1.0. https://github.com/riscvarchive/ riscv-v-spec/releases/tag/v1.0, September 2023. Frozen specification for public review; accessed 21 May 2025

    2023

  26. [34]

    Iterative Methods for Sparse Linear Systems

    Yousef Saad. Iterative Methods for Sparse Linear Systems . SIAM, Philadelphia, PA, 2nd edition, 2003. ISBN 9780898715347

    2003

  27. [35]

    Mo- bileNetV2: Inverted residuals and linear bottlenecks

    Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. Mo- bileNetV2: Inverted residuals and linear bottlenecks. InProceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR) , pages 4510–4520, 2018

    2018

  28. [36]

    Victor Sanh, Thomas Wolf, and Alexander M. Rush. Movement pruning: Adaptive sparsity by fine- tuning. In Advances in Neural Information Processing Systems , volume 33 of NeurIPS, 2020. URL https://proceedings.neurips.cc/paper/2020/file/eae15aabaa768ae4a5993a8a4f4fa6e4-Paper.pdf

    2020

  29. [37]

    Sifive accelerates RISC–V vector integration in xnnpack for optimized ai inference, Aug

    SiFive Inc. Sifive accelerates RISC–V vector integration in xnnpack for optimized ai inference, Aug

  30. [38]

    Dominosearch: Find layer-wise fine-grained n:m sparse schemes from dense neural networks

    Wei Sun, Aojun Zhou, Sander Stuijk, Andrew Oakleigh Nelson, Rob Wijnhoven, Hongsheng Li, and Henk Corporaal. Dominosearch: Find layer-wise fine-grained n:m sparse schemes from dense neural networks. In Advances in Neural Information Processing Systems , volume 34 of NeurIPS, p...

    2021

  31. [39]

    Hidenori Tanaka, Daniel Kunin, Daniel L. K. Yamins, and Surya Ganguli. Pruning neural net- works without any data by iteratively conserving synaptic flow. In Advances in Neural Infor- mation Processing Systems 33 (NeurIPS 2020) , 2020. doi: 10.48550/arXiv.2006.05467. URL https...

    2020 doi arXiv

  32. [40]

    Optimizing structured-sparse matrix multiplication in risc-v vector proces- sors

    Vasileios Titopoulos, Kosmas Alexandridis, Christodoulos Peltekis, Chrysostomos Nicopoulos, and Giorgos Dimitrakopoulos. Optimizing structured-sparse matrix multiplication in risc-v vector proces- sors. IEEE Transactions on Very Large Scale Integration (VLSI) Systems , 31(7):1...

    2023

  33. [41]

    Picking winning tickets before training by preserving gradient flow, 2020

    Chaoqi Wang, Guodong Zhang, and Roger Grosse. Picking winning tickets before training by preserving gradient flow, 2020. URL https://arxiv.org/abs/2002.07376

    2020 arXiv

  34. [42]

    Learning n :m fine-grained structured sparse neural networks from scratch

    Aojun Zhou, Yukun Ma, Junnan Zhu, Jianbo Liu, Zhijie Zhang, Kun Yuan, Wenxiu Sun, and Hongsheng Li. Learning n :m fine-grained structured sparse neural networks from scratch. InProceedings of the 9th International Conference on Learning Representations, ICLR, 2021. URL https:/...

    2021 arXiv

  35. [43]

    FGGP: Fixed-rate gradient-first gradual pruning

    Lingkai Zhu, Can Deniz Bezek, and Orcun Goksel. FGGP: Fixed-rate gradient-first gradual pruning. https://arxiv.org/abs/2411.05500, 2024. arXiv 2411.05500. Received 19 March 2025

    2024 arXiv

  36. [2023]

    Accessed 6 May 2025

    URL https://www.sifive.com/blog/sifive-accelerates-risc-v-vector-integration-in-xnnpack-for- optimized-ai-inference. Accessed 6 May 2025

    2025

Pith tools

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