Pith. sign in

REVIEW 4 major objections 5 minor 34 references

QS4D: Quantization-aware training for efficient hardware deployment of structured state-space sequential models

T0 review · 4 major / 5 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 Quantization-aware training lets S4D state-space models drop to 5–6 bit precision with under 1% accuracy loss, cutting computational effort by up to two orders of magnitude, shrinking memory about tenfold, and making the models tolerant…

desk verdict Useful systems paper, but the headline complexity numbers rest on an unverified convolutional-mode proxy; the hardware demo uses coarser quantization and doesn't close the gap. read the letter →

arxiv 2507.06079 v1 pith:DPDKGA4U submitted 2025-07-08 cs.LG cs.AI

Sebastian Siegel , Ming-Jay Yang , Younes Bouhadjar , Maxime Fabre , Emre Neftci , John Paul Strachan This is my paper
classification cs.LGcs.AI
keywords quantization-awaretrainingstatespacemodelsS4Danalogin-memorycomputingmemristivecrossbararraysedgedeploymentstructuralpruningnoiserobustness
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 tries to establish that quantization-aware training is not just a memory-saving trick but a hardware-enabling one for structured state-space models. It shows that S4D models, whose linear recurrences are trained as convolutions, can be quantized to 5–6 bits with less than 1% accuracy loss when quantization is baked into training, whereas post-training quantization fails at 10–16 bits. Across sequential image, path-finding, and audio keyword tasks, this cuts computational effort by up to two orders of magnitude, shrinks parameter memory by roughly a factor of ten, and lowers the estimated complexity of analog-to-digital conversion. It also reports that aggressive quantization makes the models more tolerant of analog read noise and more amenable to structural pruning of entire recurrent kernels. The payoff, demonstrated on a small memristive crossbar array, is a fully mapped S4D kernel for keyword spotting whose hardware accuracy nearly matches the software model.

What carries the argument

The central object is the S4D model, a structured state-space sequence model whose transition matrix is diagonalized so that each kernel's recurrent state update becomes an elementwise multiplication. The mechanism carrying the argument is quantization-aware training with a straight-through estimator: the forward pass rounds each parameter and activation onto an equally spaced integer ladder centered on zero, while the backward pass treats the rounding as an identity so gradients can flow. Because the model is trained in convolutional mode, state quantization is emulated by quantizing the input and convolutional kernel to half the target state precision, a proxy the paper explicitly notes is not numerically identical to recurrent computation. On the hardware side, the IMSSA mapping places the $A$, $B$, and $C$ operations of a kernel into one memristive crossbar array, with the output read from a one-time-step-delayed state, so the whole kernel executes as a single vector-matrix multiplication.

What would settle it

Run a QAT-trained S4D model in true recurrent mode on a memristive crossbar array at the bit widths of Table 1 on a longer, multi-class task, and compare hardware accuracy to the convolutional-emulation prediction; if the extra error exceeds 1% while the emulation said it would not, the emulation proxy is the point of failure.

Watch

Extended reading notes

Core claim

The paper claims that quantization-aware training (QAT) is the enabling step for deploying S4D structured state-space models on edge hardware: with QAT, all core parameters — the diagonal transition matrix $A$, the output vectors $C$, the trainable time steps $\Delta t$, the encoder, decoder, mixing layers, and inter-layer activations — can be projected onto an equally spaced integer ladder and trained with a straight-through estimator until the model tolerates 5–6 bit homogeneous precision with under 1% extra error, a far more aggressive quantization than post-training quantization allows. The consequence is that computational effort (ACE) falls by up to two orders of magnitude, memory footprint by about a factor of ten, and the ADC peripheral complexity of an analog in-memory implementation by several fold, while the model simultaneously becomes more tolerant of transient read noise and more prunable at the level of whole kernels. The paper closes by showing that a small keyword-spotting S4D kernel can be programmed onto a memristive crossbar array via the IMSSA mapping, recovering 95.3% accuracy against a 95.8% software baseline.

Load-bearing premise

The load-bearing premise is that quantization emulated during convolutional-mode training faithfully predicts how the recurrent computation will behave on the analog chip; the paper itself notes in Section 2.1 that the two computations do not give exactly the same numerical results.

Editorial extensions

