Pith. sign in

REVIEW 3 major objections 6 minor 22 references

COGNATE: Acceleration of Sparse Tensor Programs on Emerging Hardware using Transfer Learning

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

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

Pith's one-line read COGNATE claims that learned cost models for sparse-tensor accelerators can be pretrained on cheap CPU execution data and then adjusted with only a handful of simulator samples, cutting the accelerator data budget to roughly 5% of what…

desk verdict Interesting data-frugal transfer approach for cost models, but the key mapping is inconsistently specified and the headline numbers are tuned on the test set. read the letter →

arxiv 2506.00424 v2 pith:ENO2MTEI submitted 2025-05-31 cs.LG cs.AIcs.ARcs.ET

Chamika Sudusinghe , Gerasimos Gerogiannis , Damitha Lenadora , Charles Block , Josep Torrellas , Charith Mendis This is my paper
classification cs.LGcs.AIcs.ARcs.ET
keywords transferlearningcostmodelsparsetensorprogramshardwareacceleratorSpMMSDDMMdesignspaceexplorationfew-shotfine-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 claims that learned cost models for emerging sparse-tensor accelerators can be trained almost entirely on cheap CPU execution data, then adjusted with a handful of simulator samples. It reports that this transfer-learning recipe, called COGNATE, reaches the same configuration quality as models trained on 20–200 times more accelerator data, cutting the simulated data budget to about 5%. If correct, hardware architects can explore the design space of accelerators that exist only as slow simulators without months of simulation time. The framework is demonstrated on SpMM and SDDMM for the SPADE accelerator and an NVIDIA A100 GPU.

What carries the argument

The central mechanism is the configuration mapper $\mathcal{F}_M$, which approximates CPU loop strip-mining by SPADE tiling plus barrier via $\phi:\{p_{col}, p_{row}, s_{split}, b\} \to \{I,J,K,\omega\}$, and CPU loop reordering by GPU loop insertion via $\pi$. The approximate mapping creates a shared feature space for feature reuse, while a per-target autoencoder produces a latent encoding $z_j = \mathcal{LE}(c_j)$ for hardware-specific parameters. A modified input featurizer with deeper and wider sparse convolutions captures low-level sparsity statistics. The predictor merges $s_M \| p_j \| z_j$ through an MLP, trained with pairwise ranking loss.

What would settle it

A direct test would replace the mapping functions $\phi$ and $\pi$ with random permutations of the same parameters, keep everything else fixed, and measure the fine-tuned speedup on SPADE; if the drop is small, the mappings are not load-bearing. Alternatively, transfer from CPU to a simulator whose barrier semantics are inverted relative to the mapping assumption and observe whether COGNATE's speedup falls below the no-transfer baseline.

Watch

Extended reading notes

Core claim

On the paper's own terms, COGNATE establishes that heterogeneous program configurations across CPU, accelerator, and GPU can be decomposed into a homogeneous part (loop strip-mining, loop reordering, tiling, barriers) that transfers across platforms via approximate mapping functions, and a heterogeneous part (hardware-specific knobs) that is compressed into fixed-size latent vectors by per-target autoencoders. With this split, a WACO-style cost model pretrained on 100 CPU matrices and fine-tuned on 5 SPADE matrices attains a top-1 geomean speedup of 1.40x and top-5 of 1.47x for SpMM, reaching 90–95% of the optimal 1.55x, while a model trained with no transfer needs 100–1000 matrices to match. The same recipe reaches 1.17x top-5 SpMM speedup on the A100 GPU.

Load-bearing premise

The hand-defined approximate mappings equate CPU loop transformations with accelerator tiling and barrier semantics; if those equivalences misrepresent the true effect on performance, the shared feature space is misaligned and transfer can hurt rather than help.

Editorial extensions

If this is right

  • The data budget for design-space exploration of sparse accelerators shrinks by roughly 20x–200x compared to training a cost model from scratch on the target simulator.
  • COGNATE approaches the optimal program configuration within a constrained search space, reaching 90–95% of the optimal speedup for SpMM on SPADE.
  • Fine-tuning on just five matrices is near the saturation point; increasing to 100 or 1000 matrices provides negligible additional speedup.
  • The same transfer recipe generalizes across heterogeneous target types, achieving 1.17x and 1.15x top-5 speedups for SpMM and SDDMM on an NVIDIA A100 GPU, and 1.28–1.30x on an end-to-end GNN workload.

