Modeling Retinal Ganglion Cells with Neural Differential Equations

AI summary

Overview

• Research area: Machine learning / computational neuroscience — specifically Neural Ordinary Differential Equations (NODEs) applied to predicting the neural activity of retinal ganglion cells (RGCs). The paper is categorized under Computer Vision (arXiv:2511.18014v1 [cs.CV], 22 Nov 2025) and is accepted to the AAAI-26 Student Abstract and Poster Program, with supplementary material.
• Technical level: Advanced. It assumes familiarity with convolutional networks, recurrent networks (LSTM), Neural ODEs, and specifically Liquid Time-Constant Networks (LTCs) and Closed-form Continuous-time Networks (CfCs).
• One-sentence scope: The authors build LTC- and CfC-based models of tiger salamander retinal ganglion cell activity across three datasets of 9, 14, and 27 recorded cells, and compare them against a ConvNet baseline and an LSTM on accuracy, correlation, model size, training time, convergence speed, query time, and noise robustness.

What This Paper Is About

Predicting exactly when and how strongly a retinal neuron will fire in response to what the eye sees is a hard time-series problem, and the recorded signals are irregular and bursty. The authors ask whether modern continuous-time neural network architectures — Liquid Time-Constant Networks and Closed-form Continuous-time Networks, both built on the Neural ODE idea — can model retinal ganglion cell responses better than the standard convolutional baseline (a ConvNet) and an LSTM. Their goal is not only raw accuracy, but also efficiency, since retinal prosthetics and edge hardware settings require models that are small and can be retrained frequently with limited data.

Key Contributions

1. First application of LTCs and CfCs to retinal ganglion cell modeling. The authors design NODE-based architectures for the RGC task and evaluate them against a replicated ConvNet baseline from Maheswaranathan et al. (2023) and against an LSTM.
2. A controlled architectural comparison. All four architectures share the same convolutional encoder stack, processing 40 consecutive frames concatenated into a single 40-channel image, with hidden state sizes of 16, 24, and 32 chosen to match the 9, 14, and 27 output channels of the three datasets. This isolates the effect of the temporal component.
3. A comprehensive multi-metric evaluation. Results are reported over 5 train-test runs per configuration, with Pearson correlation (with 95% confidence intervals), MAE, parameter counts, training time, and ANOVA p-values — plus supplementary studies on convergence speed, query time, noise robustness, a multi-scale temporal variant, and hyperparameter optimization.
4. A hypothesis about why continuous-time models do not win everywhere. The paper argues that the near-binary, highly irregular nature of the firing series and the apparent absence of complex long-term temporal dependencies (other than a roughly constant lag) explain why a simpler ConvNet retains the highest correlation.

Main Findings

• NODEs win on MAE across all three datasets. LTC achieved the lowest MAE on every dataset: 2.73 ± 12 (rgc9), 2.19 ± 4 (rgc14), and 2.94 ± 6 (rgc27). CfC was second-best on each: 2.86 ± 7, 2.35 ± 6, and 3.03 ± 13.
• The ConvNet retains the highest correlation. ConvNet correlation was 0.569 ± 5 (rgc9), 0.586 ± 03 (rgc14), and 0.586 ± 15 (rgc27), ahead of LTC (0.480 ± 12, 0.569 ± 02, 0.529 ± 1), CfC (0.474 ± 06, 0.555 ± 09, 0.517 ± 07), and LSTM (0.421 ± 38, 0.484 ± 34, 0.399 ± 17). ANOVA p-values were 5.187 × 10⁻⁸ (rgc9), 6.522 × 10⁻⁷ (rgc14), and 1.633 × 10⁻¹² (rgc27).
• The discrepancy is about values versus timing. The authors report that NODEs predict the values of dependent variables better, while the ConvNet better captures the timing of peaks; the ConvNet often overestimates ground-truth firing values.
• Much smaller models. NODEs achieve their performance with 5x-8x fewer parameters (for example, 49,442 for LTC on rgc9 versus 227,251 for the ConvNet; 59,830 versus 421,993 on rgc27).
• Training time is comparable to the ConvNet, and the LSTM is worse. LTC training time on rgc9 was 1,823 ± 360 s versus 2,416 ± 196 s for the ConvNet and 4,759 ± 414 s for the LSTM.
• NODEs converge very quickly. The paper reports in the supplementary material that most learning in the NODEs occurs in the first training epoch, and a dedicated experiment in which the LTC learning rate was reduced from 2 × 10⁻³ to 1 × 10⁻⁶ showed the model learned most of its dynamics in the first 20 epochs, corresponding to about 7% of the entire training set — but reached a worse Pearson correlation of 0.41.
• Favorable query times are reported in the supplementary material (Sec. K), though the specific query-time figures are not shown in the main text. The paper also reports noise robustness: ConvNet and LSTM were more robust when tested on time series perturbed with noise.
• MAE as a loss function fails. Detailed results show that training with MAE loss instead of MSE produced very poor correlation (for example, ConvNet MAE-40 on rgc9 reached 0.05 ± 4).
• Fewer input frames hurt. Reducing the number of historical frames from 40 to 20 worsened performance across models.
• More temporal scales hurt too. A multi-scale variant of the CfC model was tested with configurations 1x40, 2x20, 4x10, and 8x5; performance dropped as the sequence count grew (for rgc9, CfC 1x40 reached ρ = 0.47(1), while 8x5 fell to ρ = 0.18 ± 10).
• Hyperparameter optimization did not beat the hand-set defaults. A 24-hour Bayesian search over 197 runs on rgc9 found a best validation ρ = 0.33; five models retrained with those optimal parameters reached ρ = 0.41 (± 0.06) on the test set, with a top score of 0.49.

