Noise2Void (Self-Supervised)

Every conventional denoiser you've used - SCUNet, NAFNet, whatever - learned its job from pairs of clean and noisy images somebody trained it on. Noise2Void doesn't have that luxury and doesn't need it: it trains directly on your single noisy image, right here in this node, and never sees a clean reference at all. That's the whole point of the method, and it's also why this node behaves less like "apply a filter" and more like "kick off a short training run" every time you use it.

How it denoises without ever seeing clean data

The trick is blind-spot training. The network is trained to predict each pixel's value from its surrounding pixels only - the center pixel itself is masked out during training, so the network can never just memorize "copy the input." Since real noise is (mostly) independent from pixel to pixel while real image structure is spatially correlated, a network that's only allowed to look at neighbors learns to predict the underlying signal, because that's the only thing actually predictable from context - the noise itself isn't. Run that trained network on the full image afterward and you get a denoised result, with the whole training-and-inference cycle happening on this one image, this one time.

That makes it genuinely useful for the case competitors struggle with: noise nobody has a training set for. Scanner artifacts, unusual sensor patterns, anything without a matching public dataset. It's the tradeoff that matters - no dataset needed, but no shortcuts either.

Inputs and outputs that matter

• train_epochs (default 100, range 10–500) - how long the on-image training runs. Too low and the network hasn't learned the structure yet; too high costs time for diminishing returns.
• model_size - small, medium, or large. Bigger capacity can capture more complex structure but trains slower and risks overfitting a small image faster.
• learning_rate (default 0.001) - the usual knob; the default is a safe starting point.

Outputs are denoised_image and training_info, a string with the final training loss and architecture used - a genuinely useful sanity check, since a loss that hasn't settled by the end of training is a sign train_epochs needs to go up.

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. Like Deep Image Prior, there's no checkpoint to download - the method is defined by training on the fly, so there's nothing pretrained to fetch. A GPU is strongly recommended; train_epochs on CPU adds up fast.

Where people get burned

The recurring surprise is speed, or the lack of it. This node retrains from scratch on every single image, so throwing it at a batch node the way you would a pretrained denoiser turns a five-second job into a multi-minute one, times however many images you feed it. If you're processing a big folder of similarly-noisy images, a pretrained option like NAFNet Denoise will get you 90% of the way there in a fraction of the time - save Noise2Void for images where the noise is genuinely unusual and a pretrained model just doesn't handle it well.

The second thing to watch: results vary run to run, because training starts from random weights every time. Two runs on the same image with identical settings won't be pixel-identical. If you need a reproducible result for a pipeline, that's a mismatch with what this node fundamentally is - it's a per-image optimization, not a deterministic filter. And if the output still looks noisy after training, raise train_epochs before touching anything else; a Noise2Void run that hasn't had enough epochs looks like it's barely doing anything, because it isn't finished yet.