Reading between the lines

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

  • The hand-defined mappings may transfer to other accelerators such as PIUMA or Vesper, where the paper argues similar loop transformations exist, but this remains untested because those platforms were inaccessible.
  • The choice of pairwise ranking loss, rather than regression on runtime, likely carries much of the transfer benefit: ranking is robust to scale differences between CPU and simulator timings, an effect the paper does not isolate.
  • A natural extension not explored here is multi-source pretraining (CPU plus GPU data) or using COGNATE as a filter to prune the configuration space before exhaustive simulation, which could further cut simulator cost.
  • If the approximate mappings are the load-bearing part, then a direct test is to replace $\phi$ and $\pi$ with random permutations: if speedups barely change, the homogeneity assumption is not what drives the result.
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

3 major / 6 minor

Summary. The paper introduces COGNATE, a transfer-learning framework for building cost models for sparse tensor programs on emerging hardware accelerators. It pre-trains a WACO-style cost model on inexpensive CPU data and then fine-tunes it on a few simulator samples from the target accelerator, exploiting a hand-designed approximate mapping between CPU loop optimizations and accelerator tiling/barrier parameters, while encoding hardware-specific parameters with per-target autoencoders. The evaluation on 715 SuiteSparse matrices for SpMM and SDDMM reports average speedups of 1.47x/1.39x (top-5) on the SPADE simulator and 1.17x/1.15x on an A100 GPU, with the headline claim being that COGNATE needs only 5% of the target-platform samples required by non-transfer cost models to achieve comparable performance.

Significance. If the results are reproducible, COGNATE addresses a genuinely important bottleneck: learned cost models for early-stage accelerators are impractical because simulator-based data collection is extremely expensive. The central idea of explicitly mapping comparable code optimizations across heterogeneous hardware into a homogeneous feature space, combined with unsupervised latent encoding of hardware-specific parameters, is novel and potentially generalizable. Strengths include evaluation on a large matrix suite, ablation of all model components, comparison against feature-augmentation and feature-mapping baselines, and transparency about the enormous data-collection cost. However, the core cross-platform mapping is specified inconsistently between the main text and the appendix, and the headline data-efficiency numbers are obtained by selecting key hyperparameters on the test set without error bars. These issues make the central claim currently not reproducible, so the significance is conditional on the authors resolving them.

major comments (3)
  1. [Section 3.2 vs. Appendix E] The approximate mapping φ is specified inconsistently. Section 3.2 defines φ(p_col, p_row, s_split, b) = (I, J, K, ω) with I≈p_col, J≈p_row, K≈s_split and a six-element loop order ω, while the worked example in Appendix E maps a SPADE configuration with row panels=4 and column panels=1024 to i split=4 and j split=1024, which is the opposite assignment if p_col and p_row refer to column and row panels, respectively. The same example uses seven loop-order entries although the formula produces six loops, and it lists split=1 even though Section 4.1 restricts the split factor to {32, 256}. Since the ablation in Figure 7 shows that removing the configuration mapper drops speedup from 1.40x to 1.16x, the headline sample-efficiency result is materially contingent on this mapping being correct and unambiguous. The authors must resolve the inconsistency by providing the exact implemented mapping, and ideally release source code so that the reader can verify which version was used.
  2. [Section 4.1 and Section 4.4] The source training size (100 matrices) and fine-tuning size (5 matrices) are selected by inspecting the same 715-matrix test set used to report the headline speedups. The paper states in Section 4.1 that the 100-matrix choice is based on the empirical demonstration in Figure 11 and that the 5-matrix choice is guided by the observations in Figure 12; those figures appear to plot geomean speedup on the test set. This constitutes test-set-driven hyperparameter selection, which can inflate the reported gains. The paper does not report a held-out validation split for these choices, nor does it report variance over multiple training runs. Without such information, the abstract's claim of 'just 5% of the data samples' may be optimistic. The authors should either select these hyperparameters on a validation set and re-report test performance, or provide confidence intervals from repeated experiments.
  3. [Abstract and Table 2] The headline '5% of data' claim relies on a specific comparison point. In Table 2, TL5 (500 SPADE samples) reaches 1.40x speedup while NT100 (10,000 samples) reaches 1.38x, but NT1000 (100,000 samples) reaches 1.43x, which is higher. Thus 'comparable performance' is conditional on the chosen baseline and a tolerance for a 0.02-0.03 speedup difference that is within plausible noise given the absence of error bars. The abstract should state both top-1 and top-5 numbers explicitly (the 1.47x/1.39x figures are top-5; top-1 is 1.40x/1.27x on SPADE) and clarify the exact comparison protocol behind the '5%' statement.
