acceptodds
Under review as a conference paper at ICLR 2027

Parallel Memristive-Friendly Reservoirs for Gradient-Free Long-Sequence Classification

Abstract

Can a highly efficient sequence model remain competitive when none of its feature-producing weights are optimized? We introduce memristive-friendly parallelized reservoirs (MARS), a deep reservoir architecture whose dynamics are derived from a potentiation–depression model of memristive devices. MARS removes the dense recurrent matrix, reformulates the resulting input-dependent recurrence as an associative parallel scan, and stacks fixed, randomly initialized blocks through subtractive skip connections. All reservoir and encoder weights are sampled once and remain frozen; only a linear readout is trained with ridge regression. Training therefore requires neither gradient descent nor backpropagation through the reservoir. Despite this restriction, MARS is competitive with fully trained sequence models, including Mamba and LinOSS, on six long-sequence time-series classification datasets. It attains the highest mean accuracy on two datasets and a higher mean accuracy than Mamba on five of six. For fixed hyperparameters, MARS trains in – seconds. Based on the reported times, this is approximately – faster than the fastest gradient-trained baseline with reported timing on each dataset and – faster than Mamba. MARS also provides an approximately forward-pass speedup over an already lightweight echo state network on long sequences. These results show that deep, partially random dynamical systems can achieve competitive accuracy with exceptionally fast model fitting. Because its local state update is derived from memristive potentiation and depression, MARS also offers a starting point for future implementations on memristive and in-memory hardware.

Primary area:
learning on time series and dynamical systems
Keywords:
reservoir computing, efficient sequence modeling, recurrent neural networks, parallel scan, neuromorphic computing

Reviews

Among:
Shape:
1234this paper, Top 32%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.50 over 2 reviews, above 68% of the others.
Reviewer_ELrXOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

This paper introduces MARS, a deep reservoir architecture combining memristive-inspired state dynamics with parallel scans and subtractive skip connections. All feature-producing weights remain fixed after random initialization, and only a linear readout is fitted using ridge regression. Experiments on seven short-sequence and six long-sequence classification benchmarks report competitive accuracy and substantial reductions in fitting time.

Critical strengths

The effort to connect device-inspired dynamics with efficient parallel computation is a critical strength

Critical weaknesses

I believe equation 13 is wrong. Let's do it for simplicity in 1D We have the recurrence: h(t) = a(t) h (t-1) + b(t) If we solve this we will find h(t) = product of (h(0) a(1) a(2)...a(t)) + sum from i=1 to t ( b(i) a(i+1) a(i+2) ..a(t)) So h(t) is a sum and there is no way that this sum gives rise to equation (13)

The authors should correct the derivation and demonstrate numerical agreement between sequential and parallel implementations across representative inputs and sequence lengths. This is essential to validating the central methodological contribution.

Questions for authors

The related-work discussion could consider ROCKET (Dempster, Petitjean, and Webb, 2020) and MiniRocket (Dempster, Schmidt, and Webb, 2021). These methods use fixed convolutional features and linear classifiers for efficient time-series classification, making them particularly relevant to MARS-TC and its claims about fast fitting with untrained features. Direct comparisons would help establish the method’s novelty and practical advantages. The authors should also clarify how their contribution differs from existing parallel recurrent scans and reservoir architectures.

Overall, MARS is a potentially interesting contribution, but the mathematical issue in the scan derivation is a fundamental concern. If you can fix this error and follow up with stronger ablations and more comparable computational evaluations, you may have a good paper.

2 comments

We thank the reviewer for recognizing the potential of MARS and highlighting the connection between device-inspired dynamics and efficient parallel computation as a critical strength. This connection is central to our study. We investigate whether fixed, memristive-inspired recurrent features can support competitive long-sequence classification with low training cost. The reviewer’s constructive feedback helped us make this contribution clearer and strengthen its validation. We have added an explicit scan derivation and numerical equivalence tests, expanded the related-work discussion, and strengthened the ablations and runtime analysis. We also revisited the manuscript throughout to sharpen the explanations, clarify the assumptions and experimental protocols, and make the presentation easier to follow. Below, we address each concern in detail.

Associative scan derivation

