The dynaxx phase space: emergent learning paradigms beyond backpropagation

Backpropagation has been the workhorse of deep learning for over three decades, but its dominance is showing cracks. The credit assignment problem deep in recurrent or stacked architectures, the requirement for differentiable everywhere, and the energy cost of storing activations for backward passes are pushing researchers and engineers to explore alternatives. The dynaxx phase space is a conceptual framework for understanding these emergent learning paradigms—approaches that learn without full backward propagation, often inspired by biological or physical principles. This guide maps that space, compares the leading contenders, and helps you decide which one fits your problem, hardware, and appetite for approximation.

Why the search beyond backprop? The real problems practitioners face

Backpropagation works brilliantly on GPU clusters with clean gradients and ample memory, but real-world constraints expose its weaknesses. The first is credit assignment: in a deep network, the gradient for early layers must be computed through a chain of multiplications, which can vanish or explode. Even with modern normalisation techniques, training very deep models remains fragile. Second, backprop requires storing all intermediate activations for the backward pass, which imposes a memory footprint that scales linearly with depth—problematic for on-device or embedded training. Third, the assumption of differentiability excludes many useful models: spiking neural networks, discrete decision layers, or hybrid symbolic-neural systems. Finally, the biological implausibility of backprop (the brain does not seem to propagate error signals backwards through symmetric weights) has motivated a search for more local learning rules.

Teams working on edge AI, neuromorphic hardware, or continual learning often find that backprop simply does not fit their constraints. For example, a robotics team trying to train a controller on a low-power MCU cannot afford the memory for full activation storage. A researcher studying brain-inspired learning needs a rule that operates on local information only. These pain points are not niche; they represent a growing fraction of the deep learning landscape.

What goes wrong without alternatives? Many projects either force backprop into unsuitable settings—resulting in high latency, memory overflow, or training failure—or abandon learning altogether, falling back to hand-crafted features. The cost is not just performance; it is the inability to adapt post-deployment. The dynaxx phase space offers a structured way to evaluate non-backprop paradigms before committing to one.

The core tension: global vs. local learning

Backprop is a global learning rule: a single scalar loss drives updates across all layers. Emergent paradigms often rely on local rules, where each layer or neuron updates based on locally available signals. The trade-off is between optimality and flexibility. Global rules can find better minima for a fixed architecture, but local rules enable parallel, asynchronous updates and better match distributed hardware.

When backprop still wins

For problems with abundant compute, large datasets, and stable training environments (e.g., cloud-based image classification), backprop remains the gold standard. The alternatives discussed here are not meant to replace it universally, but to expand the toolkit for scenarios where backprop is impractical or biologically implausible.

Prerequisites: what you need to understand before diving into emergent paradigms

Before exploring specific algorithms, readers should settle a few foundational concepts. First, credit assignment—how does a learning rule determine which parameters contributed to an error? Backprop uses the chain rule; local rules use approximations like eligibility traces or feedback alignment. Understanding the difference is crucial for diagnosing training failures.

Second, differentiability and its absence. Many emergent paradigms work with non-differentiable components, such as binary spikes or discrete decisions. If you come from a background where everything is smooth, wrapping your head around surrogate gradients or stochastic estimators is necessary.

Third, hardware constraints. The choice of paradigm is often dictated by the target platform: analog compute, digital ASICs, or general-purpose GPUs. For instance, equilibrium propagation requires solving a fixed-point iteration, which is expensive on von Neumann architectures but natural on analog crossbar arrays.

Key mathematical background

A solid grasp of gradient descent, backpropagation, and the chain rule is assumed. Familiarity with energy-based models (Hopfield networks, Boltzmann machines) is helpful for equilibrium propagation. For forward-forward algorithms, understanding local loss functions and contrastive learning (e.g., SimCLR) provides context.

Software and tools landscape

Most emergent paradigms have at least one reference implementation in PyTorch or JAX. The forward-forward algorithm, for example, can be implemented by splitting the network into blocks and computing local losses. Libraries like snnTorch (for spiking networks) or ngclearn (for local learning) are worth exploring. However, many implementations are research-grade—expect to debug and adapt them to your use case.

The core workflow: from problem to paradigm selection

Choosing an emergent learning paradigm is not a one-size-fits-all decision. The following steps outline a systematic workflow we have seen work across several projects.

Step 1: Characterise your constraints

