💻 computer science

Analog Diffusion Models

This paper introduces Analog Diffusion Models (ADMs), which leverage a fixed-point correspondence between analog hardware dynamics and implicit diffusion inference to enable fully analog, high-efficiency generative AI without requiring model redesign or compromising compatibility with standard training ecosystems.

Original authors: Jiaqi Chu, Heiner Kremer, Fabian Falck, Grace Brennan, Burcu Canakci, James Clegg, Daniel Cletheroe, Doug Kelly, Christos Gkantsidis, Michael Hansen, Paul Jeha, Kirill Kalinin, Jim Kleewein, Babak Rah

Published 2026-08-06

📖 9 min read🧠 Deep dive

CC BY 4.0

Original authors: Jiaqi Chu, Heiner Kremer, Fabian Falck, Grace Brennan, Burcu Canakci, James Clegg, Daniel Cletheroe, Doug Kelly, Christos Gkantsidis, Michael Hansen, Paul Jeha, Kirill Kalinin, Jim Kleewein, Babak Rahmani, Saravan Rajmohan, Victor Rühle, Jannes Gladrow, Francesca Parmigiani, Hitesh Ballani

Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine the world of artificial intelligence as a massive, high-speed train station. For years, the trains (our AI models) have been getting faster and more powerful, but they are also becoming incredibly heavy and energy-hungry. The most popular type of train right now is called a "diffusion model." Think of it like a sculptor who starts with a block of chaotic, noisy marble and slowly chips away the noise, step by step, until a beautiful statue emerges. To get that perfect statue, the sculptor has to make thousands of tiny, careful chiseling motions. Each motion takes time and energy, and as the statues get bigger, the process becomes exhausting for our current computer chips, which are like digital calculators that can only do one thing at a time very quickly.

Enter the idea of "analog computing." If digital computers are like a digital clock that ticks in precise, separate seconds, analog computers are like a flowing river or a swinging pendulum. They don't count steps; they let physics do the work. Instead of calculating a number, they let a signal flow through a circuit until it naturally settles into a stable state, much like a pendulum eventually coming to rest at the bottom of its swing. Scientists have long hoped that using these "flowing" machines could make AI incredibly fast and energy-efficient. However, there's been a stubborn problem: the AI algorithms were designed for the "digital clock" style of thinking. Trying to force them to run on "flowing river" hardware usually meant either breaking the AI's brain or only using the hardware for a tiny part of the job, leaving the heavy lifting to the old, energy-hungry digital computers.

This paper introduces a clever new way to bridge that gap, called Analog Diffusion Models (ADMs). The researchers, working at Microsoft Research, discovered that the way a diffusion model "chisels away" noise looks suspiciously similar to the way a physical analog system naturally "settles down" to a stable state. Instead of forcing the AI to change its personality to fit the hardware, they reimagined the AI's steps so that the hardware could do the work naturally. They tested this on a special optical computer that uses light and electricity to perform calculations. In their experiments, the system successfully generated images and data patterns entirely on this analog hardware, with each step of the process taking just 10–15 microseconds.

The team didn't stop at just the small prototype. They used a "digital twin"—a super-accurate computer simulation of their hardware—to test how this idea would work on much larger, real-world AI models, including some with billions of parameters. These simulations suggest that this approach could be a game-changer. By using this "settling" method, the AI might need up to 16 times fewer steps to create a high-quality image compared to standard methods. Even though each of these new steps requires a few internal "settling" loops, the total amount of work drops significantly. The researchers suggest that if this technology is scaled up to future, miniaturized hardware, it could offer massive energy savings, potentially making the next generation of AI much more sustainable without needing to reinvent the algorithms we already love.

The Core Idea: Letting Physics Do the Chiseling

To understand why this is a big deal, let's look at how the "sculpting" usually works. In a standard digital AI, the computer calculates one step, stops, saves the result, calculates the next step, and so on. It's like a robot that has to pause, think, and then move its arm for every single chip of marble it removes. This is slow and uses a lot of electricity.