If this is right

  • On the three tasks studied, homogeneous quantization to 5–6 bits with QAT keeps additional error below 1%, where PTQ already fails at 10–16 bits; individual parameters such as $\Delta t$ can fall to 1 bit.
  • Computational effort, measured by ACE, drops 11–24x with PTQ and a further 2–11.5x with QAT, pushing the combined reduction toward two orders of magnitude; model memory shrinks by roughly 10x and ADC read-out complexity by several fold.
  • QAT-trained models degrade more gracefully under transient read noise on the recurrent matrix, and training with explicit Gaussian noise on top restores some quantization loss and improves all models.
  • Aggressive quantization enables structural pruning of entire kernels, with more than half the first-layer kernels removable at 7 bits on the sequential CIFAR10 task, and this pruning advantage grows as bit width drops.
  • A complete S4D kernel can be mapped onto a single 64x64 memristive crossbar array, and the programmed hardware reached 95.3% accuracy on a two-class keyword-spotting subset, close to the 95.8% software model.

Reading between the lines

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

  • The convolutional-emulation proxy for state quantization means the headline two-orders-of-magnitude complexity gain is validated in software emulation; the small hardware demo is a two-class keyword spotter, so the gain at scale still needs a recurrent-mode hardware check.
  • Because QAT behaves like noise injection, combining it with explicit noise training and device-aware programming could close the residual software–hardware accuracy gap further, a combination the paper only explores separately.
  • The pruning result suggests QAT changes the loss landscape so that entire recurrent kernels become redundant; an automated co-design loop could search over bit width, state dimension, and kernel count together.
  • The same recipe may transfer to selective SSMs such as Mamba, but their input-dependent dynamics would need a different state-quantization emulation, so the gains are not automatic.
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 / 5 minor

Summary. The paper studies quantization-aware training (QAT) of S4D structured state-space models for edge deployment. It introduces an indirect state quantization by quantizing the convolutional kernel and input, compares QAT against post-training quantization on sCIFAR10, Pathfinder, and a Heidelberg Digits keyword-spotting subset, and reports maximum bit widths that stay below a 1%-additional-error threshold. From those bit levels, the paper derives reductions in three hardware-oriented metrics: arithmetic complexity (ACE), parameter memory, and an ADC peripheral complexity measure. It also examines size-versus-precision trade-offs, structural pruning of complete kernels, robustness to transient analog noise, and finally reports a small memristive crossbar-array deployment of an S4D kernel. The central claims are that QAT can reduce SSM complexity by up to two orders of magnitude, improves noise robustness, and enables structural pruning.

Significance. If the claims hold, the paper provides a practical hardware-software co-design recipe for S4D-style models on edge and analog in-memory substrates, with concrete bit-width-to-metric mappings that are useful for accelerator design. Strengths include the systematic PTQ-versus-QAT comparison across three tasks and several parameter groups, algebraically transparent complexity metrics, explicit noise-robustness experiments, and a real memristive hardware demonstration with a calibrated write/read noise treatment. The main risk is that the headline complexity reductions are computed from quantization levels obtained in convolutional-mode emulation, while the recurrent-mode deployment that hardware actually executes is only checked on a much coarser, small model; the lack of error bars on all accuracy experiments further tempers the strength of the quantitative claims.

major comments (4)
  1. [§2.1, §3, Table 1 vs. Table 3] The central two-orders-of-magnitude complexity claim is computed from quantization levels found in convolutional-mode QAT, but Section 2.1 states that this indirect state quantization 'does not yield the exact same numerical results as the recurrent computation' and that the state is never explicitly computed. In the recurrent deployment mode (Eq. 3), quantization errors in A, B, C, Δ, and activations propagate through the recurrence, so the aggressive levels in Table 1 (e.g., HD: homogeneous QAT 5 bits, A 1 bit, state 3 bits) may not transfer. The hardware check in Table 3 uses substantially coarser settings (rstate/ract = 8 bits, rkernelweights = 4 bits, N = 14, H = 3) on a two-class HD subset, so it does not validate the aggressive QAT levels. A recurrent-mode inference test using the Table 1 quantized parameters, or direct recurrent-mode QAT, is needed before the headline complexity reductions can be considered established for real deployments.
  2. [Table 1, Figures 2 and 4] All reported accuracy numbers appear to be single-run results with no error bars or seed information. Because the headline gains are defined by a 1%-additional-error threshold (e.g., QAT 5 vs. 6 bits on HD, or PTQ 10 vs. 9 bits on sCIFAR10), the reported bit-level differences need to be distinguished from run-to-run variation. The 100.0% baseline accuracy for Heidelberg Digits in Table 1 is unexplained; please state the test-set size and confirm whether this value is rounded, since a rounded 100% baseline makes the 'below 1% additional error' criterion ill-defined.
  3. [§2.4, Table 2] The structural-pruning claim is presented as a benefit of QAT, but Table 2 is captioned 'Post training pruning' and the pruning method is not specified. No importance criterion, threshold, retraining protocol, or data-split details are provided, so it is unclear whether the larger pruning margins for 7-bit models reflect a property induced by QAT or simply the action of an unspecified criterion on different weight distributions. To support the statement that QAT 'enables structural pruning,' report the pruning algorithm and verify that the pruned models remain within the stated error budget after pruning.
  4. [§5.3.1–5.3.2, Eqs. (6)–(7)] Equations (6) and (7) contain unmatched parentheses and ambiguous operator precedence in the encoder/decoder terms: 'H*(n_in + n_out * r_act * r_coder' and 'H*(n_in + n_out * r_coder'. As written, the metric values in Figure 3 cannot be reproduced unambiguously. Please write the terms as H*(n_in + n_out)*r_act*r_coder and H*(n_in + n_out)*r_coder, or specify the intended grouping, and define all variables consistently.
