Lock-Aware Low-Bit Codebooks for Cascaded Laser Neurons

An optical neural network computes with light, which makes it fast and potentially energy-cheap. That advantage disappears if the light must be converted back to electronics at every layer to apply the nonlinearity. One way to avoid this is a laser neuron. Light from the previous layer is injected into a small semiconductor laser, which then emits at the same wavelength with a nonlinear, ReLU-like power response. This is "injection locking": the laser is forced to follow the frequency and phase of the injected light. Because the output wavelength equals the input wavelength, identical neurons can be chained without conversion. These neurons only behave this way inside a bounded window of input power and frequency offset. Their response also changes with signaling speed, sharpening like a ReLU at low rates and softening toward an exponential-linear shape near 20 GHz. Both facts are invisible to the static activation curves that current training pipelines use. Separately, these optical systems are driven by low-precision converters, and 2–3-bit signals take only a handful of discrete power values.

This proposal turns that coarseness into an advantage. With only four or eight allowed input levels, the laser neuron's messy dynamic behavior shrinks to a small table that can actually be measured: the output for each level, conditioned on the previous one or two levels. We propose to learn where those few levels sit, keeping them inside the locking window and away from regions where the laser misbehaves dynamically. We would train networks through the measured, history-dependent table rather than through a static curve. The claim is that this closes most of the gap between simulated and measured accuracy for cascaded all-optical networks at multi-GHz rates. It does so at a precision where uniform quantization would otherwise push the lasers out of lock.

Core Claim

Wavelength-preserving cascades of injection-locked lasers fail in hardware for two reasons that current pipelines do not model. First, the neuron's response has memory: it depends on the recent input sequence, a consequence of the slave laser's relaxation oscillations. Second, coarse quantization steps can push the injected power or detuning outside the locking range, after which wavelength preservation is lost for every downstream stage.

At low bit-width, both problems become tractable together. Let $x_t \in \{c_1,\dots,c_L\}$ be the quantized optical input in time slot $t$, chosen from $L$ learnable power levels $c_\ell$. We model the neuron as

$$y_t = g\big(x_t \mid x_{t-1},\dots,x_{t-k};\ \Delta f\big),$$

where $\Delta f$ is the master–slave frequency detuning and $k$ is the memory depth. This is a finite table with $L^{k+1}$ entries, each storing a measured mean, variance, and probability of losing lock. With $L=4$ and $k=2$, that is 64 entries, each measurable with pseudo-random multilevel test sequences.

The codebook, the detuning $\Delta f$, and the network weights are then optimized jointly. The objective is task loss plus a penalty $\beta\,\mathbb{E}[p_{\text{unlock}}]$ on the expected lock-loss probability, with $\beta$ weighting stability against accuracy.

There is an extra source of error, because time-multiplexed optical networks feed different neurons into consecutive time slots of one laser. Memory in $g$ therefore couples neighboring neurons. The order in which neurons are assigned to time slots becomes a design variable. We optimize it alongside the codebook.

Relation to Prior Work

Three papers motivate the proposal by establishing the physical primitive and its limits.

None of these quantizes inputs, models memory, or tests a physical multi-stage cascade.

Three further works supply the methodology for closing the gap between simulation and silicon.

We extend these surrogates from static linear components to a dynamic, history-conditioned, quantized nonlinearity.

Two lines of work on low-bit quantization constrain the design.

Our setting differs in a way that matters. The quantized quantity feeds an elementwise physical nonlinearity, so a rotation cannot simply be folded into neighboring weights. The relevant "outlier" here is a level that falls outside the locking window, not merely a large value. We therefore borrow non-uniform, learned codebooks, as in 1-Bit Wonder: Improving QAT Performance in the Low-Bit Regime through K-Means Quantization, but place the levels using a physical stability constraint.

Research Program

The hardware is a master–slave distributed-feedback laser pair of the kind used in the 20-GHz work. It has a bandpass filter at the slave output, and a second slave stage is driven by the first slave's output through an attenuator and modulator. That gives a physical two-stage wavelength-preserving cascade.

Characterization. We drive the first stage with pseudo-random multilevel sequences at symbol rates of 2, 5, 10, and 20 GHz, with $L \in \{2,4,8\}$ and a dense sweep of candidate power levels and detunings. We record three quantities:

  • output power per symbol, which gives the conditional mean and variance in $g$;
  • side-mode suppression on an optical spectrum analyzer, used together with heterodyne beat against the master to flag symbols where lock is lost;
  • the same measurements at the second stage, to measure how errors compound.

This produces a dense table over candidate levels. We interpolate it with a small monotone network so that level positions remain differentiable.

Training. Networks are trained with straight-through estimation for the level assignment. Gradients flow through the interpolated conditional table and through the lock penalty. Slot ordering is optimized by alternating between gradient steps and a greedy reordering that places neurons with similar activation statistics in adjacent slots.

Energy accounting. We add a laser-neuron element to the photonic extension of CiMLoop from Architecture-Level Modeling of Photonic Deep Neural Network Accelerators. This answers whether the drive and bias power needed to keep each stage locked costs less than the converters it removes. That paper reports converters and memory dominating system energy, so the comparison is not foregone.

Baselines

