Rank-One Sign Pulses with Peripheral Error Feedback for Single-Device Crossbar Training

Analog crossbar chips store each neural-network weight as the conductance of one tiny device and compute matrix products for free through Ohm's and Kirchhoff's laws. On such chips, the area spent on synapses, not on neurons, decides how large a network fits. Training on the chip itself breaks this economy. The devices change conductance unevenly: an "up" pulse and a "down" pulse do not move a device by the same amount. The methods that fix this pay in area. They add a second full array (Tiki-Taka), use ten devices per weight (multi-memristive synapses), or, for the one optimizer family that is naturally hardware-friendly, keep a high-precision error register at every synapse (error-feedback signSGD). This proposal targets the last of these. The question is whether the per-synapse register can be removed without losing the convergence guarantee that makes 1-bit updates work.

The observation behind the proposal is simple. A crossbar can cheaply apply an update only in the form of a row pattern times a column pattern: each row line and each column line carries a pulse polarity, and a device switches where they coincide. The sign of a rank-one matrix $uv^\top$ is itself rank-one, $\operatorname{sign}(u)\operatorname{sign}(v)^\top$. This means that if the error-feedback residual is kept in low-rank form in the digital circuitry at the array edges, three things hold at once. Each step's fixed-amplitude polarity-only update can be applied in a single pulse-coincidence sweep. Subtracting that update from the residual keeps the residual low-rank. The extra storage scales with rows plus columns rather than rows times columns. The proposal builds and tests this scheme, which we call peripheral error feedback, on one device per synapse.

Core Claim

For a layer with $m$ inputs and $n$ outputs, let $E_t$ be the error-feedback residual, stored as $r$ pairs of row and column vectors at the array edges. Let $G_t$ be the mini-batch gradient, which on a crossbar arrives as a sum of $B$ outer products of layer inputs and backpropagated errors. Each step then does four things. It forms $M_t = E_t + G_t$, a matrix of rank at most $r+B$. It extracts its leading singular pair $(u_t, v_t)$ with one warm-started power-iteration step. It applies the pulse update

$$\Delta W_t = -\alpha\, \tau(u_t)\, \tau(v_t)^\top,$$

where $\tau$ is a ternary sign that outputs $\pm 1$ for entries whose magnitude exceeds a threshold and $0$ otherwise, and $\alpha$ is the device's nominal step. Finally, it stores the rank-$r$ truncation of $M_t + \Delta W_t/\eta$ as the new residual. Here $\eta$ is the learning-rate scale that converts pulse steps into gradient units.

Storage is $r(m+n)$ words per layer instead of $mn$. For a $512\times 512$ layer with $r=4$, this is about 4,000 words against 262,000. Every write is a single coincidence sweep. The ternary threshold makes most rows and columns silent on each step, which reduces device wear.

We claim that this recovers most of the accuracy that full per-synapse error feedback recovers over plain signSGD. We further claim that, combined with a cheap global correction for up/down asymmetry, it comes within a small margin of Tiki-Taka's accuracy at half its array area. The first claim is the main hypothesis. The second is the one most likely to fail, and the experiments are built to find out.

How This Relates to Prior Work

Two results motivate the design. Error Feedback Fixes SignSGD and other Gradient Compression Schemes shows that plain signSGD can diverge and generalizes poorly at small batch sizes. It reports a roughly 36% accuracy drop at batch size 8. It also shows that feeding back the discarded residual restores SGD-like convergence and matches SGD with momentum on CIFAR-100. The residual in that work is a full-precision vector with one entry per parameter. On a crossbar, that is exactly the per-synapse storage that plasticity circuits such as Implementing Synaptic Plasticity in a VLSI Spiking Neural Network Model show inflates synapse area to many transistors. We keep the feedback loop but compress where it lives.

Towards Exact Gradient-based Training on Analog In-memory Computing proves that analog SGD on devices with uneven up/down steps has an error floor that no learning rate removes. It also proves that Tiki-Taka removes the floor by filtering updates through an auxiliary array. Tiki-Taka is the accuracy target, and its duplicated array is the area cost we try to avoid.

Three papers supply methods we reuse. The four-phase, sign-clustered write scheme of In-situ Stochastic Training of MTJ Crossbar based Neural Networks groups row and column polarities to avoid stray currents in transistor-free arrays. That scheme is exactly how a rank-one sign pattern is applied. That work, however, encodes gradient magnitude as switching probability through analog pulse shaping, which we eliminate. The error-triggered gating of Error-triggered Three-Factor Learning Dynamics for Crossbar Arrays cut DVS Gesture writes from 1 million to 10,000. Our ternary threshold plays the same role, but the update amplitude stays fixed rather than modulated by pulse width, and the skipped mass is kept in the residual rather than lost. The simulator in A Flexible and Fast PyTorch Toolkit for Simulating Training and Inference on Analog Crossbar Arrays supplies calibrated device models and a Tiki-Taka implementation.

Two results constrain the design. BAS: Bridging Adam and SignSGD for Memory-Efficient LLM Training found that compressing per-parameter momentum below FP8 made training diverge. This argues against the obvious alternative of shrinking the per-synapse register to a few bits, and it is why we compress by rank rather than by bit depth. Training large-scale ANNs on simulated resistive crossbar arrays found that continuous analog updates on ImageNet needed 12,000 to 48,000 conductance states. This is our reason to hope that fixed-step sign pulses with feedback lower the required state count. It also warns that large-scale results may not transfer, so ImageNet is out of scope for this proposal.

Research Program

The first component is the algorithm and a convergence analysis. We will extend the error-feedback argument to the case where the compression operator is "take the leading singular pair, then sign it, then truncate the residual to rank $r$." The analysis must bound the energy discarded by truncation. We expect a guarantee of the form "converges to a neighbourhood whose size is set by the tail singular values of the gradient-plus-residual." The observation that layer gradients are dominated by few directions makes that neighbourhood small in practice, and we will measure the tail directly during training.

