⚡ electrical engineering

GALOSH: Blind, Training-Free Denoising of Raw Bayer and sRGB Images by Parallel-Friendly Local Shrinkage

GALOSH is a fast, training-free denoising method that achieves high-quality results on both raw Bayer and sRGB images by replacing inefficient block-matching searches with a fully local, data-independent pipeline of noise estimation, generalized Anscombe transformation, and localized shrinkage, making it suitable for both CPU and fixed-point hardware deployment.

Original authors: Yoshiro Sato

Published 2026-07-07

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Yoshiro Sato

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 photo that looks like it was taken in a dark room with a shaky hand. It's full of "grain" (random speckles) and "color blotches" (weird splotches of red, green, or blue). Your goal is to clean it up without making it look like a plastic painting or losing the important details.

For a long time, there were two main ways to fix these photos:

The "Detective" Method (Classical): These programs (like BM3D) act like detectives. They scan the whole image, looking for tiny patches that look similar to the noisy patch they are trying to fix. They compare millions of patches to find the best match. It works well, but it's slow because the computer has to "search" everywhere, and the path it takes changes depending on what's in the photo. It's like trying to find a specific needle in a haystack by looking at every single piece of hay one by one.
The "Student" Method (AI/Deep Learning): These programs are like students who memorized thousands of clean photos. When they see a noisy photo, they guess what it should have looked like based on their training. They are very fast and accurate if the photo looks exactly like what they studied. But if the photo is different (like a different camera or lighting), they can get confused and make huge mistakes. Plus, they need a massive computer (GPU) to run.

Enter GALOSH: The "Local Mechanic"

The paper introduces a new method called GALOSH. Instead of being a detective that searches the whole image, or a student that memorizes the world, GALOSH is like a local mechanic who knows exactly how to fix a specific type of engine part using a fixed set of tools.

Here is how GALOSH works, broken down into simple steps:

1. No Searching, Just Local Fixes

GALOSH doesn't look for similar patches across the whole photo. Instead, it looks at a tiny neighborhood around every single pixel and fixes it right there.

The Analogy: Imagine a crowd of people. The "Detective" method tries to find everyone who looks like you to copy their clothes. GALOSH just hands you a tailor who fixes your clothes based on your own body shape, right where you are standing.
The Benefit: Because it doesn't have to search or make decisions based on what it sees, the process is the same for every single pixel. This makes it incredibly fast and easy to run on regular computers (CPUs), not just super-computers.

2. Two Different Tools for Two Different Problems

GALOSH realizes that "noise" isn't just one thing. It treats the picture in two separate layers:

The "Grain" (Luminance): This is the black-and-white texture. A little bit of grain actually looks nice, like film in an old movie. GALOSH is gentle here, smoothing it out just enough to keep the texture but removing the ugly parts.
The "Blotches" (Chrominance): This is the weird color noise (like a red splotch on a blue sky). This is never acceptable. GALOSH is much more aggressive here, scrubbing these colors away completely.
The Analogy: Think of cleaning a muddy window. You might gently wipe the glass to remove the smudges (grain) but you'd use a squeegee to violently wipe away a big blob of paint (color blotch). GALOSH uses a "gentle wipe" for the texture and a "squeegee" for the colors.

3. Blind and Training-Free

GALOSH doesn't need to be taught with thousands of examples. It figures out the "noise level" of the photo itself, just by looking at it.

The Analogy: Most AI cleaners are like a chef who only knows how to cook Italian food because they only studied Italian recipes. If you give them a Japanese dish, they fail. GALOSH is like a chef who can taste the ingredients in front of them and figure out exactly how to cook any dish, right then and there, without needing a recipe book.

4. Speed and Hardware

Because GALOSH doesn't search and doesn't need a massive brain (AI model), it is lightning fast.

