BlurDM: A Blur Diffusion Model for Image Deblurring

ArXiv: 2512.03979

🎯 Pitch

Motion blur isn't random noise—it's a structured, progressive accumulation along a trajectory, yet standard diffusion models treat it as if it were. BlurDM embeds this physical blur formation process directly into the dual forward diffusion of noise and blur itself, enabling the model to jointly denoise and deblur from pure noise. The result is a plug-and-play prior that boosts four different deblurring architectures by up to 1.2 dB.

---

1. Executive Summary

This paper proposes BlurDM (Blur Diffusion Model), a diffusion-based framework that integrates the physical blur formation process — specifically the continuous exposure that progressively accumulates motion blur — into the diffusion model's forward and reverse processes through a dual noise and blur diffusion scheme (adding both Gaussian noise and structured blur residuals at each step, then simultaneously estimating and removing both during reverse generation via dedicated noise and blur residual estimators). Operating in the latent space as a plug-and-play prior generation network, BlurDM consistently improves four representative deblurring backbones (MIMO-UNet, Stripformer, FFTformer, and LoFormer) across four benchmarks, delivering average PSNR gains of 0.31–0.78 dB on GoPro, HIDE, and RealBlur-J/R datasets (including individual gains up to 1.24 dB) with minimal computational overhead (~4.16 GFLOPs and ~9 ms), establishing that explicitly modeling the inductive bias of blur accumulation within a diffusion framework yields consistent and transferable deblurring improvements while remaining limited to motion blur and not extending to defocus blur arising from depth-dependent optical aberrations.

2. Context and Motivation

The Core Problem: Diffusion Models Ignore the Physics of Blur

The fundamental problem this paper addresses is a mismatch between the standard diffusion process and how motion blur actually forms during image capture. Standard diffusion models — DDPM (Ho et al., 2020), DDIM (Song et al., 2021), latent diffusion (Rombach et al., 2022) — were designed for unconditional or text-conditioned image generation. Their forward process corrupts images by adding isotropic Gaussian noise at each step, and their reverse process learns to remove that noise. This noise-only formulation is elegant and general, but it encodes no domain knowledge about specific degradation types.

When these models are applied to image deblurring — either by conditioning on a blurred input (Whang et al., 2022; Ren et al., 2023) or by using them as prior generation networks that guide a separate deblurring backbone (Chen et al., 2023; Xia et al., 2023) — they treat blur as just another form of corruption to be removed through learned denoising. The problem is that motion blur is not random noise. It has a specific physical origin and a specific mathematical structure that standard diffusion models completely ignore.

Motion blur arises from continuous exposure integration: during the time the camera shutter is open, light from moving objects (or from a moving camera) accumulates on the sensor along motion trajectories. Mathematically, a blurred image $B$ is the integral of instantaneous sharp frames $H(\tau)$ over the exposure duration $[0, \alpha_T]$:

$B = \frac{1}{\alpha_T} \int_0^{\alpha_T} H(\tau) \, d\tau$

This means blur is directional, structured, and spatially correlated in ways that Gaussian noise is not. A standard diffusion model's forward process — which adds independent Gaussian noise at each pixel — bears no resemblance to this physical process. The paper argues that this mismatch limits the potential of diffusion-based deblurring because the model wastes capacity learning to represent a degradation mechanism that could instead be built in as an inductive bias.

Why This Matters: The Gap Between Generation and Restoration

This mismatch matters for both practical and theoretical reasons.

Practically, image deblurring is a critical preprocessing step for countless downstream vision applications. As the paper notes (Section 1), blurred images degrade performance in object detection (Kim et al., 2024; Wang et al., 2024), semantic segmentation (Benigmim et al., 2024; Weber et al., 2024), and face recognition (Kim et al., 2024; Mi et al., 2024). In autonomous driving, surveillance, medical imaging, and consumer photography, the ability to recover sharp details from blurry inputs directly impacts safety and usability. Even small improvements in deblurring quality can cascade into measurable gains in these downstream tasks.

Theoretically, the problem exposes a broader question about how to incorporate physical domain knowledge into generative models. Diffusion models are remarkably flexible, but that flexibility comes at a cost: they must learn everything from data, including the structure of the degradation they're trying to reverse. If the degradation has known mathematical properties — as motion blur does — then encoding those properties into the model architecture should improve sample efficiency (requiring less data or fewer parameters to achieve the same performance), generalization (transferring better to unseen blur patterns), and interpretability (the model's internal representations align with physically meaningful quantities). The paper's core hypothesis is that explicit physical modeling matters, and the consistent improvements across four different backbones on four different datasets provide evidence for this hypothesis.

The Landscape of Prior Approaches

To understand what BlurDM contributes, we need to survey the three main families of prior work and identify exactly where they fall short.

CNN and Transformer-Based Deblurring (Non-Diffusion)

The dominant paradigm before diffusion models was direct regression: train a neural network to map a blurred image directly to a sharp image, supervised with pixel-wise losses (typically L1 or L2). This line of work spans recurrent CNN architectures and attention-based Transformer designs.

CNN-based approaches exploit various forms of recurrence to handle the multi-scale nature of blur. Tao et al. (2018) proposed a scale-recurrent network that processes the image at multiple resolutions in a coarse-to-fine manner, progressively refining estimates. Zamir et al. (2021) introduced multi-stage patch-recurrent networks that split images into non-overlapping patches for hierarchical processing. Park et al. (2020) designed temporal-recurrent networks that mimic the progressive nature of deblurring through incremental temporal training. Gao et al. (2019) incorporated parameter sharing and nested skip connections to improve efficiency.

Transformer-based approaches emerged to capture long-range dependencies that CNNs struggle with, since motion blur often involves global information (the camera trajectory affects the entire image). Cho et al. (2021) with MIMO-UNet, Tsai et al. (2022) with Stripformer (using strip-wise attention), Kong et al. (2023) with FFTformer (using frequency-domain attention), and Mao et al. (2024) with LoFormer (using local frequency attention) all pushed state-of-the-art deblurring performance through architectural innovations in attention mechanisms.

Where these methods fall short: Despite their architectural sophistication, CNN and Transformer-based deblurring models share a fundamental limitation — they are typically trained with regression losses (L1, L2, or Charbonnier) that penalize pixel-wise deviations from the ground truth. As the paper notes (Section 2.1):

"the inherent constraints of regression loss typically lead to over-smoothed results with limited high-frequency details"

This is a well-known consequence of using L1/L2 losses for image restoration: they encourage the model to predict the conditional mean of the distribution of possible sharp images given the blurred input. When multiple sharp explanations are equally plausible (which is common in deblurring due to the ill-posed nature of the problem), the conditional mean is a blurred average of those explanations — exactly the opposite of what we want. The model produces images that are mathematically optimal under the loss function but perceptually unsatisfactory, lacking the crisp textures and fine details that distinguish sharp photographs.

Diffusion models offer a way out of this problem because they learn the full conditional distribution, not just the mean. During sampling, they can produce a specific, high-frequency sample from that distribution rather than an averaged, over-smoothed estimate.

Diffusion Models Applied to Deblurring

Recognizing the advantages of diffusion models for detail generation, several works have adapted them to deblurring. The paper categorizes these efforts (Section 2.2) and identifies two distinct strategies:

Strategy 1: Full diffusion in pixel space. These methods run the full diffusion process (forward noise addition, reverse denoising) directly on images, conditioning on the blurred input. Whang et al. (2022) introduced stochastic refinement, where a diffusion model iteratively refines a deblurring estimate. Ren et al. (2023) incorporated multi-scale structure guidance into the diffusion process. These methods can produce high-quality results with rich textures, but they suffer from the typical drawbacks of pixel-space diffusion: hundreds or thousands of iterative sampling steps, making them computationally expensive and slow for practical deployment.

Strategy 2: Diffusion as a prior generator in latent space. To address the efficiency problem, several works (Chen et al., 2023; Chen and Liu, 2024; Liang et al., 2025) perform diffusion in a compressed latent space and use the resulting representations as conditioning signals (or "priors") for a separate, efficient deblurring network. The key insight is that diffusion models are excellent at learning rich, realistic image representations, but they don't need to be responsible for pixel-level reconstruction. Instead, they can produce a compact latent code that encodes high-level structure and texture information, which a lightweight deblurring network then decodes into the final image.

For example, Chen et al. (2023) proposed HI-Diff (Hierarchical Integration Diffusion) , which runs a latent diffusion process to generate a prior representation, then fuses this prior into a deblurring U-Net at multiple scales through a hierarchical integration module. Xia et al. (2023) proposed DiffIR, which similarly uses a diffusion model to estimate a compact IR prior from the degraded image and injects it into a restoration network.

Where these methods fall short: The paper identifies a critical gap in all these approaches, regardless of whether they operate in pixel space or latent space:

"While these methods effectively reduce diffusion model latency for deblurring, they overlook the intrinsic characteristics of the blurring process within the diffusion framework, limiting their full potential."

In other words, they treat diffusion as a generic black-box mechanism for generating useful representations from corrupted inputs. The forward process still adds isotropic Gaussian noise; the reverse process still learns to remove that noise. The fact that the corruption is motion blur — with its specific physical structure — is not reflected in the diffusion dynamics. The model must learn the structure of blur implicitly from data, which the paper argues is less effective than building it in.

RDDM and the Partial Exception

The paper specifically discusses RDDM (Residual Denoising Diffusion Models) by Liu et al. (2024) as the closest prior work. RDDM attempts to go beyond standard noise-only diffusion by modeling a residual component alongside noise. In their formulation, the forward process transitions from a clean image to a degraded image plus noise, and the reverse process estimates both the residual (the difference between clean and degraded) and the noise.

How RDDM differs from BlurDM: The paper is careful to distinguish its approach from RDDM (Section 2.2):

"Although Liu et al. [17] proposed residual diffusion by computing the difference between sharp and blurred images using a subtraction operation, the blur formation process is inherently a convolutional process rather than a direct additive difference, making this approach insufficient for accurately capturing blur characteristics."

This is a subtle but important point. If blur were a simple additive residual, then subtracting the blurred image from the sharp image would give you the "blur map," and you could model this as a residual in the diffusion process. But motion blur is not additive — it's convolutional. A blurred pixel is a weighted average of multiple sharp pixels along the motion trajectory. The relationship between sharp and blurred images involves spatially varying kernels, not point-wise differences. Modeling blur as an additive residual captures the magnitude of the difference but misses the spatial structure — which pixels contributed to which blurred pixels, and along what trajectories.

BlurDM addresses this by modeling the blur accumulation process explicitly: the forward process doesn't just add a residual difference, it progressively integrates new image content along exposure trajectories (encoded in the blur residuals $e_t$), mimicking how a real camera accumulates light during exposure. The reverse process correspondingly "disentangles" this accumulation, undoing the exposure integration step by step.

How BlurDM Positions Itself

The paper positions BlurDM at the intersection of two design choices:

1. Latent-space prior generation (efficient, plug-and-play, compatible with any deblurring backbone), following the paradigm established by HI-Diff and DiffIR — but with a fundamentally different diffusion process.

2. Physically grounded diffusion dynamics that mirror the continuous exposure accumulation of motion blur, setting it apart from all prior diffusion-based deblurring methods (standard DDPM/DDIM-based approaches) and residual approaches (RDDM).

The key conceptual move is the dual diffusion formulation (Figure 1): at each forward step, the image receives not just Gaussian noise $\beta_t \epsilon_t$ (the standard diffusion component) but also a blur residual $\frac{1}{\alpha_t} e_t$ that represents newly accumulated blur from the extended exposure. The reverse process correspondingly estimates both the noise residual and the blur residual at each step, performing dual denoising and deblurring rather than denoising alone.

This formulation embeds the physics of blur accumulation into the model's inductive biases. The forward process now structurally resembles what happens in a real camera (progressive blur accumulation during exposure), and the reverse process structurally resembles the inverse operation (progressive sharpening by removing accumulated blur). The paper argues that this alignment between model dynamics and physical reality is what yields the consistent improvements across diverse backbones and datasets.

Importantly, BlurDM is not proposed as a standalone deblurring model. It is designed as a flexible prior generation network that can enhance existing deblurring methods. This modular design is strategic: it means the contributions (physical blur modeling within diffusion) are tested independently of any particular backbone architecture, and the consistent gains across four different backbones (MIMO-UNet, Stripformer, FFTformer, LoFormer) provide evidence that the benefit comes from the diffusion formulation itself, not from architectural choices in the deblurring network.

Summary of the Gap

To crystallize the motivation:

• Non-diffusion deblurring methods (CNN/Transformer regression) produce over-smoothed results because regression losses encourage the conditional mean, suppressing high-frequency details.

• Standard diffusion-based deblurring methods can produce rich details but treat diffusion as a generic mechanism, failing to encode the structured, convolutional nature of motion blur.

• RDDM takes a partial step toward modeling degradation structure but uses an additive residual formulation that doesn't capture the exposure integration process underlying motion blur.

BlurDM fills the gap by re-engineering the diffusion dynamics themselves to mirror blur formation physics. The forward process progressively integrates exposure (adding structured blur), and the reverse process progressively disentangles that integration (removing blur and noise jointly). This turns the diffusion model from a generic denoiser into a blur-aware generative process, and the paper's extensive experiments demonstrate that this physical inductive bias translates into consistent, transferable improvements in deblurring quality.

3. Technical Approach

3.1 Reader Orientation

This paper proposes BlurDM, a diffusion model specifically redesigned for image deblurring by embedding the physical process of motion blur formation directly into the diffusion dynamics. The core problem it solves is that standard diffusion models treat image degradation as isotropic noise, but motion blur is actually a structured, progressive accumulation of light during continuous camera exposure — so BlurDM replaces the standard "add noise only" forward process with a dual process that adds both noise AND blur residuals representing incremental exposure, then simultaneously removes both during reverse generation through dedicated blur and noise estimators.

3.2 Big-Picture Architecture (Diagram in Words)

The BlurDM system, as illustrated in Figure 2, operates in three stages and involves five main components arranged as a latent-space prior generator that enhances any existing deblurring network:

1. Sharp Encoder (SE): Takes a concatenation of the blurred image $B$ and its sharp ground truth $S$ as input (during training) and compresses them into a compact 1×1×C latent vector $Z_S$ — the "sharp prior" — which encodes what a properly deblurred image should look like.

2. Blur Encoder (BE): Structurally identical to SE but takes only the blurred image $B$ as input (deployable at test time when sharp images are unavailable) and produces a blurred latent $Z_B$ of the same shape, which serves as the starting point for the diffusion-based prior estimation.

3. BlurDM Core: The diffusion engine that takes the noisy-blurred latent $Z^B_T = Z_B + \bar{\beta}_T \epsilon$ (blurred latent plus terminal noise), and through $T$ reverse steps, jointly estimates and removes both noise residuals (via $\epsilon_\theta$) and blur residuals (via $e_\theta$) to produce the estimated sharp prior $Z^B_0$. This is where the dual denoising and deblurring happens.

4. Prior Fusion Module (PFM): A lightweight module (one MLP layer) that takes the estimated sharp prior $Z^B_0$ and generates channel-wise affine transformation parameters $(Z_{S,\alpha_i}, Z_{S,\beta_i})$ that modulate the decoder features $F_i$ at each scale of the deblurring backbone via $F'_i = Z_{S,\alpha_i} \times F_i + Z_{S,\beta_i}$, injecting the diffusion-learned prior into the reconstruction process.

