Training a neural network is, for the most part, a bookkeeping problem. Backpropagation works by recording what every layer did, then walking the error backwards through the whole stack to decide what to change. On a digital chip that bookkeeping is expensive but routine. On a physical system — a loop of optical fibre, a nonlinear resonator, any device whose computation happens in the physics rather than in a register file — it is the hard part. You have to measure the system as it evolves, store those states, and run the gradient back through hardware never designed to be differentiated.
A team at the University of Tokyo, working with researchers at NTT, has now published the most complete answer yet to that problem. In a paper published on November 5, 2026, in Nature Computational Science, associate professor Kohei Nakajima’s group — first author and graduate student Yongbo Zhang, with Mitsumasa Nakajima and Toshikazu Hashimoto of NTT, Katsuma Inoue, and Yasuo Kuniyoshi — presents a framework that attacks both halves at once: a training method that skips the intermediate states, and a simpler architecture that needs far fewer parameters. They demonstrate it on an optical system built around a 200-metre fibre loop, reporting performance matching or beating more complex architectures at substantially lower computation.
The training claim is the strongest part of the paper; the demonstration is a bench-top fibre loop, not a chip or a language model.
The training problem, stated plainly
Backpropagation demands three things: read out every layer’s activations, store them, and propagate errors backwards using the transpose of each layer’s weight matrix. A physical neural network breaks that assumption in several places at once. The “layers” are the evolving state of a physical system — light circulating in a fibre loop — and reading out the state at every step means interrupting the physics to measure it, digitizing the measurement, and storing it. The weights live in the device’s response, which drifts, so the exact transposes backpropagation needs may not even be well defined — and running the system backwards is not something a physical device can do.
The field’s responses have split into a few camps: train a digital model of the physical system and transfer the weights; use gradient-free methods, which avoid the backward pass but scale poorly; or use direct feedback alignment (DFA), a 2016 idea in which the error signal is projected directly to each layer through a fixed random matrix. DFA sidesteps the weight-transport problem, but it still requires access to the intermediate states, and a backward computation of its own.
Nakajima’s group has been working this seam for years. In 2022, the same collaboration published a Nature Communications paper introducing “augmented” DFA, adapted to physical hardware, and reported the first experimental demonstration of efficient optical deep-network learning on a photonic system. The new paper is the next step, aimed at the two costs the earlier work left in place: measuring intermediate states, and the complexity of the architecture itself.
SS-DFA: skipping the states
The training method at the centre of the new paper is called state-skipping direct feedback alignment, or SS-DFA. Conventional training, as Nakajima puts it, “requires information about the system to be measured and recorded as it evolves, before the learning process can then backtrack to determine what needs to change.” SS-DFA, he says, “avoids the need to access most of these intermediate states, using the final error together with information about the system to guide learning.”
The mechanism eliminates access to intermediate states, substantially simplifying error backpropagation: the output error is projected directly to the trainable parameters, and the update uses the system’s own dynamics rather than a stored record of its evolution. The payoff is threefold: less measurement, less data storage, and less computation in the training loop — the costs that grow fastest as a physical system gets larger.
How much less? The paper’s headline quantitative claim is a resource number, not an accuracy number. Integrated into modern architectures, the framework “attain[ed] improved performance with an approximately 40% reduction in computational resources,” according to the abstract, with substantially reduced computational costs and parameter counts against conventional deep networks at comparable performance. The claim is not that SS-DFA beats backpropagation on accuracy, but that it matches it while spending considerably less.
In this literature, “comparable” usually means: on the benchmark tasks tested, within a few percentage points of the digital baseline. The benchmarks here are the standard ones — MNIST handwritten-digit classification and CIFAR-10 image classification, according to the paper’s supplementary training tables — plus an experiment integrating the framework into a ResMLP-style modern architecture on CIFAR-10. Honest benchmarks for a training-method paper, and modest ones: small enough to run many times — each experiment was run five times — and a long way from the workloads that make training expensive. Exact test accuracies were not verifiable from the published material — the abstract reports the comparison in relative terms — so the roughly 40% resource reduction is the claim to hold the authors to, not any single accuracy percentage.
The single-map architecture: fewer knobs, same behaviour
The second half of the framework is the architecture, and it carries the paper’s more surprising conceptual claim. The “single-map” framework replaces a network of many distinct, intricately connected units with a design in which many units follow the same general rules. As Nakajima describes it, the team “designed a simpler architecture in which many units follow the general rules, rather than relying on a set of highly complex internal connections.”
The idea has a lineage: the team previously showed that complex patterns of activity emerge naturally inside deep networks — including large language models — and suggested those patterns could be exploited. The single-map framework builds that in: if rich dynamics emerge from simple rules iterated through a shared map, you need one good map, applied repeatedly, with few trainable parameters around it.
The trade is clear. Fewer trainable parameters means less to update, less to store, and less to go wrong when the parameters live in a drifting physical device. The cost is expressivity: a single shared map cannot, in principle, represent everything a fully parameterised network can. On the tasks tested, the cost did not show up — a result about these tasks, at these scales. Whether the single map keeps up as tasks get harder is the open question the authors flag for future work.
The abstract also claims the approach “challenges the scaling laws of conventional counterparts” — a claim about the shape of a curve, testable only by experiments not yet run.
The demonstration: a 200-metre loop of fibre
The experimental half is where the claims meet hardware. The system converts information into an optical signal, processes it as it passes through a fibre loop, and converts it back into an electrical signal for analysis — using a 200-metre optical fibre and a small number of electronic components.
That is a bench-top system, not a chip: two hundred metres of fibre is a spool on a table, and the “small number of electronic components” handles the input encoding, readout, and training updates the optics cannot do alone. None of that diminishes the result — the point is to show the method works on real optical dynamics, with real noise and imperfections, and that training converges there. But it sets the correct expectation: a training method validated on an optoelectronic platform, not a photonic training chip. A deployable system still needs the dynamics miniaturised, stabilised against drift, and manufactured at volume. Nakajima is explicit about this. “If our system can be miniaturised and integrated onto a chip,” he says, “it could process data directly inside phones, cameras or self-driving cars, enabling faster responses with lower energy consumption. Before this becomes practical, however, further work is needed on miniaturisation, stability and large-scale manufacturing.”
The same candour applies to scale. “At present, we have integrated the proposed architecture into several relatively baseline modern neural network architectures, and the results show that it can improve performance while reducing computation,” Nakajima says. “However, we have not yet tested it on today’s largest AI models, particularly language and so-called multimodal models, and this is an important direction for future research.” The framework is modular, he notes, and can be inserted as a block into existing networks — “a possible route toward such scales.” Possible, not demonstrated.
Why the training bill is the right target
Why does a training-method paper deserve this much attention from a desk that usually covers hardware? Because the cost structure of AI has shifted, and training is where the shift is most visible. Inference gets the headlines because it is where the electricity bills land, but training is where the capital goes: the largest training runs now consume energy and hardware at a scale that constrains who can build frontier models at all. Any method that cuts the computation required to train a model — rather than merely the energy required to run it — addresses the binding constraint directly.
The field has produced a long series of inference accelerators; training has lagged, because training is where the bookkeeping lives, and bookkeeping is where physical systems are weakest. A method native to physical dynamics — one that does not require the device to pretend to be a digital computer running backpropagation — is an advance in what physical systems can learn, not just in what they can compute once taught. If training can be done on the physical system itself, the boundary between model and hardware starts to dissolve: the device becomes a learning system in its own right, not a fixed accelerator running weights computed elsewhere. That is the vision physical neural networks have always gestured toward, and it is also the vision that has repeatedly stalled on the training problem.
The energy argument should be stated carefully. The University of Tokyo’s account notes that if the framework succeeds at scale, it “could lower the energy needed for both computing and cooling in future AI data centers, while also reducing water consumption due to the lower heat output.” That is a conditional about a future, scaled-up system, not a measurement from this experiment: the paper reports no measured energy-per-operation figure for the fibre-loop system, and none should be inferred. The energy case rests on two claims — that the optics compute cheaply, and that the training method is cheap — and this paper substantiates the second; the first still needs a system-level measurement.
What would make this story matter
As with every photonic AI result this desk covers, the right response is a list of checkable developments, not a verdict.
First, scale — the experiment Nakajima names: the framework integrated into a large language or multimodal model, with training cost and final performance both reported against a backpropagation baseline. Until it runs, the roughly 40% reduction is a result about baseline architectures on image classification, not a general statement about training.
Second, a chip. The fibre loop proves the method on optical dynamics, not that it survives miniaturisation. An integrated photonic implementation would move this from a methods paper to a hardware programme; stability data — how the trained system holds performance as the device drifts — would be as informative as any accuracy figure.
Third, a system-level energy measurement: a complete system, measured end to end against a digital baseline, reporting energy per training step, not just computational-resource reductions. The paper’s claim is about computation; the datacenter claim is about energy, and the conversion is where optical computing claims have historically come unstuck.
Fourth, replication on a second platform. SS-DFA is, in principle, a general method, not only for fibre loops; a demonstration elsewhere would test whether its advantages are about the training rule or this loop’s particular dynamics.
Until those appear, the paper belongs in a category this desk takes seriously but does not overclaim: a genuine advance in how physical systems learn, demonstrated on real hardware, with its limits stated by its own authors. A method that cuts the training bill by roughly two-fifths on the architectures tested, with far fewer parameters and no record of intermediate states, is worth watching closely — without declaring that the bill has been paid.
Sources and further reading
Primary source: Zhang, Y., Nakajima, M., Inoue, K., Hashimoto, T., Kuniyoshi, Y., and Nakajima, K., “Scalable physical deep learning using optical dynamics with state-skipping training and single-map architecture,” Nature Computational Science (2026), published November 5, 2026, DOI: 10.1038/s43588-026-01075-w. Benchmark tasks (MNIST and CIFAR-10, including a ResMLP-style integration) are from the paper and its supplement; the ~40% reduction in computational resources with improved performance is from the abstract. The fibre loop and quotations are from the University of Tokyo’s account, reported by TechXplore on November 5, 2026. Earlier augmented-DFA work: Nakajima, M., et al., “Physical deep learning with biologically inspired training method: gradient-free approach for physical hardware,” Nature Communications 13, 7847 (2022); the “world’s first” characterisation of that work is NTT’s claim, not independently verified here. No measured energy-per-operation figure was publicly available, and no test-accuracy percentages are cited because the published material reports the comparison in relative terms.