The second component is asymmetry handling. With fixed pulses, the realized step is $\alpha_+(w)$ for "up" and $\alpha_-(w)$ for "down," and the difference is not rank-one. So it cannot be folded into the residual exactly. We will test two cheap corrections. One is per-row and per-column pulse-count ratios, in the spirit of the global counters of Neuromorphic computing with multi-memristive synapses but with one device per weight. The other is an occasional full-array read that re-estimates the rank-$r$ part of the realized-minus-intended error.

The third component is an area, write-count, and energy accounting. Peripheral storage and power-iteration arithmetic will be charged against the saved second array or the saved per-synapse registers, using simple area models per stored word and per device.

Baselines

The naive reference point is plain signSGD with momentum, applied as polarity-only pulses on one device per weight, with momentum kept only as a per-layer scalar scale in the style of BAS. It has the same area as our method and shows what the residual buys. We will also report digital floating-point SGD with momentum as the accuracy ceiling.

The standard analog baseline is stochastic-pulse analog SGD as implemented in aihwkit. Here gradient magnitude becomes pulse probability and no residual is stored. Towards Exact Gradient-based Training on Analog In-memory Computing reports that this suffers a greater-than-6% accuracy drop versus digital on its CNN experiments. Beating it by a clear margin at equal area is the minimum bar for this proposal.

The strongest existing method is Tiki-Taka, run through aihwkit on the same device presets. The same paper reports 95.15% CIFAR-10 accuracy for Tiki-Taka on ResNet-34, against 93.44% for its digital SGD baseline. We will rerun Tiki-Taka ourselves rather than compare to that number, because our model sizes and device presets will differ. We count it as beaten if we reach accuracy within one point of Tiki-Taka with half the device count. We count it as tied-and-cheaper if we are within two points while also cutting writes.

The upper bound for our compression is full per-synapse error-feedback signSGD, simulated with an idealized full-precision register at every cell. It isolates how much of error feedback's benefit the rank-$r$ residual keeps.

The multi-device baseline is the multi-memristive synapse of Neuromorphic computing with multi-memristive synapses with $N=10$ on the PCM preset. That paper reports 88.9% on its MNIST network, against under 15% for a two-device differential synapse.

Two ablations isolate the key ingredients. The first sweeps the rank $r$ from 0 to 16; $r=0$ reduces to rank-one sign updates with no memory. The second turns off the ternary threshold to separate the endurance benefit from the accuracy effect.

All methods will receive the same training data and augmentation, the same number of epochs, and the same device model. Each will get an equal hyperparameter search budget of 20 trials over learning rate and method-specific knobs. Results will be reported over three seeds.

Why not just…?

Why not just use stochastic pulse updates, which are unbiased in expectation and need no memory at all? This is the most serious practical competitor, because it is what analog training hardware already does. Its weakness is not bias but the device asymmetry floor. Wu et al. prove that this floor does not vanish with smaller steps, and they measure a greater-than-6% gap. A residual that accumulates what the device failed to apply is our proposed remedy. If stochastic pulses match our method on the asymmetric device presets, the residual is not earning its storage and we will say so.

Why not just keep error feedback per synapse but at 2–4 bits? BAS reports that per-parameter optimizer state below FP8 caused divergence, even on digital hardware. Even a 4-bit register per cell also multiplies cell area several-fold. We will nonetheless run a 4-bit per-synapse residual as an extra point, because the BAS result concerns momentum in large language models rather than sign residuals in small networks.

Why not just use Tiki-Taka and accept the doubled array? If area were free, it would be the right choice, and it has a convergence proof that our method lacks under asymmetry. The case against it is purely density: the synapse array dominates die area. The experiment that settles this is accuracy at matched device count. We compare our method against Tiki-Taka run on a network with half the width, so that both use the same number of devices.

Why not just raise the batch size so plain signSGD becomes stable? On-chip and edge learning typically sees small streaming batches. Karimireddy et al. show that the failure of plain signSGD is sharpest at batch size 8. We will sweep batch size from 1 to 128 and report where, if anywhere, the naive baseline catches up.

Proposed Experiments

All runs use aihwkit device presets for symmetric linear, asymmetric linear, and soft-bounded ReRAM-like and PCM-like devices, with write noise and device-to-device variation enabled. The tasks, in order of difficulty, are an MNIST multilayer perceptron, FashionMNIST, CIFAR-10 on a VGG-8 network (the aihwkit reference setting), and CIFAR-10 on ResNet-18. Reported quantities are test accuracy, total device writes per epoch, number of distinct conductance states actually used, peripheral storage in words per layer, and devices per weight.

The first decisive check is on the symmetric linear device. Here asymmetry is absent, so this isolates compression. Peripheral error feedback with $r \le 4$ should close at least 70% of the accuracy gap between plain sign pulses and full per-synapse error feedback. If a rank of 16 or more is needed, the compression argument fails.

The second check is on the asymmetric linear device, which is the regime Wu et al. analyse. We test whether the pulse-count asymmetry correction lets our method approach Tiki-Taka at matched device count. This is where the proposal may partly fail. A negative result there, combined with success on the first check, would still establish a density-efficient optimizer for near-symmetric devices such as MTJs.

The third check concerns wear. We track per-device write counts to test whether the ternary threshold reproduces write reductions of the order Payvand et al. report, roughly 100-fold, without losing accuracy.

Finally, we will measure the singular-value tail of $E_t + G_t$ throughout training. This connects the empirical results to the convergence bound. It also determines whether the approach should be expected to extend to wider layers, where the rank needed may grow.