The researchers realized that the "implicit" math used in some advanced AI models is actually a "fixed-point" problem. In plain English, this means finding a spot where if you apply a rule, you end up in the exact same spot. It's like a ball rolling down a hill; it keeps moving until it hits the bottom and stops. Once it's at the bottom, applying the rule "roll down" doesn't change anything because it's already there.

The magic of this paper is that analog hardware naturally does exactly this. When you send a signal through a loop of light and electronics, it doesn't count steps. It just flows until it stabilizes. The authors realized that if they set up their AI model correctly, the "settling down" of the light and electricity is the AI taking a step. The hardware doesn't need to be told to stop after one calculation; it naturally finds the answer by reaching equilibrium.

The Experiment: Light, Mirrors, and Micro-LEDs

To prove this works, the team built a physical machine called an Analog Optical Computer (AOC). Imagine a tiny, high-tech maze made of light.

The Light Source: They used arrays of tiny lights (micro-LEDs) to represent the data.
The Weights: They used special mirrors called Spatial Light Modulators (SLMs) that can change how much light they reflect. These mirrors act as the "brain" of the AI, holding the weights (the knowledge) of the model.
The Loop: The light travels from the LEDs, hits the mirrors, gets summed up by sensors, and then the result is fed back into the system.

This creates a feedback loop. The system keeps adjusting itself until the light pattern stabilizes. This stabilization happens in the blink of an eye—specifically, in 10 to 15 microseconds per step.

They tested this on a few different tasks:

2D Shapes: They asked the machine to generate simple 2D patterns like hearts, stars, and letters. The hardware did this successfully, producing shapes that matched their digital simulations almost perfectly.
Latent Space Generation: They used a technique called "latent diffusion" (which is how modern image generators like DALL-E or Stable Diffusion work). They ran the entire iterative process on the analog hardware and only used a digital computer for the very last step to turn the result into a picture. They successfully generated images of handwritten digits (MNIST), fashion items (FashionMNIST), and letters (EMNIST).

The Big Picture: Simulations and Scaling

The physical machine they built is small, with 2,304 programmable weights. That's tiny compared to modern AI models, which can have billions of weights. So, how do we know this works for big models?

The researchers created a "Digital Twin" (DT). This is a computer simulation that mimics the exact behavior, noise, and quirks of their physical hardware. They trained standard AI models on regular digital computers but told them to expect the "noise" and behavior of the analog machine. Then, they ran these models through the Digital Twin to see how they would perform if they were actually running on the light-based hardware.

They tested this on:

Convolutional Neural Networks (U-Nets)
Diffusion Transformers (DiT)
Huge models with up to 13 billion parameters (like the FLUX.1 model).

The results were promising. In these simulations, the "Analog Diffusion Models" (ADMs) could achieve the same high-quality image results as standard digital methods but with up to 16 times fewer diffusion steps.

For example, on a dataset of butterfly images, the standard method needed 128 steps to get a good picture. The analog method only needed 8 steps to get a similar quality. Even though each of those 8 steps required a few internal "settling" loops (fixed-point iterations), the total amount of work was still much lower.