This is an important observation and we agree that the derivation of Eq. (13) should have been given explicitly. Equation (13) is the log-space form used to evaluate the affine recurrence by associative scan and it follows the Equation 1 in Heinsen (2023). The given unrolled scalar recurrence in the review is exactly the starting point of the derivation. We provide the full derivation in the Appendix E and pointed to the derivation from the main text. We believe this contribution further developed the robustness of our manuscript. With the included derivation, we hope to make it crystal clear that the Equation (13) is indeed correct.

As suggested by the reviewer, we also compared our parallel implementation with the sequential recurrence on synthetic inputs. The table below reports absolute errors across the full state trajectories for different sequence lengths up to 20,000t. We include a short Jupyter notebook file in the supplementary material which produced the following values:

Sequence lengthMax absolute errorMean absolute error
108.73e-112.22e-11
1005.24e-107.03e-11
1,0001.92e-092.37e-10
10,0002.50e-082.19e-09
20,0005.68e-084.47e-09

Relationship to ROCKET and MiniRocket

We thank the reviewer for suggesting new baselines. Our study focuses on whether fixed, memristive-inspired recurrent dynamics can be a viable option for sequential classification tasks in the realm of recurrent neural networks. The small convolutional filters in MARS-TC serve as an input encoder within this recurrent architecture, particularly developed for very long sequences (e.g., EigenWorms with ~18k steps). ROCKET and MiniRocket instead construct high-dimensional representations through fixed convolutional feature transforms (for instance ROCKET applies the linear mapping from a 20,000 dimensional space). The proposed convolutional architectures can access the full sequence at once, without stateful memories, which makes them --in our view-- an entirely different model family. Therefore, we have not added that comparison in this revision. We believe, even if convolutional feature methods achieved higher accuracy, this would not invalidate our finding that fixed, memristive-inspired recurrent dynamics can provide competitive classification with low fitting cost.

We agree that our naming was misleading. Our model is not a classical temporal convolution model. We use convolution as a tool to generate local temporal features. Hence, we decided to change our naming to MARS-LTF (local temporal features). Also, it can be seen from the results that the benefit of these local features varies across datasets. The encoder provides a way to extract high-frequency patterns with potentially low-frequency recurrent dynamics.

Following this suggestion, we realized that the manuscript did not sufficiently position MARS within the existing literature. Therefore, we have expanded Section 2, also discussing the fixed-kernel convolutional approaches.

We consequently retain the recurrent-model focus of our experimental evaluation and clarify this scope in the revised related-work discussion.

Relationship to parallel scans and reservoir architectures

We agree that these distinctions should be clarified. We have expanded Section 2 into “Background and related work” to position MARS more explicitly.

Associative parallel scans and the log-space construction are established methods; we do not claim these algorithms as new. Our contribution is to reformulate the memristive-inspired reservoir update into a compatible input-dependent affine recurrence and integrate it into a deep architecture with fixed feature-producing weights and readout-only training.

We now distinguish MARS from DeepESNs, which already establish stacked untrained reservoirs; MF-ESN, whose dense recurrent coupling makes its update sequential; and ParalESN, which uses a fixed complex-valued diagonal transition matrix. MARS instead uses real-valued transition coefficients determined by the input through the memristive potentiation–depression rates, while enabling parallel evaluation.

Additional ablations and computational evaluation

We also strengthened the experimental evaluation. Appendix A now compares subtractive, additive, and no-skip variants under fixed configurations. Section 4.1 additionally compares sequential and parallel implementations of the same memristive recurrence, isolating the contribution of parallel execution and measuring approximately 26–99× speedups across the tested sequence lengths. We also clarified the hardware and the exclusion of hyperparameter-search costs from the reported training times in Section 4.2.

Closing remarks

We would like to close by clarifying the motivation of this study. Walker et al. (2024) introduced Log-NCDEs to improve the efficiency of neural controlled differential equations, while Rusch and Rus (2025) demonstrated the effectiveness of oscillatory state-space models for long-sequence learning. All these models are gradient-based requiring many training iterations to converge. Building on this benchmark setting, we investigate whether competitive classification accuracy can also be achieved with fixed, device-inspired recurrent features and a linear readout.

Our results show that, on the evaluated tasks, competitive performance is possible without gradient-based training of the feature-producing layers. Our primary aim is to demonstrate this accuracy–cost trade-off and the potential of lightweight memristive-inspired reservoirs. The physical memristive-based reservoir demonstrated by Milano et al. (2022b) indicates a potential for future hardware implementations. Honestly, achieving such competitive results in the tested benchmarks was more of a byproduct of our aim, showcasing a stable (physical) model development. We have updated the conclusion section to state our aim more explicitly.