Start by listing non-negotiable requirements: Is the model differentiable? What is the memory budget per training step? Is the training distributed or centralised? Do you need online (streaming) learning? For example, a team building a gesture recognition system on a smartwatch had a 256KB SRAM budget—backprop was impossible. They chose a forward-forward algorithm with local losses, which required storing only the current layer's activations.

Step 2: Map constraints to paradigm families

The dynaxx phase space groups paradigms by two axes: locality (how much information is shared across layers) and differentiability requirement. Forward-forward and local predictive coding are highly local and work with non-differentiable layers. Equilibrium propagation is less local (it needs to iterate the entire network to equilibrium) but works with any differentiable energy function. Neuromorphic approaches like spike-timing-dependent plasticity (STDP) are fully local and event-driven, but require spiking neurons.

A comparison table helps:

Step 3: Prototype with a small-scale benchmark

Do not commit to a full training run immediately. Implement a toy version (e.g., a 3-layer MLP on MNIST) for each candidate paradigm. Measure convergence speed, stability, and memory usage. Many teams report that forward-forward requires careful tuning of the local loss temperature, while equilibrium propagation can oscillate if the damping factor is not set correctly. A one-day prototype saves weeks of wasted effort.

Step 4: Scale with monitoring

When scaling to larger models or datasets, monitor gradient signal-to-noise ratio (or its local equivalent), layer-wise update magnitudes, and loss landscape curvature. Emergent paradigms often have different failure modes: for example, in predictive coding, the top-down predictions can dominate and suppress bottom-up errors, leading to a collapsed representation. Early detection of such patterns allows you to adjust hyperparameters or switch paradigms.

Tools, setup, and environment realities

Implementing emergent learning paradigms often requires more than just changing the optimizer. The software stack matters, and hardware constraints can make or break an approach.

Software frameworks and libraries

PyTorch is the most flexible platform for prototyping because you can override the backward pass or use custom autograd functions. For forward-forward, you can define a model as a list of modules, each with its own loss. For equilibrium propagation, libraries like ngclearn provide energy-based model utilities. For spiking networks, snnTorch and Norse offer surrogate gradient support. However, be prepared to write custom training loops—the standard loss.backward() pattern is not always appropriate.

Hardware considerations

On GPUs, equilibrium propagation can be slower than backprop because it requires iterative fixed-point solving (often 10–100 steps per training iteration). Forward-forward, by contrast, is embarrassingly parallel across layers. On edge devices (microcontrollers, FPGAs), forward-forward and STDP are the only practical choices due to memory constraints. Some teams have successfully deployed STDP-based classifiers on Intel Loihi neuromorphic chips, achieving microwatt power consumption.

Data and preprocessing

Most emergent paradigms benefit from contrastive or unsupervised pre-training. For forward-forward, the original paper used positive and negative examples; you need a mechanism to generate negative samples (e.g., corrupting inputs or using a different class). For predictive coding, the model learns to generate representations, so it works well with unlabeled data. Plan your data pipeline accordingly—do not assume you can plug in a standard supervised dataset without modification.

Variations for different constraints

Not every project needs the same trade-offs. Here we cover common variations and how to adapt the core paradigms.

Low-memory on-device training

If memory is the primary constraint (e.g., microcontroller with <1MB RAM), the forward-forward algorithm is the strongest candidate. Each layer's weights are updated independently using a local loss, so you never need to store activations for all layers simultaneously. A variant called sequential forward-forward processes one layer at a time, further reducing peak memory. The trade-off is slower convergence and sensitivity to the local loss design.

Non-differentiable models (e.g., discrete outputs)

When your model includes argmax, sampling, or thresholding operations, backprop fails. Predictive coding with surrogate gradients (using a smooth approximation for the non-differentiable step) is a common workaround. Alternatively, the forward-forward algorithm can handle non-differentiable layers because it only requires a contrastive loss at each layer's output. For spiking neural networks, STDP is the natural choice, but it requires precise spike timing and is less effective for rate-coded information.

Continual learning scenarios

In continual learning, the model must adapt to new tasks without forgetting old ones. Local learning rules have an advantage because they do not propagate error signals across the entire network, which can interfere with previously learned representations. Predictive coding, with its top-down and bottom-up interactions, has been shown to mitigate catastrophic forgetting in some benchmarks. However, it requires careful tuning of the balance between prediction and error signals.

Hardware-constrained scenarios: analog and neuromorphic