minor comments (5)
  1. [§1, §2.2] There are several typos: 'quantization-aware training (QTA)' should be 'QAT', 'going the the left' should be 'going to the left', and the phrase 'perfect memory tasks' in the Discussion overstates what the benchmarks measure.
  2. [Figure 2 caption] The caption line '4 bits 4 bits 2 bits 4 bits / 7 bits3 bits1 bit 1 bit' is unclear; each subplot should be labeled with the parameter being quantized, and the PTQ/QAT line styles need to be defined in a legend.
  3. [§2.5, Figure 4] The noise-robustness plots would benefit from explicit axis definitions and error bars; the caption says 'the large range of the x-axis should be noted' but does not state the units or the noise injection point precisely enough for reproduction.
  4. [§3, Table 4] The comparison with the Jetson Nano is not apples-to-apples: the technology nodes differ (180nm custom chip vs. 20nm commercial GPU), and it is unclear whether the reported throughput is measured or theoretical peak, or whether the comparison includes the ADC/DAC and programming overhead of the memristive system. Please specify the measurement conditions and workload for both systems.
  5. [§5.2.1, Eq. (5)] The quantization formula should state whether the scaling grid is per-tensor or per-channel and should define how zero is handled; this detail is relevant because the encoder/decoder and recurrent parameters may need different ranges.

Circularity Check

0 steps flagged · score 2.0 of 10

No significant circularity: QAT gains are benchmark-driven, hardware results include independent chip measurements, and self-citations are not load-bearing.

full rationale

The core QAT-versus-PTQ comparison is evaluated on external benchmarks (sequential CIFAR10, Pathfinder, and Heidelberg Digits) and does not reduce to a fitted parameter. The complexity reductions in Figure 3 are arithmetic consequences of Equations 6-8 applied to the quantization levels obtained in training; this is an openly stated engineering calculation, not a prediction disguised as a fit. The state-quantization emulation is explicitly flagged in Section 2.1 as approximate ('it should be noted that this does not yield the exact same numerical results as the recurrent computation'), so it is a validation caveat rather than a circular step. The hardware deployment uses the authors' own IMSSA architecture (Siegel et al. 2025) and memristor tuning method (Yang et al. 2025), but these self-citations supply independent chip measurements and device models, including the measured 95.3% mCBA accuracy versus 95.8% software accuracy in Table 3, and no uniqueness or forced-choice argument is imported from them. No step defines the claimed result in terms of itself; the main risk is transfer of convolutional-mode quantization to recurrent-mode hardware, which is a correctness and generalization concern, not circularity.

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

No new physical entities are proposed. The closest to a new artifact is the ADC complexity metric (Section 5.3.3), but it is an accounting rule, not a physical entity. The free parameters are the state quantization split and the inherited global scaling constant. The axioms are standard methods plus two domain assumptions (memristive programmability and the quantization-as-noise equivalence) that the central hardware claims partly depend on.

free parameters (2)
  • state quantization split factor = k/2
    Section 2.1 chooses to emulate state quantization at k levels by quantizing the input and convolutional kernel to k/2 levels each, based on summed-precision reasoning. This is a hand-set design choice, not validated against recurrent-mode quantization.
  • common constant maximum value for kernel parameters = not reported
    Section 3 uses a shared global scale from Siegel et al. (2025) to map all kernel parameters onto the memristive substrate, recovering accuracy from 83.7-86.4% to 95.3%. The constant is inherited from prior work and its value or tuning procedure is not given here.