We hope that the additional experiments, analysis, presentation improvements, and the fact that the Equation (13) is correct address the reviewer’s concerns and we actually now "have a good paper". If so, we would be grateful if the reviewer would reconsider their assessment in light of these revisions. We would be happy to discuss further if needed.

Sincerely, The authors

Reviewer_Jph6OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes MARS, a memristive-inspired reservoir computing architecture for efficient long-sequence classification without gradient-based training of its feature-producing layers. The method removes the dense recurrent matrix from a memristive-friendly echo state network, reformulates the resulting input-dependent state update as an elementwise affine recurrence, and evaluates this recurrence using an associative parallel scan. To increase representational capacity, the authors stack multiple randomly initialized reservoir blocks through subtractive skip connections. All feature-producing weights remain fixed, while the final linear readout is trained using ridge regression. An additional variant, MARS-TC, incorporates a fixed random temporal convolutional encoder.

The paper evaluates MARS against conventional reservoir models on seven short-sequence classification datasets and against gradient-trained sequence models on six long-sequence datasets. MARS obtains the highest mean accuracy on six of the seven short-sequence benchmarks. On the long-sequence benchmarks, MARS or MARS-TC achieves the highest reported mean accuracy on two datasets and exceeds Mamba's mean accuracy on five of six datasets. The authors also report an approximately 21× forward-pass speedup over a classical ESN and model-fitting times of 0.2 to 1.6 seconds for selected configurations.

Overall, the paper presents an interesting combination of physics-inspired reservoir dynamics, parallel recurrent computation, and gradient-free representation extraction. However, the evidence currently provided is insufficient to isolate the contributions of the main architectural components or fully substantiate the claimed computational advantages over gradient-trained baselines under controlled conditions.

Critical strengths

Strength 1: A practically meaningful integration of parallel reservoir dynamics and gradient-free training. The paper develops a coherent architecture that combines input-dependent memristive-inspired state updates with parallel recurrent evaluation and readout-only learning. The resulting approach is particularly interesting for scenarios where rapid model fitting is important.

Strength 2: Encouraging empirical accuracy-efficiency trade-offs.The proposed model exhibits competitive classification accuracy against several modern sequence architectures. The results on the short-sequence benchmarks, together with the long-sequence comparisons and the reported forward-pass speedup over ESN, provide evidence that the general approach is worth investigating.

Critical weaknesses

Weakness 1: Insufficient ablation studies of key architectural components

The paper combines several established techniques, including affine recurrences, parallel scans, and subtractive skip connections, but lacks controlled ablations to isolate their individual contributions. In particular, comparisons between subtractive and additive skip connections, different reservoir depths, and sequential versus parallel implementations of the same recurrence are missing. Moreover, the runtime comparison with ESN changes both the recurrent structure and execution strategy, making it difficult to attribute the speedup specifically to parallelization. These limitations weaken the evidence supporting the proposed architectural design.

Weakness 2: Insufficiently controlled efficiency comparisons

The reported 0.2 to 1.6 second fitting times are impressive, but comparisons with gradient-trained models rely on timings from previous studies using different implementations and potentially different hardware. Furthermore, the reported times exclude the computational cost of 300 Optuna trials evaluated over five seeds per dataset. The paper also lacks separate training-time results for MARS-TC, despite its competitive accuracy. Consequently, the claimed computational advantages require more controlled comparisons and a clearer accounting of the overall computational cost.

Questions for authors

Q1. Contribution of architectural components : Could the authors provide ablations examining subtractive versus additive skip connections, different reservoir depths, and memristive-specific dynamics? Such comparisons would help establish which components are essential to the reported performance improvements.

Q2. Fairness and scope of the efficiency comparison : Could the authors clarify the hardware and measurement protocol used for the training times in Table 4 and provide a limited same-hardware comparison against representative gradient-trained baselines? It would also be useful to report the separate fitting and inference costs of MARS-TC, as well as the approximate total computational cost of hyperparameter search for MARS and MARS-TC.

Q3. Validity of the positivity assumption in the log-space scan : The log-space scan in Equations (11)–(14) requires positive affine recurrence coefficients. However, according to Equation (16), positivity of K_p and K_d alone does not guarantee positivity of a_t. For example, Appendix B reports Δ = 0.5 and γ = 1 for JapaneseVowels, for which negative coefficients are mathematically possible within the stated RESCALE output range.