Why This Matters (And What It's Not)

The paper suggests a new path forward. Instead of trying to force AI algorithms to fit into the constraints of new hardware (which often breaks the AI), they aligned the hardware's natural physics with the algorithm's needs.

What the paper does NOT claim:

It does not say this is a finished product you can buy today. The hardware is still a prototype.
It does not claim to have solved the energy problem for all AI yet. The energy savings are "projected" based on simulations and the known efficiency of optical computing.
It does not say that every AI model will work better this way. In some specific tests (like with the AFHQ dataset using a DiT model), the basic method struggled, but a more advanced version called "Implicit-CN" (Crank-Nicolson) fixed the issue.

The Confidence Level:
The authors are very careful with their language. They demonstrated the concept on the small hardware. They showed that the 2D and latent-space results match the digital twin. They suggest that the scaling results (for the billion-parameter models) are highly likely to hold true because the math checks out, but those specific large-scale results are currently simulations, not physical experiments on a billion-weight machine.

The Future Roadmap

The paper outlines a roadmap for the future. The current hardware is about the size of a small chip. The authors propose that by stacking these optical systems in three dimensions (using the third dimension to route light, rather than just across a flat surface), they could scale up to 100 million weights within a volume the size of a centimeter.

If this scaling happens, and if the hardware can be made to operate at gigahertz speeds (which is much faster than the current megahertz speeds), the energy efficiency could be 100 times better than current digital chips for the actual calculation part. Even when you add in the cost of the final digital step to turn the result into a picture, the total system could still be 26 times more efficient than current methods.

In short, this paper suggests that by listening to the physics of light and electricity, and letting the AI "settle" naturally rather than forcing it to count, we might finally unlock the massive energy savings that analog computing has promised for decades. It's a shift from "making the algorithm fit the machine" to "letting the machine do what it does best."

Technical Summary: Analog Diffusion Models

Problem Statement

Generative AI, particularly diffusion models, has become dominant for creating images, audio, and video, but its iterative inference process is computationally and energy-intensive, accounting for an estimated 90% of energy use in commercial deployments. While analog and optical hardware offers orders-of-magnitude potential for efficiency gains in matrix multiplications, a "structural lock-in" has prevented its adoption. Previous attempts to run diffusion models on analog hardware have faced a binary trade-off: either confine analog components to small parts of a digital pipeline (limiting system-level gains) or redesign the generative model to fit hardware constraints (sacrificing compatibility with standard training pipelines, pretrained weights, and the evolving ecosystem). Consequently, no system has yet demonstrated fully analog diffusion inference that remains compatible with standard model formulations.

Methodology

The authors introduce Analog Diffusion Models (ADMs), which exploit a structural correspondence between the physical equilibration dynamics of analog feedback loops and the fixed-point structure of implicit diffusion inference.

Core Concept: Fixed-Point Correspondence

Diffusion models typically integrate an Ordinary Differential Equation (ODE) over a finite time horizon using explicit solvers. ADMs reformulate this using an implicit ODE solver (specifically implicit Euler or Crank-Nicolson). In this formulation, each diffusion step corresponds to finding the stable fixed-point of a learned nonlinear transformation. This aligns naturally with analog hardware, which evolves via physical relaxation dynamics toward a stationary state, effectively solving the ODE as $t \to \infty$ .

Training and Inference Separation

A key innovation is the decoupling of training and inference constraints:

Training: Models are trained using standard flow-matching objectives on digital GPUs. To account for analog non-idealities (noise, non-linearities, crosstalk), the authors employ a Digital Twin (DT). The DT acts as a differentiable, task-agnostic translation layer that applies hardware-specific corruptions to parameters and outputs during training but leaves the neural network architecture standard. Crucially, training does not require fixed-point search or hardware-in-the-loop optimization.
Inference: The trained model is executed entirely on analog hardware. The ADM operator is constructed such that iterating the update map on the analog system until convergence yields the implicit Euler update. This allows the system to perform the diffusion step natively in the analog domain without modifying the model weights.

Hardware Implementation

The authors demonstrate ADMs on an Analog Optical Computer (AOC) featuring:

Architecture: A recursive loop integrating 3D optical matrix-vector multiplication (using microLEDs, Spatial Light Modulators (SLMs), and photodetectors) with analog electronic nonlinearities (bipolar differential pairs).
Scale: The prototype supports 2,304 programmable weights, scaled tenfold from previous work. It uses a block-matrix layout to implement multi-layer networks within a single recursive loop.
Latency: Measured convergence times are 10–15 µs per diffusion step, governed by a 5 MHz system bandwidth.

Latent Space Execution

For high-dimensional data, the authors employ a Latent ADM framework. The iterative diffusion process runs entirely in the analog latent space of a Variational Autoencoder (VAE). Only the final decoding step from latent space to pixel space is performed digitally. This isolates the most energy-intensive part of the generation process (the iterative denoising) to the analog hardware.

Key Contributions and Results

1. Hardware Validation on 2D Distributions

The authors demonstrated fully analog diffusion steps on the AOC hardware using diverse 2D distributions.

Performance: The hardware results closely matched the Digital Twin simulations, with a per-step Normalized Root Mean Square Error (NRMSE) of approximately $10^{-2}$ .
Robustness: The fixed-point attractor dynamics and the diffusion process itself were shown to be robust to analog noise, allowing stable generation with minimal averaging (5 repetitions).

2. Latent Image Generation

Using the latent ADM approach, the system generated samples from MNIST, FashionMNIST, and ExtendedMNIST datasets.

Quality: ADMs on hardware substantially outperformed VAE-alone baselines, achieving lower Fréchet Inception Distance (FID) and lower distributional discrepancies in latent space.
Efficiency: The entire iterative diffusion process was executed in the analog domain, with only the final decoding step remaining digital.

3. Algorithmic Scalability (Digital Twin Simulations)

To test scalability beyond current hardware limits, the authors simulated ADMs on architectures ranging from 32M to 13B parameters (including U-Nets and Diffusion Transformers) across high-resolution datasets (Smithsonian Butterflies, AFHQ, Oxford Flowers-102).

Step Reduction: Implicit sampling consistently outperformed explicit sampling in the low-step regime. ADMs achieved the same sample quality (FID) as standard methods with up to 16× fewer diffusion steps.
Total Operations: Although each implicit step requires multiple fixed-point iterations (e.g., 4), the reduction in diffusion steps results in a net reduction of 1–2× in total neural network evaluations.
Stability: For architectures where basic implicit methods struggled (e.g., AFHQ with DiT), the Crank-Nicolson variant (Implicit-CN) provided a more favorable trade-off, offering second-order accuracy and relaxed stability conditions, achieving up to 8× fewer steps.
State-of-the-Art Compatibility: The approach was successfully applied to the 13B parameter FLUX.1 model, improving sample quality at extremely low step counts (2 steps) where standard implicit methods failed to converge.

4. Energy Efficiency Projections

The paper projects end-to-end energy gains based on a conservative 100× per-operation efficiency advantage for analog hardware over current digital accelerators.

Native Resolution: For generation within the hardware's native resolution (no digital decoder), the full 100× gain is preserved.
Latent Scaling: For high-resolution generation requiring a digital decoder, the overhead reduces the projected gain to approximately 26× in the Smithsonian Butterflies setting, still representing a significant system-level improvement.

Significance and Claims

The paper claims that Analog Diffusion Models offer a practical route to unlocking the efficiency potential of analog computing for AI workloads without sacrificing ecosystem compatibility.

Structural Alignment vs. Algorithm Redesign: The authors argue that matching hardware physics to algorithmic structure (by exploiting the fixed-point correspondence) is a more general and practical approach than redesigning algorithms to fit hardware constraints.
Ecosystem Compatibility: ADMs preserve the use of standard training pipelines, pretrained weights, and the rapidly improving algorithms of the mainstream AI ecosystem, addressing the "hardware lottery" problem where alternative hardware risks irrelevance due to incompatibility.
Scalability: The results suggest that as analog hardware scales to millions of weights (e.g., via 3D optical stacking), the combination of reduced diffusion steps and per-operation efficiency could deliver orders-of-magnitude energy savings for generative AI inference.

The authors remain modest, noting that realizing these gains for industrial applications requires further scaling of analog hardware to match the precision and weight counts of modern generative models, and that the current prototype serves as a validation of the operating principle.