assumptions (6)
  • standard math Zero-order-hold discretization of the continuous SSM (Equation 3) is a valid discrete approximation.
    Section 5.1; standard technique from Gu et al. (2021).
  • domain assumption Dropping the low-rank residual of A in S4D has only minor impact on task performance.
    Section 5.1; relies on Gu et al. (2022), and the paper's claims about the recurrent kernel quantizability inherit this approximation.
  • standard math Straight-through estimator with forward-only quantization is a valid training procedure for QAT.
    Section 5.2.3; standard practice as described in Ma et al. (2024).
  • domain assumption Emulated fixed-point quantization on GPU float32 arithmetic represents low-precision hardware behavior.
    Section 5.2.1; the authors apply this throughout, and Section 2.1 acknowledges the state quantization emulation is not numerically identical to recurrent computation.
  • ad hoc to paper Quantization itself is a form of noise, so QAT is equivalent to training with noise.
    Section 2.5: 'We suggest that this acquired noise robustness stems from the fact that quantization itself is a form of noise.' This postulate underpins the explanation of noise resilience but is not proven by an isolation ablation.
  • domain assumption Memristive devices can be programmed to 3 bits per cell with the stated tuning method.
    Section 3: 'we assume a device programming precision of 3 bits per cell', which determines the achievable weight precision in the hardware experiment.

how reviews work

0 comments
Cite this review

Pith. "Pith review of QS4D: Quantization-aware training for efficient hardware deployment of structured state-space sequential models." pith.science (2026). https://pith.science/paper/DPDKGA4U

@misc{pith2026250706079,
  author       = {Pith},
  title        = {Pith review of: QS4D: Quantization-aware training for efficient hardware deployment of structured state-space sequential models},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/DPDKGA4U}},
  note         = {Machine review of arXiv:2507.06079}
}
read the original abstract

Structured State Space models (SSM) have recently emerged as a new class of deep learning models, particularly well-suited for processing long sequences. Their constant memory footprint, in contrast to the linearly scaling memory demands of Transformers, makes them attractive candidates for deployment on resource-constrained edge-computing devices. While recent works have explored the effect of quantization-aware training (QAT) on SSMs, they typically do not address its implications for specialized edge hardware, for example, analog in-memory computing (AIMC) chips. In this work, we demonstrate that QAT can significantly reduce the complexity of SSMs by up to two orders of magnitude across various performance metrics. We analyze the relation between model size and numerical precision, and show that QAT enhances robustness to analog noise and enables structural pruning. Finally, we integrate these techniques to deploy SSMs on a memristive analog in-memory computing substrate and highlight the resulting benefits in terms of computational efficiency.

Figures

Figures reproduced from arXiv: 2507.06079 by the authors.