minor comments (6)
  1. [Section 4.3] In the GPU SDDMM results, the text says 'while COGNATE(Top-1) yielded a 1.15x speedup', but the preceding sentence and Figure 4 show that 1.15x is the top-5 value; the top-1 value is 1.07x. This appears to be a typo and should be corrected.
  2. [Abstract] The abstract should specify that the reported average speedups of 1.47x and 1.39x correspond to the top-5 (k-best) configuration selection; the top-1 values are lower (1.40x and 1.27x on SPADE) and affect the interpretation of 'average speedup'.
  3. [Section 4.1] The statement that COGNATE reaches '95% of the optimal speedup' refers to the optimal within the constrained 256-configuration search space, not the true global optimal. This should be stated explicitly when interpreting the optimal speedup values.
  4. [Appendix C] The discussion of generalizability to Intel PIUMA and Vesper is necessarily speculative, and the authors correctly note that no evaluation was possible. This should be clearly identified as a hypothesis for future work rather than a demonstrated property.
  5. [Table 2] The column headings 'CPU' and 'SPADE' under 'Data Samples' should clarify that CPU samples are used for pre-training and SPADE samples for fine-tuning or non-transfer training; this is partially clear from the caption but would be more explicit in the table itself.
  6. [General] The paper does not mention plans for code or data release. Given the central role of the hand-crafted mapping and the internal inconsistency noted above, releasing the mapping implementation and the trained model would substantially improve reproducibility.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the transfer-learning results are measured against SPADE and A100 runtimes, and the mapping/autoencoder are hand-specified or unsupervised inputs rather than fitted predictions.

full rationale

COGNATE's headline result is an empirical measurement, not a derivation: the model is pre-trained on CPU runtimes and fine-tuned on 500 SPADE samples, then its top-1/top-5 configurations are executed on SPADE and an A100 GPU (Fig. 4, Table 2). No fitted parameter from target runtimes is renamed as a prediction. The configuration mapper phi (Sec. 3.2) is a hand-designed feature-engineering assumption mapping SPADE tiling/barrier parameters to CPU strip-mining/loop-order parameters; it is an input to the system, not something inferred from target labels, so its correctness affects validity but does not make the evaluation circular. The latent encoder (Sec. 3.3) is trained unsupervised on configuration parameterizations without runtime labels, so it cannot force the reported speedups. Self-citations to WACO and SPADE are to a base architecture and an evaluation substrate; the A100 experiments provide an independent external benchmark, and no uniqueness theorem or prior-result chain is used to forbid alternatives. The internal inconsistency between Sec. 3.2's phi (I approx p_col, J approx p_row) and the Appendix E example (row panels=4 -> i split=4, column panels=1024 -> j split=1024, seven loop entries, and split=1 outside the declared {32,256} range) is a serious reproducibility/correctness concern but not a circularity, since the mapping is stated as an approximation rather than derived from the result. Likewise, the untested PIUMA/Vesper generalization (Appendix C) is a scoping limitation. Hence no circular step is established.

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

The central claim depends on hand-crafted configuration mappings and on hyperparameters (source 100 matrices, fine-tune 5 matrices) selected against the test set. The autoencoder latent representation is a design choice rather than an invented physical entity.

free parameters (5)
  • Source training dataset size = 100 matrices
    Chosen by evaluating transfer performance on the test set (Figure 11); the model trained on 100 matrices gave the best fine-tuned speedup.
  • Fine-tuning dataset size = 5 matrices (500 samples)
    Chosen by evaluating test-set speedups for 3, 5, 7, 100, and 1000 matrices (Figure 12 and Section 4.4); 5 was selected as the best trade-off.
  • Latent embedding dimension = 64
    Autoencoder latent size in Table 6; fixed without justification or sensitivity study.
  • Configuration mapping approximations = I approximately p_col, J approximately p_row, K approximately s_split; fixed loop orders for b=1 and b=0
    Hand-crafted mapping functions in Section 3.2; no validation that the mapped features faithfully represent equivalent optimizations.
  • Input featurizer depth and channels = 12 layers, up to 256 channels
    Architecture chosen by hand, deviating from WACO's 14 layers and 32 channels; no ablation on these choices beyond the full model.
