Entropy Analysis

Information theory has a word for "how much stuff is going on in this image," and it's entropy - measured in bits, on a scale of 0 to 8 for an 8-bit image. A flat, repetitive, over-denoised render scores low: every pixel is predictable. A busy, textured frame scores high: every pixel is a surprise. Entropy Analysis computes that number, per block, and hands you the map.

It's part of ThatGlennD's ComfyUI-Image-Analysis-Tools pack, and it's one of the most useful diagnostic nodes there precisely because it's content-agnostic. It doesn't know or care what the subject is - it just measures how much information the pixels carry. That makes it a great "is this output suspiciously empty" detector that never goes stale across model changes.

How it works

The image goes grayscale and gets split into square blocks (the block_size input, 8–128, default 32, steps of 8). For each block, the pixel-value histogram is built and run through the Shannon entropy formula - -Σ p·log₂(p) over the probabilities - giving a per-block score in bits. entropy_score is the mean across all blocks, on that 0–8 scale. The interpretation string reads like "Moderate entropy (4.87 bits)" or "Very low entropy (1.24 bits)", stepping through low/moderate/high/very-high bands.

entropy_map (when visualize_entropy_map is on) is an inferno heatmap fixed to the full 0–8 bit range, so you can compare maps across different images without rescaling confusion: bright = information-dense, dark = flat and repetitive.

The block-size trade is the usual one: small blocks (16) expose fine texture and detail variation; large blocks (64+) reflect broader complexity patterns and run faster.

Where it earns its keep

• Flagging low-effort or over-denoised outputs. The classic failure mode: an image that looks "clean" but has had all its structure smoothed out. Entropy catches that as a flat map even when the global sharpness score looks fine.
• Comparing rendering richness across prompts, models, or samplers - same prompt, which version kept the most information?
• Auditing a texture pass - if you added a detail LoRA and the entropy didn't move, it didn't do anything.

The honest caveat, and it's a big one: entropy can't tell signal from noise. Random grain is high-entropy, and a noisy render will score "rich" while looking like static. And a deliberately minimal image - a clean studio shot on a seamless background - scores low by design, which is correct. So treat it as an information meter, not a quality meter, and pair it with Noise Estimation and Edge Density when a score feels off.

Install

Manager (search "Image Analysis") or:

cd ComfyUI/custom_nodes
git clone https://github.com/ThatGlennD/ComfyUI-Image-Analysis-Tools
cd ComfyUI-Image-Analysis-Tools
pip install -r requirements.txt

Restart ComfyUI. Requirements: numpy, opencv-python, matplotlib, scikit-learn, Pillow, torch - no models, no downloads.

Common gotchas

• Pack won't load: scikit-learn is imported at module load by the Color Harmony Analyzer; missing it disables the entire pack. Windows portable: python_embeded\python.exe -m pip install scikit-learn.
• comfy_api import error: update ComfyUI - the pack needs the newer node API.
• First frame only: batches analyze frame 0; video frames go through one at a time.
• Reading too much into one number: entropy is an average over blocks. A frame with a busy subject and a dead background can score "moderate" while being half-dense and half-empty - the map is where the real story is.

If you wire interpretation into a text node next to your image and watch it while tuning CFG or denoise, you'll quickly build intuition for what "normal" looks like for your style - and the next time an output comes back at 1.8 bits, you'll know something got flattened.