Figure 1
Figure 1. Hardware-software co-design for efficient deployment of state-space models [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Quantization-aware training of sequential CIFAR10 (grayscale). [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Quantization benefits in different hardware metrics [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: Relation of model size and quantization a) Below a state size of N = 256, an increase of the state dimension increases the model accuracy and can compensate the loss due to quantization. For higher state dimension the accuracy plateaus. b) A similar behavior can be obs…
Figure 5
Figure 5. Figure 5: In-Memory State-Space Model Accelerator (IMSSA) kernel implementation on an mCBA. [PITH_FULL_IMAGE:figures/full_fig_p007_5.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

34 extracted references · 23 canonical work pages

  1. [1]

    write newline

    " write newline "" before.all 'output.state := FUNCTION article output.bibitem format.authors "author" output.check author format.key output output.year.check new.block format.title "title" output.check new.block crossref missing format.jour.vol output format.article.crossref output.nonnull format.pages output if new.block note output fin.entry FUNCTION b...

    work page

  2. [2]

    Q-S5: Towards Quantized State Space Models

    Abreu, S., Pedersen, J. E., Heckel, K. M., & Pierro, A. (2024). Q-s5: Towards quantized state space models. arXiv preprint arXiv:2406.09477\/

    work page Pith review arXiv 2024

  3. [3]

    B., Aydin, G., Puthankattil, S

    Ay, B., Yildirim, O., Talo, M., Baloglu, U. B., Aydin, G., Puthankattil, S. D., & Acharya, U. R. (2019). Automated depression detection using deep representation and sequence learning with EEG signals. Journal of medical systems\/ 43\/ (7), 1--12

    work page 2019

  4. [4]

    H., Marcus, G

    Ballinger, B., Hsieh, J., Singh, A., Sohoni, N., Wang, J., Tison, G. H., Marcus, G. M., Sanchez, J. M., Maguire, C., Olgin, J. E., et al. (2018). Deepheart: semi-supervised sequence learning for cardiovascular risk prediction. In Thirty-Second AAAI Conference on Artificial Intelligence

    work page 2018

  5. [5]

    Hardware Aware Training for Efficient Keyword Spotting on General Purpose and Specialized Hardware

    Blouw, P., Malik, G., Morcos, B., Voelker, A. R., & Eliasmith, C. (2020). Hardware aware training for efficient keyword spotting on general purpose and specialized hardware. arXiv preprint arXiv:2009.04465\/

    work page Pith review arXiv 2020

  6. [6]

    M., Lee, S

    Cai, F., Correll, J. M., Lee, S. H., Lim, Y., Bothra, V., Zhang, Z., Flynn, M. P., & Lu, W. D. (2019). A fully integrated reprogrammable memristor--cmos system for efficient multiply--accumulate operations. Nature Electronics\/ 2\/ (7), 290--299

    work page 2019

  7. [7]

    Chiang, H.-Y., Chang, C.-C., Frumkin, N., Wu, K.-C., & Marculescu, D. (2024). Quamba: A post-training quantization recipe for selective state space models. arXiv preprint arXiv:2410.13229\/

    arXiv 2024

  8. [8]

    Cramer, B., Stradmann, Y., Schemmel, J., & Zenke, F. (2020). The heidelberg spiking data sets for the systematic evaluation of spiking neural networks. IEEE Transactions on Neural Networks and Learning Systems\/ 33\/ (7), 2744--2757

    work page 2020

Show all 34 references
  1. [9]

    Dao, T., & Gu, A. (2024). Transformers are ssms: Generalized models and efficient algorithms through structured state space duality. arXiv preprint arXiv:2405.21060\/

    2024 arXiv

  2. [10]

    H., Dimou, G., Joshi, P., Imam, N., Jain, S., et al

    Davies, M., Srinivasa, N., Lin, T.-H., Chinya, G., Cao, Y., Choday, S. H., Dimou, G., Joshi, P., Imam, N., Jain, S., et al. (2018). Loihi: A neuromorphic manycore processor with on-chip learning. Ieee Micro\/ 38\/ (1), 82--99

    2018

  3. [11]

    Esteva, A., Robicquet, A., Ramsundar, B., Kuleshov, V., DePristo, M., Chou, K., Cui, C., Corrado, G., Thrun, S., & Dean, J. (2019). A guide to deep learning in healthcare. Nature medicine\/ 25\/ (1), 24--29

    2019

  4. [12]

    Gu, A., & Dao, T. (2023). Mamba: Linear-time sequence modeling with selective state spaces. arXiv preprint arXiv:2312.00752\/

    2023 arXiv

  5. [13]

    Gu, A., Dao, T., Ermon, S., Rudra, A., & R \'e , C. (2020). Hippo: Recurrent memory with optimal polynomial projections. Advances in neural information processing systems\/ 33 , 1474--1487

    2020

  6. [14]

    Gu, A., Goel, K., Gupta, A., & R \'e , C. (2022). On the parameterization and initialization of diagonal state space models. Advances in Neural Information Processing Systems\/ 35 , 35971--35983

    2022

  7. [15]

    Gu, A., Goel, K., & R \'e , C. (2021). Efficiently modeling long sequences with structured state spaces. arXiv preprint arXiv:2111.00396\/

    2021 arXiv

  8. [16]

    F., Bordelon, B., Muennighoff, N., Paul, M., Pehlevan, C., R \'e , C., & Raghunathan, A

    Kumar, T., Ankner, Z., Spector, B. F., Bordelon, B., Muennighoff, N., Paul, M., Pehlevan, C., R \'e , C., & Raghunathan, A. (2024). Scaling laws for precision. arXiv preprint arXiv:2411.04330\/

    2024 arXiv

  9. [17]

    Li, C., Ignowski, J., Sheng, X., Wessel, R., Jaffe, B., Ingemi, J., Graves, C., & Strachan, J. P. (2020). CMOS -integrated nanoscale memristive crossbars for cnn and optimization acceleration. IEEE International Memory Workshop\/

    2020

  10. [18]

    Ma, S., Wang, H., Ma, L., Wang, L., Wang, W., Huang, S., Dong, L., Wang, R., Xue, J., & Wei, F. (2024). The era of 1-bit llms: All large language models are in 1.58 bits. arXiv preprint arXiv:2402.17764\/

    2024 arXiv

  11. [19]

    M., Weidel, P., Plank, P., Campos-Macias, L., Shrestha, S

    Meyer, S. M., Weidel, P., Plank, P., Campos-Macias, L., Shrestha, S. B., Stratmann, P., & Richter, M. (2024). A diagonal structured state space model on loihi 2 for efficient streaming sequence processing. arXiv preprint arXiv:2409.15022\/

    2024 arXiv

  12. [20]

    Ott, J., Lin, Z., Zhang, Y., Liu, S.-C., & Bengio, Y. (2016). Recurrent neural networks with limited numerical precision. arXiv preprint arXiv:1608.06902\/

    2016 arXiv

  13. [21]

    Z., Ibanez-Guzman, J., Li, G., Piazzoni, A., Wang, P., & Santra, A

    Pandharipande, A., Cheng, C.-H., Dauwels, J., Gurbuz, S. Z., Ibanez-Guzman, J., Li, G., Piazzoni, A., Wang, P., & Santra, A. (2023). Sensing and machine learning for automotive perception: A review. IEEE Sensors Journal\/ 23\/ (11), 11097--11115

    2023

  14. [22]

    Siegel, S., Yang, M.-J., & Strachan, J.-P. (2025). Imssa: Deploying modern state-space models on memristive in-memory compute hardware. In 2025 IEEE International Symposium on Circuits and Systems (ISCAS) , pp.\ 1--5

    2025

  15. [23]

    T., Warrington, A., & Linderman, S

    Smith, J. T., Warrington, A., & Linderman, S. W. (2022). Simplified state space layers for sequence modeling. arXiv preprint arXiv:2208.04933\/

    2022 arXiv

  16. [24]

    Tang, S., Ma, L., Li, H., Sun, M., & Shen, Z. (2024). Bi-mamba: Towards accurate 1-bit state space models. arXiv preprint arXiv:2411.11843\/

    2024

  17. [25]

    Tay, Y., Dehghani, M., Abnar, S., Shen, Y., Bahri, D., Pham, P., Rao, J., Yang, L., Ruder, S., & Metzler, D. (2020). Long range arena: A benchmark for efficient transformers. arXiv preprint arXiv:2011.04006\/

    2020 arXiv

  18. [26]

    Vaswani, A. (2017). Attention is all you need. Advances in Neural Information Processing Systems\/

    2017

  19. [27]

    Voelker, A., Kaji \'c , I., & Eliasmith, C. (2019). Legendre memory units: Continuous-time representation in recurrent neural networks. Advances in neural information processing systems\/ 32

    2019

  20. [28]

    Waser, R., & Aono, M. (2007). Nanoionics-based resistive switching memories. Nature materials\/ 6\/ (11), 833--840

    2007

  21. [29]

    Xia, Q., & Yang, J. J. (2019). Memristive crossbar arrays for brain-inspired computing. Nature materials\/ 18\/ (4), 309--323

    2019

  22. [30]

    Yang, M.-J., & Strachan, J. P. (2023). State-space modeling and tuning of memristors for neuromorphic computing applications. ICONS '23: Proceedings of the 2023 International Conference on Neuromorphic Systems\/

    2023

  23. [31]

    Yang, M.-J., Yu, Z., Pedretti, G., Neftci, E., & Strachan, J. P. (2025). Improved memristor control using device physics and deep reinforcement learning. In 2025 IEEE International Conference on Artificial Intelligence Circuits and Systems (AICAS) , pp.\ 1--5

    2025

  24. [32]

    P., & Neftci, E

    Yu, Z., Yang, M.-J., Finkbeiner, J., Siegel, S., Strachan, J. P., & Neftci, E. (2024). The ouroboros of memristors: Neural networks facilitating memristor programming. In 2024 IEEE International Conference on Artificial Intelligence Circuits and Systems (AICAS) , pp.\ 1--5

    2024

  25. [33]

    Zhang, Y., Zhang, Z., & Lew, L. (2022). Pokebnn: A binary pursuit of lightweight accuracy. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition , pp.\ 12475--12485

    2022

  26. [34]

    Zhao, L., Torchet, T., Payvand, M., Kriener, L., & Moro, F. (2025). Quantizing small-scale state-space models for edge ai. arXiv preprint arXiv:2506.12480\/

    2025 arXiv

Pith tools

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