assumptions (5)
  • ad hoc to paper Tiling plus barrier on SPADE approximates loop strip-mining on CPU
    Section 3.2 states 'We can approximately map tiling and barrier parameters to the corresponding strip-mining parameters'; the mapping is assumed without independent verification.
  • ad hoc to paper Loop reordering maps between CPU and GPU via inserted dummy loop segments
    Section 3.2 defines pi_a1 and pi_a3 with dummy segments k3=1 and j'=1; correctness of the approximation is assumed.
  • domain assumption Source cost model features (CPU/TACO) transfer to target accelerators after fine-tuning
    Core premise of transfer learning; the paper shows zero-shot is poor (0.71x), so transfer works only with fine-tuning, but the assumption that fine-tuning suffices is untested beyond the two targets.
  • standard math Ranking loss optimization improves top-k configuration selection
    Borrowed from Kaufman et al. 2021 and prior work; used in the pairwise ranking loss in Appendix A.4.
  • domain assumption SuiteSparse matrices are representative of real sparse workloads
    Dataset choice from Davis and Hu 2011, standard in prior sparse tensor work.

how reviews work

0 comments
Cite this review

Pith. "Pith review of COGNATE: Acceleration of Sparse Tensor Programs on Emerging Hardware using Transfer Learning." pith.science (2026). https://pith.science/paper/ENO2MTEI

@misc{pith2026250600424,
  author       = {Pith},
  title        = {Pith review of: COGNATE: Acceleration of Sparse Tensor Programs on Emerging Hardware using Transfer Learning},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/ENO2MTEI}},
  note         = {Machine review of arXiv:2506.00424}
}
read the original abstract

Sparse tensor programs are essential in deep learning and graph analytics, driving the need for optimized processing. To meet this demand, specialized hardware accelerators are being developed. Optimizing these programs for accelerators is challenging for two reasons: program performance is highly sensitive to variations in sparse inputs, and early-stage accelerators rely on expensive simulators. Therefore, ML-based cost models used for optimizing such programs on general-purpose hardware are often ineffective for early-stage accelerators, as they require large datasets for proper training. To this end, we introduce COGNATE, a novel framework that leverages inexpensive data samples from general-purpose hardware (e.g., CPUs) to train cost models, followed by few-shot fine-tuning on emerging hardware. COGNATE exploits the homogeneity of input features across hardware platforms while effectively mitigating heterogeneity, enabling cost model training with just 5% of the data samples needed by accelerator-specific models to achieve comparable performance. We conduct extensive experiments to demonstrate that COGNATE outperforms existing techniques, achieving average speedups of 1.47x (up to 5.46x) for SpMM and 1.39x (up to 4.22x) for SDDMM.

Figures

Figures reproduced from arXiv: 2506.00424 by the authors.

