💻 computer science

Restoration-Aligned Generative Flow Models for Blind Motion Deblurring

DeblurFlow is a novel framework that aligns generative flow models with blind motion deblurring by reformulating the flow trajectory to target residual errors and introducing a specialized r-space latent, thereby achieving a superior balance between high restoration fidelity and perceptual realism while significantly reducing computational costs.

Original authors: Insoo Kim, Jinwoo Shin

Published 2026-05-12

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Insoo Kim, Jinwoo Shin

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

Imagine you have a beautiful photo, but someone accidentally took a picture while the camera was shaking or the subject was moving. The result is a blurry mess. Your goal is to fix it.

For a long time, computer scientists have tried to fix this in two different ways, but they usually had to choose between being accurate or being realistic.

The "Accuracy" Team: These methods are like a strict editor. They look at the blurry photo and try to mathematically calculate exactly what the original pixels should have been. The result is very sharp and true to the original scene, but it often looks a bit "plastic" or smooth, lacking the tiny, messy details that make a photo look real.
The "Realism" Team: These methods use powerful AI models trained on millions of perfect photos. They are like a creative artist who knows how light and texture should look. They can add amazing details, but if you ask them to fix a specific blurry photo, they often get carried away. They might invent new details that weren't there or change the shape of the object entirely, making the photo look fake or distorted.

The Problem:
The paper argues that trying to combine these two teams usually fails. If you take a "Realism" artist and ask them to fix a photo that an "Accuracy" editor already fixed, the artist often ruins the editor's hard work. The photo becomes weird and loses its original shape (a problem the authors call "fidelity collapse").

The Solution: DeblurFlow
The authors created a new system called DeblurFlow. Think of it as a brilliant new way to organize the workflow so the "Accuracy" and "Realism" teams can work together without fighting.

Here is how it works, using simple analogies:

1. Changing the Goal (The "Residual" Trick)

Normally, a "Realism" AI is trained to start with random static (like TV snow) and turn it into a clear picture. This is great for making new art, but bad for fixing old photos because it doesn't care about the original image.

The authors changed the AI's training. Instead of asking it to turn "Snow" into "Clear," they taught it to turn "Blur" into "Clear."

The Analogy: Imagine you have a muddy window.
- Old Way: The AI tries to imagine a brand new, clean window from scratch. It might paint a window that looks nice but isn't the right shape.
- DeblurFlow Way: The AI is told, "Look at the mud on this specific window. Just tell me exactly how much mud needs to be wiped away to reveal the glass underneath."
- By focusing only on the difference (the "residual" or the mud), the AI learns to clean the window without changing the shape of the frame. This keeps the photo accurate while still adding realistic texture.

2. The "Specialized Workspace" (r-space)

AI models usually work in a "compressed" version of an image to save memory, like a zip file. The authors realized that standard "zip files" are designed for storing whole pictures, not for calculating the "mud" (residuals) we just talked about. It's like trying to measure the thickness of a layer of dust using a ruler meant for measuring the height of a building.

They built a specialized workspace called r-space.

The Analogy: Instead of using a giant warehouse to store the whole picture, they built a tiny, specialized workshop just for handling the "mud." This workshop is so efficient that it does the job 9 times faster and uses much less computer power than the old methods.

3. The "Two-Expert" Team (Dual-Expert Sampling)

Instead of forcing one AI to be perfect at everything, DeblurFlow uses a two-step team approach:

Expert A (The Fidelity Expert): This is a standard, high-accuracy AI. It looks at the blurry photo and produces a very sharp, mathematically correct version. It's safe, but maybe a bit boring.
Expert B (The Realism Expert): This is the new DeblurFlow AI. It takes Expert A's safe version and gently adds back the realistic details (like skin texture or grass blades) that were smoothed out.
The Magic: Because of the "Residual Trick" mentioned in step 1, Expert B knows exactly how to add details without messing up the shape that Expert A created.

The Results

The paper shows that this new method is a winner on all fronts:

It's Accurate: It keeps the photo looking like the original scene (high PSNR scores).
It's Realistic: It adds beautiful, natural details that other methods miss (high MUSIQ scores).
It's Fast: It can fix a high-resolution photo in less than half a second, which is much faster than previous "Realism" methods.

In Summary:
DeblurFlow is like hiring a master architect (the Fidelity Expert) to build a perfect house, and then hiring a master interior designer (the Realism Expert) to decorate it. The secret sauce is a new set of instructions (the Residual Loss and r-space) that tells the decorator, "Add all the fancy details you want, but do not move a single brick of the architect's foundation." The result is a house that is both structurally perfect and beautifully detailed.

Technical Summary: Restoration-Aligned Generative Flow Models for Blind Motion Deblurring

Problem Statement

Blind motion deblurring aims to recover a clean latent image from a single blurred observation. While restoration-based deep learning architectures have achieved high fidelity (closely matching ground-truth images via pixel-wise losses), they often struggle to produce perceptually realistic details, resulting in over-smoothed outputs. Conversely, generative models (such as diffusion and flow matching models) trained on large-scale natural images excel at perceptual quality but suffer from severe fidelity degradation when applied directly to restoration tasks. This "fidelity collapse" occurs because the training objectives of generative models (transporting noise to clean data) are inherently misaligned with restoration objectives (recovering specific content from a degraded input). Naively applying generative models on top of high-fidelity restoration networks often leads to a significant drop in PSNR, failing to preserve the initial reconstruction quality.

