RECAP: Local Hebbian Prototype Learning as a Self-Organizing Readout for Reservoir Dynamics
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.
Tom: We're looking at the paper: "RECAP: Local Hebbian Prototype Learning as a Self-Organizing Readout for Reservoir Dynamics".
Jane: Here's the gist of the paper. Robust perception in brains is often attributed to high-dimensional population activity together with local plasticity mechanisms that reinforce recurring structure <ref:2603.06639#pg2> RECAP (Reservoir Computing with HEbbian Co-Activation Proto-types), a bio-inspired learning strategy for robust image classification that couples untrained reservoir dynamics with a self-organizing Hebbian prototype readout <ref:2603.06639#pg2> This method avoids error backpropagation and is naturally compatible with online prototype updates <ref:2603.06639#pg2> Pruning redundant reasoning tokens The paper introduces RECAP, a bio-inspired learning strategy that combines untrained reservoir dynamics with a Hebbian co-activation prototype readout trained without error backpropagation or gradient descent <ref:2603.06639#pg2> The core idea involves discretizing time-averaged reservoir responses into activation levels to construct a co-activation mask over reservoir unit pairs <ref:2603.06639#pg2> For each class, RECAP learns a sparse binary prototype updated by a simple potentiation–decay rule inspired by Hebbian plasticity <ref:2603.06639#pg2> Inference is performed by overlap-based prototype matching <ref:2603.06639#pg2> How the training signal is built The reservoir feature generator adopts a standard leaky echo-state network, which evolves according to equation (1) <ref:2603.06639#pg2> A stable representation of a static image is obtained by computing the time-averaged state vector x¯(u) <ref:2603.06639#pg2> This average reduces sensitivity to transient dynamics and provides a single vector representation per image <ref:2603.06639#pg2> The reservoir response x¯(u) is then discretized into a code vector z(u) using a scalar quantizer Q <ref:2603.06639#pg2> This discretization yields a binary co-activation mask M(u) over unit pairs, where Mij (u) = 1
zi(u) = zj (u): · 1
i!= j: <ref:2603.06639#pg2> The class-wise prototype state S(c) is updated using a potentiation–decay rule inspired by local plasticity <ref:2603.06639#pg2> Specifically, equation (7) describes the update rule for S(c), combining positive updates on co-activated pairs and negative updates on non-co-activated pairs <ref:2603.06639#pg2> Where the gains come from The primary source of robustness is attributed to the readout representation and local prototype updates, rather than from training the recurrent dynamics <ref:2603.06639#pg2> Discretization provides perturbation-tolerant codes that reduce sensitivity by mapping reservoir states into discrete activation levels <ref:2603.06639#pg2> Relational masks emphasize structure over magnitude, remaining stable when corruptions distort intensities while preserving overall structure <ref:2603.06639#pg2> The Hebbian learning yields stable prototypes because the potentiation–decay update rule strengthens co-activation relations recurring across class examples while suppressing unstable relations <ref:2603.06639#pg2> Implications for online and continual adaptation The co-activation prototype update is incremental and does not require storing full training batches or backpropagating gradients through time <ref:2603.06639#pg2> This suggests that RECAP could be used in streaming settings where data arrive sequentially, with prototypes updated online <ref:2603.06639#pg2> The method provides an interpretable decomposition where inference is performed via overlap scoring (Eq.
Tom: (12)) <ref:2603.06639#pg2> This resembles a template-based decision process and connects naturally to classical ideas in associative memory and prototype recall <ref:2603.06639#pg2> The mechanism-focused study is restricted to MNIST-C as a controlled testbed, and robustness behavior may differ on complex natural images <ref:2603.06639#pg2> Despite these constraints, RECAP achieves zero-shot robustness without end-to-end optimization <ref:2603.06639#pg2> The paper demonstrates that a self-organizing readout rule can materially improve robustness under a clean-only training regime <ref:2603.06639#pg2> Limitations and Conclusion This mechanism-focused study is restricted to MNIST-C as a controlled testbed, and robustness behavior may differ on complex natural images <ref:2603.06639#pg2> The model is bio-inspired rather than neurobiologically faithful, and exhaustive ablations over hyperparameters such as discretization levels and sparsity thresholds remain unexplored <ref:2603.06639#pg2> Also, the N × N prototype matrices may require sparse implementations to scale to larger reservoirs and more complex datasets <ref:2603.06639#pg2> In addition, although the prototype update is online, we did not test sequential task learning or catastrophic forgetting protocols <ref:2603.06639#pg2> Despite these constraints, our results demonstrate that robustness under common corruptions can emerge from the choice of readout representation rather than corruption-specific training <ref:2603.06639#pg2> By learning stable relational prototypes through Hebbian coactivation, RECAP achieves zero-shot robustness without end-to-end optimization <ref:2603.06639#pg2> This offers a simple, interpretable alternative compatible with untrained dynamical systems <ref:2603.06639#pg2> The paper is 25 Feb 2026 [cs.
Paper summary: Tom: So we're looking at this paper, "RECAP: Local Hebbian Prototype Learning as a Self-Organizing Readout for Reservoir Dynamics." The main idea is that robust perception in brains comes from high-dimensional population activity plus local plasticity, which is different from how most modern systems are trained using error backpropagation and gradient descent.
Jane: That sounds like the setup. So what's RECAP actually proposing? What's the core claim here that makes it stand out?
Lu: They introduce RECAP, which is a bio-inspired learning strategy for image classification. It couples untrained reservoir dynamics with a self-organizing Hebbian prototype readout that they train without error backpropagation or gradient descent.
Meng: Without using those heavy optimization methods, you're saying the robustness comes from this readout structure instead of tuning the reservoir itself? That sounds like it could save a ton of training time, but what are we looking at in terms of accuracy gains?
Tom: Well, the paper shows that RECAP achieves thirty-four point one percent accuracy on MNIST-C compared to fifty-two point one percent for an MLP and fifty-five point zero percent for ESN Ridge, even though they never trained on corrupted images. That gain is attributed to this specific readout learning rule <ref:2603.06639#pg3>.
Jane: So it's not about beating optimized deep architectures on clean data accuracy, but showing that this self-organizing readout can give strong robustness under common corruptions when training is constrained <ref:2603.06639#pg2>. That shifts the focus from just raw performance to reliability in messy real-world data.
Lalam: I'm seeing that RECAP discretizes the time-averaged reservoir responses into activation levels, which then constructs a co-activation mask over reservoir unit pairs <ref:2603.06639#pg2>. This mask is what drives the prototype updates.
Tom: Exactly. They use this mask to incrementally update class-wise prototype matrices using a potentiation decay rule inspired by local plasticity <ref:2603.06639#pg2>. It’s not learning through backpropagation; it’s learning by strengthening connections that fire together and weakening those that don't.
Jane: That sounds really elegant—using Hebbian-like rules to build stable representations, which is what the authors say gives these prototypes stability because they strengthen co-activation relations across class examples <ref:2603.06639#pg2>. So, how does that actually translate into something useful for a system we’d deploy?
Meng: For deployment, I'm worried about the memory footprint of those prototype matrices. They mention that the N by N prototype matrices might require sparse implementations to scale up to larger reservoirs and bigger datasets <ref:2603.06639#pg1>. If we have a massive reservoir, storing those relations might become prohibitive unless it’s very sparse.
Lu: They are pointing out that the primary source of robustness isn't in training the recurrent dynamics themselves, but squarely in the readout representation and those local prototype updates <ref:2603.06639#pg2>. The discretization part is key because it provides perturbation-tolerant codes by mapping those continuous reservoir states into discrete activation levels <ref:2603.06639#pg2>.
Tom: So the discretization gives us something that’s less sensitive to noise, and the relational masks focus on structure instead of just magnitude when things get distorted <ref:2603.06639#pg2>. That structural emphasis seems like a smart way to handle common corruptions.
Jane: And it sounds like this approach is naturally compatible with online adaptation because the class-wise prototype update is incremental and doesn't require storing full training batches or backpropagating gradients through time <ref:2603.06639#pg1>. That opens up possibilities for streaming data where we update prototypes as things arrive sequentially <ref:2603.06639#pg1>.
Lalam: The inference part is also simple, it uses overlap-based prototype matching to determine the final classification <ref:2603.06639#pg1>. This whole system avoids error backpropagation and is compatible with online updates because of that mechanism <ref:2603.06639#pg1>.
Meng: That’s interesting for production, but what about continual learning? If we are constantly updating prototypes online, how does this handle catastrophic forgetting or sequential task learning? That’s a big gap for me right now at the engineering level <ref:2603.06639#pg1>.
Tom: The paper itself doesn't test those specific continual learning protocols; they only focus on MNIST-C as a controlled testbed <ref:2603.06639#pg1>. But the mechanism suggests that if you design the readout right, you can achieve zero shot robustness without needing end to end optimization <ref:2603.06639#pg3>.
Jane: So the main takeaway is that we don't need exhaustive training on corrupted data to get strong performance on common corruptions, provided we learn a stable relational prototype structure through Hebbian coactivation <ref:2603.06639#pg2>. It’s a simple, interpretable alternative compatible with untrained dynamics <ref:2603.06639#pg1>.
Lu: The limitation they flag is that this study is restricted to MNIST-C as a controlled testbed and the robustness behavior might differ when applied to more complex natural images <ref:2603.06639#pg1>. Plus, they haven't explored exhaustive ablations over things like discretization levels or sparsity thresholds <ref:2603.06639#pg1>.
Meng: I agree with Lu on the complexity issue. If we want to ship this for real use on complex data, those hyperparameter choices—how fine the discretization is—are going to be critical and hard to tune reliably <ref:2603.06639#pg1>.
Tom: It does feel like a mechanism-focused study, but the results show that robustness under common corruptions can emerge from the choice of readout representation rather than needing corruption-specific training <ref:2603.06639#pg1>. That's a strong point for how we think about building resilient models.
Jane: So, to wrap up, this paper on RECAP demonstrates that learning stable relational prototypes through Hebbian coactivation can provide zero shot robustness without needing end to end optimization <ref:2603.06639#pg1>. It offers a simple, interpretable alternative for systems that need to be resilient under common distortions <ref:2603.06639#pg1>.
Conclusion: Tom: So we're wrapping up RECAP, that paper about local Hebbian prototype learning as a readout for reservoir dynamics.
Jane: Right, so the core idea is this self-organizing readout structure helps make reservoir systems robust without needing to train the dynamics themselves using error backpropagation.
Lu: Essentially, they’re showing how you can build stable representations by having the prototypes learn through local plasticity rules instead of traditional gradient descent optimization.
Meng: It seems like a neat way to get robustness on MNIST-C, but what does this actually mean when we move these reservoir systems to something more complex?
Tom: The authors say the main gain isn't from training the reservoir dynamics themselves, but from this readout representation and those local prototype updates.
Jane: That discretization part is important because it gives us codes that tolerate noise by mapping continuous reservoir states into discrete activation levels.
Lu: The relational masks emphasize structure over magnitude when things get distorted, which seems like a solid way to preserve the overall pattern even when intensities are corrupted.
Meng: I’m still thinking about the scaling of those prototype matrices. They mention they need sparse implementations if we want to use this on really large reservoirs or bigger datasets.
Tom: The authors admit that this mechanism-focused study is mostly on MNIST-C, and their robustness behavior might be different when applied to complex natural images.
Jane: True, and they also didn't test sequential task learning or catastrophic forgetting protocols yet.
Lu: But the paper does show that you can achieve zero shot robustness without needing end to end optimization under a clean-only training regime.
Meng: So, it’s a simple, interpretable alternative that avoids heavy optimization but still gets good results when the data is mostly clean?
Tom: Yeah, it offers an interpretable path compatible with untrained dynamical systems. And we need to see how these prototype updates handle streaming data in the next study.
Heng Zhang
International Research Center for Neurointelligence, University of Tokyo
cs.NE, cs.AI, cs.CV, cs.LG, q-bio.NC
Submitted: 2026-02-25
Updated: 2026-11-10
Comments: Accepted at AICCC 2026. 14 pages, 6 figures
License: http://creativecommons.org/licenses/by/4.0/
Importance score: 91/100
The gist: Robust perception in brains is often attributed to high-dimensional population activity together with local plasticity mechanisms that reinforce recurring structure <ref:2603.06639#pg2> RECAP…
Key concepts
- Reservoir Computing
- This involves using a recurrent neural network structure (the reservoir) whose internal dynamics are left untrained. The network learns by observing input patterns and projecting them onto high-dimensional states. These states capture complex features of the data, acting as a rich, non-linear feature extractor without needing explicit training on labels.
- Hebbian Co-Activation
- This is a learning rule inspired by neuroscience where neurons that fire together become more connected or active. In RECAP, this is used to update class prototypes. If reservoir units consistently activate together during the processing of an image belonging to a specific class, their corresponding prototype state is strengthened, reinforcing the learned structure.
- Co-activation Mask
- This mask is a binary map calculated over pairs of reservoir units. It indicates whether two units are co-activated (i.e., both active) at a given time step. This mask captures the structural relationships within the reservoir's activity, allowing RECAP to focus on which unit pairs are working together to represent an input pattern.
- Prototype Matching
- This is the inference mechanism used for classification. Instead of traditional classification layers, RECAP matches a new input image against stored class prototypes using overlap scoring based on the co-activation masks. A high overlap score between the input and a prototype suggests a match to that class, enabling classification without an end-to-end training process.
Terminology
Summary
Robust perception in brains is often attributed to high-dimensional population activity together with local plasticity mechanisms that reinforce recurring structure <ref:2603. p. 0 RECAP: Local Hebbian Prototype Learning as a
Self-Organizing Readout for Reservoir Dynamics
Heng Zhang∗
International Research Center for Neurointelligence (IRCN), University of Tokyo, Japan
March 10, 2026
Abstract
Robust perception in brains is often attributed to high-dimensional population activity together with local plasticity mechanisms that reinforce recurring structure. In
contrast, most modern image recognition systems are trained by error backpropagation and end-to-end gradient optimization, which are not naturally aligned with local
computation and local plasticity. In
contrast, most modern image recognition systems are trained by error backpropagation and end-to-end gradient optimization, which are not naturally aligned with local
computation and local plasticity. We introduce RECAP (Reservoir Computing with
HEbbian Co-Activation Proto-types), a bio-inspired learning strategy for robust image
classification that couples untrained reservoir dynamics with a self-organizing Hebbian
prototype readout. Inference is performed by overlap-based prototype matching. The method avoids error
backpropagation and is naturally compatible with online prototype updates.Where the paper says it
Where the paper says it
Where the paper says it
Pruning redundant reasoning tokens
The paper introduces RECAP, a bio-inspired learning strategy that combines untrained reservoir dynamics with a Hebbian co-activation prototype readout trained without error backpropagation or gradient descent <ref:2603.06639#pg2> The core idea involves discretizing time-averaged reservoir responses into activation levels to construct a co-activation mask over reservoir unit pairs <ref:2603. p. 0 We introduce RECAP (Reservoir Computing with
HEbbian Co-Activation Proto-types), a bio-inspired learning strategy for robust image
classification that couples untrained reservoir dynamics with a self-organizing Hebbian
prototype readout. RECAP discretizes time-averaged reservoir responses into activation levels, constructs a co-activation mask over reservoir unit pairs, and incrementally
updates class-wise prototype matrices via a Hebbian-like potentiation–decay rule. This vector is discretized into a small
number of activation levels, yielding a co-activation mask encoding which reservoir units
share the same discrete state. For each class, RECAP learns a sparse binary prototype
updated by a simple potentiation-and-decay rule inspired by Hebbian plasticity [1], where
backpropagation and end-to-end gradient-based optimization are not required. RECAP discretizes time-averaged reservoir responses into activation levels, constructs a co-activation mask over reservoir unit pairs, and incrementally
updates class-wise prototype matrices via a Hebbian-like potentiation–decay rule. Inference is performed by overlap-based prototype matching.Where the paper says it
Where the paper says it
Where the paper says it
How the training signal is built
The reservoir feature generator adopts a standard leaky echo-state network, which evolves according to equation (1) <ref:2603.06639#pg2> A stable representation of a static image is obtained by computing the time-averaged state vector x¯(u) <ref:2603. p. 6 To obtain a stable representation of a static image, we
repeatedly inject the same u for T cycles and compute a time-averaged state:
x¯(u) = 1
T
X
T
t=1
xt ∈ R
Nr
. (2)
This average reduces sensitivity to transient dynamics and provides a single vector representation per image. To obtain a stable representation of a static image, we
repeatedly inject the same u for T cycles and compute a time-averaged state:
x¯(u) = 1
T
X
T
t=1
xt ∈ R
Nr
. (2)
This average reduces sensitivity to transient dynamics and provides a single vector representation per image. Define a scalar quantizer Q : R → {0, . , K − 1} using fixed bin edges
{bk}
K
k=0 with b0 = −1 and bK = 1. , K − 1}
Nr
. We then define a binary co-activation mask M(u) over unit pairs:
Mij (u) = 1[zi(u) = zj (u)] · 1[i ̸= j], 1 ≤ i, j ≤ Nr. Email: rogerzhangheng[at]gmail. com
1
arXiv:2603. This vector is discretized into a small
number of activation levels, yielding a co-activation mask encoding which reservoir units
share the same discrete state. For each class, RECAP learns a sparse binary prototype
updated by a simple potentiation-and-decay rule inspired by Hebbian plasticity [1], where
backpropagation and end-to-end gradient-based optimization are not required. For each pair (i, j):
S
(c)
ij ←
clip[0,1]
S
(c)
ij + η+
, if M
(n)
ij = 1,
η− S
(c)
ij , if M
(n)
ij = 0,
(7)
where η+ > 0 is the potentiation rate and η− ∈ (0, 1) is the decay rate. Equation (7) is a direct and unambiguous combination of the two intended operations:
(1) positive update (addition) on co-activated pairs, and (2) negative update (multiplicative
decay) on non-co-activated pairs.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the gains come from
The primary source of robustness is attributed to the readout representation and local prototype updates, rather than from training the recurrent dynamics <ref:2603.06639#pg2> Discretization provides perturbation-tolerant codes that reduce sensitivity by mapping reservoir states into discrete activation levels <ref:2603. p. 7 3 Discretization and Co-Activation Mask Construction
RECAP converts x¯(u) into a discrete code that is less sensitive to small amplitude perturbations. Let K be the number of discretization levels (we use a small fixed K, e. During training, each sample updates
its class prototype via Hebbian potentiation–decay; prototypes are then thresholded into
binary templates for inference. Interpretation As in Hebbian learning, pairs that repeatedly fall into the same discrete
activation level across many class-c examples are incrementally strengthened (potentiation)
and saturate due to clamping.Where the paper says it
Where the paper says it
Implications for online and continual adaptation
The co-activation prototype update is incremental and does not require storing full training batches or backpropagating gradients through time <ref:2603.06639#pg2> This suggests that RECAP could be used in streaming settings where data arrive sequentially, with prototypes updated online <ref:2603. p. 1 Because the prototype updates are incremental, the readout can in
principle be updated online as new data arrive, suggesting a potential bridge to adaptive
and continual learning settings. Figure 1 provides a graphical overview of RECAP, showing
how untrained reservoir dynamics are converted into co-activation masks and then matched
against class-wise prototypes for inference. Inference is performed by overlap-based prototype matching. The method avoids error
backpropagation and is naturally compatible with online prototype updates. Email: rogerzhangheng[at]gmail. com
1
arXiv:2603. For each class, RECAP learns a sparse binary prototype
updated by a simple potentiation-and-decay rule inspired by Hebbian plasticity [1], where
backpropagation and end-to-end gradient-based optimization are not required. At inference,
classification reduces to template matching: the predicted label corresponds to the prototype
with highest overlap. 1 Robustness Under Common Corruptions
Strong clean-data performance does not guarantee reliable behavior under realistic perturbations. Beyond adversarial examples crafted to induce errors [4, 12], vision systems must
handle natural corruptions. RECAP: Local Hebbian Prototype Learning as a
Self-Organizing Readout for Reservoir Dynamics
Heng Zhang∗
International Research Center for Neurointelligence (IRCN), University of Tokyo, Japan
March 10, 2026
Abstract
Robust perception in brains is often attributed to high-dimensional population activity together with local plasticity mechanisms that reinforce recurring structure. In
contrast, most modern image recognition systems are trained by error backpropagation and end-to-end gradient optimization, which are not naturally aligned with local
computation and local plasticity. 0% for ESN-Ridge (ablation), and near-baseline
performance for ResNet-18 and AlexNet—despite never observing corrupted images during
training. This gain involves a tradeoff in clean accuracy, which we discuss explicitly: our
goal is not to outperform optimized deep architectures on clean data, but to demonstrate
that a biologically inspired, self-organizing readout can provide strong corruption robustness
under constrained training.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Limitations and Conclusion
This mechanism-focused study is restricted to MNIST-C as a controlled testbed, and robustness behavior may differ on complex natural images <ref:2603.06639#pg2> The model is bio-inspired rather than neurobiologically faithful, and exhaustive ablations over hyperparameters such as discretization levels and sparsity thresholds remain unexplored <ref:2603.06639#pg2> Also, the N × N prototype matrices may require sparse implementations to scale to larger reservoirs and more complex datasets <ref:2603.06639#pg2> In addition, although the prototype update is online, we did not test sequential task learning or catastrophic forgetting protocols <ref:2603.06639#pg2> Despite these constraints, our results demonstrate that robustness under common corruptions can emerge from the choice of readout representation rather than corruption-specific training <ref:2603. p. 2 0% for ESN-Ridge (ablation), and near-baseline
performance for ResNet-18 and AlexNet—despite never observing corrupted images during
training. This gain involves a tradeoff in clean accuracy, which we discuss explicitly: our
goal is not to outperform optimized deep architectures on clean data, but to demonstrate
that a biologically inspired, self-organizing readout can provide strong corruption robustness
under constrained training. This simple dynamic promotes stable, class-specific relational templates without
gradient-based optimization. 5 Prototype Binarization
Because different classes can induce different overall scales in S
(c)
, RECAP normalizes prototypes by enforcing equal density across classes before comparison. Figures modified from [27, 28, 29]. 4 Self-Organization and Dynamical Inspirations
Self-organization in nonlinear dynamical systems offers a complementary perspective on
neuro-inspired learning, emphasizing how structured representations can emerge from simple
update rules and iterative dynamics [30, 31]. 06639v1 [cs. NE] 25 Feb 2026Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
Backpropagation-free readout learning allows for online prototype updates, suggesting a
potential bridge to adaptive and continual learning settings.
This enables systems to be updated incrementally as new data arrives without requiring full retraining. -
The method achieves robustness under common corruptions on MNIST-C
without training on corrupted samples,
highlighting the importance of the readout learning rule for generalization. This means the system can maintain resilience against real-world noise and blur simply by being trained only on clean data. -
Discretization provides
perturbation-tolerant codes
by mapping reservoir states into discrete activation levels, which reduces sensitivity to small amplitude changes that would otherwise shift activations across decision boundaries. This stabilizes representations against intensity distortions like those found in JPEG compression or noise. -
The Hebbian potentiation-decay rule
strengthen[s] co-activation relations recurring across class examples while suppressing unstable relations,
leading tostable, class-specific relational templates without gradient-based optimization.
This results in compact binary templates that can be used for robust matching under distortion. -
The inference mechanism uses
overlap (logical-AND followed by summation)
between the test mask and the class prototypes, providing an interpretable decision process that resembles atemplate based decision process and connects naturally to classical ideas in associative memory.
Abstract
Robust perception in brains is often attributed to high-dimensional population activity together with local plasticity mechanisms that reinforce recurring structure. In contrast, most modern image recognition systems are trained by error backpropagation and end-to-end gradient optimization, which are not naturally aligned with local computation and local plasticity. We introduce RECAP (Reservoir Computing with Hebbian Co-Activation Prototypes), a bio-inspired learning strategy for robust image classification that couples untrained reservoir dynamics with a self-organizing Hebbian prototype readout. RECAP discretizes time-averaged reservoir responses into activation levels, constructs a co-activation mask over reservoir unit pairs, and incrementally updates class-wise prototype matrices via a Hebbian-like potentiation-decay rule. Inference is performed by overlap-based prototype matching. The method avoids error backpropagation and is naturally compatible with online prototype updates. We illustrate the resulting robustness behavior on MNIST-C, where RECAP remains robust under diverse corruptions without exposure to corrupted training samples.
Sources
- Explaining and Harnessing Adversarial Examples
- Towards Biologically Plausible Deep Learning
- Towards Deep Learning Models Resistant to Adversarial Attacks
- Do CIFAR-10 Classifiers Generalize to CIFAR-10?
- Robustness May Be at Odds with Accuracy
- Bidirectional predictive coding
Related papers
- Evolutionary Ensemble of Agents
- EvoDR: Evolving Dispatching Rules via Large Language Model for Dynamic Flexible Assembly Flow Shop Scheduling
- Encoding and Decoding Temporal Signals with Spiking Bandpass Wavelets
- Design and Analysis of Temporal Representations in Neural Networks
- Evolutionary Computation: A Paradigm of Natural Generative AI and Creative Synthesis
- Large Language Models and Evolutionary Computation: A Critical Review of Bidirectional Interaction, Automated Algorithm Design, and Co-Adaptive Systems