The Stats: On a standard graphics card, it is 7 to 650 times faster than the best AI cleaners. On a regular computer processor (CPU), it is the only strong method that actually works well; the AI methods are too slow to be practical there.
The Future: The paper mentions that because the steps are so regular and simple, this method is designed to be built directly into camera chips (hardware) that use simple math (fixed-point), making it perfect for future smartphones and cameras.

Summary of Results

The authors tested GALOSH on real-world noisy photos (from smartphones and cameras) and compared it to the best "Detective" methods and the best "Student" (AI) methods.

Vs. Detectives: GALOSH is much better at cleaning the photo and looks more natural, even when the "Detectives" are given the perfect answer key (knowing the exact noise level).
Vs. Students: GALOSH isn't quite as perfect as the AI students if the photo looks exactly like what the AI was trained on. However, if the photo is different or very noisy, the AI students often fail or crash, while GALOSH stays stable and reliable.
The Winner: GALOSH is the only method that is fast, works on regular computers, doesn't need training, and looks great on both raw camera data and finished photos.

In short, GALOSH takes the best ideas from old-school photo fixing, removes the slow "searching" part, and creates a fast, reliable, universal cleaner that works on any photo, anywhere.

Technical Summary: GALOSH – Blind, Training-Free Denoising via Parallel-Friendly Local Shrinkage

1. Problem Statement

Image denoising is currently dominated by two distinct families, each with significant limitations:

Classical Training-Free Methods (e.g., BM3D, Non-Local Means): These methods generalize well across sensors without training data but rely heavily on content-dependent search (block matching, neighborhood weighting). This search mechanism creates irregular memory access and data-dependent control flow, which hinders vectorization, GPU occupancy, and fixed-latency implementations. Furthermore, they typically assume a known noise level.
Learned Methods (CNNs, Transformers): These achieve the highest quality within their training domain but require extensive training pairs, suffer from catastrophic degradation outside their training distribution, and demand high computational budgets (tens of thousands of MACs per pixel) that effectively necessitate GPU acceleration.

The paper asks: How much of the classical family's quality survives if the search is removed by design? The goal is to create a blind, training-free, multi-domain denoiser that is fast, parallelizable, and suitable for fixed-latency hardware without sacrificing perceptual quality.

2. Methodology: GALOSH

GALOSH (Generalized Anscombe LOcal SHrinkage) replaces the search-based architecture of classical methods with a pipeline where every stage is local, regular, and data-independent. The computation graph is fixed for every pixel, enabling trivial parallelization.

The pipeline consists of four core stages:

A. Blind Noise Estimation

Instead of assuming a known noise level, GALOSH fits a Poisson–Gaussian noise model ( $Var[x] = \alpha E[x] + \sigma^2$ ) directly from the noisy frame. This is achieved via robust regression of local Laplacian variance against local mean over overlapping blocks (a Foi-style estimator), yielding per-image parameters $(\alpha, \sigma^2)$ without oracle data or calibration.

B. Variance Stabilization (GAT)

A Generalized Anscombe Transform (GAT) maps the signal-dependent noise to approximately unit-variance Gaussian. This allows a single global threshold to be valid across the entire frame. The transform uses an exact unbiased inverse for reconstruction.

C. Two-Pass Local Luminance Shrinkage (LOSH)

Luminance is denoised using a cycle-spun local shrinkage on overlapping $8 \times 8$ Walsh–Hadamard blocks, replacing BM3D's collaborative 3D stack:

Pass 1: Applies a robust BayesShrink threshold to generate a pilot estimate.
Pass 2: Applies an empirical Wiener gain computed from the pilot's coefficients.
Overlapping blocks are recombined via windowed overlap-add. This removes all content dependence while retaining the "shrink-then-Wiener" refinement architecture of BM3D.

D. Luminance-Guided Chrominance Regression

Chrominance is treated differently from luminance based on perceptual requirements:

Luminance noise appears as grain and coexists with texture; thus, it is shrunk conservatively to preserve high-frequency structure.
Chrominance noise appears as unacceptable color blotches; thus, it is smoothed aggressively.
Chrominance planes are denoised via a degree-1 locally-weighted regression (LOESS) guided by the denoised luminance. A multi-scale residual pyramid handles large-grain blotches. Crucially, reconstructed chroma values are clamped to the local input chroma range to prevent the "invention" of colors not present in the input.

Domain Front-Ends

A single core operates on two inputs:

GALOSH-RAW: Works directly on Bayer mosaics. A $2 \times 2$ Walsh–Hadamard transform splits each quad into full-resolution luminance and half-resolution chroma planes.
GALOSH-YUV/RGB: Works on rendered sRGB images. Input is linearized and converted to BT.709 YCbCr; chroma is processed at full resolution without subsampling.

3. Key Contributions

Search-Free Pipeline: A fully blind, training-free denoising pipeline where all stages are local, regular, and data-independent, featuring a shared core with two domain front-ends (Raw Bayer and sRGB/YUV).
Perceptual Superiority over Classical Methods: Evidence across four real-noise benchmarks (SIDD Medium, RawNIND) showing GALOSH is the strongest blind, training-free method, surpassing BM3D and NLM families even when those baselines are given an oracle noise level.
Speed and Hardware Efficiency: A demonstration that removing search yields massive speedups (7×–650× faster than deep learning baselines on GPU) and practical CPU performance. The fixed computation graph is shown to map naturally to fixed-point and streaming hardware via an operation-count analysis and a working INT16 realization.

4. Experimental Results

The paper evaluates GALOSH against classical baselines (BM3D, NLM, and their variants) and deep learning baselines (Blind2Unblind, NAFNet, Restormer, SCUNet) on Raw Bayer and sRGB domains.

Raw Domain: GALOSH achieves the best perceptual metrics (LPIPS, DISTS) among all blind, training-free methods by a wide margin, closing most of the gap with the trained Blind2Unblind network without any training.
sRGB Domain:
- GALOSH decisively beats blind classical methods (e.g., 35.01 dB vs. 27–29 dB on SIDD sRGB).
- Even when classical methods are given an oracle noise level, they fail to match GALOSH's performance, proving the advantage lies in the algorithm, not just noise estimation.
- Comparison with Trained DL: On in-domain data (SIDD), trained networks (e.g., NAFNet) hold a moderate lead. However, on cross-domain data (RawNIND) at high ISO, trained networks only maintain a slight lead (+0.3–0.7 dB) over GALOSH, while GALOSH significantly outperforms classical methods. Notably, GALOSH remains numerically stable on near-black scenes where some trained networks diverge.
Speed:
- GPU: 0.76s per 16-MP raw frame (vs. 5.6s for Blind2Unblind) and 0.87s per 15.8-MP sRGB frame (vs. 13.5s–565s for DL baselines).
- CPU: GALOSH is the only strong method practical on CPUs, running 2–3× faster than BM3D-CFA/NLM-CFA on raw data and faster than Color-NLM on sRGB with higher quality.

5. Significance and Claims

The paper claims that GALOSH demonstrates that search is not essential for high-quality denoising. By replacing content-dependent search with a variance-stabilized, cycle-spun local shrinkage and a luminance-guided regression, the method retains and extends the quality of the classical family while achieving:

Blindness: No training data or noise level oracle required.
Multi-Domain Coverage: A single core handles both raw mosaics and rendered images.
Parallelism and Latency: The fixed, data-independent structure enables fixed-latency implementations and natural mapping to fixed-point streaming hardware (supported by an INT16 realization).
Robustness: It avoids the domain degradation and numerical instability sometimes seen in trained networks.

The authors position GALOSH not as a state-of-the-art quality competitor to in-domain trained networks, but as a superior solution for the specific constraints of blind, training-free, multi-domain, and hardware-efficient denoising.