Figure 1
Figure 1. Transfer learning pipeline of COGNATE. 5 100 1000 # of Matrices 1.0 1.1 1.2 1.3 1.4 1.5 Geomean Speedup WACO+FM WACO+FA Ours (Top-1) Optimal: 1.55 Baseline: 1.0 [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Performance [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗
Figure 3
Figure 3. A comparative overview of the enhanced cost [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (8 more)
Figure 4
Figure 4. Figure 4: Geomean speedups of COGNATE and other techniques, normalized to the baseline. [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]
Figure 5
Figure 5. Figure 5: COGNATE per-matrix speedups (SpMM) [PITH_FULL_IMAGE:figures/full_fig_p007_5.png]
Figure 6
Figure 6. Figure 6: Loss and accuracy during training. 4.3. Transferability to GPU COGNATE is generalizable and is not only applicable to one target hardware platform. To showcase COGNATE’s capability, we extended our evaluation to a GPU acceler￾ator (NVIDIA A100) ( [PITH_FULL_IMAGE:figu…
Figure 9
Figure 9. Figure 9: Selection of auto￾encoders for COGNATE. 1.0 1.2 1.4 1.6 Geomean Speedup 1.29 1.38 1.43 1.40 1.55 NT 5 NT 100 NT 1000 COGNATE Optimal [PITH_FULL_IMAGE:figures/full_fig_p009_9.png]
Figure 11
Figure 11. Figure 11: Impact of nega [PITH_FULL_IMAGE:figures/full_fig_p009_11.png]
Figure 13
Figure 13. Figure 13: COGNATE (Top-5) per-matrix speedups (SpMM) [PITH_FULL_IMAGE:figures/full_fig_p018_13.png]
Figure 14
Figure 14. Figure 14: COGNATE (Top-1) per-matrix speedups (SDDMM) [PITH_FULL_IMAGE:figures/full_fig_p018_14.png]
Figure 15
Figure 15. Figure 15: COGNATE (Top-5) per-matrix speedups (SDDMM) [PITH_FULL_IMAGE:figures/full_fig_p018_15.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

22 extracted references · 10 canonical work pages

  1. [5]

    Frustratingly easy domain adaptation.arXiv preprint arXiv:0907.1815,

    Daum´e III, H. Frustratingly easy domain adaptation.arXiv preprint arXiv:0907.1815,

    arXiv

  2. [9]

    URL https://doi.org/10

    doi: 10.1145/3133901. URL https://doi.org/10. 1145/3133901. Krizhevsky, A., Sutskever, I., and Hinton, G. E. Imagenet classification with deep convolutional neural networks. Advances in neural information processing systems, 25,

    doi:10.1145/3133901

  3. [11]

    Mu˜noz-Mart´ınez, F., Garg, R., Pellauer, M., Abell´an, J

    doi: 10.1109/ICCT46805.2019.8947072. Mu˜noz-Mart´ınez, F., Garg, R., Pellauer, M., Abell´an, J. L., Acacio, M. E., and Krishna, T. Flexagon: A multi- dataflow sparse-sparse matrix multiplication accelerator for efficient dnn processing. InProceedings of the 28th ACM International Conference on Architectural Support for Programming Languages and Operating ...

    work page arXiv 2019

  4. [13]

    A cost model for compilers based on transfer learning

    Sasaki, Y ., Takahashi, K., Shimomura, Y ., and Takizawa, H. A cost model for compilers based on transfer learning. In 2022 IEEE International Parallel and Distributed Pro- cessing Symposium Workshops (IPDPSW), pp. 942–951. IEEE,

    work page 2022

  5. [14]

    S., and Amarasinghe, S

    Won, J., Mendis, C., Emer, J. S., and Amarasinghe, S. Waco: Learning workload-aware co-optimization of the format and schedule of a sparse tensor program. InProceedings of the 28th ACM International Confer- ence on Architectural Support for Programming Lan- guages and Operating Systems, Volume 2, ASPLOS 2023, pp. 920–934, New York, NY , USA,

    work page 2023

  6. [15]

    ISBN 9781450399166

    Associa- tion for Computing Machinery. ISBN 9781450399166. doi: 10.1145/3575693.3575742. URL https://doi. org/10.1145/3575693.3575742. Yang, H., Liu, Y ., Luan, Z., Gan, L., Yang, G., and Qian, D. Input-aware sparse tensor storage format selection for optimizing mttkrp.Computer, 56(08):4–7, aug

    arXiv

  7. [16]

    doi: 10.1109/MC.2023.3279447

    ISSN 1558-0814. doi: 10.1109/MC.2023.3279447. 11 COGNATE: Acceleration of Sparse Tensor Programs on Emerging Hardware using Transfer Learning Ye, Y . and Ji, S. Sparse graph attention networks.IEEE Transactions on Knowledge and Data Engineering, 35 (1):905–916,

    work page arXiv 2023

  8. [17]

    Sparse- tir: Composable abstractions for sparse compilation in deep learning

    Ye, Z., Lai, R., Shao, J., Chen, T., and Ceze, L. Sparse- tir: Composable abstractions for sparse compilation in deep learning. ASPLOS 2023, pp. 660–678, New York, NY , USA,

    work page 2023

Show all 22 references
  1. [18]

    ISBN 9781450399180

    Association for Computing Machinery. ISBN 9781450399180. doi: 10.1145/ 3582016.3582047. URL https://doi.org/10. 1145/3582016.3582047. Zhai, Y ., Zhang, Y ., Liu, S., Chu, X., Peng, J., Ji, J., and Zhang, Y . Tlp: A deep learning-based cost model for tensor program tuning. InPr...

  2. [20]

    We use thepairwise ranking lossas our learning objective (implemented using margin ranking loss) to rank program configurations based on their true performance differences

    has shown that training with ranking loss significantly improves a model’s ability to identify optimal configurations. We use thepairwise ranking lossas our learning objective (implemented using margin ranking loss) to rank program configurations based on their true performanc...

    2024

  3. [21]

    These mappings are conceptually aligned with those we applied to SPADE and GPU, highlighting the general applicability of our approach across diverse hardware backends

    as examples. These mappings are conceptually aligned with those we applied to SPADE and GPU, highlighting the general applicability of our approach across diverse hardware backends. Intel PIUMA (Gerogiannis et al., 2024; Aananthakrishnan et al.,

    2024

  4. [22]

    evolve, COGNATE can be extended with minimal changes. Assuming these accelerators were available, the data collection process would still be highly time-consuming, likely requiring millions of machine hours to gather sufficient data for training, validation, and testing. For e...

    2023

  5. [100]

    10000 500 1.40 9.58 0.51 TL 100 10000 10000 1.41 8.74 10.01 TL 1000 10000 100000 1.42 7.28 100.01 CPU 5 500 500 1.07 27.80 0.50 CPU 20 2000 500 1.21 19.35 0.50 CPU 500 50000 500 1.36 16.34 0.55 CPU 1000 100000 500 1.19 36.00 0.60 Zero-Shot (CPU) 10000 - 0.71 46.22 0.01 Table 2...

  6. [2012]

    Crafting papers on machine learning

    Langley, P. Crafting papers on machine learning. In Langley, P. (ed.),Proceedings of the 17th International Conference on Machine Learning (ICML 2000), pp. 1207–1216, Stan- ford, CA,

    2000

  7. [2016]

    In13th USENIX Symposium on Operating Sys- tems Design and Implementation (OSDI 18), pp

    Chen, T., Moreau, T., Jiang, Z., Zheng, L., Yan, E., Shen, H., Cowan, M., Wang, L., Hu, Y ., Ceze, L., et al.{TVM}: An automated {End-to-End} optimizing compiler for deep learning. In13th USENIX Symposium on Operating Sys- tems Design and Implementation (OSDI 18), pp. 578–594,...

    1904 arXiv

  8. [2017]

    Learning with augmented features for heterogeneous domain adaptation.arXiv preprint arXiv:1206.4660,

    Duan, L., Xu, D., and Tsang, I. Learning with augmented features for heterogeneous domain adaptation.arXiv preprint arXiv:1206.4660,

    arXiv

  9. [2018]

    and Sung, H

    Ryu, J. and Sung, H. Metatune: Meta-learning based cost model for fast and efficient auto-tuning frameworks. arXiv preprint arXiv:2102.04199,

    arXiv

  10. [2019]

    Pixelated butterfly: Simple and efficient sparse training for neural network models.arXiv preprint arXiv:2112.00029,

    Dao, T., Chen, B., Liang, K., Yang, J., Song, Z., Rudra, A., and Re, C. Pixelated butterfly: Simple and efficient sparse training for neural network models.arXiv preprint arXiv:2112.00029,

    arXiv

  11. [2020]

    Reminder of the first paper on transfer learn- ing in neural networks, 1976.Informatica, 44(3),

    Bozinovski, S. Reminder of the first paper on transfer learn- ing in neural networks, 1976.Informatica, 44(3),

    1976

  12. [2021]

    E., and Cohan, A

    Beltagy, I., Peters, M. E., and Cohan, A. Long- former: The long-document transformer.arXiv preprint arXiv:2004.05150,

    2004 arXiv

  13. [2023]

    ISBN 9798400700958

    Associ- ation for Computing Machinery. ISBN 9798400700958. doi: 10.1145/3579371.3589054. URL https://doi. org/10.1145/3579371.3589054. Gerogiannis, G., Aananthakrishnan, S., Torrellas, J., and Hur, I. Hottiles: Accelerating spmm with heterogeneous accelerator architectures. In...

  14. [2024]

    and Van der Maaten, L

    Graham, B. and Van der Maaten, L. Submanifold sparse con- volutional networks.arXiv preprint arXiv:1706.01307,

    arXiv

Pith tools

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