🤖 machine learning

Energy Scaling Laws for Diffusion Models: Quantifying Compute in Image Generation

This paper proposes an adapted Kaplan scaling law that accurately predicts GPU energy consumption for diffusion models by decomposing inference into text encoding, denoising, and decoding components, demonstrating that denoising dominates energy usage and enabling reliable cross-architecture estimation for sustainable AI planning.

Original authors: Aniketh Iyengar, Jiaqi Han, Boris Ruf, Vincent Grari, Marcin Detyniecki, Stefano Ermon

Published 2026-05-14

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Aniketh Iyengar, Jiaqi Han, Boris Ruf, Vincent Grari, Marcin Detyniecki, Stefano Ermon

Original paper licensed under CC BY 4.0 (http://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 you have a very expensive, high-powered kitchen robot (a GPU) that can turn a messy pile of ingredients into a perfect, photorealistic cake (an image). This robot doesn't just bake the cake in one go; it has to mix, taste, adjust, and mix again, dozens of times, to get the texture just right. This is how Diffusion Models work to create images.

The problem is that this robot eats a lot of electricity. The more complex the cake (higher resolution) and the more times it has to mix (more steps), the higher your electric bill gets.

This paper is like a smart energy calculator for these image-making robots. The authors wanted to answer a simple question: "If I change the size of the cake, the type of robot, or how many times it mixes, can I predict exactly how much electricity it will use without actually running the robot?"

Here is the breakdown of their findings using everyday analogies:

1. The "Recipe" for Energy (The Scaling Law)

The authors took a famous rule from the world of language models (called Kaplan Scaling Laws) and adapted it for image generation. Think of this rule as a universal recipe that says: "The more work the robot does, the more energy it eats."

They discovered that for these image robots, the relationship is almost perfectly straight. If you double the amount of math the robot has to do (called FLOPs), it roughly doubles the energy it uses. It's like driving a car: if you drive twice as far, you use twice as much gas.

2. The "Mixing" is the Heavy Lifter

When the robot makes a cake, there are three parts:

Reading the order (Text Encoding): Reading what kind of cake you want.
Mixing the batter (Iterative Denoising): The actual baking process where it cleans up the noise.
Plating the cake (Decoding): Putting the final image together.

The paper found that Step 2 (Mixing) is the heavy lifter. It accounts for over 90% of the energy used. The robot spends almost all its time and electricity on the repetitive mixing process, not on reading the order or plating the cake. This is why the energy bill is so high: the robot has to mix the batter 10 to 50 times for a single image.

3. The "Robot Model" Doesn't Matter as Much as You Think

The researchers tested this rule on four different types of robots (Stable Diffusion 2, Stable Diffusion 3.5, Flux, and Qwen) and three different types of kitchens (NVIDIA A100, A4000, and A6000 GPUs).

Here is the surprising part: The rule works across all of them.

If you know how much energy a "Flux" robot uses, you can use that same math to predict how much a "Qwen" robot will use, even if they are built differently.
It doesn't matter if you are using a professional data-center robot (A100) or a high-end workstation robot (A6000); the relationship between "work done" and "energy used" stays consistent.

This is like discovering that whether you are driving a Toyota or a Ford, if you drive the same distance at the same speed, you will burn roughly the same amount of fuel. You don't need to test every single car on the road to know the fuel cost; you just need the distance and speed.

4. The "Knobs" That Change the Bill

The paper also looked at what happens when you turn the knobs on the robot:

Resolution (Size): Making the image bigger (from 256x256 to 1024x1024) is like asking the robot to bake a giant wedding cake instead of a cupcake. The energy cost shoots up dramatically.
Precision (Accuracy): Using "float32" (super precise) vs. "float16" (standard precision) is like asking the robot to measure ingredients with a microscopic scale instead of a kitchen scale. The super-precise mode uses significantly more energy (about 7 times more in some cases).
Steps (Mixing): Asking the robot to mix 50 times instead of 10 is like asking it to stir the batter for an hour instead of 10 minutes. The energy cost goes up linearly.

5. Why This Matters (The "So What?")

Before this paper, if a company wanted to know how much it would cost to run an image generator for a million users, they had to actually run the system and measure the power meter. It was like guessing your electric bill by flipping a coin.

Now, they have a predictive tool.

For Planners: A company can say, "If we switch to this new robot and ask for 4K images, here is exactly how much electricity we will need," without buying the robot first.
For the Environment: It helps us understand the "carbon footprint" of AI. The paper notes that generating one high-quality image can use as much energy as 10 typical text-based AI chats (like asking a chatbot a question).

Summary

The paper proves that energy consumption in image generation is predictable. It follows a simple math rule: More Math = More Energy. By understanding this rule, we can plan better, choose the right equipment, and understand the environmental cost of creating digital art, all without needing to run a single test.

Technical Summary: Energy Scaling Laws for Diffusion Models

Problem Statement

The rapid deployment of diffusion models for high-quality image synthesis has introduced substantial computational costs, raising critical concerns regarding energy consumption and environmental impact. Unlike single-pass models, diffusion models require iterative denoising steps (typically 10–50), where each step involves a full network evaluation, compounding energy usage. While existing energy optimization strategies focus on architectural improvements or hardware acceleration, there is a lack of principled, predictive methods to estimate energy consumption across diverse model configurations and hardware setups. Current approaches often rely on post-hoc empirical measurements or specialized benchmarks, which provide ground truth but fail to offer generalizable predictive frameworks linking architectural complexity (FLOPs) directly to energy footprints.

Methodology

The authors propose adapting Kaplan scaling laws—originally developed for transformer-based language model training—to predict GPU energy consumption for diffusion model inference. The core hypothesis is that energy usage follows a power-law relationship with computational complexity (FLOPs), modulated by hardware and configuration factors.

Theoretical Framework

The total energy consumption ( $E$ ) is modeled as a function of computational complexity, precision, hardware architecture, and resolution. The authors formulate a log-linear regression model:
$\log(E) = \log(A) + \alpha \log(\text{FLOPs} \times 2^{I_{cfg}}) + \beta_{dtype} I_{dtype} + \beta_{gpu} I_{gpu} + \beta_{res} \log\left(\frac{H \times W}{256}\right)$
Where:

FLOPs: The primary predictor, decomposed into text encoding, iterative denoising, and image decoding. The authors argue that iterative denoising dominates energy consumption (accounting for >90% of FLOPs), allowing the model to approximate total compute as $N \times T \times \text{FLOPs}_{denoise}$ .
$I_{cfg}$ : An indicator for Classifier-Free Guidance, which effectively doubles the computational cost.
$I_{dtype}$ and $I_{gpu}$ : One-hot encoded variables for floating-point precision (fp16 vs. fp32) and GPU architecture (A100, A4000, A6000).
$\beta_{res}$ : A bias term accounting for resolution-dependent efficiency variations not captured by FLOPs alone (e.g., memory bandwidth utilization).

Experimental Design

The study validates this framework through comprehensive experiments across:

Models: Four state-of-the-art diffusion models spanning different architectures: Stable Diffusion 2 (U-Net), Stable Diffusion 3.5 (MMDiT), Flux (MMDiT with flow-matching), and Qwen (MMDiT).
Hardware: Three NVIDIA GPU architectures (A100, RTX A4000, RTX A6000).
Configurations: Variations in resolution ( $256^2$ to $1024^2$ ), precision (fp16/fp32), step counts (10–50), and guidance settings.
Measurement: Energy consumption was measured using CodeCarbon's EmissionsTracker (via NVML) at a 1Hz sampling rate, isolating dynamic GPU power by subtracting idle baselines.

Key Contributions

Adaptation of Scaling Laws: The first application of Kaplan-style scaling laws to predict diffusion model inference energy, establishing a theoretical link between FLOPs and energy footprints.
FLOP Decomposition: A detailed analytical decomposition of diffusion inference costs, confirming that iterative denoising is the dominant computational component.
Cross-Architecture Generalization: Demonstration that energy scaling laws learned on specific model-hardware combinations generalize effectively to unseen models (e.g., predicting Qwen energy from Flux/SD3.5 data) and unseen hardware platforms.
Hardware-Aware Modeling: Incorporation of precision and GPU architecture effects into a unified predictive framework, enabling energy estimation without per-operator profiling.
Deployment Framework: A practical methodology for estimating the energy impact of large-scale diffusion deployments, supporting sustainable AI planning.

Results

High Predictive Accuracy: The proposed energy scaling law achieves high accuracy within individual architectures, with $R^2 > 0.9$ (often exceeding 0.99) for models like Flux, SD3.5, and Qwen on the A100.
Compute-Bound Nature: The scaling exponent ( $\alpha$ ) approaches 1.0 (e.g., 0.989 for Flux), validating the hypothesis that diffusion inference is largely compute-bound rather than memory-bound.
Cross-Model Transfer: Scaling laws trained on subsets of models (e.g., Flux + SD3.5) successfully predict energy consumption for held-out models (e.g., Qwen), with strong rank correlations ( $R, R_s > 0.9$ ).
Cross-Architecture Transfer: The framework successfully bridges architectural paradigms, predicting energy for U-Net models (SD2) using laws derived from MMDiT models, and vice versa.
Energy Magnitude: The study quantifies that a single high-resolution diffusion image can consume up to 10 times the energy of a typical large language model query (e.g., up to 3.58 Wh for a high-quality Qwen image vs. ~0.34 Wh for a ChatGPT query). Energy consumption spans three orders of magnitude depending on configuration.

Significance and Claims

The paper claims to establish energy consumption estimation as a necessary foundation for sustainable AI deployment planning. By validating that FLOP-based models can provide practical guidance for deployment, the work enables:

Pre-deployment Planning: Organizations can predict energy costs across different GPU platforms without extensive empirical testing.
Carbon-Aware Optimization: Systems can dynamically adjust hyperparameters (precision, resolution, steps) based on grid carbon intensity.
Standardization: The methodology offers a standardized approach for reporting energy consumption, supporting regulatory compliance and reproducible energy accounting.

The authors conclude that while limitations exist regarding system-wide scope (excluding CPU/RAM/cooling) and specific hardware types (NVIDIA-focused), the framework successfully captures fundamental, architecture-agnostic principles of energy-complexity relationships in diffusion models. This provides a scalable tool for assessing and mitigating the environmental impact of generative AI.