Naive reference. Uniform 2- or 3-bit levels spanning the full input range, with weights trained against a static ReLU. This is what one gets by combining standard quantization-aware training with an idealized activation. It is evaluated through the measured table and on the two-stage hardware, and we expect it to lose lock frequently.

Strongest existing method. The static measured-curve approach of 20-GHz bandwidth optical activation function based on a semiconductor laser. It is strengthened in three ways: the curve measured at the target symbol rate, Gaussian noise injection, and quantization-aware training. This is effectively the static differentiable-surrogate recipe of the subspace neural chip applied to a laser neuron, which is the most capable pipeline in the file.

On MNIST with a three-layer fully connected network, that paper reports 97.9% simulated accuracy with the low-speed ReLU-like curve, 96.1% at the 20 GHz ELU-like limit, and 98.1% for a digital leaky ReLU. These figures come from full-precision simulation, not from measured cascades. For the closest hardware analog, measured versus simulated accuracy at 3 bits, the subspace chip reports 94.16% versus 94.59% on MNIST. That chip uses electronic activations.

Fairness. All methods share the same architectures, data, and characterization budget: identical measurement time per method, so the static baseline may use its share for denser single-symbol sweeps. They also share the same hyperparameter search budget and the same evaluation path, namely the measured conditional table and the physical two-stage cascade.

What counts as winning. We beat the baseline if, at 10–20 GHz and 2–3 bits, two things hold. First, our measured two-stage cascade error is at least halved relative to the baseline's prediction-versus-measurement gap. Second, end-task accuracy, evaluated through the conditional model, exceeds the baseline by more than the run-to-run spread, with lower lock-loss rate.

Ablations. Three ablations isolate the two ingredients:

  • learned levels with the memoryless table ($k=0$);
  • uniform levels clipped to the locking window, with the full conditional table;
  • the full method without slot reordering.

Why not just…?

Why not just train against a static measured curve plus noise, as existing photonic surrogates do? This is the real threat. If the neuron's memory is short compared with the symbol period, it may suffice. The 20-GHz paper's own observation that the curve shape depends on rate implies dynamics on the scale of the relaxation oscillation. That paper never measured whether those dynamics produce cross-symbol coupling. The $k=0$ ablation settles the question. If the memoryless table matches the full model on two-stage hardware at all rates, we drop the memory claim and keep only the stability-aware codebook.

Why not just run the laser neurons slowly, below 5 GHz, where they act like ReLU? That gives up the bandwidth that justifies an all-optical activation. We report accuracy-versus-symbol-rate curves for every method. If our method's advantage exists only above 5 GHz, that is the honest scope of the result.

Why not just clip the input range to the locking window and quantize uniformly inside it? This is cheap and may capture much of the stability benefit. It is exactly our second ablation. Learned placement must beat it on lock-loss and accuracy, or the codebook-learning component is unnecessary.

Why not just use Hadamard-style rotations, possibly implemented optically, to remove outliers as QuIP# does? In QuIP and QuIP# the rotation is absorbed into adjacent linear layers. Placing it before an elementwise laser nonlinearity changes the function computed, rather than reparameterizing it. Rotations also spread values toward a Gaussian rather than keeping them inside a hard physical window. We include a rotated-weights variant on the linear side as a secondary baseline but do not expect it to address lock loss.

Why not just use electronic activations between optical layers? This avoids every stability problem. Architecture-Level Modeling of Photonic Deep Neural Network Accelerators shows converter and memory energy dominating photonic systems, but the trade-off is not settled for laser neurons. Our CiMLoop extension reports energy per inference for both designs. If keeping the lasers locked costs more than the converters it replaces, we will say so.

Proposed Experiments

Characterization and the decisive check. The first experiment is the characterization sweep itself. Its decisive output is the mutual information between $y_t$ and $x_{t-1}$ given $x_t$, as a function of symbol rate. Non-negligible dependence at 10–20 GHz is the precondition for the memory claim.

The second experiment is the physical cascade test. We drive the two-stage setup with activations produced by MNIST- and FashionMNIST-trained networks, time-multiplexed into the laser. We compare measured stage-two outputs against the outputs predicted by each surrogate, in two ways:

  • as mean squared error per symbol;
  • as task accuracy when the measured outputs are fed to the remaining layers in software.

This hardware-in-the-loop accuracy gap is the primary metric. The bar from the subspace chip is under 0.5 points.

Depth scaling. The third experiment extends depth in simulation using the validated table: MNIST and FashionMNIST fully connected networks, plus a small CIFAR-10 CNN in which every nonlinearity is a laser neuron. We report accuracy at 2, 3, and 4 bits and at each symbol rate. The CIFAR-10 accuracy of 80.04% reported for the compressed photonic tensor core uses electronic nonlinearities and a different architecture, so it serves only as context, not a head-to-head target. We also track how lock-loss rate and prediction error grow with depth. The prediction is that uniform codebooks show a cliff in lock-loss at 2 bits, and that lock-aware codebooks flatten it.

Energy. The fourth experiment reports CiMLoop energy per inference for our all-optical cascade against the electronic-activation hybrid at matched accuracy.

The proposal fails cleanly in either of two cases: the $k=0$ ablation matches the full model on hardware, or clipped-uniform matches learned levels. Either result would still be a useful negative finding for the field.