Analog crossbar arrays (e.g., memristor-based) can implement equilibrium propagation naturally because the physics of the circuit performs the fixed-point iteration. However, analog noise and device non-idealities require robust algorithm variants. STDP is the go-to for neuromorphic chips, but it typically underperforms backprop on standard benchmarks. Hybrid approaches that use local learning for feature extraction and a small backprop-trained classifier on top are a pragmatic middle ground.

Pitfalls, debugging, and what to check when it fails

Emergent learning paradigms are less mature than backprop, so failures are common. Here are the most frequent issues and how to diagnose them.

Gradient misalignment

In forward-forward and predictive coding, the local updates may not align with the true gradient of the global loss. This can cause the model to converge to a suboptimal solution or oscillate. Monitor the cosine similarity between local updates and the (computed for reference) global gradient on a small batch. If the alignment is consistently below 0.1, consider adjusting the local loss function or increasing the contrastive margin.

Training instability

Equilibrium propagation can exhibit oscillations if the damping factor is too low. If the loss does not decrease steadily, try increasing the damping (e.g., from 0.5 to 0.9) or reducing the learning rate. For forward-forward, instability often manifests as loss spikes; this can be mitigated by normalising the local losses or using a learning rate schedule.

Memory leaks in iterative methods

When implementing equilibrium propagation or iterative predictive coding, be careful to detach gradients from previous iterations to avoid building a computation graph that grows with each step. Use torch.no_grad() for the fixed-point solver and only compute gradients at the final state. Failure to do so can cause memory exhaustion even on large GPUs.

Hyperparameter sensitivity

Emergent paradigms often have more hyperparameters than backprop (e.g., number of fixed-point iterations, local loss temperature, contrastive margin). We recommend using Bayesian optimisation or a simple grid search for the most sensitive parameters first. A common mistake is to treat the new hyperparameters as secondary—they often dominate performance.

FAQ: Common questions from practitioners

Can I combine emergent learning with backprop in the same model? Yes. A typical hybrid uses backprop for the final classifier layer and local learning for the feature extractor. This can reduce memory usage while maintaining accuracy. Some architectures use equilibrium propagation for the early layers and backprop for the top layers.

Do emergent paradigms work on large-scale datasets like ImageNet? Generally, no—not yet. Forward-forward has been shown to work on CIFAR-10 and small ImageNet subsets, but it lags behind backprop by several percentage points on full ImageNet. Predictive coding and equilibrium propagation scale better but still underperform. For large-scale tasks, backprop remains the default; emergent paradigms are best for constrained settings.

How do I measure convergence for a local learning rule? Since there is no global loss, use task-specific metrics (accuracy, F1) or a held-out validation set. Alternatively, monitor the average magnitude of weight updates across layers—if it plateaus, training may have converged.

Is there a theoretical guarantee that local learning works? No universal guarantee. Some works show that forward-forward approximates a contrastive divergence objective, and predictive coding minimises a variational free energy. However, convergence proofs are limited to specific architectures and loss functions. Empirical testing is essential.

What about energy efficiency in practice? On digital hardware, forward-forward and predictive coding reduce memory traffic but may not reduce total energy because they require additional forward passes for contrastive samples. On analog or neuromorphic hardware, STDP and equilibrium propagation can be orders of magnitude more efficient. Measure energy per inference and per training step on your target hardware, not just FLOPs.

What to do next: concrete steps for your project

If you are considering adopting an emergent learning paradigm, here are five specific actions to take now.

1. Profile your current training bottleneck. Measure memory usage, latency, and energy for a single training step with backprop. If memory is the main issue, forward-forward is your first candidate. If it is latency due to gradient computation, consider predictive coding or equilibrium propagation depending on your model's differentiability.

2. Implement a minimal prototype on a small dataset. Choose one paradigm and implement it for a simple task (e.g., MNIST or CIFAR-10). Compare convergence speed and final accuracy against backprop. This will reveal hyperparameter sensitivity and implementation pitfalls early.

3. Join the research community. Follow repositories for forward-forward (e.g., the original PyTorch implementation) and predictive coding (e.g., the pred-coding library). Engage with issues and discussions—many practical tricks are not in the papers.

4. Evaluate on your target hardware. If you plan to deploy on an MCU or neuromorphic chip, test the prototype on that hardware as soon as possible. Emulators (e.g., the Loihi simulator) can give a rough estimate of performance and power.

5. Plan for failure. Have a fallback strategy. If the emergent paradigm does not meet accuracy requirements, consider a hybrid approach or a simplified backprop-based model with reduced depth. The goal is not to replace backprop everywhere, but to use the right tool for the right constraint.