Could the authors explain how positivity is guaranteed or handled in the actual implementation? Does the implementation use clipping, a sign-aware scan, or an alternative numerical treatment? A direct numerical equivalence test against the sequential recurrence would resolve this concern.

Q4. Statistical significance and parameter-count consistency : On SCP1, MARS-TC achieves 90.1% accuracy versus 89.9% for S5, with standard deviations exceeding this difference. Is the improvement statistically significant?

9 comments

We thank the reviewer for recognizing the integration of physics-inspired reservoir dynamics, parallel computation, and readout-only learning, as well as the encouraging accuracy–efficiency trade-offs. We are grateful for the constructive feedback. Addressing these comments led to additional experiments, a more careful analysis of the scan coefficients and skip connections, and clearer reporting of the computational comparisons. These investigations helped us make the manuscript more rigorous. We also revisited the manuscript throughout to sharpen the explanations, clarify the assumptions and experimental protocols, and make the presentation easier to follow. We begin with the runtime analysis to distinguish the MARS–ESN comparison from the contribution of parallelization. We then address Q3 on the scan coefficients, Q1 on the architectural components, Q2 on the efficiency comparison, and Q4 on statistical significance.

Runtime comparison and the contribution of parallelization

This was clearly an ambiguity in the paper. We agree that the approximately 21x runtime difference in Figure 2 and Table 1 compares two different models (MARS vs. ESN) and combines changes to the recurrent structure and execution strategy. It demonstrates the efficiency of the complete MARS architecture relative to ESN but the contribution of parallelization requires a strict comparison between two implementations of the same recurrence.

We therefore timed the equivalent memristive computation using a sequential loop and the parallel log-space formulation. This experiment uses a single recurrence, with no encoder, input projection, rescaling, or stacked layers. Inputs are sampled from a normal distribution and enter the recurrence directly. Both implementations return the state at every time step. The sequential implementation loops over time, while the parallel implementation uses a cumulative sum and a cumulative log-sum-exp to evaluate the closed form.

The table reports total wall-clock time in seconds for 100 forward passes on the same input. The largest absolute difference between the state trajectories was 1.1e-5, observed at 500k time steps.

Implementation501001k10k100k500k
Sequential0.19240.38713.865638.9893396.82772,005.5794
Parallel0.00730.00730.03920.59357.393336.9862
Speedup26.4×53.0×98.6×65.7×53.7×54.2×

Evaluating the same recurrence in parallel gives a speedup of approximately 26–99× across the tested lengths, including 54.2x at 500k steps. This comparison isolates the change in execution strategy while preserving the recurrence. In the paper, we distinguish these results from the MARS–ESN comparison and correct the attribution of the 21x speedup.

Moreover, we provide the code used in this experiment as a supplementary material. It only includes the equivalence check and not the runtime analysis.

Q3. Positivity of the log-space scan coefficients

Positivity of the scan coefficient and Δ = 0.5 for JapaneseVowels

This is a very careful observation. It concerns an important aspect of the log-space parallel scan that we addressed only briefly. In the original submission, our statement in Section 2 was inaccurate: there we argue that the inputs of the logarithm are positive "as KpK_p and KdK_d are always positive due to the exponentiation". While bt=ΔKp(zt)>0b_t = \Delta K_p(z_t) > 0 holds by construction, the coefficient

at=γ−Δ (Kp(zt)+Kd(zt))a_t = \gamma - \Delta\ \big(K_p(z_t) + K_d(z_t)\big)

can in principle become negative and it would produce NaN's in the computation. Although this is technically possible, it depends on several factors and our code handles the configurations that produce negative coefficients. In the following we try to explain as clearly as possible why it is hard to get negative ata_t and how we deal with negative inputs in case they occur. Our analysis regarding this positivity issue resulted in very interesting additions, that --we believe-- increased the soundness of the work substantially.

The positivity of the input depends on several factors. However, it is practically satisfied because Δ\Delta is mostly small, but how is it still possible to set large values such as Δ=0.5\Delta=0.5? We take JapaneseVowels as example.

