Lightweight Progressive CNN Denoise

Read the optional inputs before you drop this one in expecting instant results. This node's whole pitch is a tiny (~500KB) CNN built for real-time, resource-constrained denoising - dense blocks feeding a progressive residual fusion from shallow to deep features, plus a lightweight attention layer. That's a genuinely sensible architecture for the job. The catch is that unless you point model_path at weights you've trained yourself, the network runs with random initialization. It's an untrained network in a box, waiting for you to bring the training.

Why it exists this way

This is a distinct design choice from most of the pack's denoisers, and it's worth understanding rather than treating as a bug. NAFNet ships with real pretrained weights that auto-download; this node instead gives you a small, fast, from-scratch architecture and an explicit model_path slot for weights you supply. That's the right shape for someone who wants to train a compact denoiser on their own footage or grain type and deploy it cheaply - a ~500KB model runs fast enough for real-time or batch work that a full transformer wouldn't keep up with. It's the wrong shape if you were expecting a working denoiser out of the box, because with no model_path set, that's not what you get.

You can tell when this is happening: the node's own processing_report output flags it, printing "Using random initialization (untrained network)" and recommending you supply pretrained weights or switch to something else for heavy grain.

Inputs and outputs that matter

• show_comparison (boolean, default on) - computes before/after noise estimates (via a Laplacian-based noise metric) and a PSNR-derived quality rating, so you can actually see whether the pass helped rather than guessing from the thumbnail.
• model_path (optional string, default empty) - path to your own trained .pth weights. Leave empty and you get random initialization; that's the entire behavior difference this input controls.

Outputs: denoised_image and processing_report, which includes model parameter count, model size in MB, device, and - critically - whether it's running trained or random weights and the estimated noise reduction it achieved.

Installing it

Through ComfyUI Manager, search Eric's Image Processing Nodes. By hand:

cd ComfyUI/custom_nodes
git clone https://github.com/EricRollei/Eric_Image_Processing_Nodes
cd Eric_Image_Processing_Nodes
pip install -r requirements.txt

Restart ComfyUI. There's no pretrained checkpoint bundled with the pack for this node and none to auto-download - the architecture ships, the weights don't, and that's by design given the "bring your own training" framing.

Where people get burned

Almost everyone who tries this node without reading the tooltip hits the same thing: it runs, it doesn't error, and the output looks basically identical to the input (or subtly worse) - because a randomly-initialized network doesn't denoise anything, it just adds a small amount of learned-nothing noise of its own. That's not a broken node; it's working exactly as designed with no weights loaded. The processing_report's noise-reduction percentage is the tell: if it's reporting a low single-digit reduction, you're looking at the untrained path.

If you don't have your own trained weights, this node isn't the one to reach for on real film grain - use BM3D Film Grain Denoising or NAFNet Denoise instead, both of which do something useful with zero setup. Come back to this node once you've trained a compact model of your own (the architecture is genuinely well-suited to it), or if the pack author publishes trained weights for it later - check the repo's release notes, since as of this writing none ship.