Methodology in Plain English

The researchers took a publicly available dataset of tiger salamander (Ambystoma tigrinum) retinal recordings in which a 60-electrode array and sharp microelectrodes captured the firing of 9, 14, or 27 ganglion cells while the animal viewed natural grayscale video at 30 Hz. Stimuli and responses were binned into 10 ms windows, and roughly 80% of response values are zero, with brief high-frequency bursts typically occurring about 8-12 frames after a change in the visual scene.

They built four models that all share the same convolutional encoder, which takes 40 consecutive frames stacked into one 40-channel 50×50 image and compresses it into a 32-dimensional vector. For the ConvNet, that vector goes into a single dense layer producing the n output series. For the LSTM, it feeds an LSTM cell and two dense layers. For LTC and CfC, it feeds the NODE module directly, wired according to the biologically inspired NCP framework from Lechner et al. (2020) via the ncps Python package. The ConvNet baseline had to be adjusted: the original Poisson log-likelihood loss was replaced with MSE to reproduce the reported behavior.

Training used the Adam optimizer, MSE loss, batch size 4,096, early stopping after 7 epochs without validation-correlation improvement, up to 50 epochs, separate learning rates for encoder (0.001) and predictor (0.002), and Min-Max normalization per target channel. Each configuration was trained from scratch 5 times and averaged. All code was written in PyTorch with CUDA, with logging in Weights & Biases and configuration management via Hydra.

Why This Matters

Impact on research. This is a rigorous negative/partial result for NODE architectures on neural data: continuous-time models can be smaller, faster to train, and more accurate on absolute firing values, yet they can lose on correlation and on robustness to noise. It suggests that the temporal dependencies in this RGC dataset may be shallow or dominated by a fixed response lag, which has implications for how the neuroscience community should choose and interpret sequence models for neural prediction.

Real-world applications:

• Vision prosthetics — the paper explicitly motivates its efficiency results by the need for models that can be retrained quickly on specialized edge hardware for retinal implants.
• Edge deployment on specialized hardware — where model size, training time, and query latency are primary constraints rather than marginal accuracy gains.
• Neural interfaces and brain-computer interfaces — where decoding models may need frequent recalibration as electrode recordings drift over time.
• Closed-loop neuroscience experiments — where fast convergence on small data is more valuable than squeezing out the highest correlation.

Industry relevance. The finding that well-tuned continuous-time models converge on a small fraction of the data (about 7% of the training set in one experiment) is relevant to any deployment where labeled data are scarce or expensive, and where retraining must happen on-device or on a budget. The paper sits in the intersection of computer vision and time-series ML, making its architectural lessons relevant beyond neuroscience.

Future Directions

1. Synthetic data with controlled noise and confounders. The authors explicitly state that a more in-depth investigation, possibly using synthetic data with a controlled amount of noise and confounders, is necessary to verify their explanation for why the ConvNet wins on correlation.
2. Exploiting irregular sampling. Because the firing rates are available only in binned form, the NODE architectures cannot take advantage of their natural ability to sample data at irregular time points; obtaining or simulating irregularly sampled recordings could change the comparison.
3. Extending beyond natural images. The dataset also contains responses to white-noise stimuli, which the authors deliberately excluded; testing on those six possible datasets could test whether the conclusions are stimulus-specific.
4. Improving timing precision rather than value accuracy. Since NODEs predict values well but peaks poorly, closing that timing gap — through architecture or loss design — is the most direct route to a model that dominates on every metric.

Target Audience

This paper is best suited to machine learning researchers working on Neural ODEs and continuous-time models, computational neuroscientists modeling sensory systems, and engineers building low-power or edge-deployed models for neural decoding. It is also useful for practitioners who need evidence about when a simple convolutional baseline beats a more sophisticated recurrent or ODE-based architecture on real, noisy biological time series. Beginners will find the comparison framework intuitive, but the architectural details (LTC, CfC, NCP wiring) require intermediate-to-advanced background.

Authors’ abstract

This work explores Liquid Time-Constant Networks (LTCs) and Closed-form Continuous-time Networks (CfCs) for modeling retinal ganglion cell activity in tiger salamanders across three datasets. Compared to a convolutional baseline and an LSTM, both architectures achieved lower MAE, faster convergence, smaller model sizes, and favorable query times, though with slightly lower Pearson correlation. Their efficiency and adaptability make them well suited for scenarios with limited data and frequent retraining, such as edge deployments in vision prosthetics.