Why at>0a_t > 0 for JapaneseVowels even though Δ=0.5\Delta = 0.5: The positivity does not depend solely on Δ\Delta. It actually depends on Δ(Kp(zt)+Kd(zt))\Delta (K_p(z_t) + K_d(z_t)) evaluated at the rescaled range. Rescale is basically the sigmoid function with re-defined boundaries [a,b]=[0.35,1.15][a, b] = [0.35, 1.15]. The function effectively computes zt=0.35+0.8σ(s⋅ut)z_t = 0.35 + 0.8 \sigma(s \cdot u_t), where utu_t is the pre-activation.

  • For Δ=0.5\Delta = 0.5, at≤0a_t \le 0 requires Kp+Kd≥2K_p + K_d \ge 2, i.e. zt≥0.980z_t \ge 0.980.
  • When we analyze the data in JapaneseVowels, the slope s=1s = 1 and the scalings ω=β=0.1\omega = \beta = 0.1 keep the pre-activations small, i.e. ∣ut∣≤0.73|u_t| \le 0.73 over all units, time steps, layers and train/test sequences.
  • Hence zt∈[0.61,0.89]z_t \in [0.61, 0.89] is close to the centre of the possible range [0.35,1.15][0.35, 1.15].

Even the largest observed value zt=0.889z_t = 0.889 does not reach remotely to the critical threshold 0.9800.980. Consequently, the large Δ\Delta value does not harm in this particular dataset and model setting.

Global Δ\Delta threshold: Our investigation regarding the positivity of coefficients took us deep into the matter and we realized that it is possible to set a worst-case threshold for Δ\Delta, which can be given as an optional constraint. Note that Kp+KdK_p + K_d is convex in zz because the second derivatives of both functions are positive everywhere (with given constants in the paper) and the rescaling is bounded (zt∈[0.35,1.15]z_t \in [0.35, 1.15]). Hence, the maximum of Kp+KdK_p + K_d (the sum of convex functions is also convex) is at the upper end, i.e. Kmax⁡=Kp(1.15)+Kd(1.15)=9.872+0.158=10.03K_{\max} = K_p(1.15) + K_d(1.15) = 9.872 + 0.158 = 10.03. This gives us a clear threshold for Δ\Delta, where γ=1\gamma = 1:

Δ<γ/Kmax⁡≈0.0997\Delta < \gamma / K_{\max} \approx 0.0997

This expression guarantees that at>0a_t > 0 for any input, slope and weights. The threshold is sufficient but conservative because it assumes a fully saturated rescaling. Also, whether that regime is approached does not depend solely on Δ\Delta, it is also jointly effected by the slope ss, the input and bias scalings (ω\omega and β\beta), and the range of the data. In the case of JapaneseVowels dataset, a small ss keeps the coefficients far from zero even for Δ\Delta well above the bound.

Overall, the reported results remain unchanged. In our experiments, replacing NaN features with zeros degraded validation accuracy, so these configurations were not selected by Optuna. In fact, all Optuna optimized Δi\Delta_i satisfy the worst-case bound (see Tables 13 and 15 in Appendix D). However, the raised point by the reviewer led to a much sharper analysis of MARS. We include the global Δ\Delta threshold in the manuscript, added a small explanation about how negative coefficients are dealt with, and why JapaneseVowels dataset was still be able to processed by our model. We are grateful for this contribution.

Numerical agreement between sequential and parallel computation

As suggested by the reviewer, we compared our parallel implementation with the direct sequential recurrence. The table below reports absolute errors across the full state trajectories. We provide a small Jupyter notebook in the supplementary material to reproduce these results.

We use random inputs to keep the notebook self-contained and make both implementations as intuitive as possible. The two computations agree within floating-point precision across the tested sequence lengths. Running one cell in jupyter notebook produces the following table:

Sequence lengthMax absolute errorMean absolute error
108.73e-112.22e-11
1005.24e-107.03e-11
1,0001.92e-092.37e-10
10,0002.50e-082.19e-09
20,0005.68e-084.47e-09

For JapaneseVowels, our separate investigation verifies that the scan coefficients remain positive across all reported seeds, as detailed above. We hope these checks resolve the concern, and we would be happy to provide a dataset-specific sequential-versus-parallel comparison if further verification is needed.

Q1. Contribution of architectural components

effectiveness of the subtractive skip connection

This is yet another constructive and to-the-point question. Indeed, the motivation behind the subtractive skip connection is only supported with a toy example in a non-realistically clean setting. Addressing this comment led us to a more careful analysis, and the revised manuscript is now more evidence-based and free of overstatements regarding the skip connection.