Methodology: DeblurFlow

The authors propose DeblurFlow, a framework that resolves the objective mismatch between generation and restoration by reformulating the generative flow trajectory. The methodology consists of three core components:

1. Restoration-Aligned Flow Formulation

Standard flow matching models learn a vector field to transport a noise sample ( $\epsilon$ ) to a clean image ( $x$ ). DeblurFlow reinterprets this trajectory by replacing the noise endpoint with the blurred observation ( $y$ ).

Trajectory Redefinition: The path is defined as $x^*_t = (1-t)x + ty$ , where $y$ is the blur input and $x$ is the clean ground truth.
Vector Field as Residual: The derivative of this path, $v^* = y - x$ , naturally represents the residual error between the blur and the clean image.
Loss Alignment: Under this formulation, the standard flow matching loss coincides with a residual loss ( $L_{res} = \|v_\theta(x^*_t, t) - (y - x)\|^2$ ). This allows pretrained flow models to be optimized under restoration-oriented objectives via Low-Rank Adaptation (LoRA), enabling them to predict residuals rather than generating images from noise.

2. Dual-Expert Sampling Strategy

To balance restoration fidelity and perceptual realism, the framework decomposes the task into two complementary roles:

Fidelity Expert: A pretrained restoration network (e.g., NAFNet) provides a high-fidelity initial estimate ( $x^*_t = f_\psi(y)$ ).
Realism Expert: DeblurFlow acts as a fidelity-preserving realism expert. It refines the initial estimate by predicting the residual error under the flow matching sampling process.
Co-training: To address potential distribution gaps between training on raw blur inputs versus high-fidelity initializations, the model is co-trained on both the direct blur-to-clean mapping ( $y \to x$ ) and the expert-dependent mapping ( $f_\psi(y) \to x$ ).

3. r-Space Latent Representation

To ensure computational efficiency, the framework operates in a specialized latent space termed r-space, rather than standard VAE latent spaces.

Design: r-space is tailored for residual decoding rather than clean image reconstruction.
Architecture: It utilizes an encoder-decoder pair with residual shortcuts that propagate structural cues directly from the blur input.
Efficiency: This design significantly reduces the computational cost of the encoder-decoder components compared to standard VAEs, making the iterative sampling process practical for real-world applications.

Key Contributions

Restoration-Aligned Formulation: The paper proposes a new deblurring framework that reformulates the generative flow trajectory to treat the vector field as a task-aligned residual error. This mitigates fidelity collapse and makes generative flow models compatible with high-fidelity deblurring models.
r-Space Latent Space: The introduction of r-space enables fidelity-preserving encoding and decoding with high computational efficiency, reducing the encoder-decoder cost by up to 9 $\times$ compared to standard VAE latents.
Dual-Expert Sampling: A strategy that decomposes the problem into a fidelity expert and a fidelity-preserving realism expert, ensuring high restoration fidelity while substantially improving perceptual realism.

Experimental Results

The authors evaluated DeblurFlow on four datasets: GoPro, HIDE, RealBlur-J, and RWBI.

Fidelity vs. Realism: On the GoPro dataset, DeblurFlow achieved a PSNR of 33.05 dB (compared to 33.69 dB for the fidelity expert alone and 27.60 dB for a naive generative application) and a MUSIQ score of 50.81 (significantly higher than restoration-based methods like NAFNet at 45.28). This demonstrates the ability to preserve fidelity while enhancing perceptual quality.
Generalization: On the real-world RWBI dataset (which lacks ground-truth), DeblurFlow outperformed both restoration-based and diffusion-based methods across all no-reference metrics (CLIPIQA, NIQE, MUSIQ, MANIQA).
Computational Efficiency: DeblurFlow processes 2K resolution images in 0.41 seconds on a single GPU. This is approximately 3.4 $\times$ faster than DiffIR and 6.5 $\times$ faster than FFTFormer. The use of r-space reduced the computational cost of the encoder-decoder from 422.7 GMACs to 19.5 GMACs.
Ablation Studies: Experiments confirmed that the standard generation objective causes fidelity collapse (PSNR drop from 33.69 to 27.60). The proposed residual loss formulation mitigated this drop (restoring PSNR to 32.40), and the r-space further improved both fidelity and realism while reducing costs.

Significance and Claims

The paper claims that DeblurFlow successfully bridges the gap between restoration and generation. By reformulating the generative flow trajectory to align with restoration objectives (predicting residuals rather than transporting noise), the framework allows a single generative model to function effectively as a deblurring tool without sacrificing the fidelity provided by traditional restoration networks.

The authors emphasize that their contribution lies not merely in combining existing components, but in the unification under a restoration-aligned generative formulation. This approach suggests that restoration and generation need not be viewed as distinct, incompatible tasks but can be explored within a single generative flow model. The method is presented as a practical solution that achieves strong restoration fidelity and perceptual realism while remaining computationally efficient enough for real-world deployment. The authors note that this framework could potentially be extended to other restoration tasks such as image denoising and super-resolution.