Your wallpaper pack has three copies of the same image

#ai #python #api

Last month I generated 50 wallpapers for a digital asset pack. Different prompts, different categories, different seeds. When I laid them out in a grid to review, I counted at least 12 that looked nearly identical. Same color distribution. Same composition. Three of them had the exact same orange-to-purple gradient in the lower third.

I had fallen into the latent collapse trap, and I did not know it was a thing until I started measuring.

The problem: seeds lie to you

Here is what I assumed: different seed, different image. That is the contract. You pass seed=42 and seed=99 to your generation API, and you get two distinct outputs.

That assumption breaks down in two ways. First, diffusion models have documented mode collapse in certain prompt regions. Ask ten humans to draw a sunset and you get ten different paintings. Ask a diffusion model for sunset across 50 seeds and you get three clusters of near-identical images, with the rest scattered around them.

Second, and this is the one that stung: if your prompts share structural keywords like neon, cyberpunk, or night city, the model maps them to a narrow region of latent space. Different seeds in that region produce images that differ in fine detail but share the same overall color distribution and composition. To a customer browsing a pack, they look like the same wallpaper with a filter applied.

I am going to say something that will annoy prompt engineering enthusiasts: varying your prompt wording is the least effective way to get visual diversity. Seed selection matters more. Category selection matters more. But most creators spend 90% of their effort rephrasing prompts and 0% measuring whether the output is actually different from what they already have.

Measuring what same means

I needed a way to catch near-duplicates before publishing a pack. The obvious approach is eyeballing, but at 50+ images that stops working fast. I needed something automated.

Full perceptual hashing (pHash, dHash) is overkill for a first pass. Those detect structural similarity, which is useful but slow and sensitive to crops. What I wanted first was a cheap filter: do these two images have the same color fingerprint?

Color histograms are fast to compute and surprisingly good at catching the latent collapse problem. Two images generated from nearby seeds in the same prompt cluster will have nearly identical histograms. If the histogram correlation is above 0.98, the images are almost certainly too similar to ship together.

Here is the code:

from PIL import Image
import numpy as np
from itertools import combinations
from pathlib import Path

def color_histogram(img_path, bins=32):
    img = Image.open(img_path).convert("RGB")
    arr = np.array(img)
    hist = []
    for channel in range(3):
        h, _ = np.histogram(arr[:, :, channel], bins=bins, range=(0, 256))
        h = h.astype(float)
        h /= h.sum() if h.sum() > 0 else 1.0
        hist.extend(h)
    return np.array(hist)

def histogram_correlation(h1, h2):
    if np.std(h1) == 0 or np.std(h2) == 0:
        return 0.0
    return float(np.corrcoef(h1, h2)[0, 1])

def find_near_duplicates(directory, threshold=0.98):
    images = sorted(Path(directory).glob("*.png"))
    histograms = {}
    for img_path in images:
        histograms[img_path.name] = color_histogram(img_path)
    duplicates = []
    for name_a, name_b in combinations(histograms, 2):
        corr = histogram_correlation(histograms[name_a], histograms[name_b])
        if corr >= threshold:
            duplicates.append((name_a, name_b, round(corr, 4)))
    duplicates.sort(key=lambda x: -x[2])
    return duplicates

if __name__ == "__main__":
    dupes = find_near_duplicates("./wallpapers", threshold=0.97)
    if dupes:
        print(f"Found {len(dupes)} near-duplicate pairs:")
        for a, b, corr in dupes:
            print(f"  {corr:.4f}  {a}  <->  {b}")
    else:
        print("No near-duplicates found.")

Run this on a folder of generated images and it spits out pairs with correlation scores. Here is what I got on my 50-image batch:

Found 11 near-duplicate pairs:

  0.9987  wp_014.png  <->  wp_031.png
  0.9971  wp_008.png  <->  wp_022.png
  0.9963  wp_008.png  <->  wp_041.png
  0.9944  wp_012.png  <->  wp_037.png
  0.9931  wp_019.png  <->  wp_044.png
  ...

Eleven pairs out of 50 images. That is 22% of my batch that was essentially the same image with minor variations. If I had published this as 50 unique 4K wallpapers, I would have been lying to every customer who bought it.

Why prompt variation fails but seed spacing works

The fix is not to write better prompts. The fix is to stop trusting random seeds and start treating seed selection as an optimization problem.

When you pick seeds at random from a large range (say 1 to 2^32), you are sampling from a uniform distribution. But the images that come out are not uniformly distributed. Certain seed ranges produce clusters. The same prompt with seeds 1000 through 1010 might all converge to the same composition, while seeds 2000 through 2010 produce wildly different results.

Here is a practical approach: generate a batch with evenly spaced seeds instead of random ones.

def spaced_seeds(count, start=1000, step=7919):
    # 7919 is prime, which reduces the chance of hitting
    # the same latent cluster twice across different prompts.
    # ponytail: prime step is a heuristic, not mathematically proven
    # to maximize diversity. Use quasi-random sequences (Sobol) if needed.
    return [start + i * step for i in range(count)]