Ablation. We took the trained MARS models of Table 4 and changed only the skip connection between layers. The encoder and reservoir weights were kept fixed, and the ridge readout was refit for each variant. The resulting table show test accuracy in percentage over the same 5 seeds used throughout this study:

DatasetSubtractive z−hz - h (ours)Additive z+hz + hNo skip(hh only)
EigenWorms78.33 ± 6.3376.11 ± 6.3965.56 ± 5.05
SelfRegulationSCP189.18 ± 3.2688.94 ± 2.7176.24 ± 4.27
SelfRegulationSCP250.69 ± 6.6352.07 ± 2.8349.31 ± 5.67
EthanolConcentration36.71 ± 4.0033.16 ± 2.2632.15 ± 2.77
Heartbeat67.42 ± 8.0267.74 ± 7.9872.58 ± 7.90
MotorImagery52.63 ± 7.1353.68 ± 4.9053.33 ± 9.42
  • Skip vs. no skip. Removing the skip clearly reduces accuracy on EigenWorms and SCP1, and slightly on EthanolConcentration. It does not on Heartbeat, where no skip is even better, nor on SCP2 or MotorImagery.

  • Subtractive vs. additive. The two variants perform similarly on all six datasets.

Why the sign does not matter on these datasets. The high-pass interpretation of z−hz - h (Fig. 3) requires hh to follow zz with a comparable magnitude. In our trained long-sequence models this is not the case. In order to investigate this, we computed the standard deviation of hh and of zz over the time steps of each sequence, averaged over samples and units, and took their ratio std(h)/std(z)\mathrm{std}(h)/\mathrm{std}(z) (mean over 5 seeds). This operation was done for each layer separately. Here is our results:

Datasetstd(h)/std(z)\mathrm{std}(h)/\mathrm{std}(z) per layer
EigenWorms0.43, 0.025
SelfRegulationSCP10.017, 0.14, 0.084, 0.14, 0.13
SelfRegulationSCP20.020, 0.001, 0.014, 0.020, 0.016, 0.016
EthanolConcentration0.0007, 0.0009, 0.000005, 0.001
Heartbeat0.00007, 0.00003
MotorImagery0.002, 0.034

For instance, EigenWorms layer 1 gives std(h)=0.1875\mathrm{std}(h) = 0.1875 and std(z)=0.4347\mathrm{std}(z) = 0.4347, so the ratio is 0.430.43. That means the temporal standard deviation of hh is 43% of that of zz. However, we can call this particular results as an outlier. Apart from the first layer in Eigenworms, three layers in SCP1 show ratio around 13-14 percent. All the other 4 datasets show ratio below 4%. These ratios show that hh has smaller temporal fluctuations than zz in most layers. This observation offers a possible explanation for the similar classification accuracies obtained with either sign. In other words, hh is relatively small with respect to zz such that adding or subtracting does not make much of a difference.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary of the rebuttal and invitation for further discussion

We thank the reviewers for their constructive feedback and appreciate the updated assessment by the reviewer ELrX. With limited time remaining, we would like to summarize how the manuscript has developed through this process:

  • Mathematical clarification: We added an explicit derivation of Eq. (13), numerical sequential–parallel equivalence tests, and a detailed analysis of the scan’s positivity conditions, including the JapaneseVowels configuration.
  • Architectural evaluation: We added subtractive, additive, and no-skip ablation studies and revised the interpretation of the skip connections to reflect these findings.
  • Computational evaluation: We added a controlled sequential–parallel runtime comparison of the same recurrence, supplied the missing variant timings and parameter counts, and clarified the hardware and hyperparameter-search scope.
  • Positioning and presentation: We expanded the related-work discussion, sharpened the explanations, and clarified that our central aim is to investigate the accuracy–cost trade-off of fixed, memristive-inspired recurrent computation.
  • Supplementary material: We also provided two self-contained supplementary Jupyter notebooks to reproduce the sequential–parallel numerical equivalence check and the illustrative additive–subtractive skip-connection comparison.

The feedback has strengthened both the evidence and the presentation of the manuscript. We remain available and would welcome further discussion before the period closes. Are there any remaining concerns, questions, or requests that we could address to help the reviewers and Area Chairs reach their assessment?

Thank you again for your time and consideration.

Sincerely, The authors

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.