5. Deblurring Backbone: Any existing deblurring network (MIMO-UNet, Stripformer, FFTformer, or LoFormer in the paper's experiments) that takes the blurred image $B$ as input, processes it through its encoder-decoder architecture, and produces the final deblurred output $O$ — with its decoder features modulated at each scale by the PFM using the BlurDM-generated prior.

Information flows through three training stages (Figure 2): Stage 1 pre-trains SE, PFM, and the backbone together using ground-truth sharp images to establish what an ideal sharp prior should look like and how it should modulate decoder features. Stage 2 freezes the backbone and SE, then trains BE and BlurDM to estimate the sharp prior $Z_S$ from $Z_B$ by minimizing the L1 distance $\|Z^B_0 - Z_S\|_1$ — this forces BlurDM to learn the dual denoising and deblurring operation in latent space, with gradients from this reconstruction loss backpropagating through all $T$ reverse steps to provide trajectory-level supervision without needing ground-truth blur residuals. Stage 3 jointly fine-tunes BE, BlurDM, PFM, and the backbone end-to-end using the backbone's original deblurring loss, allowing the estimated prior $Z^B_0$ to adapt specifically to the backbone's reconstruction needs. At inference, only BE, BlurDM, PFM, and the backbone are used — SE is not needed since sharp ground truths are unavailable.

3.3 Roadmap for the Deep Dive

Below I will unpack the approach in the following order, chosen to build understanding from physical foundations upward through the full system:

• The dual noise and blur forward process (Section 3.4.1) — This is the conceptual core: how does BlurDM model the progressive accumulation of motion blur during continuous exposure as a Markov diffusion chain? I will derive the transition kernel, show how it embeds blur residuals as deterministic mean shifts, and explain the reparameterization that yields a computationally efficient one-step sampling formula.

• The dual denoising and deblurring reverse process (Section 3.4.2) — Given the forward process that adds both noise and blur, what does the reverse process look like? I will derive the variational objective, show how it decomposes into separate noise and blur estimation losses, and explain the DDIM-inspired deterministic sampling formulation that enables efficient inference with only $T = 5$ steps.

• The latent-space formulation and architecture (Section 3.4.3) — How is the dual diffusion implemented in practice? I will detail the encoder architectures (SE and BE), the noise and blur residual estimators within BlurDM, the prior fusion mechanism (PFM), and the specific hyperparameters (number of layers, activation functions, diffusion steps, noise schedules).

• The three-stage training strategy (Section 3.4.4) — Why is a three-stage approach necessary, and what does each stage accomplish? I will walk through the training objectives, data flow, and loss functions for each stage, explaining the purpose of pretraining components separately before joint optimization and addressing why end-to-end training from scratch is suboptimal.

• Design choice rationale (Section 3.4.5) — A consolidated analysis of the key design decisions: why dual diffusion instead of noise-only or residual-only, why latent space instead of pixel space, why only 5 diffusion steps, why a plug-and-play prior generator instead of a standalone deblurring model, and how these choices trade off between physical fidelity, computational efficiency, and compatibility with existing methods.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a method paper whose core idea is replacing standard noise-only diffusion with a dual noise-and-blur diffusion process that mirrors the continuous exposure integration underlying motion blur formation, then using the resulting blur-aware latent representations as a plug-and-play prior to enhance any existing deblurring network.

---

3.4.1 The Dual Noise and Blur Forward Process

Physical Motivation and Mathematical Setup

The starting point for BlurDM's forward process is the physical model of motion blur formation during image capture. When a camera captures an image with exposure time $\alpha_T$, the sensor continuously accumulates photons from the scene. If either the camera or objects in the scene move during this exposure, each sensor pixel integrates light from multiple scene points along the motion trajectory. The resulting blurred image $B \in \mathbb{R}^{H \times W \times 3}$ can be expressed as:

$B = \frac{1}{\alpha_T} \int_{\tau=0}^{\alpha_T} H(\tau) \, d\tau$

where $H(\tau) \in \mathbb{R}^{H \times W \times 3}$ is the instantaneous scene radiance (the perfectly sharp image that would be captured with an infinitesimally short exposure) at continuous time $\tau$, and $\alpha_T$ is the total exposure duration. The integral averages all instantaneous frames $H(\tau)$ over the exposure window, which is what produces the characteristic directional smearing of motion blur — each pixel's final value is a weighted combination of multiple scene locations.

The paper contrasts this with a sharp image $I_0$, captured with a much shorter proper exposure time $\alpha_0$ where $\alpha_0 < \alpha_T$:

$I_0 = \frac{1}{\alpha_0} \int_{\tau=0}^{\alpha_0} H(\tau) \, d\tau$

Since $\alpha_0$ is short, there is minimal motion during this interval, so $I_0$ approximates a single instantaneous frame $H(0)$. The key observation is that the only difference between the sharp $I_0$ and the blurred $B$ is the exposure duration — if we could progressively increase the exposure time from $\alpha_0$ to $\alpha_T$, the image would transition from sharp to blurred as more motion trajectories get integrated.

The Forward Transition Step

BlurDM models this progressive transition as a Markov diffusion chain with $T$ steps. At each step $t$, the exposure time increases from $\alpha_{t-1}$ to $\alpha_t$, where $0 = \alpha_0 < \alpha_1 < \dots < \alpha_T$ (the paper uses a uniform spacing from 0 to 1). The image at step $t$, denoted $I_t$, represents the integrated radiance over $[0, \alpha_t]$, plus accumulated noise. The forward transition from $I_{t-1}$ to $I_t$ is defined as:

$I_t = \frac{\alpha_{t-1}}{\alpha_t} I_{t-1} + \frac{1}{\alpha_t} e_t + \beta_t \epsilon_t$

where:

• $\frac{\alpha_{t-1}}{\alpha_t}$ is a scaling factor that adjusts the contribution of the previous image $I_{t-1}$ (which integrated over $[0, \alpha_{t-1}]$) to the new longer exposure $\alpha_t$ — it reweights the old integration to account for the extended exposure window;
• $e_t = \int_{\tau=\alpha_{t-1}}^{\alpha_t} H(\tau) \, d\tau \in \mathbb{R}^{H \times W \times 3}$ is the blur residual — the new scene radiance accumulated during the additional exposure time from $\alpha_{t-1}$ to $\alpha_t$, which introduces new motion information into the image;
• $\beta_t$ is a noise scaling coefficient that controls how much Gaussian noise is added at this step;
• $\epsilon_t \sim \mathcal{N}(0, I)$ is standard Gaussian noise, injected at each step to maintain the stochastic nature of the diffusion process.

What this equation computes operationally: Starting from $I_{t-1}$ (an image with exposure up to $\alpha_{t-1}$ plus accumulated noise from previous steps), we produce $I_t$ (an image with exposure up to $\alpha_t$ plus updated noise) by: (1) rescaling the old image to account for the longer exposure window; (2) adding the new scene content captured during the extended exposure interval (the blur residual $e_t$), which introduces additional motion blur; and (3) injecting fresh Gaussian noise scaled by $\beta_t$. This is the dual diffusion operation — both blur AND noise are added at each step.

Why this form instead of alternatives: A standard DDPM forward step would be $I_t = \sqrt{1 - \beta_t} I_{t-1} + \beta_t \epsilon_t$, which only adds noise without any structured degradation. The RDDM approach would model the difference between blurred and sharp images as an additive residual, i.e., $I_t = I_{t-1} + \text{residual}_t + \beta_t \epsilon_t$. But motion blur is not additive — it involves convolutional mixing of pixels along motion trajectories. BlurDM's formulation captures this through the integral-based blur residual $e_t$, which represents the physical accumulation of new scene radiance during extended exposure. The scaling factor $\frac{\alpha_{t-1}}{\alpha_t}$ is crucial because when the exposure window expands, the contribution of old content should be re-weighted relative to the new content — a detail that additive residual formulations miss.

The Transition Distribution

Equation (3) defines a Gaussian transition distribution because $\epsilon_t$ is the only random variable (the blur residual $e_t$ is deterministic for a given scene):

$q(I_t \mid I_{t-1}, e_t) = \mathcal{N}\left(I_t; \frac{\alpha_{t-1}}{\alpha_t} I_{t-1} + \frac{1}{\alpha_t} e_t, \beta_t^2 I\right)$

where:

• $q(I_t \mid I_{t-1}, e_t)$ is the conditional probability density of $I_t$ given the previous image and the current blur residual;
• The mean is $\frac{\alpha_{t-1}}{\alpha_t} I_{t-1} + \frac{1}{\alpha_t} e_t$, which is a deterministic shift from $I_{t-1}$ by the rescaled blur residual;
• The variance is $\beta_t^2 I$, representing isotropic Gaussian noise with per-step scale $\beta_t$.

What this distribution represents: At each forward step, the image $I_t$ is drawn from a Gaussian centered at the deterministic blur-and-rescaling transformation of $I_{t-1}$, with variance $\beta_t^2$. The blur residual $e_t$ acts as a mean shift — it deterministically moves the center of the Gaussian to incorporate new exposure information, while the noise adds stochastic variation around that shifted mean. This is fundamentally different from standard diffusion, where the mean is simply a scaled version of the previous image with no structured shift.

The Full Forward Chain

By iterating this transition kernel $T$ times, we generate a sequence $\{I_1, I_2, \dots, I_T\}$ of progressively more blurred and noisy images. The joint distribution over the entire chain is:

$q(I_{1:T} \mid I_0, e_{1:T}) = \prod_{t=1}^T q(I_t \mid I_{t-1}, e_t)$

where $I_{1:T}$ denotes the sequence of all intermediate images and $e_{1:T}$ denotes all blur residuals. This is a standard Markov factorization: each image depends only on the immediately previous image and the current blur residual, not on earlier history.

The Critical Reparameterization (One-Step Sampling)

The forward chain defined above requires sequential computation through all $T$ steps. However, the paper derives a crucial reparameterization (detailed in Appendix A.1) that collapses the entire forward process into a single Gaussian transition from $I_0$ to $I_T$, analogous to how DDPM reparameterizes its forward process. The derivation proceeds by recursively substituting the transition equation:

$I_T = \frac{\alpha_0}{\alpha_T} I_0 + \frac{1}{\alpha_T} \sum_{t=1}^T e_t + \sum_{t=1}^T \frac{\alpha_t}{\alpha_T} \beta_t \epsilon_t$

The first term $\frac{\alpha_0}{\alpha_T} I_0$ is the rescaled initial sharp image. The second term $\frac{1}{\alpha_T} \sum_{t=1}^T e_t$ is the sum of all blur residuals accumulated across all steps, reweighted by the final exposure time — this represents the total blur added over the entire forward process. The third term is a weighted sum of independent Gaussian noise variables, which is itself Gaussian with zero mean and variance:

$\bar{\beta}_T^2 = \sum_{t=1}^T \left(\frac{\alpha_t}{\alpha_T}\right)^2 \beta_t^2$

Therefore, we can reparameterize the noise sum as $\bar{\beta}_T \epsilon$ where $\epsilon \sim \mathcal{N}(0, I)$.

Crucially, the combination of the initial image and all blur residuals simplifies to the fully blurred image:

$\frac{\alpha_0}{\alpha_T} I_0 + \frac{1}{\alpha_T} \sum_{t=1}^T e_t = \frac{1}{\alpha_T} \int_0^{\alpha_T} H(\tau) \, d\tau = B$

The first equality follows from the definitions of $I_0$ (integral over $[0, \alpha_0]$) and each $e_t$ (integral over $[\alpha_{t-1}, \alpha_t]$) — the sum of all these non-overlapping integrals covers the full exposure window $[0, \alpha_T]$. The second equality is just the definition of the blurred image $B$.

Putting this together yields the one-step sampling formula:

$I_T = B + \bar{\beta}_T \epsilon$

with the marginal distribution:

$q(I_T \mid I_0, e_{1:T}) = \mathcal{N}\left(I_T; B, \bar{\beta}_T^2 I\right)$

where:

• $B$ is the fully blurred input image (the physical blur accumulated over the total exposure $\alpha_T$);
• $\bar{\beta}_T$ is the accumulated noise standard deviation across all $T$ steps;
• $\epsilon \sim \mathcal{N}(0, I)$ is a single standard Gaussian noise sample.

What this enables: Rather than simulating $T$ sequential forward steps, we can generate the terminal state $I_T$ in a single operation by simply taking the blurred input image $B$ and adding Gaussian noise with variance $\bar{\beta}_T^2$. This is both computationally efficient and theoretically important: it means BlurDM's forward process terminates at a Gaussian centered on the observed blurred image, not at pure noise. The model never needs to generate the blurred image from scratch — it starts from the observed blurry input (plus noise) and sharpens it through the reverse process. This is what makes BlurDM a conditional generation model rather than an unconditional one, and it is why the approach works in the deblurring setting where the blurred image is always available as conditioning.

Why this form matters: The terminal distribution $\mathcal{N}(B, \bar{\beta}_T^2 I)$ explicitly encodes the relationship between the forward process and the physical blur formation. The mean of the terminal distribution is the blurred image $B$, not zero (as in standard diffusion) — this is the key "inductive bias" that tells the model that the forward degradation converges to a blurred observation, not to noise. The variance $\bar{\beta}_T^2$ controls how much stochasticity remains, which affects the diversity of generated sharp images in the reverse process. By making $\bar{\beta}_T$ small enough (controlled through the noise schedule $\beta_t$), the model can focus on recovering a specific sharp image rather than exploring a broad distribution of possibilities.

Practical hyperparameters: The paper empirically sets $T = 5$ diffusion steps (examined more thoroughly in the ablation study of Figure 7, which tests $T \in \{0, 1, 2, 4, 5, 6, 8, 10\}$ and finds peak performance at $T = 5$). The noise schedule uses $\beta_{1:T}$ increasing uniformly from 0 to 0.02 across the steps, and the exposure times $\alpha_{0:T}$ increasing uniformly from 0 to 1 (so $\alpha_0 = 0$, $\alpha_5 = 1$, and intermediate values are equally spaced). The small number of steps is possible because BlurDM operates in a compact latent space rather than pixel space, and because the forward process has a clear physical interpretation that makes each step meaningful. This is a major efficiency advantage over pixel-space diffusion models that require hundreds or thousands of steps.

---

3.4.2 The Dual Denoising and Deblurring Reverse Process

The Reverse Generation Objective

The goal of the reverse process is to recover the sharp image $I_0$ from the terminal state $I_T = B + \bar{\beta}_T \epsilon$. Unlike standard diffusion models that start from pure Gaussian noise $\mathcal{N}(0, I)$, BlurDM starts from a noisy version of the observed blurred image. At each reverse step $t$, the model must estimate and remove two components: the noise residual $\epsilon_t$ and the blur residual $e_t$. This dual estimation is the defining characteristic of the reverse process.

The paper formulates the reverse process through a variational inference framework, deriving an evidence lower bound (ELBO) on the log-likelihood of the sharp image. The derivation follows the standard DDPM approach (Appendix A.2) but must account for the blur residual terms $e_{1:T}$ that appear in the forward process. The key insight is that the reverse transition distribution can be expressed as conditioning on a predicted clean image $I_0^\theta$ and the estimated blur residuals $e_{1:t}^\theta$:

$p_\theta(I_{t-1} \mid I_t) = q_\sigma(I_{t-1} \mid I_t, I_0^\theta, e_{1:t}^\theta)$

where $\theta$ denotes the learned parameters and the predicted sharp image is:

$I_0^\theta = \frac{\alpha_t}{\alpha_0} I_t - \frac{1}{\alpha_0} \sum_{i=1}^t e_i^\theta - \frac{\alpha_t}{\alpha_0} \bar{\beta}_t \epsilon^\theta$

What this equation computes: Given the current noisy-and-blurred image $I_t$ at reverse step $t$, we estimate what the fully sharp image $I_0$ would have been by: (1) rescaling $I_t$ to remove the exposure time weighting; (2) subtracting all accumulated blur residuals $\sum_{i=1}^t e_i^\theta$ estimated up to this point, which undoes the exposure integration; and (3) subtracting the accumulated noise $\bar{\beta}_t \epsilon^\theta$ estimated so far, which undoes the noise corruption. This is an analytic inversion of the forward process — if the blur and noise estimates are perfect, $I_0^\theta$ exactly recovers the sharp image.

The Reverse Transition Distribution

The paper adopts the DDIM deterministic sampling formulation (Song et al., 2021), which sets the variance of the reverse transition to zero (i.e., $\eta = 0$ in the DDIM parameterization) to enable a fully deterministic reverse process with a small number of steps. The reverse transition from $I_t$ to $I_{t-1}$ is:

$q_\sigma(I_{t-1} \mid I_t, I_0^\theta, e_{1:t}^\theta) = \mathcal{N}\left(I_{t-1}; \mu_{t-1}, \sigma_t^2 I\right)$

where the mean $\mu_{t-1}$ is:

$\mu_{t-1} = \frac{\alpha_0}{\alpha_{t-1}} I_0^\theta + \frac{1}{\alpha_{t-1}} \sum_{i=1}^{t-1} e_i^\theta + \sqrt{\bar{\beta}_{t-1}^2 - \sigma_t^2} \cdot \frac{I_t - \left(\frac{\alpha_0}{\alpha_t} I_0^\theta + \frac{1}{\alpha_t} \sum_{i=1}^t e_i^\theta\right)}{\bar{\beta}_t}$

and the variance is:

$\sigma_t^2 = \eta \cdot \frac{\beta_t^2 \bar{\beta}_{t-1}^2}{\bar{\beta}_t^2}$

When $\eta = 0$ (deterministic sampling), $\sigma_t^2 = 0$ and the $\sqrt{\bar{\beta}_{t-1}^2 - \sigma_t^2}$ term simplifies to $\bar{\beta}_{t-1}$.

What this distribution represents: The reverse step samples $I_{t-1}$ from a Gaussian centered at a specific location: the predicted sharp image $I_0^\theta$ re-blurred up to exposure $\alpha_{t-1}$ (first two terms), plus a correction term (third term) that accounts for the discrepancy between the current $I_t$ and what it would have been if $I_0^\theta$ were the true sharp image. The correction term is essentially the difference between the observed $I_t$ and the predicted $I_t^\theta$ (from the blur-and-noise forward model applied to $I_0^\theta$), scaled by the ratio of noise levels to determine how much of that discrepancy should be attributed to errors in the blur/noise estimates at step $t$ specifically.

The Deterministic Sampling Formula

When $\eta = 0$, the reverse transition simplifies to a deterministic update rule (Appendix A.3):

$I_{t-1} = \frac{\alpha_t}{\alpha_{t-1}} I_t - \frac{1}{\alpha_{t-1}} e^\theta(I_t, t, B) - \left(\frac{\alpha_t \bar{\beta}_t}{\alpha_{t-1}} - \bar{\beta}_{t-1}\right) \epsilon^\theta(I_t, t, B)$

where:

• $e^\theta(I_t, t, B)$ is the blur residual estimator — a neural network that takes the current image $I_t$, the time step $t$, and the blurred input $B$ as conditioning, and predicts the blur residual $e_t$ that was added at this forward step;
• $\epsilon^\theta(I_t, t, B)$ is the noise residual estimator — a neural network with the same inputs that predicts the noise $\epsilon_t$ added at this forward step.

What this equation computes operationally: To go from $I_t$ to $I_{t-1}$ (one reverse step toward sharpness), we: (1) rescale $I_t$ by $\frac{\alpha_t}{\alpha_{t-1}}$ (increasing its magnitude since $\alpha_t > \alpha_{t-1}$); (2) subtract the estimated blur residual $e^\theta$ scaled by $\frac{1}{\alpha_{t-1}}$, which removes the new motion content that was integrated during the $[\alpha_{t-1}, \alpha_t]$ exposure interval in the forward process; and (3) subtract the estimated noise $\epsilon^\theta$ scaled by a coefficient that depends on the noise schedule, which removes the noise added at step $t$. This is the dual denoising and deblurring operation — two different types of corruption are simultaneously estimated and removed.

Why this form matters: The reverse step explicitly separates the two degradation components. The blur residual term $-\frac{1}{\alpha_{t-1}} e^\theta$ undoes the structured, physics-based degradation, while the noise term $-\left(\frac{\alpha_t \bar{\beta}_t}{\alpha_{t-1}} - \bar{\beta}_{t-1}\right) \epsilon^\theta$ undoes the stochastic Gaussian corruption. In standard diffusion, there is only the noise term because there is no structured degradation. In RDDM, there would be a single residual term that mixes blur and noise effects. BlurDM's separation is physically motivated: the blur residuals represent the scene's motion during exposure, while the noise represents sensor and photon noise — these are distinct physical phenomena, and estimating them separately allows each estimator to specialize.

The Training Objective

The ELBO derivation (Appendix A.2) shows that, with matched Gaussian variances, the KL divergence terms in the variational bound reduce to mean squared errors between the true and estimated residuals. This yields two loss terms:

$L_{e_t}(\theta) = \mathbb{E}\left[\lambda_e \|e_t - e^\theta(I_t, t, B)\|^2\right]$

$L_{\epsilon}(\theta) = \mathbb{E}\left[\lambda_\epsilon \|\epsilon - \epsilon^\theta(I_t, t, B)\|^2\right]$

where $\lambda_e$ and $\lambda_\epsilon$ are weighting coefficients, and the expectation is over the forward process (sampling $t$, $I_t$, and the true residuals).

What these losses compute: Each is a simple L2 regression between the true residual ($e_t$ or $\epsilon$) and the model's prediction at step $t$. The blur estimator learns to predict what new motion content was integrated during a specific exposure interval. The noise estimator learns to predict what Gaussian noise was injected at a specific step.

The critical practical challenge: Deblurring datasets (GoPro, HIDE, RealBlur) provide only blurred-sharp image pairs $(B, I_0)$, not the per-step blur residuals $e_t$. There is no ground truth for what the image looked like at intermediate exposure times $\alpha_t$, and therefore no ground truth for $e_t = \int_{\alpha_{t-1}}^{\alpha_t} H(\tau) d\tau$. This means the per-step losses $L_{e_t}$ and $L_\epsilon$ cannot be directly computed.

The solution — trajectory-level supervision: The paper circumvents this by supervising only the final reconstruction, not the intermediate steps. Specifically, the model is trained with:

$L_{\text{rec}} = \|I_0^\theta - I_0\|$

where $I_0^\theta$ is obtained by unrolling the full reverse process from $I_T = B + \bar{\beta}_T \epsilon$ through all $T$ steps:

$I_0^\theta = g_1^\theta \circ g_2^\theta \circ \cdots \circ g_T^\theta(I_T)$

Here $g_t^\theta$ is the reverse step operator at time $t$, which applies the deterministic update rule (Equation 10) using the shared blur and noise estimators parameterized by $\theta$. The operator $g_t^\theta$ takes $I_t$ as input and outputs $I_{t-1}$.

Why trajectory-level supervision works: When backpropagating the gradient of $L_{\text{rec}}$ through the unrolled computation graph, each reverse step receives gradient signals that reflect its contribution to the final reconstruction error. If a particular step's blur or noise estimate is poor, $I_0^\theta$ will deviate from $I_0$, and the gradient will update that step's estimators accordingly. This is amortized trajectory-level optimization — the model learns to produce useful per-step estimates even without per-step ground truth, because the end-to-end feedback propagates through the entire chain.

This technique is inspired by prior work on diffusion model distillation (Salimans and Ho, 2022; Geng et al., 2025) and has been used in prior deblurring diffusion methods like HI-Diff and DiffIR. The paper cites these works explicitly (Section 3.3 and Appendix A.2): "Recent studies [4, 8, 35, 47] reveal that supervision on the final output can effectively influence the entire diffusion trajectory."

The complete reverse sampling algorithm proceeds as follows, given a blurred input image $B$:

1. Sample the terminal state: $I_T = B + \bar{\beta}_T \epsilon$ where $\epsilon \sim \mathcal{N}(0, I)$.
2. For $t = T, T-1, \dots, 1$:
   • Compute the blur residual estimate: $\hat{e}_t = e^\theta(I_t, t, B)$
   • Compute the noise estimate: $\hat{\epsilon}_t = \epsilon^\theta(I_t, t, B)$
   • Apply the deterministic update: $I_{t-1} = \frac{\alpha_t}{\alpha_{t-1}} I_t - \frac{1}{\alpha_{t-1}} \hat{e}_t - \left(\frac{\alpha_t \bar{\beta}_t}{\alpha_{t-1}} - \bar{\beta}_{t-1}\right) \hat{\epsilon}_t$
3. Output $I_0$ as the final deblurred (sharp) image.

With $T = 5$ steps, this requires only 5 sequential evaluations of the blur and noise estimators, making it computationally efficient compared to the hundreds of steps used in pixel-space diffusion models.

---

3.4.3 Latent-Space Formulation and Architecture

Why Operate in Latent Space?

The dual noise and blur diffusion process described above operates in the pixel space of images $I_t \in \mathbb{R}^{H \times W \times 3}$. However, the paper implements BlurDM in a compressed latent space rather than directly on pixels. There are two primary motivations for this design choice:

1. Computational efficiency: Pixel-space diffusion on high-resolution images (typical deblurring inputs are 256×256 or larger) would require substantial computation for each reverse step, and the $T=5$ steps (while already small) would each operate on large tensors. A compact latent representation dramatically reduces FLOPs and memory.

2. Integration with deblurring backbones: The paper's goal is not to build a standalone deblurring model but to create a prior generator that enhances existing deblurring networks. Operating in latent space means BlurDM produces a compact conditioning signal (a 1×1×C vector) that can be injected into any backbone's decoder through a simple modulation mechanism, making the approach architecture-agnostic.

The paper provides a theoretical justification for latent-space operation in Appendix A.4. Using a first-order Taylor expansion of an encoder $E(\cdot)$ around $I_{t-1}$, the authors show that:

$z_t \approx \frac{\alpha_{t-1}}{\alpha_t} z_{t-1} + \frac{1}{\alpha_t} e_t^\theta + \beta_t \epsilon_t^\theta$

where $z_t = E(I_t)$ is the latent representation, $e_t^\theta = J_E(I_{t-1}) e_t$ is the image-space blur residual projected into latent space through the Jacobian $J_E$, and similarly $\epsilon_t^\theta = J_E(I_{t-1}) \epsilon_t$ is the projected noise. The key insight: when exposure increments are small ($\frac{\alpha_{t-1}}{\alpha_t} \approx 1$), the latent-space dynamics have the same form as the image-space dynamics — blur residuals and noise residuals are projected with the same coefficients. This justifies learning the estimators $e^\theta$ and $\epsilon^\theta$ directly in latent space.

The Sharp Encoder (SE) and Blur Encoder (BE)

These two encoders have identical architectures but serve different roles and receive different inputs. Their architecture, shown in Figure 3(a), consists of:

• 6 residual blocks with Conv3×3, LeakyReLU, and Conv3×3 layers — these extract multi-scale features from the input image(s) through repeated convolution and nonlinearity, with skip connections preserving gradient flow.
• 4 CNN layers with Conv3×3 and LeakyReLU — these further compress spatial information.
• Average pooling followed by Conv3×3 with LeakyReLU (repeated 3 times) — these progressively reduce spatial resolution.
• Pixel-Unshuffle operation — this rearranges spatial pixels into channel dimensions, trading spatial resolution for channel depth while preserving all information.
• 2 MLP layers (Linear → LeakyReLU, repeated twice) — these project the flattened features into the final compact latent vector.

The output of both encoders is a vector $Z \in \mathbb{R}^{1 \times 1 \times C}$, where $C$ is the latent channel dimension. The 1×1 spatial dimensions mean this is a global descriptor — a single vector that summarizes the entire image. The paper does not specify the exact value of $C$, but it is determined by the channel dimensions of the deblurring backbone's decoder (since the prior must match the decoder feature channels for modulation).

Sharp Encoder (SE): Takes as input the concatenation of the blurred image $B$ and the sharp ground truth $S$ along the channel dimension: $Z_S = \text{SE}(\text{Concat}(B, S))$. This produces the sharp prior $Z_S$, which encodes the information needed to transform $B$ into $S$. During Stage 1 training (where ground truth is available), $Z_S$ serves as the target that BlurDM must learn to estimate from $B$ alone.

Blur Encoder (BE): Takes as input only the blurred image $B$: $Z_B = \text{BE}(B)$. This produces the blurred latent $Z_B$, which serves as the starting point for the diffusion process. At test time, only BE is used (SE is unavailable since we don't have sharp ground truths).

The BlurDM Core: Noise and Blur Residual Estimators

The diffusion process operates on latents $Z_t^B \in \mathbb{R}^{1 \times 1 \times C}$. The forward process terminal state is:

$Z_T^B = Z_B + \bar{\beta}_T \epsilon$

where $\epsilon \sim \mathcal{N}(0, I)$ and $Z_B = \text{BE}(B)$. This is the direct latent-space analogue of Equation (7) — the blurred image's latent $Z_B$ (which encodes the fully blurred state) has Gaussian noise added to create the initial state for reverse diffusion.

The reverse process iteratively produces $Z_{T-1}^B, Z_{T-2}^B, \dots, Z_0^B$ using the latent-space version of the deterministic update rule (Equation 12):

$Z_{t-1}^B = \frac{\alpha_t}{\alpha_{t-1}} Z_t^B - \frac{1}{\alpha_{t-1}} e^\theta(Z_t^B, t, Z_B) - \left(\frac{\alpha_t \bar{\beta}_t}{\alpha_{t-1}} - \bar{\beta}_{t-1}\right) \epsilon^\theta(Z_t^B, t, Z_B)$

where $Z_0^B$ is the estimated sharp prior — BlurDM's prediction of what $Z_S$ would be given only $Z_B$.

The noise estimator $\epsilon^\theta$ and blur estimator $e^\theta$ are implemented as two separate MLPs with identical architectures, shown in Figure 3(b):

• Each takes three inputs that are concatenated: the current latent $Z_t^B$, a time embedding of step $t$, and the conditioning latent $Z_B$ (the blurred image's encoding, which provides global context about what the final blurred state looks like).
• Each consists of 6 MLP layers (Linear → LeakyReLU, repeated 6 times).
• Each outputs a vector of the same dimension as $Z_t^B$ ($1 \times 1 \times C$), representing the estimated residual (noise or blur) for the current step.

The time step $t$ is encoded using a standard sinusoidal positional embedding (or a learned embedding — the paper doesn't specify the exact mechanism but this is standard practice in diffusion models) and expanded to match the latent dimension before concatenation. The conditioning latent $Z_B$ is concatenated as a constant input across all steps, ensuring the estimators always have access to the fully blurred state as reference.

Why separate estimators instead of a single unified one? The paper's ablation study (Table 2) explicitly tests this: "Net2" (noise-only, standard DDPM-style) improves PSNR from 31.78 to 31.91; "Net3" (blur-only, no noise estimation) improves to 32.20; "Net4" (both, full BlurDM) achieves 32.28. The complementary gains demonstrate that noise and blur represent different types of corruption that benefit from specialized estimation. A single unified estimator would need to disentangle these two components internally — the explicit separation provides an inductive bias that simplifies the learning problem.

The Prior Fusion Module (PFM)

Once BlurDM produces the estimated sharp prior $Z_0^B$, this compact latent vector must be used to influence the deblurring backbone's reconstruction. The Prior Fusion Module (PFM), shown in Figure 3(c), implements a simple but effective channel-wise modulation mechanism:

Given the prior $Z_0^B \in \mathbb{R}^{1 \times 1 \times C}$ and a decoder feature map $F_i \in \mathbb{R}^{h_i \times w_i \times c_i}$ at scale $i$ of the backbone's decoder:

1. A linear layer maps $Z_0^B$ (dimension $C$) to two vectors of dimension $c_i$: scaling parameters $Z_{S,\alpha_i}$ and bias parameters $Z_{S,\beta_i}$. These are channel-wise affine transformation parameters — each channel of the feature map gets its own scale and bias.
2. The modulation is applied as:

$F_i' = Z_{S,\alpha_i} \times F_i + Z_{S,\beta_i}$

where $\times$ denotes channel-wise multiplication (broadcast across spatial dimensions) and $+$ denotes channel-wise addition.

What this operation does: For each channel of the feature map, the PFM learns to amplify or suppress its activation (via $Z_{S,\alpha_i}$) and shift its baseline (via $Z_{S,\beta_i}$). The parameters are predicted from the global prior $Z_0^B$, so the modulation is content-dependent — different regions of the image may need different levels of sharpening or texture enhancement, and the global context encoded in $Z_0^B$ determines the appropriate per-channel adjustments. This is a form of feature-wise transformation, similar to FiLM (Feature-wise Linear Modulation) layers used in conditional image generation, but applied specifically to inject deblurring priors.

Why this mechanism instead of concatenation or attention? Simple concatenation of the prior with decoder features would require the backbone to learn how to use the prior from scratch, potentially requiring architectural changes and additional parameters. Cross-attention between decoder features and the prior would be more expressive but computationally expensive, especially at high spatial resolutions. Channel-wise modulation is lightweight (one linear layer per decoder scale), architecture-agnostic (it can be inserted into any decoder without modifying its internal structure), and effective (the affine parameters provide sufficient degrees of freedom to adapt feature representations based on the prior). The paper's consistent gains across four different backbones with very different decoder architectures (CNN-based MIMO-UNet, attention-based Stripformer and FFTformer, frequency-domain LoFormer) validate this design choice.

Integration with the Deblurring Backbone

The PFM is applied at multiple scales of the deblurring backbone's decoder. For a typical U-Net-style architecture with $N$ decoder levels, there are $N$ feature maps $F_1, F_2, \dots, F_N$ at progressively increasing spatial resolutions. The PFM generates a separate set of affine parameters $(Z_{S,\alpha_i}, Z_{S,\beta_i})$ for each scale $i$, using a separate linear projection from the shared prior $Z_0^B$. This means the same global prior vector can influence features at different resolutions in different ways — e.g., it might enhance high-frequency texture channels at fine resolutions while adjusting global contrast at coarse resolutions.

The modulated features $F_i'$ then continue through the normal decoder processing. The rest of the backbone operates exactly as in its original design — BlurDM does not modify the backbone's architecture, only injects the prior through these modulation points.

Computational Overhead

Table 4 quantifies the computational cost of adding BlurDM to each backbone, measured on 256×256 images with an NVIDIA RTX 3090:

The added FLOPs are remarkably consistent at ~4.16G across all backbones — this is because the BlurDM components (BE, BlurDM, PFM) are the same regardless of backbone architecture. The parameter increase varies (2.18M to 4.62M) because the PFM's linear layers must match the channel dimensions of each backbone's decoder, which differ across architectures. The inference time increase ranges from 6ms to 11ms, representing a 6-35% relative increase depending on the backbone's baseline speed.

---

3.4.4 The Three-Stage Training Strategy

BlurDM cannot be trained end-to-end from scratch because the components have different objectives and dependencies. The paper adopts a three-stage curriculum that progressively builds the system's capabilities, illustrated in Figure 2.

Stage 1: Pre-training the Sharp Prior and Deblurring Backbone

Objective: Establish what an ideal sharp prior $Z_S$ should look like and how it should modulate decoder features for optimal deblurring, using ground-truth sharp images for supervision.

Setup: The Sharp Encoder (SE), Prior Fusion Module (PFM), and the deblurring backbone are trained jointly. The Blur Encoder (BE) and BlurDM are not involved in this stage.

Data flow:

1. The blurred image $B$ and sharp ground truth $S$ are concatenated along the channel dimension and fed into SE.
2. SE outputs the sharp prior $Z_S = \text{SE}(\text{Concat}(B, S)) \in \mathbb{R}^{1 \times 1 \times C}$.
3. $Z_S$ is passed to PFM, which generates per-scale affine parameters $(Z_{S,\alpha_i}, Z_{S,\beta_i})$ for each decoder level of the backbone.
4. Simultaneously, $B$ is fed into the deblurring backbone's encoder.
5. At each decoder level $i$, the feature map $F_i$ is modulated to $F_i' = Z_{S,\alpha_i} \times F_i + Z_{S,\beta_i}$.
6. The backbone's decoder produces the deblurred output $O$.
7. $O$ is supervised against $S$ using the backbone's original loss function (e.g., L1 loss, Charbonnier loss, or a combination — the paper uses whatever loss the backbone was originally designed with, to ensure fair comparison).

What this stage accomplishes: The SE learns to encode the transformation from blurred to sharp into a compact latent code. The PFM learns how to translate that latent code into effective feature modulations. The backbone learns to produce sharp images when given an oracle prior (since $Z_S$ is computed from the ground-truth sharp image). This establishes an upper bound on what BlurDM could achieve with a perfect prior — Table 6 shows that "Net2" (Stage 1 only, oracle prior) achieves 32.69 dB PSNR, substantially above the baseline 31.78 dB.

Loss function: $L_{\text{Stage1}} = L_{\text{backbone}}(O, S)$, where $L_{\text{backbone}}$ is the original loss of the deblurring model (typically L1 or Charbonnier).

Stage 2: Training BlurDM to Estimate the Sharp Prior

Objective: Train the Blur Encoder (BE) and BlurDM to estimate the sharp prior $Z_S$ from only the blurred image $B$, without access to the ground-truth sharp image during inference.

Setup: The backbone and Sharp Encoder (SE) are frozen (their weights from Stage 1 are kept fixed). BE and BlurDM are trained from scratch. The frozen SE serves as the target: BE and BlurDM must learn to produce $Z_0^B$ that matches $Z_S = \text{SE}(\text{Concat}(B, S))$.

Data flow:

1. The blurred image $B$ is fed into the Blur Encoder to obtain $Z_B = \text{BE}(B)$.
2. The forward diffusion terminal state is computed: $Z_T^B = Z_B + \bar{\beta}_T \epsilon$ where $\epsilon \sim \mathcal{N}(0, I)$.
3. The reverse process runs for $T$ steps using Equation (12), producing $Z_0^B$.
4. In parallel (not for training BE/BlurDM, but for computing the target), the frozen SE processes $\text{Concat}(B, S)$ to produce the target sharp prior $Z_S$.
5. The L1 loss between estimated and target priors is minimized: $L_{\text{prior}} = \|Z_0^B - Z_S\|_1$.

What this stage accomplishes: BlurDM learns to perform the dual denoising and deblurring operation in latent space: starting from the noisy blurred latent $Z_T^B$, it must iteratively remove both noise and blur residuals to recover $Z_0^B$, which should approximate $Z_S$. The blur and noise estimators ($e^\theta$ and $\epsilon^\theta$) are trained to produce useful intermediate estimates, even without per-step ground truth, because $L_{\text{prior}}$ backpropagates through the entire unrolled computation graph of $T$ reverse steps.

This is the key stage where the physics of blur formation is actually learned. The forward process from $Z_B$ to $Z_T^B$ adds noise according to the same schedule that, in image space, corresponds to progressive exposure accumulation. The reverse process must learn to invert this, which requires internalizing the relationship between blur residuals (structured, exposure-dependent) and noise (stochastic, independent). The estimators are forced to separate these components because the loss only supervises the final output — if the estimators conflate blur and noise, the accumulated errors over $T$ steps will produce a $Z_0^B$ that differs from $Z_S$.

Why freeze SE and the backbone? If the backbone were trained jointly in this stage, it could adapt to imperfect priors, which would reduce the pressure on BlurDM to produce accurate estimates. Freezing creates a fixed target, forcing BlurDM to match the oracle prior quality established in Stage 1. This is analogous to training a student model to match a teacher's representations in knowledge distillation.

Why L1 loss? The paper uses $\|\cdot\|_1$ (mean absolute error) rather than L2 (mean squared error) for the prior matching loss. L1 loss is more robust to outliers and encourages sparser error patterns, which may be beneficial when the prior is a compact latent code where individual dimensions could have different importance.

Stage 3: Joint Fine-tuning

Objective: Adapt the Stage 2 prior estimator to work optimally with the deblurring backbone for the final reconstruction task, allowing the backbone to compensate for any remaining imperfections in the estimated prior.

Setup: All components — BE, BlurDM, PFM, and the deblurring backbone — are jointly fine-tuned. The Sharp Encoder (SE) is no longer needed since supervision comes from the backbone's deblurring loss. The weights from Stage 1 (PFM and backbone) and Stage 2 (BE and BlurDM) serve as initialization.

Data flow:

1. The blurred image $B$ passes through the full pipeline: $B \to \text{BE} \to Z_B \to \text{BlurDM forward} \to Z_T^B \to \text{BlurDM reverse} \to Z_0^B \to \text{PFM} \to \text{modulated features} \to \text{backbone decoder} \to O$.
2. The output $O$ is supervised against $S$ using the backbone's original loss.
3. Gradients flow through the entire pipeline, including back through BlurDM's reverse steps to the blur and noise estimators.

What this stage accomplishes: While Stage 2 forced BlurDM to match the oracle prior exactly, Stage 3 allows for task-specific adaptation. The backbone might prefer a slightly different prior than the oracle $Z_S$ if that leads to better final reconstruction — for example, the prior might learn to emphasize certain features that the backbone's decoder finds easier to use, or might compensate for limitations in the backbone's architecture. The joint optimization lets BlurDM and the backbone co-adapt, which typically yields better end-task performance than keeping them separate.

Additionally, this stage allows the PFM to be updated — its linear layers from Stage 1 were optimized for the oracle prior $Z_S$, but $Z_0^B$ from Stage 2 may have slightly different statistical properties (e.g., different variance, different correlation structure across dimensions). Fine-tuning PFM adapts it to the actual distribution of BlurDM outputs.

Loss function: $L_{\text{Stage3}} = L_{\text{backbone}}(O, S)$, the same as Stage 1.

Training Settings and Hyperparameters

The paper states in Section 4.1: "The overall framework (Third Stage) is optimized using the default training settings of each deblurring model, including learning rate, number of epochs, batch size, optimizer, etc., to ensure fair comparisons." This means BlurDM does not introduce new training hyperparameters — it inherits whatever settings the backbone originally used. This is a deliberate design choice to isolate the effect of the diffusion prior: any improvement must come from the prior itself, not from hyperparameter tuning.

The ablation on training epochs in Appendix A.5 (Table 7) provides specific numbers for MIMO-UNet on GoPro:

• Baseline 1: 3,000 epochs, 66.7 hours, 32.44 dB
• Baseline 2: 6,000 epochs, 133.4 hours, 32.51 dB (doubling epochs yields marginal +0.07 dB gain)
• BlurDM 3 (final): Stage 1 for 3,000 epochs + Stage 2 for 500 epochs + Stage 3 for 3,000 epochs, total 141.4 hours, 32.93 dB

The key takeaway from this ablation: the 8% increase in training time (141.4 vs. 133.4 hours compared to Baseline 2) yields a substantial 0.42 dB improvement, validating that the gains come from the method rather than simply from more training.

Why three stages instead of end-to-end from scratch?

The paper's ablation in Table 6 directly addresses this. "Net6" (full three-stage training) achieves 32.28 dB PSNR, compared to:

• "Net3" (joint training without pretraining): 31.80 dB — barely above the 31.78 dB baseline
• "Net4" (Stage 1 + Stage 2 only, no Stage 3): 32.01 dB
• "Net5" (Stage 1 + Stage 3 only, no Stage 2): 31.95 dB

Training everything from scratch (Net3) fails because BlurDM's estimators have no guidance on what constitutes a good prior — they must simultaneously learn to perform dual diffusion AND produce representations useful for deblurring, which is a significantly harder optimization problem. Stage 1 establishes the target (what a good prior looks like), Stage 2 teaches BlurDM to hit that target, and Stage 3 fine-tunes the entire system for the specific deblurring task. This curriculum decomposes a complex joint learning problem into manageable sub-problems, each with a clear objective.

---

3.4.5 Design Choice Rationale

Why dual noise-and-blur diffusion instead of noise-only?

Standard diffusion models (DDPM, DDIM) add only isotropic Gaussian noise during the forward process. When applied to deblurring, this means the reverse process must learn to map from pure noise to sharp images conditioned on a blurred input — but the forward degradation (adding noise) bears no resemblance to the actual degradation that produced the blurred image (continuous exposure integration). The model must learn the structure of blur entirely from the conditioning signal, without any architectural or dynamical support.

BlurDM's dual diffusion means the forward process itself encodes blur structure: at each step, the image mean shifts according to a blur residual that represents progressive exposure accumulation. The reverse process correspondingly must estimate and remove these blur residuals. The ablation in Table 2 (Net2 vs. Net4) quantifies the benefit: adding the blur estimator to a noise-only baseline contributes approximately +0.37 dB PSNR (32.28 vs. 31.91), demonstrating that the dual formulation provides complementary information beyond noise estimation alone.

Why not use ground-truth blur residuals?

Existing deblurring datasets provide only $(B, I_0)$ pairs — one blurred image and one sharp image per scene. There are no intermediate images $I_t$ at partial exposure times, and therefore no ground-truth blur residuals $e_t$. The paper could theoretically synthesize these by capturing high-frame-rate video and simulating different exposure integrations, but this approach would require new data collection, is not scalable to existing benchmarks, and might not generalize to real-world blur patterns that can't be captured with consumer cameras.

Instead, the paper makes a virtue of necessity: by using only trajectory-level supervision ($L_{\text{rec}}$ on the final output), BlurDM learns to allocate the total blur across time steps in whatever way produces the best final reconstruction. The internal representations of $e^\theta$ need not match the true physical blur residuals — they only need to be useful for the deblurring task. This is a form of learned decomposition where the model discovers a factorization of the total degradation that facilitates high-quality restoration, even if that factorization doesn't perfectly match the true physical process.

Why only 5 diffusion steps?

Pixel-space diffusion models for image generation typically use $T = 1000$ steps (DDPM) or even more (continuous-time score-based models). BlurDM uses $T = 5$ in its final configuration. Several factors enable this efficiency:

1. Latent space operation: The diffusion happens on a 1×1×C latent vector, not on a 256×256×3 image. The state space is orders of magnitude smaller (hundreds of dimensions vs. ~200,000), so each reverse step can make larger progress in the relevant manifold.

2. Deterministic DDIM sampling with $\eta = 0$: DDIM showed that deterministic reverse processes can produce high-quality samples with far fewer steps than stochastic DDPM sampling. BlurDM adopts this, meaning there's no stochasticity in the reverse process to average over — each step deterministically moves toward the estimated sharp prior.

3. Small noise levels: The noise schedule $\beta_t$ from 0 to 0.02 is very narrow — the total noise added is small. This means the reverse process doesn't need to traverse a large noise landscape; it starts near the target and makes small corrections.

4. Strong conditioning: The terminal state $Z_T^B = Z_B + \bar{\beta}_T \epsilon$ is centered on the blurred latent $Z_B$, which already contains substantial information about the scene. In standard unconditional generation, the terminal state is pure noise with no scene information, requiring many steps to gradually hallucinate structure.

Figure 7 validates the choice empirically: performance increases sharply from $T=0$ (no diffusion, ~31.78 dB baseline) to $T=2$ (~32.20 dB), peaks at $T=5$ (~32.28 dB), and plateaus or slightly declines for $T=6$ to $T=10$. This suggests that beyond 5 steps, the additional model capacity needed for more steps doesn't yield better latent representations — the prior estimation is already saturated.

Why a plug-and-play prior generator instead of a standalone deblurring model?

The paper explicitly frames BlurDM as an enhancement to existing methods, not a replacement. This design choice has several motivations:

1. Inheriting architectural advances: Deblurring backbones benefit from years of architectural innovation (multi-scale processing, attention mechanisms, frequency-domain operations). Rather than building these capabilities into BlurDM from scratch, the paper leverages them as-is and focuses innovation on the diffusion prior.

2. Demonstrating transferability: By showing consistent gains across four architecturally diverse backbones (CNN-based MIMO-UNet, strip-attention Stripformer, frequency-attention FFTformer, local-frequency LoFormer), the paper provides stronger evidence that the benefit comes from the blur-aware diffusion formulation rather than from any particular architectural synergy. If BlurDM were a monolithic model, it would be unclear whether its performance came from diffusion, architecture, or their interaction.

3. Practical adoption: A plug-and-play module that adds minimal overhead (~4.16 GFLOPs, ~9ms) and works with existing trained models is more likely to be adopted by practitioners than a completely new architecture. The three-stage training can be applied to any backbone with minimal modification (only adding PFM at decoder levels).

4. Avoiding the reconstruction-detail tradeoff: Pure diffusion models in pixel space can generate rich textures but often struggle with content fidelity — they may hallucinate details that look realistic but don't match the ground truth. By using diffusion only in a compact latent space and letting the backbone handle pixel-level reconstruction, BlurDM provides high-level guidance (what should the image look like) while the backbone ensures pixel-accurate reconstruction through its regression loss. This hybrid approach aims to get the best of both worlds: diffusion-driven detail generation and regression-driven content preservation.

Why the specific noise schedule $\beta_{1:T}$ from 0 to 0.02?

The paper provides limited theoretical justification for the noise schedule but the empirical results are clear. A maximum $\beta_t$ of 0.02 means that at each forward step, the noise standard deviation is at most 0.02 (on the scale of latent features, not pixel intensities). This relatively small noise level keeps the forward process close to the blurred latent, making the reverse process more about "removing a small amount of accumulated degradation" rather than "generating from scratch." This is appropriate for deblurring, where the input $B$ already contains most of the scene structure — the model's job is refinement, not generation.

The uniform spacing of $\alpha_{0:T}$ from 0 to 1 means the exposure times increase linearly: $\alpha_t = t/T$. This models constant-velocity motion during exposure (the simplest assumption). Non-uniform spacing could potentially model acceleration or deceleration, but the uniform schedule is a reasonable default that the ablation shows works well.

Why latent dimension 1×1×C rather than a spatial latent?

Standard latent diffusion models (e.g., Stable Diffusion) use spatial latents (e.g., 64×64×4) to preserve spatial structure. BlurDM compresses to 1×1×C, which is a global descriptor with no spatial dimensions. This is possible because the prior doesn't need to encode pixel-level details — those are handled by the backbone. The prior only needs to encode global properties: "this image has a certain amount of blur in a certain direction, certain texture characteristics, certain lighting conditions." A single global vector is sufficient to modulate the backbone's decoder features to account for these global properties through channel-wise affine transformations. The 1×1 spatial extent also makes the diffusion process extremely efficient since there are only $C$ dimensions to denoise, compared to $64 \times 64 \times C$ in a spatial latent.

4. Key Insights and Innovations

Innovation 1: Diffusion Dynamics Can Embed Physical Degradation Mechanisms, Not Just Generic Noise

The paper's conceptual contribution is the recognition that a diffusion model's forward process — the sequence of operations that progressively corrupt data — is not a fixed, universal mechanism but a design space that can be aligned with specific physical degradation processes. The field has overwhelmingly treated diffusion as a generic "add isotropic Gaussian noise" engine, where the forward process is mathematically convenient (yielding tractable posterior distributions and reparameterizations) but physically uninformative. Whether applied to image generation (Ho et al., 2020), image restoration (Xia et al., 2023), or specifically deblurring (Chen et al., 2023; Whang et al., 2022), the forward process has remained noise-only, with any structure of the degradation being learned implicitly from the conditioning signal during the reverse process.

BlurDM challenges this orthodoxy by asking: what if the forward process itself encodes the structure of the degradation we want to reverse? For motion blur specifically, the degradation is a continuous exposure integration (Section 3.1 in the paper; Section 3.4.1 in the prior analysis). The forward process of BlurDM replaces isotropic noise steps with a dual mechanism where each step adds both Gaussian noise AND a blur residual representing newly accumulated scene radiance during an extended exposure interval. The terminal state is not pure noise — it is a Gaussian centered on the blurred input image. The reverse process correspondingly estimates and removes both noise and blur residuals at each step.

This is a fundamental reframing of what diffusion models are for, not an incremental refinement. Standard diffusion answers: "given corrupted data, learn to reverse the corruption." BlurDM answers: "design the corruption to match the physics of how the data got degraded, so that reversing it is a more structured and learnable problem." The difference is analogous to the distinction between a generic denoiser and a model-based inverse problem solver — the former treats all corruption as interchangeable, the latter exploits domain knowledge about the corruption's mathematical structure.

The significance extends beyond deblurring. The framework generalizes: any degradation with a known physical or mathematical model (defocus blur with depth-dependent kernels, atmospheric turbulence, JPEG compression artifacts, MRI undersampling) could potentially be embedded into a diffusion forward process, turning the model from a generic prior learner into a physics-informed restoration engine. The paper does not make this generalization explicit, but the architecture invites it — the $e_t$ blur residuals are one instance of a "structured degradation step" that could be replaced with domain-specific operations.

Prior work that came closest to this idea was RDDM (Liu et al., 2024), which modeled a residual component alongside noise. But RDDM's residual was computed as a simple subtraction between clean and degraded images — an additive formulation. BlurDM's key insight (discussed in Section 2.2 and contrasted in Appendix A.8, Figure 8) is that motion blur is inherently convolutional and integrative, not subtractive. Modeling it as a residual sum of exposure-interval integrals captures the progressive, trajectory-based accumulation of motion information, which a simple difference cannot. The visual comparison in Figure 8 (Appendix) concretely shows RDDM residuals as progressively scaled difference maps versus BlurDM residuals as spatially diffusing blur patterns, confirming that the physical modeling produces qualitatively different internal representations.

The empirical evidence for this innovation being meaningful — not just a mathematical curiosity — is the consistent performance gain over both standard diffusion priors (DDPM-based "Net3" in Table 3 achieves 31.91 dB vs. BlurDM's 32.28 dB on GoPro) and residual diffusion priors (RDDM-based "Net4" achieves 32.03 dB). The gap between RDDM and BlurDM (~0.25 dB PSNR) isolates the benefit of physical blur modeling beyond simple residual decomposition.

Innovation 2: Blur Formation as a Continuous Process Motivates Dual Residual Estimation, and the Two Components Complement Each Other

The second conceptual move is the explicit separation of noise and blur as distinct estimands in the reverse process, with evidence that they provide complementary information. This is not an architectural detail — it reflects a physical claim: the noise in a diffusion model's forward process and the blur in a camera's exposure process are fundamentally different types of corruption that benefit from specialized estimation.

In standard diffusion-based deblurring, the reverse process estimates only noise — the model must implicitly attribute some of that "noise" to blur structure. In RDDM, the reverse process estimates a single residual that conflates noise and degradation. BlurDM decomposes the reverse step into two dedicated estimators: $e^\theta$ for the blur residual (structured, deterministic given the scene motion) and $\epsilon^\theta$ for the noise residual (stochastic, independent across pixels and steps). Each estimator receives the same inputs (current latent, time step, blurred conditioning) but is trained to predict a different target.

The insight that makes this more than an architectural choice is that the two components provide complementary gains. The ablation in Table 2 quantifies this directly:

• Adding only the noise estimator (standard DDPM-style) over a no-diffusion baseline: +0.13 dB (31.78 → 31.91)
• Adding only the blur estimator (no noise modeling): +0.42 dB (31.78 → 32.20)
• Adding both: +0.50 dB (31.78 → 32.28)

The gains are nearly additive: the blur estimator alone provides ~0.42 dB, and adding noise estimation on top provides an additional ~0.08 dB. This additivity would not hold if the two estimators were largely redundant. It demonstrates that noise and blur capture different aspects of the forward degradation — the blur estimator handles the deterministic, structured, exposure-dependent corruption while the noise estimator handles the stochastic, unstructured perturbation — and that the deblurring task benefits from having both explicitly modeled.

This finding has implications for how to think about diffusion-based restoration more broadly. The standard practice of training a single network to predict $\epsilon$ (the noise) implicitly assumes that all forward-process corruption is noise-like. BlurDM's results suggest that when the degradation has known structure, factoring it into a structured component and a noise component allows each estimator to specialize, improving sample efficiency and final performance. This is analogous to the benefit of factored representations in other domains (e.g., separating shape and appearance in generative models, separating content and style in image translation).

The conceptual move here is from "diffusion models are denoisers" to "diffusion models can be multi-component restoration engines where each reverse-step sub-task targets a specific degradation mode." The paper demonstrates this for exactly two modes (blur and noise), but the principle could scale to more complex combinations of structured degradations + noise.

Innovation 3: A Plug-and-Play Prior Generator That Transfers Across Architectures Validates the Physical Inductive Bias

The third insight is methodological rather than theoretical: by designing BlurDM as a backbone-agnostic prior generation module and testing it on four architecturally diverse deblurring networks, the paper provides unusually clean evidence that the performance gains come from the diffusion formulation itself — not from architectural synergy or hyperparameter tuning.

This is a deliberate experimental design choice with significant implications. If BlurDM were a monolithic new deblurring architecture, it would be unclear whether its improvements over prior work came from (a) the blur-aware diffusion dynamics, (b) the specific U-Net/Transformer design, (c) training recipe improvements, or (d) some interaction of all three. The plug-and-play design isolates variable (a): the same BlurDM components (BE, BlurDM core, PFM) are attached to each backbone with minimal modification (adding channel-wise modulation at decoder scales), and each backbone is trained with its original loss, optimizer, learning rate schedule, and number of epochs. Any improvement is therefore attributable to the diffusion prior.

The results in Table 1 validate this isolation strategy with striking consistency:

The gains are universal across CNN and Transformer architectures, spatial and frequency-domain attention mechanisms, and different baseline performance levels (MIMO-UNet's 32.44 dB to FFTformer's 34.21 dB). The smaller gains for FFTformer and LoFormer likely reflect their already higher baselines (harder to improve from 34.21 dB than from 32.44 dB), not a failure of transfer. On RealBlur-J — a real-world dataset with more complex blur patterns — the gains are actually larger and more consistent: +0.54, +1.05, +0.30, and +1.24 dB respectively (Table 1), suggesting the physical blur modeling may be particularly valuable when blur patterns deviate from synthetic training distributions.

This is a diagnostic contribution to the deblurring literature. Prior works introducing diffusion-based deblurring (HI-Diff, DiffIR, RDDM) typically evaluated on a single backbone or proposed a new backbone alongside their method. The transferability of their core ideas — independent of architecture — is therefore unknown. BlurDM's results set a standard for what "the method works" should mean: consistent gains across diverse architectures and datasets, not just a new state-of-the-art number on one benchmark with one model.

The practical significance is also noteworthy: practitioners with existing trained deblurring models can integrate BlurDM through the three-stage fine-tuning pipeline without rebuilding their system from scratch. The ~4.16 GFLOPs and ~9ms overhead (Table 4) makes this integration feasible for many deployment scenarios where training a new model from scratch would be prohibitive.

Innovation 4: Trajectory-Level Supervision Eliminates the Need for Unavailable Per-Step Ground Truth While Still Learning Meaningful Step-Wise Representations

The fourth innovation is a training strategy insight: amortized trajectory-level optimization can teach a multi-step reverse process to produce useful per-step estimates even when no per-step supervision is available. This is not entirely novel in the diffusion literature — the paper cites prior work using similar strategies (HI-Diff, DiffIR, consistency models) — but BlurDM applies it in a particularly challenging setting where the intermediate targets (blur residuals $e_t$ at partial exposure times) are fundamentally unavailable, not just expensive to obtain.

In standard diffusion model training, the per-step noise $\epsilon_t$ is known because it is sampled during the forward process. The model is trained to predict $\epsilon_t$ from $I_t$ via a per-step MSE loss. In BlurDM, the blur residuals $e_t$ are not known — they would require intermediate-exposure images that don't exist in deblurring datasets. The paper could have sidestepped this by treating blur as part of the conditioning and only predicting noise (which is known), but that would revert to the standard noise-only diffusion paradigm that the paper argues is suboptimal.

Instead, the paper trains through the unrolled computation graph of all $T$ reverse steps with supervision only on the final output $Z_0^B$ (matching it to $Z_S$ in Stage 2, or to the sharp image via the backbone's loss in Stage 3). When backpropagating $\partial L / \partial Z_0^B$ through the chain of reverse updates (Equation 12 applied $T$ times), each step's blur and noise estimators receive gradient signals that reflect their contribution to the final reconstruction error. This is mathematically equivalent to the implicit function theorem at work: the chain rule propagates error signals backward through time, assigning credit to each step's estimates based on how they affect the terminal state.

The insight is not the mechanism (which is standard backpropagation) but rather the empirical demonstration that it works for learning physically meaningful representations without intermediate supervision. The evidence comes from the visualization in Figure 6: when the trained BlurDM's intermediate latents $Z_5^B, Z_4^B, \dots, Z_0^B$ are decoded through the deblurring backbone, they produce images $I_5, I_4, \dots, I_0$ that transition progressively from blurred to sharp. The model was never trained to make $I_3$ less blurred than $I_5$ — it was only trained to make $I_0$ sharp. Yet the intermediate states exhibit a monotonic deblurring trajectory.

This is significant because it demonstrates emergent step-wise structure from end-to-end training. The model discovers that organizing its internal computation as progressive deblurring (removing some blur at each step) is the most effective way to achieve the final sharp output, even though nothing in the loss function explicitly rewards this organization. This is an example of the "simplicity bias" or "implicit regularization" of gradient descent finding a solution with desirable properties (smooth, progressive refinement) rather than an arbitrary computation that happens to produce the correct final output.

The contrast with RDDM is instructive here as well. RDDM also uses unrolled trajectory-level supervision (via its own reconstruction loss), but Figure 8 and the associated discussion in Appendix A.8 show that RDDM's intermediate residuals are progressively scaled difference maps — they don't exhibit the same physically meaningful spatial diffusion pattern. BlurDM's forward process embeds the physics directly (through the exposure-integration formulation of $e_t$), and the reverse process learns to invert that specific forward process, which naturally produces intermediate states that correspond to partial deblurring. The trajectory-level supervision works because the forward process is physically grounded — the learning problem is well-posed in a way that a generic residual diffusion's forward process is not.

5. Experimental Analysis

Evaluation Methodology

• Dataset. The paper uses four benchmark datasets: GoPro (Nah et al., 2017) with 2,103 training and 1,111 test image pairs of synthetic motion blur; HIDE (Shen et al., 2019) with 2,025 test-only image pairs (no training set) for human-aware motion deblurring evaluation; and RealBlur (Rim et al., 2020), a real-world dataset with two subsets — RealBlur-J (JPEG format) and RealBlur-R (Raw format) — each containing 3,758 training and 980 test pairs. GoPro serves as the primary training benchmark, HIDE tests cross-dataset generalization, and RealBlur evaluates real-world deblurring capability.

• Base model(s). Four architecturally diverse deblurring backbones are used: MIMO-UNet (Cho et al., 2021), a CNN-based multi-scale architecture; Stripformer (Tsai et al., 2022), a Transformer using strip-wise attention; FFTformer (Kong et al., 2023), a Transformer operating in the frequency domain; and LoFormer (Mao et al., 2024), which uses local frequency attention. These span CNNs, spatial attention, and frequency-domain attention, providing a broad test of BlurDM's backbone-agnostic claims.

• Metrics. Three standard image quality metrics are reported: PSNR (Peak Signal-to-Noise Ratio, in dB, higher is better) measuring pixel-level fidelity; SSIM (Structural Similarity Index, higher is better) measuring perceptual structural similarity; and LPIPS (Learned Perceptual Image Patch Similarity, lower is better) measuring perceptual distance using deep features. All metrics are computed against ground-truth sharp images using the standard implementations in the respective papers.

• Baselines. For each backbone, the primary baseline is the same backbone trained without BlurDM, using its original training recipe (loss function, optimizer, learning rate schedule, number of epochs). Additional comparative baselines include: HI-Diff (Chen et al., 2023), a latent-space diffusion prior method that uses standard noise-only diffusion; RDDM (Liu et al., 2024), which models a residual component alongside noise but uses additive subtraction rather than exposure-integration blur modeling; and an MLP baseline ("Net2" in Table 3) that replaces the diffusion prior with a purely feedforward MLP of equivalent capacity, testing whether diffusion specifically (versus just added parameters) drives the improvements.

• Generation budget / compute accounting. The primary compute measurement for BlurDM itself is the number of reverse diffusion steps T (tested from 0 to 10, with T=5 used in final models). Computational overhead is measured via FLOPs (floating-point operations, in GFLOPs), parameter count (in millions), and inference time (in milliseconds on an NVIDIA RTX 3090 at 256×256 resolution), comparing each backbone with and without BlurDM (Table 4). Training cost is measured in GPU-hours (Appendix A.5, Table 7).

• Cross-validation / statistical protocol. The paper does not employ cross-validation — all results use the standard dataset splits described above (GoPro 2,103/1,111 train/test, HIDE 2,025 test-only, RealBlur 3,758/980 per subset). No error bars, confidence intervals, or statistical significance tests are reported. The authors acknowledge this in the NeurIPS checklist (Question 7): "it would be too computationally expensive" but note that "consistent PSNR and SSIM improvements across four benchmark datasets... and four different deblurring models" provide evidence of robustness despite the absence of formal statistical analysis.

Main Quantitative Results

Deblurring Performance Across Backbones and Datasets (Table 1)

The central quantitative result is the consistent improvement BlurDM provides when added to existing deblurring backbones. Table 1 reports PSNR, SSIM, and LPIPS for each backbone with and without BlurDM on all four datasets.

On GoPro, BlurDM improves over baselines by: MIMO-UNet (+0.49 dB, from 32.44 to 32.93), Stripformer (+0.44 dB, from 33.09 to 33.53), FFTformer (+0.13 dB, from 34.21 to 34.34), and LoFormer (+0.16 dB, from 33.54 to 33.70). The average gain across backbones is +0.31 dB, with SSIM improving by 0.003 and LPIPS dropping by 0.0013.

On HIDE (cross-dataset generalization, trained only on GoPro): MIMO-UNet (+0.73 dB, 30.00 → 30.73), Stripformer (+0.33 dB, 31.03 → 31.36), FFTformer (+0.14 dB, 31.62 → 31.76), LoFormer (+0.09 dB, 31.18 → 31.27). Average gain: +0.32 dB PSNR, +0.004 SSIM, -0.0025 LPIPS.

On RealBlur-J (real-world JPEG): MIMO-UNet (+0.54 dB, 31.59 → 32.13), Stripformer (+1.05 dB, 32.48 → 33.53), FFTformer (+0.30 dB, 32.62 → 32.92), LoFormer (+1.24 dB, 32.23 → 33.47). Average gain: +0.78 dB PSNR, +0.008 SSIM, -0.0047 LPIPS.

On RealBlur-R (real-world Raw): MIMO-UNet (+0.60 dB, 39.03 → 39.63), Stripformer (+1.16 dB, 39.84 → 41.00), FFTformer (+0.44 dB, 40.11 → 40.55), LoFormer (+0.56 dB, 40.36 → 40.92). Average gain: +0.69 dB PSNR, +0.003 SSIM, -0.0025 LPIPS.

The paper reports that "on average across all backbones and datasets, BlurDM achieves an overall gain of 0.53 dB in PSNR, 0.004 in SSIM, and a reduction of 0.0028 in LPIPS." The gains are larger on RealBlur subsets (+0.78 and +0.69 dB average) than on synthetic datasets (+0.31 and +0.32 dB), suggesting BlurDM's physical blur modeling may be particularly beneficial for real-world blur patterns that deviate from synthetic training distributions.

Critically, the gains are not uniform across backbones. FFTformer (already the strongest baseline at 34.21 dB) shows the smallest improvements (+0.13 dB on GoPro, +0.14 dB on HIDE), while weaker baselines gain more (MIMO-UNet gains +0.49 dB on GoPro). This suggests BlurDM's prior provides complementary information that is partially redundant with what the strongest backbones already learn — a pattern consistent with the prior helping most when the backbone's own representations are less rich.

Comparison Against Alternative Diffusion-Based Methods (Table 5)

Table 5 compares BlurDM (configured with different backbones) against two prior diffusion-based deblurring approaches on GoPro:

• HI-Diff (Chen et al., 2023): 33.33 dB PSNR, 0.955 SSIM, 23.99M parameters, 125.47 GFLOPs
• RDDM (Liu et al., 2024): 32.40 dB, 0.963 SSIM, 15.49M parameters, 134.20 GFLOPs
• BlurDM (Stripformer): 33.53 dB, 0.966 SSIM, 24.33M parameters, 174.18 GFLOPs
• BlurDM (FFTformer): 34.34 dB, 0.970 SSIM, 18.66M parameters, 135.69 GFLOPs
• BlurDM (LoFormer): 33.70 dB, 0.967 SSIM, 19.08M parameters, 56.35 GFLOPs

All three BlurDM configurations outperform HI-Diff and RDDM on both PSNR and SSIM. BlurDM (FFTformer) achieves the highest PSNR (34.34 dB vs. 33.33 for HI-Diff, +1.01 dB) while using comparable FLOPs to RDDM (135.69G vs. 134.20G). BlurDM (LoFormer) achieves strong performance (33.70 dB) with less than half the FLOPs of HI-Diff (56.35G vs. 125.47G). The comparison against RDDM is particularly important because RDDM is the closest conceptual prior work (modeling a residual component in diffusion), and BlurDM's advantage (+1.13 to +1.94 dB across configurations) isolates the benefit of the exposure-integration blur formulation over simple residual subtraction.

Prior Generation Method Comparison (Table 3)

Table 3 ablates the type of prior generator on GoPro and RealBlur-J, with MIMO-UNet as the backbone:

• No prior (baseline): 31.78 / 31.59 dB (GoPro / RealBlur-J)
• MLP prior (no diffusion): 31.90 / 31.84 dB
• DDPM prior (standard noise-only diffusion): 31.91 / 31.85 dB
• RDDM prior (residual diffusion): 32.03 / 31.90 dB
• BlurDM prior (dual blur+noise diffusion): 32.28 / 32.13 dB

The key finding: a standard DDPM-based diffusion prior (+0.13 dB over baseline) provides essentially the same gain as an MLP of equivalent capacity (+0.12 dB), suggesting that standard noise-only diffusion in latent space contributes little beyond what additional parameters alone provide. RDDM's residual modeling adds a modest further gain (+0.25 dB over baseline), but BlurDM's exposure-integration formulation provides a substantially larger improvement (+0.50 dB over baseline on GoPro, +0.54 dB on RealBlur-J). This isolates BlurDM's specific contribution: the benefit comes from the physics-aligned dual diffusion, not from simply using diffusion or adding capacity.

Ablation Studies and Robustness Checks

• Noise estimator vs. blur estimator (Table 2): Ablating which residual estimators are active in BlurDM, using MIMO-UNet on GoPro. The baseline without either estimator achieves 31.78 dB. Adding only the noise estimator (standard DDPM-style, "Net2"): 31.91 dB (+0.13). Adding only the blur estimator (no noise modeling, "Net3"): 32.20 dB (+0.42). The full model with both estimators ("Net4"): 32.28 dB (+0.50). The gains are nearly additive — the blur estimator alone provides most of the improvement (+0.42), and adding noise estimation on top provides an additional +0.08 — demonstrating that the two components capture complementary information about the degradation process.

• Number of diffusion steps T (Figure 7): Tested across T ∈ {0, 1, 2, 4, 5, 6, 8, 10} on GoPro. Performance increases sharply from T=0 (no diffusion, ~31.78 dB baseline equivalent) to T=2 (~32.20 dB), peaks at T=5 (~32.28 dB), and plateaus for T=6–10 (fluctuating around ~32.22–32.28 dB without further improvement). The rapid saturation at very few steps contrasts sharply with pixel-space diffusion models requiring hundreds or thousands of steps, validating the latent-space design choice. The peak at T=5 (rather than T=1 or T=2) confirms that multi-step progressive deblurring provides benefit over single-step estimation, but beyond 5 steps the models do not learn improved representations with the additional capacity.

• Effect of each training stage (Table 6): Using MIMO-UNet on GoPro, six configurations are tested: "Net1" (baseline without BlurDM, 31.78 dB) serves as the lower bound. "Net2" (Stage 1 only, oracle prior from ground-truth sharp image via SE): 32.69 dB — this is the upper bound achievable with a perfect prior. "Net3" (joint training all components from scratch, no pretraining): 31.80 dB — barely above baseline, demonstrating that end-to-end training fails without the curriculum. "Net4" (Stage 1 + Stage 2 only, no joint fine-tuning): 32.01 dB. "Net5" (Stage 1 + Stage 3 only, skipping Stage 2): 31.95 dB. "Net6" (full three-stage): 32.28 dB — substantially outperforming all partial-training variants. The gap between Net6 (32.28) and the upper bound Net2 (32.69) of 0.41 dB represents room for improvement in prior estimation quality.

• Blur residual visualization across steps (Figure 6 and Appendix A.8, Figure 8): When the trained BlurDM's intermediate latents ZB_5 through ZB_0 are decoded via the deblurring backbone, the resulting images I_5 to I_0 show progressively reduced blur — from fully blurred at I_5 to sharp at I_0. This emergent progressive deblurring behavior was never explicitly supervised (the model was only trained to make I_0 sharp), confirming that the trajectory-level optimization naturally induces step-wise refinement. Appendix Figure 8 compares BlurDM's blur residuals against RDDM's: RDDM produces progressively scaled difference maps that lack spatial structure, while BlurDM's residuals exhibit spatially diffusing blur patterns that resemble physical motion blur spread — a qualitative validation of the exposure-integration formulation.

• Training cost analysis (Appendix A.5, Table 7): Comparing MIMO-UNet on GoPro: Baseline 1 (3,000 epochs, default training): 66.7 hours, 32.44 dB. Baseline 2 (6,000 epochs, doubled training): 133.4 hours, 32.51 dB — only +0.07 dB gain, indicating the backbone is near saturation. BlurDM configurations with varying stage lengths: BlurDM 1 (1500+500+1500 epochs): 70.7 hours, 32.62 dB; BlurDM 2 (3000+500+1500 epochs): 104.1 hours, 32.71 dB; BlurDM 3 (3000+500+3000 epochs): 141.4 hours, 32.93 dB. The final model (BlurDM 3) requires only 8% more training time than Baseline 2 (141.4 vs. 133.4 hours) while delivering 0.42 dB improvement, confirming the gains are not simply from increased training computation.

• Comparison against RDDM across step counts (Appendix A.6, Table 8): RDDM and BlurDM are compared at step counts T ∈ {2, 4, 5, 6, 8, 10} on GoPro, measuring both PSNR and LPIPS. RDDM peaks at 32.08 dB (T=4) and 0.0121 LPIPS (T=10). BlurDM peaks at 32.28 dB (T=5) and 0.0113 LPIPS (T=8/10). At every step count tested, BlurDM achieves both higher PSNR and lower (better) LPIPS than RDDM, with the PSNR gap ranging from +0.14 to +0.25 dB and the LPIPS gap from -0.0008 to -0.0017. This demonstrates BlurDM's advantage is robust to the number of diffusion steps, not an artifact of a particular T.

• Computational overhead (Table 4): Across the four backbones on 256×256 images (RTX 3090), BlurDM adds: +4.16–4.17 GFLOPs (consistent since BlurDM components are backbone-independent), +2.18–4.62M parameters (varies because PFM linear layers must match each backbone's decoder channel dimensions), and +6–11 ms inference time (representing 6–35% relative increase, lowest for FFTformer at 10ms/131ms ≈ 8%, highest for MIMO-UNet at 11ms/31ms ≈ 35%).

• Latent space blur modeling verification (Figure 6 and Appendix Figure 9): Appendix Figure 9 visualizes blurred images at different exposure times T (T=0 sharp, T=0.25, 0.50, 0.75, 1.0 fully blurred) synthesized from GoPro, alongside the corresponding blur residuals obtained from BlurDM. As T increases, the images progressively blur and the residuals evolve accordingly, visually confirming that BlurDM's latent representations encode exposure-dependent blur accumulation patterns — consistent with the physical model but learned without per-step supervision.

Critical Assessment

Does BlurDM genuinely encode blur formation physics, or does it just add useful capacity?

The paper's central claim is that explicitly modeling the exposure-integration process within diffusion dynamics yields better deblurring than generic diffusion. The evidence is strongest in the comparative ablations. The DDPM prior (Table 3, "Net3") adds diffusion but provides only +0.13 dB over baseline — essentially the same as an MLP with equivalent parameters (+0.12 dB, "Net2"). This strongly suggests that standard diffusion alone, in this latent-space prior-generation setup, contributes negligible benefit beyond parameter count. RDDM's residual formulation adds +0.25 dB, and BlurDM adds +0.50 dB. The progressive improvement from generic diffusion → residual diffusion → exposure-integration diffusion is consistent with the claimed mechanism.

However, the paper does not fully disentangle whether the benefit comes specifically from the exposure-integration mathematical form (the α_t scaling and integral-based blur residuals) or from the simpler design choice of estimating two separate components (noise and blur) rather than one. The ablation in Table 2 shows that a blur-only estimator without noise modeling ("Net3," 32.20 dB) achieves most of the full model's gain (32.28 dB) — adding noise estimation on top provides only +0.08 dB. This could mean: (a) the blur modeling is doing the heavy lifting (supporting the paper's physics claim), or (b) simply having a second estimator with separate parameters, regardless of what it estimates, provides a small additional benefit through increased capacity (weakening the specific physics claim). An ablation where the second estimator predicts a different decomposition (e.g., low-frequency vs. high-frequency residuals rather than blur vs. noise) would help distinguish these interpretations, but is not present.

Are the improvements practically meaningful or just statistically consistent?

The average PSNR gain of 0.53 dB across all backbones and datasets is modest in absolute terms. For context, the gap between the weakest backbone (MIMO-UNet, 32.44 dB) and the strongest (FFTformer, 34.21 dB) is 1.77 dB — BlurDM's 0.53 dB average gain represents about 30% of that architectural gap. The visual improvements in Figures 4–5 and Appendix Figures 10–13 show perceptible sharpening (clearer text, better-defined edges) but are not dramatic — the baseline models already produce reasonable deblurring, and BlurDM refines details rather than rescuing catastrophic failures.

The larger gains on RealBlur datasets (+0.78 dB average on RealBlur-J, +0.69 dB on RealBlur-R) compared to GoPro (+0.31 dB) and HIDE (+0.32 dB) are noteworthy. Real-world blur is more complex and varied than GoPro's synthetic linear motion blur, so a method that encodes blur formation physics might be expected to generalize better. However, the paper does not analyze why the gains are larger on RealBlur — is it because the physical model handles spatially varying blur kernels better? Because the latent prior captures real-world blur statistics that synthetic training misses? Without this analysis, the larger RealBlur gains remain an empirical observation rather than a validated mechanistic claim.

Single-dataset training and cross-dataset generalization.

All models are trained on GoPro (except RealBlur results, which use RealBlur training sets). HIDE results are zero-shot cross-dataset evaluation (trained on GoPro, tested on HIDE). The consistent gains on HIDE (+0.32 dB average) demonstrate that BlurDM's prior does not overfit to GoPro-specific blur patterns. However, HIDE's blur is also synthetic (generated from high-frame-rate video similar to GoPro's methodology), so this is a relatively weak cross-dataset test — the blur statistics are similar. A stronger test would be generalization to genuinely different blur types (e.g., from different synthetic generation algorithms, or from different real-world capture scenarios not represented in RealBlur). The paper does not test this.

Missing baselines and comparisons.

Several comparisons that would strengthen the paper's claims are absent:

1. BlurDM vs. simply increasing backbone capacity: BlurDM adds ~2–5M parameters to each backbone. Would adding those parameters directly to the backbone (deeper layers, more channels) without any diffusion prior achieve similar gains? The MLP baseline ("Net2" in Table 3) partially addresses this by adding equivalent MLP capacity without diffusion, showing minimal gain (+0.12 dB). But a comparison where the added parameters are integrated into the backbone architecture itself (not as a separate prior pathway) would be more convincing that the prior structure — not just the parameter count — matters.

2. BlurDM with an oracle (ground-truth) blur residual: The paper's Stage 2 trains BlurDM to match the oracle prior Z_S, but there's no experiment where ground-truth blur residuals e_t (if obtainable) are used to supervise the per-step estimators. Such an oracle experiment would establish an upper bound on how much the trajectory-level approximation loses compared to perfect step-wise supervision.

3. BlurDM applied to defocus blur: The paper acknowledges (Section 5) that BlurDM is designed for motion blur and not suited for defocus blur. An experiment applying BlurDM to a defocus deblurring dataset (and presumably showing no improvement or degradation) would validate this limitation claim and delineate the method's applicability boundary. Without it, the limitation is a stated assumption rather than an empirical finding.

Statistical reliability concerns.

The paper explicitly states it does not report error bars or statistical significance tests (NeurIPS checklist Q7), citing computational expense. Given that the test sets are moderately sized (GoPro: 1,111 images; HIDE: 2,025; RealBlur: 980 each), the reported PSNR differences of 0.09–1.24 dB across individual backbone-dataset pairs may or may not be statistically significant — without variance estimates, we cannot distinguish genuine improvement from sampling noise. The consistency across 16 comparisons (4 backbones × 4 datasets) provides informal evidence of robustness, but individual claims about specific gains (e.g., "+1.24 dB for LoFormer on RealBlur-J") could reflect favorable test splits rather than reliable improvement. This is a genuine weakness for a paper whose primary contribution is empirical demonstration of consistent gains.

The upper bound analysis reveals substantial headroom.

Table 6 shows that the oracle prior ("Net2," Stage 1 with ground-truth sharp image): 32.69 dB, versus BlurDM's estimated prior ("Net6"): 32.28 dB — a gap of 0.41 dB. The baseline without any prior ("Net1"): 31.78 dB. So BlurDM recovers approximately 55% of the maximum possible improvement from an ideal prior (0.50 dB out of 0.91 dB possible). This is substantial but leaves nearly half the potential gain on the table, indicating that prior estimation quality — not the prior fusion mechanism or backbone capacity — is the primary bottleneck. The paper does not analyze what aspect of prior estimation fails (e.g., specific blur types, image regions, frequency bands), which would guide future improvements.

Computational overhead hides training cost complexity.

The paper emphasizes inference-time efficiency (~4.16 GFLOPs, ~9ms overhead) and notes in Appendix A.5 that the three-stage training adds only 8% training time versus a doubled-epoch baseline. However, this comparison uses a baseline with 6,000 epochs (double the original 3,000) — a configuration no prior work uses. Against the standard 3,000-epoch baseline (66.7 hours), BlurDM's 141.4 hours represents a 2.1× increase, not 8%. The three-stage pipeline also requires storing intermediate checkpoints and managing separate training phases, which adds engineering complexity not reflected in GPU-hour comparisons.

Qualitative results are selective but consistent.

Figures 4–5 and Appendix Figures 10–13 show consistent visual improvements: sharper text, better-defined edges, reduced artifacts. However, as with most deblurring papers, these are selected examples — we cannot assess failure cases or typical-case behavior from the provided visualizations. The paper does not report worst-case performance, failure mode analysis, or per-image gain distributions that would reveal whether gains are concentrated on "easy" cases or distributed broadly.

6. Limitations and Trade-offs

Limitation 1: BlurDM Is Fundamentally Designed for Motion Blur and Does Not Extend to Defocus Blur

The assumption or constraint. The entire dual-diffusion formulation in BlurDM rests on the physical model of motion blur as a continuous exposure integration process: $B = \frac{1}{\alpha_T} \int_0^{\alpha_T} H(\tau) d\tau$ (Section 3.1). This specific mathematical structure — where blur accumulates progressively along motion trajectories during an extended exposure window — is what the forward process embeds and what the reverse process learns to invert. The paper explicitly acknowledges the scope limitation in its dedicated Limitations section (Section 5):

"Since BlurDM is designed based on the motion blur formation process, it effectively handles blur caused by camera motion and moving objects. However, it may not be well-suited for handling defocus blur, which arises from optical aberrations due to out-of-focus issues. Unlike motion blur, defocus blur is depth-dependent and does not exhibit the same temporal accumulation properties, making it fundamentally different in nature."

The consequence. Defocus blur is caused by the camera's aperture and focal plane geometry, not by temporal integration. Its mathematical form involves depth-dependent point spread functions (typically modeled as disks or Gaussians whose size varies with scene depth), not trajectory-based accumulation over time. BlurDM's forward process — which progressively reweights and accumulates new scene radiance $e_t = \int_{\alpha_{t-1}}^{\alpha_t} H(\tau) d\tau$ over extended exposure intervals — has no physical interpretation for defocus. If applied directly to defocus deblurring, the model would attempt to decompose a depth-dependent blur into exposure-interval residuals, a mismatch that would likely produce artifacts or fail to remove blur in out-of-focus regions. The practical consequence is that BlurDM is not a general-purpose deblurring prior — it is specifically a motion deblurring prior, and practitioners working on defocus deblurring (microscopy, portrait mode photography, shallow depth-of-field correction) cannot expect the reported gains to transfer.

What evidence exists in the paper. None. The paper does not run a single experiment on a defocus deblurring dataset (e.g., DPDD, RealDOF, or any depth-of-field benchmark). The limitation is stated as a theoretical incompatibility based on the physical formulation, but it is never empirically validated. The paper does not show what happens when BlurDM is applied to defocus-blurred images — whether performance degrades gracefully (the prior simply becomes uninformative, reverting to baseline quality), whether it actively hurts (the prior injects motion-blur-specific biases that worsen defocus deblurring), or whether the model surprisingly generalizes somewhat despite the physical mismatch.

Mitigation status. The paper explicitly defers this to future work: "Addressing defocus deblurring would require a distinct approach, potentially incorporating depth estimation or optical defocus modeling, which remains an open direction for future research" (Section 5). No architecture modifications, training strategies, or experimental protocols are proposed for extending BlurDM to defocus blur. The limitation is purely a scope disclaimer — honest and precise, but leaving a significant fraction of the deblurring problem space unaddressed.

---

Limitation 2: Difficulty Estimation for Blur Severity Is Implicit and Not Externally Controllable

The assumption or constraint. BlurDM's forward process uses a fixed exposure-time schedule $\alpha_{0:T}$ that increases uniformly from 0 to 1 (Section 4.1): "We empirically set $T = 5$ in BlurDM, with $\beta_{1:T}$ increasing uniformly from 0 to 0.02 and $\alpha_{0:T}$ increasing uniformly from 0 to 1." This means the model assumes that all blurred images were produced by the same total exposure duration (always reaching $\alpha_T = 1$ at the terminal state) and the same linear accumulation rate (uniform spacing of $\alpha_t$). In reality, motion blur severity varies enormously across images — a slightly blurred photo from mild camera shake involves a short exposure and small motion trajectories, while a severely blurred action shot involves long exposure and large displacements. The blur residual magnitudes $e_t$ that BlurDM estimates internally should scale with blur severity, but the forward noise schedule $\beta_t$ and exposure schedule $\alpha_t$ are fixed regardless.

The consequence. BlurDM does not receive an explicit "blur severity" signal as input. The blurred image $B$ is encoded into a fixed-dimensional latent $Z_B$ and then diffused with a fixed schedule. The model must infer blur severity purely from the latent content of $B$ and allocate the reverse steps' capacity accordingly — but the number of steps and the step sizes (determined by the $\alpha_t$ schedule) are fixed. For mildly blurred images, 5 reverse steps with uniform spacing may be overkill — the model expends computation on negligible blur residuals at early steps, effectively wasting capacity. For severely blurred images, 5 steps may be insufficient — the total blur magnitude exceeds what the model learned to decompose into $T=5$ steps during training, potentially leaving residual blur in the final output. The paper's ablation on step count (Figure 7) tests $T \in \{0, 1, 2, 4, 5, 6, 8, 10\}$ but evaluates aggregate PSNR across all test images, not per-difficulty performance. It is therefore unknown whether hard examples (severe blur) would benefit from more steps while easy examples (mild blur) would be fine with fewer — a difficulty-adaptive schedule that varies $T$ per image could improve efficiency-accuracy tradeoffs, but the current fixed schedule provides no such mechanism.

What evidence exists in the paper. The paper does not analyze performance stratified by blur severity. There is no binning of test images by motion magnitude, no reporting of per-image gain distributions, and no experiment varying the $\alpha_t$ schedule or $T$ as a function of estimated blur magnitude. Figure 7 shows aggregate PSNR vs. $T$ — the curve peaks at $T=5$ and plateaus, which suggests that across the average case, additional steps don't help. But this could mask a scenario where severe-blur images improve with $T=8$ while mild-blur images degrade (overfitting to noise), yielding a flat aggregate. The visualization in Figure 6 — showing progressive deblurring from $I_5$ to $I_0$ — is a single example with unknown blur severity, providing no evidence about the method's behavior across the severity spectrum.

Mitigation status. Not addressed. The paper does not propose severity-adaptive scheduling, nor does it discuss the fixed-schedule assumption as a limitation. The uniform $\alpha_{0:T}$ schedule is presented as an empirical choice without analysis of alternatives (non-uniform spacing, learned schedules, or severity-conditioned step counts).

---

Limitation 3: The Three-Stage Training Pipeline Requires Oracle Access to Sharp Images and Adds Substantial Engineering Complexity

The assumption or constraint. BlurDM's training strategy requires ground-truth sharp images $S$ at all three stages: Stage 1 uses $\text{Concat}(B, S)$ as input to the Sharp Encoder to produce the oracle prior $Z_S$; Stage 2 uses $Z_S$ as the target for BlurDM's estimated prior $Z_0^B$ via $L_{\text{prior}} = \|Z_0^B - Z_S\|_1$; Stage 3 uses $S$ for the backbone's deblurring loss. This is standard for supervised deblurring and not a limitation relative to other supervised methods, but it means BlurDM cannot leverage unlabeled blurred images for prior learning — unlike self-supervised or unsupervised deblurring approaches that learn from blurry images alone. More importantly, the three-stage curriculum itself introduces engineering complexity beyond standard end-to-end training: practitioners must implement three separate training loops, manage checkpoint saving/loading between stages, tune stage-specific hyperparameters (the paper uses 3000, 500, and 3000 epochs respectively for the final MIMO-UNet configuration), and ensure components are correctly frozen/unfrozen at each stage boundary.

The consequence. For a practitioner with an existing trained deblurring model, integrating BlurDM is not a lightweight retrofit despite the plug-and-play inference architecture. They must:

1. Modify their backbone to include PFM modules at decoder scales (requiring architectural changes).
2. Implement the SE, BE, and BlurDM components from scratch.
3. Run Stage 1 from scratch (cannot reuse existing backbone weights directly, since the backbone must learn to use the PFM-modulated features, which changes its optimal internal representations).
4. Run Stage 2 (which requires the frozen SE and is a separate training loop with its own convergence monitoring).
5. Run Stage 3 (joint fine-tuning).

The paper's claim of "minimal overhead" (~4.16 GFLOPs, ~9ms) applies only to inference, not to the integration effort or training cost. Appendix A.5 (Table 7) reports that the full three-stage training takes 141.4 GPU-hours for MIMO-UNet on GoPro versus 66.7 hours for the standard single-stage baseline — a 2.1× increase. The paper's comparison to a "doubled baseline" (133.4 hours) obscures this: the standard baseline in the literature is 3,000 epochs (66.7 hours), and BlurDM requires more than double that. The fact that doubling the baseline to 6,000 epochs yields minimal improvement (+0.07 dB, from 32.44 to 32.51) is a separate finding about backbone saturation, not a justification that BlurDM's training cost is negligible.

What evidence exists in the paper. Table 7 (Appendix A.5) provides training times. Table 6 ablates the necessity of each stage, showing that skipping Stage 2 ("Net5," 31.95 dB) or skipping Stage 3 ("Net4," 32.01 dB) substantially underperforms the full pipeline ("Net6," 32.28 dB) — the three stages are all necessary for the reported gains. The paper does not explore whether a more sample-efficient training strategy (e.g., shorter stages, joint training with carefully tuned loss weighting, or progressive unfreezing) could reduce training cost while preserving the gains.

Mitigation status. Not addressed. The paper presents the three-stage strategy as a necessary component of the method without discussing alternatives or potential simplifications. There is no analysis of whether Stage 2 could be shortened (500 epochs was chosen empirically, but convergence curves are not shown), whether Stage 1 and Stage 3 epoch counts could be reduced, or whether a two-stage variant (combining Stage 2 and Stage 3 objectives into a single multi-loss training phase) could work.

---

Limitation 4: The Method Is Validated Only on Standard Benchmarks with Synthetic or Semi-Synthetic Blur; Generalization to Truly Unconstrained Real-World Blur Is Unproven

The assumption or constraint. The paper evaluates on four datasets: GoPro (synthetic blur generated from 240fps video), HIDE (also synthetic, from the same generation methodology as GoPro), and RealBlur-J/R (real-world blur, but captured in a controlled setup with a beam splitter to obtain aligned sharp/blurred pairs). All datasets provide perfectly aligned ground-truth sharp images and contain blur produced by specific, well-characterized capture protocols. This is standard in the deblurring literature, but it means the evaluation does not cover several real-world complexities:

• Spatially varying blur from complex 3D camera motion (rotation + translation, not just in-plane trajectories as in GoPro).
• Object motion blur with occlusions and disocclusions (where parts of the scene are revealed or hidden during the exposure, violating the simple integration model).
• Mixed defocus and motion blur (common in real photography where both out-of-focus regions and camera shake coexist).
• Non-linear camera response functions and sensor noise (RAW processing pipelines that deviate from the linear integration model).
• Compression artifacts interacting with blur (JPEG blocking in blurred regions, which RealBlur-J includes but GoPro/HIDE do not).

The consequence. BlurDM's consistent gains on RealBlur-J/R (+0.78 and +0.69 dB average) suggest some real-world generalization, but RealBlur is still a curated benchmark — it was captured with a tripod-mounted beam splitter system that produces specific types of camera shake and scene motion. Whether BlurDM's physics-aligned prior would remain beneficial for "in-the-wild" blur (e.g., smartphone photos with complex hand tremor, drone footage with vibration, surveillance footage with low-light long-exposure motion) is unknown. The exposure-integration model assumes constant scene radiance during the exposure, which breaks when lighting changes (flickering lights, flash photography) or when objects move across significant depth discontinuities. In such cases, the dual-diffusion prior might encode physically implausible blur residuals, potentially introducing artifacts that a generic diffusion prior (with no physical assumptions) would avoid because it never encoded those assumptions in the first place.

What evidence exists in the paper. The paper provides no evaluation on truly in-the-wild data. There is no user study, no qualitative assessment by human raters, and no test on datasets captured without ground-truth alignment (where only no-reference quality metrics could be used). The cross-dataset evaluation (GoPro → HIDE) tests generalization across different scenes but not across different blur generation mechanisms — both datasets use the same high-frame-rate video averaging methodology. The paper does not analyze failure cases on RealBlur where the physical model might break down (e.g., images with saturated regions, specular highlights, or non-rigid object deformation during exposure).

Mitigation status. Not addressed. The paper does not discuss the gap between benchmark blur and in-the-wild blur as a limitation, nor does it propose evaluation protocols for assessing real-world generalization. The "Limitations" section (Section 5) focuses only on the motion-vs-defocus distinction, not on the broader synthetic-to-real gap within motion deblurring itself.

---

Limitation 5: No Statistical Significance Testing; The Magnitude of Reported Gains May Overlap with Run-to-Run Variance

The assumption or constraint. The paper reports all results as single-number metrics (PSNR, SSIM, LPIPS) without error bars, confidence intervals, standard deviations across random seeds, or statistical significance tests. This is explicitly acknowledged in the NeurIPS Checklist (Question 7):

"Our paper does not include error bars or statistical significance tests because it would be too computationally expensive. However, we report consistent PSNR and SSIM improvements across four benchmark datasets... and four different deblurring models. The results in Table 1 show stable and clear performance gains, indicating the robustness and general applicability of BlurDM, even without formal statistical analysis."

The consequence. On GoPro, the per-backbone gains range from +0.13 dB (FFTformer) to +0.49 dB (MIMO-UNet). A gain of +0.13 dB PSNR on a test set of 1,111 images is a very small effect — it could plausibly arise from random initialization differences, data shuffling order, or non-deterministic GPU operations rather than from the method itself. Without variance estimates, a practitioner cannot distinguish between:

• Robust gains: The method reliably improves performance regardless of random seed; the +0.13 dB mean gain is well outside the ±run-to-run noise.
• Fragile gains: The method helps on average across seeds but sometimes hurts, and the reported number reflects a favorable seed.
• Negligible gains: The +0.13 dB is within run-to-run variance, and the method doesn't actually improve over the baseline when accounting for training stochasticity.

This is particularly relevant for FFTformer and LoFormer, where the gains are smallest (+0.13–0.16 dB on GoPro, +0.09–0.14 dB on HIDE). For Stripformer on RealBlur-J (+1.05 dB) or LoFormer on RealBlur-J (+1.24 dB), the gains are large enough that statistical significance is less in doubt, but the absence of variance estimates still prevents proper quantitative comparison with prior work.

The argument that consistency across 16 comparisons (4 backbones × 4 datasets) serves as informal evidence for robustness has merit, but it doesn't replace formal statistical analysis. Consistency could arise from a systematic bias (e.g., BlurDM adds capacity that reliably provides a small benefit, but the benefit is not distinguishable from adding equivalent capacity elsewhere) rather than from the specific dual-diffusion mechanism.

What evidence exists in the paper. The paper reports only single-run results. There are no repeated training runs with different seeds, no bootstrap confidence intervals on test-set metrics, and no per-image variance analysis. The Appendix A.5 training cost analysis (Table 7) reports three BlurDM configurations evaluated once each — no seed-based replication. The ablation on step counts (Figure 7) shows a clear peak at T=5, but the curve is from single points; we cannot assess whether the T=4 vs. T=5 difference is larger than run-to-run noise at a fixed T.

Mitigation status. The paper acknowledges the limitation transparently in the checklist and argues (reasonably) that computational cost prohibits proper statistical analysis given the number of backbone-dataset combinations. However, even modest statistical reporting — e.g., training one backbone (say, MIMO-UNet on GoPro) with 3 random seeds and reporting mean ± std for both baseline and BlurDM — would substantially strengthen the claims at manageable cost (3× the training time for one configuration, not 16×). The paper does not pursue this partial mitigation.

7. Implications and Future Directions

How This Work Changes the Landscape

BlurDM shifts the conversation around diffusion models for image restoration from "diffusion is a generic prior generator" to "the forward process is a design space that should match the physics of the degradation." This is a conceptual reframing, not a paradigm shift — it does not replace diffusion models, but it changes how the field should think about designing the forward process for restoration tasks. The magnitude sits between incremental refinement (another diffusion-based deblurring paper) and a new diagnostic tool (the insight that forward-dynamics design matters and can be validated through backbone-agnostic transfer).

The significance is twofold. First, BlurDM provides a clean empirical diagnostic that generic noise-only diffusion in latent space contributes negligible benefit beyond equivalent parameter count for deblurring. The DDPM prior in Table 3 achieves 31.91 dB versus 31.90 dB for an MLP prior — the diffusion mechanism itself adds essentially nothing. BlurDM's physics-aligned dual diffusion adds +0.50 dB over the same baseline (32.28 dB). This result reframes the question from "should we use diffusion for deblurring?" to "how should we design the forward degradation to align with the physical degradation?" — a more productive framing that moves the field beyond treating diffusion as a black box.

Second, BlurDM reconciles a tension between prior diffusion-based deblurring methods. HI-Diff (Chen et al., 2023) showed that latent-space diffusion priors help, but the mechanism was unclear — was it the diffusion, the latent space, or the hierarchical fusion architecture? DiffIR (Xia et al., 2023) similarly demonstrated gains without isolating the contribution of the diffusion process itself. RDDM (Liu et al., 2024) moved toward degradation-aware diffusion but used an additive residual model that, as BlurDM demonstrates (Tables 3 and 5, Appendix Figure 8), underperforms a physics-aligned exposure-integration formulation. BlurDM's backbone-agnostic evaluation across four architectures resolves the ambiguity: the gains come from the dual diffusion dynamics, not from backbone architecture or training recipe, and the specific form of the forward process (exposure integration vs. additive residual vs. pure noise) matters substantially.

The paper also redirects research attention in two specific ways. It makes designing degradation-specific forward processes a more attractive research direction — for defocus blur, JPEG artifacts, atmospheric turbulence, or any other degradation with known structure, the BlurDM template (dual diffusion with a structured component and a noise component) suggests a path forward. It makes generic diffusion prior generators for restoration less attractive — if standard DDPM in latent space adds negligible value over an MLP (Table 3, "Net2" vs. "Net3"), then future work proposing "another latent diffusion prior for restoration task X" without degradation-specific forward dynamics faces a higher burden of proof to demonstrate that the diffusion mechanism, specifically, provides the gains.

However, this reframing has a sharp boundary that the paper acknowledges: it applies to degradations with known, mathematically tractable physical models. For degradations where no such model exists (e.g., general image "quality" degradation, artistic effects, unknown corruption types), the BlurDM template does not apply, and generic diffusion priors remain the only option. The paper therefore does not displace standard diffusion for generative tasks — it claims a specific subdomain of restoration where physics can be embedded.

Follow-Up Research This Work Enables

Difficulty-adaptive scheduling of diffusion steps based on estimated blur severity. BlurDM uses a fixed T=5 steps and a fixed uniform exposure schedule α₀:ₜ for all images regardless of blur magnitude. Figure 7 shows aggregate PSNR peaks at T=5, but this could mask a scenario where severely blurred images benefit from more steps while mildly blurred images do fine with fewer. A concrete follow-up would: (1) bin GoPro test images by motion magnitude (using optical flow or the provided ground-truth blur kernels), (2) evaluate BlurDM at T ∈ {1, 2, 3, 4, 5, 6, 8, 10} separately per bin, and (3) test whether an oracle severity-adaptive schedule (different T per bin, selected by best per-bin PSNR) improves over the fixed T=5 aggregate. If the per-bin optimal T varies (e.g., T=3 for mild blur, T=8 for severe blur), this would motivate learning a severity estimator from ZB that predicts optimal T per image, closing the loop on adaptive test-time compute for deblurring.

BlurDM applied to defocus deblurring to empirically validate the motion-vs-defocus limitation. The paper states (Section 5) that BlurDM is unsuited for defocus blur because defocus is depth-dependent rather than temporally cumulative, but provides no experiment. A direct stress-test would: (1) take BlurDM exactly as trained on GoPro (motion blur) and apply it zero-shot to a defocus dataset (DPDD, RealDOF, or a standard depth-of-field benchmark), (2) measure whether the prior degrades gracefully (PSNR ≈ backbone baseline), actively hurts (PSNR < baseline because the motion-blur-specific prior injects wrong biases), or surprisingly transfers (PSNR > baseline, indicating the exposure-integration model captures some general sharpening principle). This experiment would delineate the method's applicability boundary with evidence rather than assertion, and a negative result (active degradation on defocus) would be as informative as a positive one, validating that the physical model genuinely constrains the learned prior rather than providing generic benefits.

Extending BlurDM to video deblurring by modeling inter-frame exposure continuity. BlurDM's forward process models a single image's exposure as a progressive integration of instantaneous frames H(τ). In video deblurring, consecutive blurred frames share overlapping exposure windows — the H(τ) that integrates into frame t's blur also contributes (with a time offset) to frame t+1's blur. A natural extension would: (1) define a video forward process where each frame's It is generated by the dual diffusion, but the blur residuals et for frame t and frame t+1 share structure (since they integrate overlapping portions of the continuous scene radiance), (2) add a temporal consistency loss between estimated blur residuals across frames, and (3) evaluate on GoPro's video deblurring benchmark or the DVD dataset. This would test whether the physical model's temporal structure provides benefits beyond per-frame deblurring, and whether explicit temporal blur consistency outperforms post-hoc temporal smoothing of independently deblurred frames.

Training a blur severity estimator from ZB to replace the fixed schedule with a learned, per-image schedule. The current method uses fixed α₀:ₜ and β₁:ₜ schedules for all images. The latent ZB = BE(B) encodes the blurred image into a compact descriptor that must contain information about blur magnitude (since the model successfully estimates how much deblurring to apply). A follow-up could: (1) freeze a trained BlurDM, (2) extract ZB for all GoPro training images, (3) train a lightweight MLP regressor to predict a scalar blur severity score from ZB, supervised by ground-truth motion magnitude (computed from GoPro's high-frame-rate source videos), and (4) use this severity score to dynamically set T (number of reverse steps) and/or the αₜ spacing (non-uniform, concentrating steps in the exposure interval where most blur accumulates). This would replace the one-size-fits-all schedule with a difficulty-adaptive mechanism, potentially improving efficiency on easy cases and accuracy on hard cases, and would connect to broader literature on adaptive computation in generative models.

Combining BlurDM with self-supervised or unsupervised deblurring to remove the ground-truth sharp image requirement. BlurDM's three-stage training requires paired (B, S) data throughout — Stage 1 uses S to produce ZS, Stage 2 uses ZS as the target, and Stage 3 uses S for the reconstruction loss. This limits applicability to domains without aligned sharp/blurred pairs (e.g., historical footage, medical imaging with unknown ground truth). A self-supervised extension could: (1) replace the sharp prior target ZS from SE(Concat(B, S)) with a self-supervised target — for example, using reblurring consistency (the estimated I₀, when reblurred through the learned forward process, should approximate B), or using cycle consistency across multiple frames in video, (2) train BlurDM's prior estimation using only these self-supervised losses, and (3) evaluate on GoPro and RealBlur against the supervised BlurDM to measure the performance gap between supervised and self-supervised variants. This would assess how much of BlurDM's gain comes from the physical model (which is independent of supervision) versus from access to ground-truth sharp images.

Replacing the channel-wise modulation fusion (PFM) with more expressive conditioning mechanisms and measuring the prior quality bottleneck. Table 6 shows that BlurDM's estimated prior (Net6, 32.28 dB) closes only 55% of the gap to the oracle prior (Net2, 32.69 dB). The paper does not analyze whether this gap comes from (a) BlurDM's prior estimation being imperfect, or (b) the PFM's channel-wise modulation being insufficiently expressive to fully utilize even a perfect prior. A diagnostic experiment would: (1) take the oracle prior ZS from Stage 1, (2) apply controlled degradations to it (adding Gaussian noise at various magnitudes, dropping dimensions, quantizing), (3) measure how PSNR degrades as the prior quality decreases, and (4) also test alternative fusion mechanisms (cross-attention between prior and decoder features, spatially-varying modulation instead of global channel-wise, injecting the prior at encoder layers rather than only decoder). If even modest prior degradation causes large PSNR drops, the bottleneck is prior estimation (motivating better BlurDM training or architecture). If near-perfect priors don't substantially outperform good-but-imperfect priors, the bottleneck is PFM expressivity (motivating better fusion mechanisms). This diagnostic would guide resource allocation for improving the system.

Practical Applications and Downstream Use Cases

Retrofitting existing deblurring deployments with a lightweight accuracy boost. Organizations with in-house deblurring models (e.g., smartphone camera pipelines, autonomous vehicle perception stacks, surveillance video enhancement) that already have trained backbones can integrate BlurDM as a post-hoc upgrade. The integration requires: (1) adding PFM modules at decoder scales (three linear layers per scale), (2) implementing BE and BlurDM (~2–5M additional parameters depending on backbone), and (3) running the three-stage fine-tuning pipeline on the existing training data. At inference, the overhead is ~4.16 GFLOPs and ~6–11ms on 256×256 images (Table 4) — for the strongest backbone tested (FFTformer), this represents an 8% latency increase (+10ms on 131ms baseline) for +0.13 dB PSNR on GoPro and +0.30 dB on RealBlur-J. For latency-tolerant applications (cloud-based photo enhancement, forensic video analysis, offline medical image processing), this is a cost-effective gain. For latency-critical applications (real-time autonomous driving at 30fps), the 35% relative overhead on lighter backbones like MIMO-UNet (+11ms on 31ms) may be prohibitive, but the stronger backbones like FFTformer (8% overhead) could be viable if the baseline already meets latency budgets.

Improving real-world motion deblurring where synthetic training data fails. The paper's largest gains appear on RealBlur-J (+0.78 dB average) and RealBlur-R (+0.69 dB average) — real-world datasets where blur patterns deviate from GoPro's synthetic linear motion model. For applications capturing in-the-wild motion blur (sports photography, wildlife cameras, handheld night photography, drone surveillance), the physical exposure-integration prior appears to provide generalization benefits beyond what synthetic training alone achieves. A practitioner training on GoPro but deploying on real-world blur would see: Stripformer improving from 32.48 to 33.53 dB on RealBlur-J (+1.05 dB), or LoFormer improving from 32.23 to 33.47 dB (+1.24 dB). These gains are large enough to be perceptually noticeable — the qualitative results in Figure 5 and Appendix Figures 10–13 show sharper text, more defined facial features, and reduced ghosting artifacts in real-world examples. The practical workflow would be: train the backbone+BlurDM on GoPro (synthetic, abundant), fine-tune Stage 3 on a small amount of in-domain real blur data if available, and deploy with the RealBlur-level performance improvements the paper demonstrates.

Deblurring as preprocessing for downstream vision systems where small PSNR gains compound. The paper's motivation (Section 1) cites object detection, semantic segmentation, and face recognition as downstream tasks degraded by motion blur. While BlurDM's 0.13–1.24 dB PSNR gains appear modest in isolation, deblurring is rarely the end goal — it feeds into perception pipelines where edge clarity, texture preservation, and artifact reduction directly affect task accuracy. A practitioner deploying a perception system (e.g., license plate recognition from traffic cameras, facial identification from surveillance footage, text recognition in scanned documents degraded by camera shake) could evaluate whether BlurDM's improvements on deblurring metrics translate to downstream accuracy gains. The consistent SSIM improvements (+0.003 to +0.008) and LPIPS reductions (-0.0013 to -0.0047) suggest better structural preservation, which is often more correlated with downstream task performance than raw PSNR. The plug-and-play design is advantageous here: the practitioner can swap BlurDM-enhanced backbones into an existing perception pipeline without modifying the downstream model, since BlurDM only changes the deblurring preprocessing stage.