I tested this against random seeds on a batch of 50 cyberpunk wallpapers. The results were stark:

Strategy	Near-duplicate pairs	Max correlation
Random seeds	11	0.9987
Spaced seeds (prime step)	3	0.9912
Spaced + category mixing	1	0.9854

Spaced seeds with category mixing cut near-duplicates from 11 down to 1. That one remaining pair was a cosmic and a nature wallpaper that happened to share a dominant purple sky. The histogram caught it correctly.

Building a diversity gate into your pipeline

If you are generating wallpaper packs for sale, a diversity check should be the last step before publishing. Here is a minimal version that drops into a batch pipeline:

from pathlib import Path
import shutil

def filter_diverse(images_dir, output_dir, min_threshold=0.96):
    # Copy images, skipping near-duplicates.
    # Greedy: process in order, skip any image whose histogram
    # correlates above threshold with one already kept.
    # ponytail: O(n^2). Fine for <500 images.
    # For larger batches, build a KD-tree on histogram vectors.
    images = sorted(Path(images_dir).glob("*.png"))
    kept = []
    kept_histograms = []
    out = Path(output_dir)
    out.mkdir(exist_ok=True)
    for img_path in images:
        hist = color_histogram(img_path)
        is_duplicate = False
        for kept_hist in kept_histograms:
            if histogram_correlation(hist, kept_hist) >= min_threshold:
                is_duplicate = True
                break
        if not is_duplicate:
            kept.append(img_path.name)
            kept_histograms.append(hist)
            shutil.copy2(img_path, out / img_path.name)
        else:
            print(f"  Skipped {img_path.name} (near-duplicate)")
    print(f"Kept {len(kept)} of {len(images)} images.")
    return kept

The greedy approach is O(n^2) in the number of images. For 50 to 200 images it runs in under a second on a modern machine. If you are processing thousands, switch to a KD-tree index on the histogram vectors. I have not needed that yet.

What this catches and what it misses

Histogram correlation is a blunt instrument. It catches:

Same color palette with different composition
Near-identical images from seed clustering
Accidental re-generations from cached prompts

It does not catch:

Same composition with different colors (structural duplicates)
Minor variations that a human would still call the same picture

For the second category, you want perceptual hashing. I use the imagehash library as a second pass:

import imagehash
from PIL import Image
from itertools import combinations
from pathlib import Path

def find_structural_duplicates(directory, threshold=5):
    images = sorted(Path(directory).glob("*.png"))
    hashes = {}
    for img_path in images:
        hashes[img_path.name] = imagehash.phash(Image.open(img_path))
    duplicates = []
    for a, b in combinations(hashes, 2):
        diff = hashes[a] - hashes[b]
        if diff <= threshold:
            duplicates.append((a, b, diff))
    duplicates.sort(key=lambda x: x[2])
    return duplicates

Run pip install imagehash and you are set. A phash difference of 0 means identical structure. Below 5 means structurally very similar. I use 5 as the cutoff for wallpaper packs.

Putting it together: a pre-publish checklist

Here is how I run the full check before shipping a pack to Gumroad:

def pre_publish_check(images_dir, hist_threshold=0.96, phash_threshold=5):
    print("=== Color histogram check ===")
    hist_dupes = find_near_duplicates(images_dir, threshold=hist_threshold)
    for a, b, corr in hist_dupes:
        print(f"  {corr:.4f}  {a} <-> {b}")
    print(f"  Total histogram near-dupes: {len(hist_dupes)}")
    print("=== Perceptual hash check ===")
    struct_dupes = find_structural_duplicates(images_dir, threshold=phash_threshold)
    for a, b, diff in struct_dupes:
        print(f"  diff={diff}  {a} <-> {b}")
    print(f"  Total structural near-dupes: {len(struct_dupes)}")
    total_images = len(list(Path(images_dir).glob("*.png")))
    flagged = len(set(a for a, _, _ in hist_dupes) | set(a for a, _, _ in struct_dupes))
    pct = (flagged / total_images * 100) if total_images else 0
    print("=== Summary ===")
    print(f"  {flagged} of {total_images} images flagged ({pct:.1f}%)")
    if pct > 10:
        print("  REGENERATE: Too many near-duplicates. Fix seed spacing.")
    else:
        print("  PASS: Safe to publish.")
    return pct <= 10

If more than 10% of images are flagged, I regenerate with better seed spacing or different categories before shipping. No exceptions.

The actual cost of shipping duplicates

I sell wallpaper packs on Gumroad for $1 each. The margins are thin enough that customer trust is the only real asset. A buyer who downloads 50 wallpapers and finds 12 of them look the same is not coming back. They are also the person who leaves a one-star review that scares off the next 20 potential buyers.

The full pipeline above is about 120 lines of Python. It runs in under a second on a 50-image batch. It caught a problem I did not know I had, and it has prevented me from shipping low-diversity packs three times since I built it.

If you are generating digital assets for sale, run this check before every publish. Your customers cannot tell you which seeds you used. They can tell you when half the pack looks the same.